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

Text File | 2008-09-02 | 6.2 KB | 246 lines

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

   public class AbstractParticle extends AbstractItem
   {


      private var _collidable:Boolean;

      private var _multisample:int;

      private var collision:Collision;

      internal var prev:Vector;

      private var _kfr:Number;

      internal var curr:Vector;

      private var _invMass:Number;

      internal var interval:Interval;

      private var _mass:Number;

      private var temp:Vector;

      private var _friction:Number;

      private var forces:Vector;

      internal var samp:Vector;

      private var _center:Vector;

      private var _fixed:Boolean;

      public function AbstractParticle(param1:Number, param2:Number, param3:Boolean, param4:Number, param5:Number, param6:Number)
      {
         super();
         if(getQualifiedClassName(this) == "org.cove.ape::AbstractParticle")
         {
            throw new ArgumentError("AbstractParticle can\'t be instantiated directly");
         }
         interval = new Interval(0,0);
         curr = new Vector(param1,param2);
         prev = new Vector(param1,param2);
         samp = new Vector();
         temp = new Vector();
         fixed = param3;
         forces = new Vector();
         collision = new Collision(new Vector(),new Vector());
         collidable = true;
         this.mass = param4;
         this.elasticity = param5;
         this.friction = param6;
         setStyle();
         _center = new Vector();
         _multisample = 0;
      }

      public function set friction(param1:Number) : void
      {
         if(param1 < 0 || param1 > 1)
         {
            throw new ArgumentError("Legal friction must be >= 0 and <=1");
         }
         _friction = param1;
      }

      public function get px() : Number
      {
         return curr.x;
      }

      public function get py() : Number
      {
         return curr.y;
      }

      public function set py(param1:Number) : void
      {
         curr.y = param1;
         prev.y = param1;
      }

      internal function getComponents(param1:Vector) : Collision
      {
         var _loc2_:Vector = null;
         var _loc3_:Number = NaN;
         _loc2_ = velocity;
         _loc3_ = param1.dot(_loc2_);
         collision.vn = param1.mult(_loc3_);
         collision.vt = _loc2_.minus(collision.vn);
         return collision;
      }

      public function set mass(param1:Number) : void
      {
         if(param1 <= 0)
         {
            throw new ArgumentError("mass may not be set <= 0");
         }
         _mass = param1;
         _invMass = 1 / _mass;
      }

      public function get fixed() : Boolean
      {
         return _fixed;
      }

      public function set px(param1:Number) : void
      {
         curr.x = param1;
         prev.x = param1;
      }

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

      internal function get invMass() : Number
      {
         return fixed ? 0 : _invMass;
      }

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

      public function get position() : Vector
      {
         return new Vector(curr.x,curr.y);
      }

      public function get multisample() : int
      {
         return _multisample;
      }

      internal function resolveCollision(param1:Vector, param2:Vector, param3:Vector, param4:Number, param5:int, param6:AbstractParticle) : void
      {
         curr.plusEquals(param1);
         velocity = param2;
      }

      public function set fixed(param1:Boolean) : void
      {
         _fixed = param1;
      }

      public function addMasslessForce(param1:Vector) : void
      {
         forces.plusEquals(param1);
      }

      public function set velocity(param1:Vector) : void
      {
         prev = curr.minus(param1);
      }

      public function set multisample(param1:int) : void
      {
         _multisample = param1;
      }

      public function get elasticity() : Number
      {
         return _kfr;
      }

      public function set position(param1:Vector) : void
      {
         curr.copy(param1);
         prev.copy(param1);
      }

      public function get center() : Vector
      {
         _center.setTo(px,py);
         return _center;
      }

      public function update(param1:Number) : void
      {
         var _loc2_:Vector = null;
         if(fixed)
         {
            return;
         }
         addForce(APEngine.force);
         addMasslessForce(APEngine.masslessForce);
         temp.copy(curr);
         _loc2_ = velocity.plus(forces.multEquals(param1));
         curr.plusEquals(_loc2_.multEquals(APEngine.damping));
         prev.copy(temp);
         forces.setTo(0,0);
      }

      public function set collidable(param1:Boolean) : void
      {
         _collidable = param1;
      }

      public function get velocity() : Vector
      {
         return curr.minus(prev);
      }

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

      public function addForce(param1:Vector) : void
      {
         forces.plusEquals(param1.mult(invMass));
      }

      public function set elasticity(param1:Number) : void
      {
         _kfr = param1;
      }

      public function get friction() : Number
      {
         return _friction;
      }

      public function get mass() : Number
      {
         return _mass;
      }
   }
}