home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / pup_idol.swf / scripts / Box2D / Dynamics / b2Island.as < prev    next >
Encoding:
Text File  |  2008-08-07  |  7.1 KB  |  235 lines
  1. package Box2D.Dynamics
  2. {
  3.    import Box2D.Common.*;
  4.    import Box2D.Common.Math.*;
  5.    import Box2D.Dynamics.Contacts.*;
  6.    import Box2D.Dynamics.Joints.*;
  7.    
  8.    public class b2Island
  9.    {
  10.       
  11.       public static var m_positionIterationCount:uint;
  12.        
  13.       
  14.       public var m_positionError:Number;
  15.       
  16.       public var m_bodyCapacity:int;
  17.       
  18.       public var m_bodies:Array;
  19.       
  20.       public var m_joints:Array;
  21.       
  22.       public var m_jointCapacity:int;
  23.       
  24.       public var m_contactCount:int;
  25.       
  26.       public var m_contacts:Array;
  27.       
  28.       public var m_contactCapacity:int;
  29.       
  30.       public var m_jointCount:int;
  31.       
  32.       public var m_allocator:*;
  33.       
  34.       public var m_bodyCount:int;
  35.       
  36.       public function b2Island(param1:int, param2:int, param3:int, param4:*)
  37.       {
  38.          var _loc5_:int = 0;
  39.          super();
  40.          m_bodyCapacity = param1;
  41.          m_contactCapacity = param2;
  42.          m_jointCapacity = param3;
  43.          m_bodyCount = 0;
  44.          m_contactCount = 0;
  45.          m_jointCount = 0;
  46.          m_bodies = new Array(param1);
  47.          _loc5_ = 0;
  48.          while(_loc5_ < param1)
  49.          {
  50.             m_bodies[_loc5_] = null;
  51.             _loc5_++;
  52.          }
  53.          m_contacts = new Array(param2);
  54.          _loc5_ = 0;
  55.          while(_loc5_ < param2)
  56.          {
  57.             m_contacts[_loc5_] = null;
  58.             _loc5_++;
  59.          }
  60.          m_joints = new Array(param3);
  61.          _loc5_ = 0;
  62.          while(_loc5_ < param3)
  63.          {
  64.             m_joints[_loc5_] = null;
  65.             _loc5_++;
  66.          }
  67.          m_allocator = param4;
  68.       }
  69.       
  70.       public function AddBody(param1:b2Body) : void
  71.       {
  72.          var _loc2_:* = m_bodyCount++;
  73.          m_bodies[_loc2_] = param1;
  74.       }
  75.       
  76.       public function AddJoint(param1:b2Joint) : void
  77.       {
  78.          var _loc2_:* = m_jointCount++;
  79.          m_joints[_loc2_] = param1;
  80.       }
  81.       
  82.       public function AddContact(param1:b2Contact) : void
  83.       {
  84.          var _loc2_:* = m_contactCount++;
  85.          m_contacts[_loc2_] = param1;
  86.       }
  87.       
  88.       public function Solve(param1:b2TimeStep, param2:b2Vec2) : void
  89.       {
  90.          var _loc3_:int = 0;
  91.          var _loc4_:b2Body = null;
  92.          var _loc6_:int = 0;
  93.          var _loc7_:Boolean = false;
  94.          var _loc8_:Boolean = false;
  95.          var _loc9_:Boolean = false;
  96.          _loc3_ = 0;
  97.          while(_loc3_ < m_bodyCount)
  98.          {
  99.             if((_loc4_ = m_bodies[_loc3_]).m_invMass != 0)
  100.             {
  101.                _loc4_.m_linearVelocity.Add(b2Math.MulFV(param1.dt,b2Math.AddVV(param2,b2Math.MulFV(_loc4_.m_invMass,_loc4_.m_force))));
  102.                _loc4_.m_angularVelocity += param1.dt * _loc4_.m_invI * _loc4_.m_torque;
  103.                _loc4_.m_linearVelocity.Multiply(_loc4_.m_linearDamping);
  104.                _loc4_.m_angularVelocity *= _loc4_.m_angularDamping;
  105.                _loc4_.m_position0.SetV(_loc4_.m_position);
  106.                _loc4_.m_rotation0 = _loc4_.m_rotation;
  107.             }
  108.             _loc3_++;
  109.          }
  110.          var _loc5_:b2ContactSolver;
  111.          (_loc5_ = new b2ContactSolver(m_contacts,m_contactCount,m_allocator)).PreSolve();
  112.          _loc3_ = 0;
  113.          while(_loc3_ < m_jointCount)
  114.          {
  115.             m_joints[_loc3_].PrepareVelocitySolver();
  116.             _loc3_++;
  117.          }
  118.          _loc3_ = 0;
  119.          while(_loc3_ < param1.iterations)
  120.          {
  121.             _loc5_.SolveVelocityConstraints();
  122.             _loc6_ = 0;
  123.             while(_loc6_ < m_jointCount)
  124.             {
  125.                m_joints[_loc6_].SolveVelocityConstraints(param1);
  126.                _loc6_++;
  127.             }
  128.             _loc3_++;
  129.          }
  130.          _loc3_ = 0;
  131.          while(_loc3_ < m_bodyCount)
  132.          {
  133.             if((_loc4_ = m_bodies[_loc3_]).m_invMass != 0)
  134.             {
  135.                _loc4_.m_position.x += param1.dt * _loc4_.m_linearVelocity.x;
  136.                _loc4_.m_position.y += param1.dt * _loc4_.m_linearVelocity.y;
  137.                _loc4_.m_rotation += param1.dt * _loc4_.m_angularVelocity;
  138.                _loc4_.m_R.Set(_loc4_.m_rotation);
  139.             }
  140.             _loc3_++;
  141.          }
  142.          _loc3_ = 0;
  143.          while(_loc3_ < m_jointCount)
  144.          {
  145.             m_joints[_loc3_].PreparePositionSolver();
  146.             _loc3_++;
  147.          }
  148.          if(b2World.s_enablePositionCorrection)
  149.          {
  150.             m_positionIterationCount = 0;
  151.             while(m_positionIterationCount < param1.iterations)
  152.             {
  153.                _loc7_ = _loc5_.SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
  154.                _loc8_ = true;
  155.                _loc3_ = 0;
  156.                while(_loc3_ < m_jointCount)
  157.                {
  158.                   _loc9_ = Boolean(m_joints[_loc3_].SolvePositionConstraints());
  159.                   _loc8_ &&= _loc9_;
  160.                   _loc3_++;
  161.                }
  162.                if(_loc7_ && _loc8_)
  163.                {
  164.                   break;
  165.                }
  166.                ++m_positionIterationCount;
  167.             }
  168.          }
  169.          _loc5_.PostSolve();
  170.          _loc3_ = 0;
  171.          while(_loc3_ < m_bodyCount)
  172.          {
  173.             if((_loc4_ = m_bodies[_loc3_]).m_invMass != 0)
  174.             {
  175.                _loc4_.m_R.Set(_loc4_.m_rotation);
  176.                _loc4_.SynchronizeShapes();
  177.                _loc4_.m_force.Set(0,0);
  178.                _loc4_.m_torque = 0;
  179.             }
  180.             _loc3_++;
  181.          }
  182.       }
  183.       
  184.       public function Clear() : void
  185.       {
  186.          m_bodyCount = 0;
  187.          m_contactCount = 0;
  188.          m_jointCount = 0;
  189.       }
  190.       
  191.       public function UpdateSleep(param1:Number) : void
  192.       {
  193.          var _loc2_:int = 0;
  194.          var _loc3_:b2Body = null;
  195.          var _loc4_:Number = Number.MAX_VALUE;
  196.          var _loc5_:Number = b2Settings.b2_linearSleepTolerance * b2Settings.b2_linearSleepTolerance;
  197.          var _loc6_:Number = b2Settings.b2_angularSleepTolerance * b2Settings.b2_angularSleepTolerance;
  198.          _loc2_ = 0;
  199.          while(_loc2_ < m_bodyCount)
  200.          {
  201.             _loc3_ = m_bodies[_loc2_];
  202.             if(_loc3_.m_invMass != 0)
  203.             {
  204.                if((_loc3_.m_flags & b2Body.e_allowSleepFlag) == 0)
  205.                {
  206.                   _loc3_.m_sleepTime = 0;
  207.                   _loc4_ = 0;
  208.                }
  209.                if((_loc3_.m_flags & b2Body.e_allowSleepFlag) == 0 || _loc3_.m_angularVelocity * _loc3_.m_angularVelocity > _loc6_ || b2Math.b2Dot(_loc3_.m_linearVelocity,_loc3_.m_linearVelocity) > _loc5_)
  210.                {
  211.                   _loc3_.m_sleepTime = 0;
  212.                   _loc4_ = 0;
  213.                }
  214.                else
  215.                {
  216.                   _loc3_.m_sleepTime += param1;
  217.                   _loc4_ = b2Math.b2Min(_loc4_,_loc3_.m_sleepTime);
  218.                }
  219.             }
  220.             _loc2_++;
  221.          }
  222.          if(_loc4_ >= b2Settings.b2_timeToSleep)
  223.          {
  224.             _loc2_ = 0;
  225.             while(_loc2_ < m_bodyCount)
  226.             {
  227.                _loc3_ = m_bodies[_loc2_];
  228.                _loc3_.m_flags |= b2Body.e_sleepFlag;
  229.                _loc2_++;
  230.             }
  231.          }
  232.       }
  233.    }
  234. }
  235.