home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / pup_idol.swf / scripts / Box2D / Collision / b2PairManager.as < prev    next >
Encoding:
Text File  |  2008-08-07  |  8.6 KB  |  281 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Common.*;
  4.    import Box2D.Common.Math.*;
  5.    
  6.    public class b2PairManager
  7.    {
  8.        
  9.       
  10.       public var m_pairCount:int;
  11.       
  12.       public var m_pairBuffer:Array;
  13.       
  14.       public var m_hashTable:Array;
  15.       
  16.       public var m_callback:b2PairCallback;
  17.       
  18.       public var m_pairs:Array;
  19.       
  20.       public var m_pairBufferCount:int;
  21.       
  22.       public var m_broadPhase:b2BroadPhase;
  23.       
  24.       public var m_freePair:uint;
  25.       
  26.       public function b2PairManager()
  27.       {
  28.          var _loc1_:uint = 0;
  29.          super();
  30.          m_hashTable = new Array(b2Pair.b2_tableCapacity);
  31.          _loc1_ = 0;
  32.          while(_loc1_ < b2Pair.b2_tableCapacity)
  33.          {
  34.             m_hashTable[_loc1_] = b2Pair.b2_nullPair;
  35.             _loc1_++;
  36.          }
  37.          m_pairs = new Array(b2Settings.b2_maxPairs);
  38.          _loc1_ = 0;
  39.          while(_loc1_ < b2Settings.b2_maxPairs)
  40.          {
  41.             m_pairs[_loc1_] = new b2Pair();
  42.             _loc1_++;
  43.          }
  44.          m_pairBuffer = new Array(b2Settings.b2_maxPairs);
  45.          _loc1_ = 0;
  46.          while(_loc1_ < b2Settings.b2_maxPairs)
  47.          {
  48.             m_pairBuffer[_loc1_] = new b2BufferedPair();
  49.             _loc1_++;
  50.          }
  51.          _loc1_ = 0;
  52.          while(_loc1_ < b2Settings.b2_maxPairs)
  53.          {
  54.             m_pairs[_loc1_].proxyId1 = b2Pair.b2_nullProxy;
  55.             m_pairs[_loc1_].proxyId2 = b2Pair.b2_nullProxy;
  56.             m_pairs[_loc1_].userData = null;
  57.             m_pairs[_loc1_].status = 0;
  58.             m_pairs[_loc1_].next = _loc1_ + 1;
  59.             _loc1_++;
  60.          }
  61.          m_pairs[b2Settings.b2_maxPairs - 1].next = b2Pair.b2_nullPair;
  62.          m_pairCount = 0;
  63.       }
  64.       
  65.       public static function EqualsPair(param1:b2BufferedPair, param2:b2BufferedPair) : Boolean
  66.       {
  67.          return param1.proxyId1 == param2.proxyId1 && param1.proxyId2 == param2.proxyId2;
  68.       }
  69.       
  70.       public static function Hash(param1:uint, param2:uint) : uint
  71.       {
  72.          var _loc3_:uint = uint(param2 << 16 & 4294901760 | param1);
  73.          _loc3_ = uint(~_loc3_ + (_loc3_ << 15 & 4294934528));
  74.          _loc3_ ^= _loc3_ >> 12 & 1048575;
  75.          _loc3_ += _loc3_ << 2 & 4294967292;
  76.          _loc3_ ^= _loc3_ >> 4 & 268435455;
  77.          _loc3_ *= 2057;
  78.          return uint(_loc3_ ^ _loc3_ >> 16 & 65535);
  79.       }
  80.       
  81.       public static function Equals(param1:b2Pair, param2:uint, param3:uint) : Boolean
  82.       {
  83.          return param1.proxyId1 == param2 && param1.proxyId2 == param3;
  84.       }
  85.       
  86.       private function FindHash(param1:uint, param2:uint, param3:uint) : b2Pair
  87.       {
  88.          var _loc4_:uint = uint(m_hashTable[param3]);
  89.          while(_loc4_ != b2Pair.b2_nullPair && Equals(m_pairs[_loc4_],param1,param2) == false)
  90.          {
  91.             _loc4_ = uint(m_pairs[_loc4_].next);
  92.          }
  93.          if(_loc4_ == b2Pair.b2_nullPair)
  94.          {
  95.             return null;
  96.          }
  97.          return m_pairs[_loc4_];
  98.       }
  99.       
  100.       private function Find(param1:uint, param2:uint) : b2Pair
  101.       {
  102.          var _loc4_:uint = 0;
  103.          if(param1 > param2)
  104.          {
  105.             _loc4_ = param1;
  106.             param1 = param2;
  107.             param2 = _loc4_;
  108.          }
  109.          var _loc3_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  110.          return FindHash(param1,param2,_loc3_);
  111.       }
  112.       
  113.       private function ValidateBuffer() : void
  114.       {
  115.       }
  116.       
  117.       public function Commit() : void
  118.       {
  119.          var _loc1_:int = 0;
  120.          var _loc4_:b2Pair = null;
  121.          var _loc5_:b2Proxy = null;
  122.          var _loc6_:b2Proxy = null;
  123.          var _loc2_:int = 0;
  124.          var _loc3_:Array = m_broadPhase.m_proxyPool;
  125.          _loc1_ = 0;
  126.          while(_loc1_ < m_pairBufferCount)
  127.          {
  128.             (_loc4_ = Find(m_pairBuffer[_loc1_].proxyId1,m_pairBuffer[_loc1_].proxyId2)).ClearBuffered();
  129.             _loc5_ = _loc3_[_loc4_.proxyId1];
  130.             _loc6_ = _loc3_[_loc4_.proxyId2];
  131.             if(_loc4_.IsRemoved())
  132.             {
  133.                if(_loc4_.IsFinal() == true)
  134.                {
  135.                   m_callback.PairRemoved(_loc5_.userData,_loc6_.userData,_loc4_.userData);
  136.                }
  137.                m_pairBuffer[_loc2_].proxyId1 = _loc4_.proxyId1;
  138.                m_pairBuffer[_loc2_].proxyId2 = _loc4_.proxyId2;
  139.                _loc2_++;
  140.             }
  141.             else if(_loc4_.IsFinal() == false)
  142.             {
  143.                _loc4_.userData = m_callback.PairAdded(_loc5_.userData,_loc6_.userData);
  144.                _loc4_.SetFinal();
  145.             }
  146.             _loc1_++;
  147.          }
  148.          _loc1_ = 0;
  149.          while(_loc1_ < _loc2_)
  150.          {
  151.             RemovePair(m_pairBuffer[_loc1_].proxyId1,m_pairBuffer[_loc1_].proxyId2);
  152.             _loc1_++;
  153.          }
  154.          m_pairBufferCount = 0;
  155.          if(b2BroadPhase.s_validate)
  156.          {
  157.             ValidateTable();
  158.          }
  159.       }
  160.       
  161.       public function RemoveBufferedPair(param1:int, param2:int) : void
  162.       {
  163.          var _loc3_:b2Pair = Find(param1,param2);
  164.          if(_loc3_ == null)
  165.          {
  166.             return;
  167.          }
  168.          if(_loc3_.IsBuffered() == false)
  169.          {
  170.             _loc3_.SetBuffered();
  171.             m_pairBuffer[m_pairBufferCount].proxyId1 = _loc3_.proxyId1;
  172.             m_pairBuffer[m_pairBufferCount].proxyId2 = _loc3_.proxyId2;
  173.             ++m_pairBufferCount;
  174.          }
  175.          _loc3_.SetRemoved();
  176.          if(b2BroadPhase.s_validate)
  177.          {
  178.             ValidateBuffer();
  179.          }
  180.       }
  181.       
  182.       private function RemovePair(param1:uint, param2:uint) : *
  183.       {
  184.          var _loc6_:uint = 0;
  185.          var _loc7_:uint = 0;
  186.          var _loc8_:b2Pair = null;
  187.          var _loc9_:* = undefined;
  188.          if(param1 > param2)
  189.          {
  190.             _loc6_ = param1;
  191.             param1 = param2;
  192.             param2 = _loc6_;
  193.          }
  194.          var _loc3_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  195.          var _loc4_:uint = uint(m_hashTable[_loc3_]);
  196.          var _loc5_:b2Pair = null;
  197.          while(_loc4_ != b2Pair.b2_nullPair)
  198.          {
  199.             if(Equals(m_pairs[_loc4_],param1,param2))
  200.             {
  201.                _loc7_ = _loc4_;
  202.                if(_loc5_)
  203.                {
  204.                   _loc5_.next = m_pairs[_loc4_].next;
  205.                }
  206.                else
  207.                {
  208.                   m_hashTable[_loc3_] = m_pairs[_loc4_].next;
  209.                }
  210.                _loc9_ = (_loc8_ = m_pairs[_loc7_]).userData;
  211.                _loc8_.next = m_freePair;
  212.                _loc8_.proxyId1 = b2Pair.b2_nullProxy;
  213.                _loc8_.proxyId2 = b2Pair.b2_nullProxy;
  214.                _loc8_.userData = null;
  215.                _loc8_.status = 0;
  216.                m_freePair = _loc7_;
  217.                --m_pairCount;
  218.                return _loc9_;
  219.             }
  220.             _loc4_ = (_loc5_ = m_pairs[_loc4_]).next;
  221.          }
  222.          return null;
  223.       }
  224.       
  225.       public function Initialize(param1:b2BroadPhase, param2:b2PairCallback) : void
  226.       {
  227.          m_broadPhase = param1;
  228.          m_callback = param2;
  229.       }
  230.       
  231.       public function AddBufferedPair(param1:int, param2:int) : void
  232.       {
  233.          var _loc3_:b2Pair = AddPair(param1,param2);
  234.          if(_loc3_.IsBuffered() == false)
  235.          {
  236.             _loc3_.SetBuffered();
  237.             m_pairBuffer[m_pairBufferCount].proxyId1 = _loc3_.proxyId1;
  238.             m_pairBuffer[m_pairBufferCount].proxyId2 = _loc3_.proxyId2;
  239.             ++m_pairBufferCount;
  240.          }
  241.          _loc3_.ClearRemoved();
  242.          if(b2BroadPhase.s_validate)
  243.          {
  244.             ValidateBuffer();
  245.          }
  246.       }
  247.       
  248.       private function AddPair(param1:uint, param2:uint) : b2Pair
  249.       {
  250.          var _loc6_:uint = 0;
  251.          if(param1 > param2)
  252.          {
  253.             _loc6_ = param1;
  254.             param1 = param2;
  255.             param2 = _loc6_;
  256.          }
  257.          var _loc3_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
  258.          var _loc4_:b2Pair;
  259.          if((_loc4_ = _loc4_ = FindHash(param1,param2,_loc3_)) != null)
  260.          {
  261.             return _loc4_;
  262.          }
  263.          var _loc5_:uint = m_freePair;
  264.          _loc4_ = m_pairs[_loc5_];
  265.          m_freePair = _loc4_.next;
  266.          _loc4_.proxyId1 = param1;
  267.          _loc4_.proxyId2 = param2;
  268.          _loc4_.status = 0;
  269.          _loc4_.userData = null;
  270.          _loc4_.next = m_hashTable[_loc3_];
  271.          m_hashTable[_loc3_] = _loc5_;
  272.          ++m_pairCount;
  273.          return _loc4_;
  274.       }
  275.       
  276.       private function ValidateTable() : void
  277.       {
  278.       }
  279.    }
  280. }
  281.