home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / pup_idol.swf / scripts / Box2D / Dynamics / b2Body.as next >
Encoding:
Text File  |  2008-08-07  |  12.1 KB  |  456 lines
  1. package Box2D.Dynamics
  2. {
  3.    import Box2D.Collision.Shapes.b2MassData;
  4.    import Box2D.Collision.Shapes.b2Shape;
  5.    import Box2D.Collision.Shapes.b2ShapeDef;
  6.    import Box2D.Common.Math.b2Mat22;
  7.    import Box2D.Common.Math.b2Math;
  8.    import Box2D.Common.Math.b2Vec2;
  9.    import Box2D.Common.b2Settings;
  10.    import Box2D.Dynamics.Contacts.b2ContactNode;
  11.    import Box2D.Dynamics.Joints.b2JointNode;
  12.    
  13.    public class b2Body
  14.    {
  15.       
  16.       public static var e_frozenFlag:uint = 2;
  17.       
  18.       public static var e_sleepFlag:uint = 8;
  19.       
  20.       public static var e_islandFlag:uint = 4;
  21.       
  22.       public static var e_destroyFlag:uint = 32;
  23.       
  24.       public static var e_allowSleepFlag:uint = 16;
  25.       
  26.       public static var e_staticFlag:uint = 1;
  27.        
  28.       
  29.       public var m_next:b2Body;
  30.       
  31.       public var m_R:b2Mat22;
  32.       
  33.       public var m_contactList:b2ContactNode;
  34.       
  35.       public var m_angularVelocity:Number;
  36.       
  37.       public var m_rotation:Number;
  38.       
  39.       public var m_shapeList:b2Shape;
  40.       
  41.       public var m_force:b2Vec2;
  42.       
  43.       public var m_torque:Number;
  44.       
  45.       public var m_mass:Number;
  46.       
  47.       public var m_rotation0:Number;
  48.       
  49.       public var m_invI:Number;
  50.       
  51.       public var m_shapeCount:int;
  52.       
  53.       public var m_userData:*;
  54.       
  55.       public var m_linearVelocity:b2Vec2;
  56.       
  57.       public var m_flags:uint;
  58.       
  59.       public var m_invMass:Number;
  60.       
  61.       public var m_position:b2Vec2;
  62.       
  63.       public var m_linearDamping:Number;
  64.       
  65.       public var m_prev:b2Body;
  66.       
  67.       public var m_world:b2World;
  68.       
  69.       public var m_angularDamping:Number;
  70.       
  71.       public var m_position0:b2Vec2;
  72.       
  73.       private var sMat0:b2Mat22;
  74.       
  75.       public var m_center:b2Vec2;
  76.       
  77.       public var m_sleepTime:Number;
  78.       
  79.       public var m_I:Number;
  80.       
  81.       public var m_jointList:b2JointNode;
  82.       
  83.       public function b2Body(param1:b2BodyDef, param2:b2World)
  84.       {
  85.          var _loc3_:int = 0;
  86.          var _loc4_:b2ShapeDef = null;
  87.          var _loc5_:b2MassData = null;
  88.          var _loc7_:b2Vec2 = null;
  89.          var _loc8_:b2Shape = null;
  90.          sMat0 = new b2Mat22();
  91.          m_position = new b2Vec2();
  92.          m_R = new b2Mat22(0);
  93.          m_position0 = new b2Vec2();
  94.          super();
  95.          m_flags = 0;
  96.          m_position.SetV(param1.position);
  97.          m_rotation = param1.rotation;
  98.          m_R.Set(m_rotation);
  99.          m_position0.SetV(m_position);
  100.          m_rotation0 = m_rotation;
  101.          m_world = param2;
  102.          m_linearDamping = b2Math.b2Clamp(1 - param1.linearDamping,0,1);
  103.          m_angularDamping = b2Math.b2Clamp(1 - param1.angularDamping,0,1);
  104.          m_force = new b2Vec2(0,0);
  105.          m_torque = 0;
  106.          m_mass = 0;
  107.          var _loc6_:Array = new Array(b2Settings.b2_maxShapesPerBody);
  108.          _loc3_ = 0;
  109.          while(_loc3_ < b2Settings.b2_maxShapesPerBody)
  110.          {
  111.             _loc6_[_loc3_] = new b2MassData();
  112.             _loc3_++;
  113.          }
  114.          m_shapeCount = 0;
  115.          m_center = new b2Vec2(0,0);
  116.          _loc3_ = 0;
  117.          while(_loc3_ < b2Settings.b2_maxShapesPerBody)
  118.          {
  119.             if((_loc4_ = param1.shapes[_loc3_]) == null)
  120.             {
  121.                break;
  122.             }
  123.             _loc5_ = _loc6_[_loc3_];
  124.             _loc4_.ComputeMass(_loc5_);
  125.             m_mass += _loc5_.mass;
  126.             m_center.x += _loc5_.mass * (_loc4_.localPosition.x + _loc5_.center.x);
  127.             m_center.y += _loc5_.mass * (_loc4_.localPosition.y + _loc5_.center.y);
  128.             ++m_shapeCount;
  129.             _loc3_++;
  130.          }
  131.          if(m_mass > 0)
  132.          {
  133.             m_center.Multiply(1 / m_mass);
  134.             m_position.Add(b2Math.b2MulMV(m_R,m_center));
  135.          }
  136.          else
  137.          {
  138.             m_flags |= e_staticFlag;
  139.          }
  140.          m_I = 0;
  141.          _loc3_ = 0;
  142.          while(_loc3_ < m_shapeCount)
  143.          {
  144.             _loc4_ = param1.shapes[_loc3_];
  145.             _loc5_ = _loc6_[_loc3_];
  146.             m_I += _loc5_.I;
  147.             _loc7_ = b2Math.SubtractVV(b2Math.AddVV(_loc4_.localPosition,_loc5_.center),m_center);
  148.             m_I += _loc5_.mass * b2Math.b2Dot(_loc7_,_loc7_);
  149.             _loc3_++;
  150.          }
  151.          if(m_mass > 0)
  152.          {
  153.             m_invMass = 1 / m_mass;
  154.          }
  155.          else
  156.          {
  157.             m_invMass = 0;
  158.          }
  159.          if(m_I > 0 && param1.preventRotation == false)
  160.          {
  161.             m_invI = 1 / m_I;
  162.          }
  163.          else
  164.          {
  165.             m_I = 0;
  166.             m_invI = 0;
  167.          }
  168.          m_linearVelocity = b2Math.AddVV(param1.linearVelocity,b2Math.b2CrossFV(param1.angularVelocity,m_center));
  169.          m_angularVelocity = param1.angularVelocity;
  170.          m_jointList = null;
  171.          m_contactList = null;
  172.          m_prev = null;
  173.          m_next = null;
  174.          m_shapeList = null;
  175.          _loc3_ = 0;
  176.          while(_loc3_ < m_shapeCount)
  177.          {
  178.             _loc4_ = param1.shapes[_loc3_];
  179.             (_loc8_ = b2Shape.Create(_loc4_,this,m_center)).m_next = m_shapeList;
  180.             m_shapeList = _loc8_;
  181.             _loc3_++;
  182.          }
  183.          m_sleepTime = 0;
  184.          if(param1.allowSleep)
  185.          {
  186.             m_flags |= e_allowSleepFlag;
  187.          }
  188.          if(param1.isSleeping)
  189.          {
  190.             m_flags |= e_sleepFlag;
  191.          }
  192.          if(Boolean(m_flags & e_sleepFlag) || m_invMass == 0)
  193.          {
  194.             m_linearVelocity.Set(0,0);
  195.             m_angularVelocity = 0;
  196.          }
  197.          m_userData = param1.userData;
  198.       }
  199.       
  200.       public function SetCenterPosition(param1:b2Vec2, param2:Number) : void
  201.       {
  202.          if(IsFrozen())
  203.          {
  204.             return;
  205.          }
  206.          m_rotation = param2;
  207.          m_R.Set(m_rotation);
  208.          m_position.SetV(param1);
  209.          m_position0.SetV(m_position);
  210.          m_rotation0 = m_rotation;
  211.          var _loc3_:b2Shape = m_shapeList;
  212.          while(_loc3_ != null)
  213.          {
  214.             _loc3_.Synchronize(m_position,m_R,m_position,m_R);
  215.             _loc3_ = _loc3_.m_next;
  216.          }
  217.          m_world.m_broadPhase.Commit();
  218.       }
  219.       
  220.       public function GetWorldPoint(param1:b2Vec2) : b2Vec2
  221.       {
  222.          return b2Math.AddVV(m_position,b2Math.b2MulMV(m_R,param1));
  223.       }
  224.       
  225.       public function SetLinearVelocity(param1:b2Vec2) : void
  226.       {
  227.          m_linearVelocity.SetV(param1);
  228.       }
  229.       
  230.       public function WakeUp() : void
  231.       {
  232.          m_flags &= ~e_sleepFlag;
  233.          m_sleepTime = 0;
  234.       }
  235.       
  236.       public function IsFrozen() : Boolean
  237.       {
  238.          return (m_flags & e_frozenFlag) == e_frozenFlag;
  239.       }
  240.       
  241.       public function IsSleeping() : Boolean
  242.       {
  243.          return (m_flags & e_sleepFlag) == e_sleepFlag;
  244.       }
  245.       
  246.       public function GetLocalVector(param1:b2Vec2) : b2Vec2
  247.       {
  248.          return b2Math.b2MulTMV(m_R,param1);
  249.       }
  250.       
  251.       public function QuickSyncShapes() : void
  252.       {
  253.          var _loc1_:b2Shape = m_shapeList;
  254.          while(_loc1_ != null)
  255.          {
  256.             _loc1_.QuickSync(m_position,m_R);
  257.             _loc1_ = _loc1_.m_next;
  258.          }
  259.       }
  260.       
  261.       public function GetInertia() : Number
  262.       {
  263.          return m_I;
  264.       }
  265.       
  266.       public function GetJointList() : b2JointNode
  267.       {
  268.          return m_jointList;
  269.       }
  270.       
  271.       public function Freeze() : void
  272.       {
  273.          m_flags |= e_frozenFlag;
  274.          m_linearVelocity.SetZero();
  275.          m_angularVelocity = 0;
  276.          var _loc1_:b2Shape = m_shapeList;
  277.          while(_loc1_ != null)
  278.          {
  279.             _loc1_.DestroyProxy();
  280.             _loc1_ = _loc1_.m_next;
  281.          }
  282.       }
  283.       
  284.       public function GetRotationMatrix() : b2Mat22
  285.       {
  286.          return m_R;
  287.       }
  288.       
  289.       public function SetAngularVelocity(param1:Number) : void
  290.       {
  291.          m_angularVelocity = param1;
  292.       }
  293.       
  294.       public function SynchronizeShapes() : void
  295.       {
  296.          sMat0.Set(m_rotation0);
  297.          var _loc1_:b2Shape = m_shapeList;
  298.          while(_loc1_ != null)
  299.          {
  300.             _loc1_.Synchronize(m_position0,sMat0,m_position,m_R);
  301.             _loc1_ = _loc1_.m_next;
  302.          }
  303.       }
  304.       
  305.       public function ApplyForce(param1:b2Vec2, param2:b2Vec2) : void
  306.       {
  307.          if(IsSleeping() == false)
  308.          {
  309.             m_force.Add(param1);
  310.             m_torque += b2Math.b2CrossVV(b2Math.SubtractVV(param2,m_position),param1);
  311.          }
  312.       }
  313.       
  314.       public function GetOriginPosition() : b2Vec2
  315.       {
  316.          return b2Math.SubtractVV(m_position,b2Math.b2MulMV(m_R,m_center));
  317.       }
  318.       
  319.       public function ApplyImpulse(param1:b2Vec2, param2:b2Vec2) : void
  320.       {
  321.          if(IsSleeping() == false)
  322.          {
  323.             m_linearVelocity.Add(b2Math.MulFV(m_invMass,param1));
  324.             m_angularVelocity += m_invI * b2Math.b2CrossVV(b2Math.SubtractVV(param2,m_position),param1);
  325.          }
  326.       }
  327.       
  328.       public function GetContactList() : b2ContactNode
  329.       {
  330.          return m_contactList;
  331.       }
  332.       
  333.       public function GetShapeList() : b2Shape
  334.       {
  335.          return m_shapeList;
  336.       }
  337.       
  338.       public function GetMass() : Number
  339.       {
  340.          return m_mass;
  341.       }
  342.       
  343.       public function GetAngularVelocity() : Number
  344.       {
  345.          return m_angularVelocity;
  346.       }
  347.       
  348.       public function SetOriginPosition(param1:b2Vec2, param2:Number) : void
  349.       {
  350.          if(IsFrozen())
  351.          {
  352.             return;
  353.          }
  354.          m_rotation = param2;
  355.          m_R.Set(m_rotation);
  356.          m_position = b2Math.AddVV(param1,b2Math.b2MulMV(m_R,m_center));
  357.          m_position0.SetV(m_position);
  358.          m_rotation0 = m_rotation;
  359.          var _loc3_:b2Shape = m_shapeList;
  360.          while(_loc3_ != null)
  361.          {
  362.             _loc3_.Synchronize(m_position,m_R,m_position,m_R);
  363.             _loc3_ = _loc3_.m_next;
  364.          }
  365.          m_world.m_broadPhase.Commit();
  366.       }
  367.       
  368.       public function GetLocalPoint(param1:b2Vec2) : b2Vec2
  369.       {
  370.          return b2Math.b2MulTMV(m_R,b2Math.SubtractVV(param1,m_position));
  371.       }
  372.       
  373.       public function GetRotation() : Number
  374.       {
  375.          return m_rotation;
  376.       }
  377.       
  378.       public function IsStatic() : Boolean
  379.       {
  380.          return (m_flags & e_staticFlag) == e_staticFlag;
  381.       }
  382.       
  383.       public function Destroy() : void
  384.       {
  385.          var _loc2_:b2Shape = null;
  386.          var _loc1_:b2Shape = m_shapeList;
  387.          while(_loc1_)
  388.          {
  389.             _loc2_ = _loc1_;
  390.             _loc1_ = _loc1_.m_next;
  391.             b2Shape.Destroy(_loc2_);
  392.          }
  393.       }
  394.       
  395.       public function GetWorldVector(param1:b2Vec2) : b2Vec2
  396.       {
  397.          return b2Math.b2MulMV(m_R,param1);
  398.       }
  399.       
  400.       public function GetNext() : b2Body
  401.       {
  402.          return m_next;
  403.       }
  404.       
  405.       public function IsConnected(param1:b2Body) : Boolean
  406.       {
  407.          var _loc2_:b2JointNode = m_jointList;
  408.          while(_loc2_ != null)
  409.          {
  410.             if(_loc2_.other == param1)
  411.             {
  412.                return _loc2_.joint.m_collideConnected == false;
  413.             }
  414.             _loc2_ = _loc2_.next;
  415.          }
  416.          return false;
  417.       }
  418.       
  419.       public function GetUserData() : *
  420.       {
  421.          return m_userData;
  422.       }
  423.       
  424.       public function AllowSleeping(param1:Boolean) : void
  425.       {
  426.          if(param1)
  427.          {
  428.             m_flags |= e_allowSleepFlag;
  429.          }
  430.          else
  431.          {
  432.             m_flags &= ~e_allowSleepFlag;
  433.             WakeUp();
  434.          }
  435.       }
  436.       
  437.       public function ApplyTorque(param1:Number) : void
  438.       {
  439.          if(IsSleeping() == false)
  440.          {
  441.             m_torque += param1;
  442.          }
  443.       }
  444.       
  445.       public function GetCenterPosition() : b2Vec2
  446.       {
  447.          return m_position;
  448.       }
  449.       
  450.       public function GetLinearVelocity() : b2Vec2
  451.       {
  452.          return m_linearVelocity;
  453.       }
  454.    }
  455. }
  456.