404 Jogos/CLJG.iso/Puzzle/filler.swf/scripts/org/cove/ape/SpringConstraint.as

Text File | 2008-09-02 | 5.9 KB | 233 lines

package org.cove.ape
{
   import flash.display.DisplayObject;

   public class SpringConstraint extends AbstractConstraint
   {


      private var _collidable:Boolean;

      private var _restLength:Number;

      private var p1:AbstractParticle;

      private var p2:AbstractParticle;

      private var _scp:SpringConstraintParticle;

      public function SpringConstraint(param1:AbstractParticle, param2:AbstractParticle, param3:Number = 0.5, param4:Boolean = false, param5:Number = 1, param6:Number = 1, param7:Boolean = false)
      {
         super(param3);
         this.p1 = param1;
         this.p2 = param2;
         checkParticlesLocation();
         _restLength = currLength;
         setCollidable(param4,param5,param6,param7);
      }

      public function set rectScale(param1:Number) : void
      {
         if(scp == null)
         {
            return;
         }
         scp.rectScale = param1;
      }

      override public function init() : void
      {
         cleanup();
         if(collidable)
         {
            scp.init();
         }
         else if(displayObject != null)
         {
            initDisplay();
         }
         paint();
      }

      internal function initDisplay() : void
      {
         if(collidable)
         {
            scp.initDisplay();
         }
         else
         {
            displayObject.x = displayObjectOffset.x;
            displayObject.y = displayObjectOffset.y;
            displayObject.rotation = displayObjectRotation;
            sprite.addChild(displayObject);
         }
      }

      private function checkParticlesLocation() : void
      {
         if(p1.curr.x == p2.curr.x && p1.curr.y == p2.curr.y)
         {
            p2.curr.x += 0.0001;
         }
      }

      public function get radian() : Number
      {
         var _loc1_:Vector = null;
         _loc1_ = delta;
         return Math.atan2(_loc1_.y,_loc1_.x);
      }

      public function setDisplay(param1:DisplayObject, param2:Number = 0, param3:Number = 0, param4:Number = 0) : void
      {
         if(collidable)
         {
            scp.setDisplay(param1,param2,param3,param4);
         }
         else
         {
            displayObject = param1;
            displayObjectRotation = param4;
            displayObjectOffset = new Vector(param2,param3);
         }
      }

      internal function get scp() : SpringConstraintParticle
      {
         return _scp;
      }

      public function get rectHeight() : Number
      {
         return scp.rectHeight;
      }

      public function set restLength(param1:Number) : void
      {
         if(param1 <= 0)
         {
            throw new ArgumentError("restLength must be greater than 0");
         }
         _restLength = param1;
      }

      public function get currLength() : Number
      {
         return p1.curr.distance(p2.curr);
      }

      public function get fixedEndLimit() : Number
      {
         return scp.fixedEndLimit;
      }

      public function get rectScale() : Number
      {
         return scp.rectScale;
      }

      internal function get delta() : Vector
      {
         return p1.curr.minus(p2.curr);
      }

      public function get angle() : Number
      {
         return radian * MathUtil.ONE_EIGHTY_OVER_PI;
      }

      public function get center() : Vector
      {
         return p1.curr.plus(p2.curr).divEquals(2);
      }

      public function set rectHeight(param1:Number) : void
      {
         if(scp == null)
         {
            return;
         }
         scp.rectHeight = param1;
      }

      public function get restLength() : Number
      {
         return _restLength;
      }

      override public function paint() : void
      {
         var _loc1_:Vector = null;
         if(collidable)
         {
            scp.paint();
         }
         else if(displayObject != null)
         {
            _loc1_ = center;
            sprite.x = _loc1_.x;
            sprite.y = _loc1_.y;
            sprite.rotation = angle;
         }
         else
         {
            sprite.graphics.clear();
            sprite.graphics.lineStyle(lineThickness,lineColor,lineAlpha);
            sprite.graphics.moveTo(p1.px,p1.py);
            sprite.graphics.lineTo(p2.px,p2.py);
         }
      }

      public function setCollidable(param1:Boolean, param2:Number, param3:Number, param4:Boolean = false) : void
      {
         _collidable = param1;
         _scp = null;
         if(_collidable)
         {
            _scp = new SpringConstraintParticle(p1,p2,this,param2,param3,param4);
         }
      }

      public function get collidable() : Boolean
      {
         return _collidable;
      }

      public function isConnectedTo(param1:AbstractParticle) : Boolean
      {
         return param1 == p1 || param1 == p2;
      }

      override internal function resolve() : void
      {
         var _loc1_:Number = NaN;
         var _loc2_:Number = NaN;
         var _loc3_:Vector = null;
         if(p1.fixed && p2.fixed)
         {
            return;
         }
         _loc1_ = currLength;
         _loc2_ = (_loc1_ - restLength) / (_loc1_ * (p1.invMass + p2.invMass));
         _loc3_ = delta.mult(_loc2_ * stiffness);
         p1.curr.minusEquals(_loc3_.mult(p1.invMass));
         p2.curr.plusEquals(_loc3_.mult(p2.invMass));
      }

      public function get fixed() : Boolean
      {
         return p1.fixed && p2.fixed;
      }

      public function set fixedEndLimit(param1:Number) : void
      {
         if(scp == null)
         {
            return;
         }
         scp.fixedEndLimit = param1;
      }
   }
}