home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / pup_idol.swf / scripts / Box2D / Collision / b2Collision.as < prev    next >
Encoding:
Text File  |  2008-08-07  |  21.8 KB  |  554 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Collision.Shapes.*;
  4.    import Box2D.Common.*;
  5.    import Box2D.Common.Math.*;
  6.    
  7.    public class b2Collision
  8.    {
  9.       
  10.       public static const b2_nullFeature:uint = 255;
  11.       
  12.       private static var b2CollidePolyTempVec:b2Vec2 = new b2Vec2();
  13.        
  14.       
  15.       public function b2Collision()
  16.       {
  17.          super();
  18.       }
  19.       
  20.       public static function EdgeSeparation(param1:b2PolyShape, param2:int, param3:b2PolyShape) : Number
  21.       {
  22.          var _loc21_:b2Vec2 = null;
  23.          var _loc22_:Number = NaN;
  24.          var _loc4_:Array = param1.m_vertices;
  25.          var _loc5_:int = param3.m_vertexCount;
  26.          var _loc6_:Array = param3.m_vertices;
  27.          var _loc7_:Number = Number(param1.m_normals[param2].x);
  28.          var _loc8_:Number = Number(param1.m_normals[param2].y);
  29.          var _loc9_:Number = _loc7_;
  30.          var _loc10_:b2Mat22;
  31.          _loc7_ = (_loc10_ = param1.m_R).col1.x * _loc9_ + _loc10_.col2.x * _loc8_;
  32.          _loc8_ = _loc10_.col1.y * _loc9_ + _loc10_.col2.y * _loc8_;
  33.          var _loc11_:Number = _loc7_;
  34.          var _loc12_:Number = _loc8_;
  35.          _loc10_ = param3.m_R;
  36.          _loc9_ = _loc11_ * _loc10_.col1.x + _loc12_ * _loc10_.col1.y;
  37.          _loc12_ = _loc11_ * _loc10_.col2.x + _loc12_ * _loc10_.col2.y;
  38.          _loc11_ = _loc9_;
  39.          var _loc13_:int = 0;
  40.          var _loc14_:Number = Number.MAX_VALUE;
  41.          var _loc15_:int = 0;
  42.          while(_loc15_ < _loc5_)
  43.          {
  44.             if((_loc22_ = (_loc21_ = _loc6_[_loc15_]).x * _loc11_ + _loc21_.y * _loc12_) < _loc14_)
  45.             {
  46.                _loc14_ = _loc22_;
  47.                _loc13_ = _loc15_;
  48.             }
  49.             _loc15_++;
  50.          }
  51.          _loc10_ = param1.m_R;
  52.          var _loc16_:Number = param1.m_position.x + (_loc10_.col1.x * _loc4_[param2].x + _loc10_.col2.x * _loc4_[param2].y);
  53.          var _loc17_:Number = param1.m_position.y + (_loc10_.col1.y * _loc4_[param2].x + _loc10_.col2.y * _loc4_[param2].y);
  54.          _loc10_ = param3.m_R;
  55.          var _loc18_:Number = param3.m_position.x + (_loc10_.col1.x * _loc6_[_loc13_].x + _loc10_.col2.x * _loc6_[_loc13_].y);
  56.          var _loc19_:Number = param3.m_position.y + (_loc10_.col1.y * _loc6_[_loc13_].x + _loc10_.col2.y * _loc6_[_loc13_].y);
  57.          _loc18_ -= _loc16_;
  58.          _loc19_ -= _loc17_;
  59.          return _loc18_ * _loc7_ + _loc19_ * _loc8_;
  60.       }
  61.       
  62.       public static function b2TestOverlap(param1:b2AABB, param2:b2AABB) : Boolean
  63.       {
  64.          var _loc3_:b2Vec2 = param2.minVertex;
  65.          var _loc4_:b2Vec2 = param1.maxVertex;
  66.          var _loc5_:Number = _loc3_.x - _loc4_.x;
  67.          var _loc6_:Number = _loc3_.y - _loc4_.y;
  68.          _loc3_ = param1.minVertex;
  69.          _loc4_ = param2.maxVertex;
  70.          var _loc7_:Number = _loc3_.x - _loc4_.x;
  71.          var _loc8_:Number = _loc3_.y - _loc4_.y;
  72.          if(_loc5_ > 0 || _loc6_ > 0)
  73.          {
  74.             return false;
  75.          }
  76.          if(_loc7_ > 0 || _loc8_ > 0)
  77.          {
  78.             return false;
  79.          }
  80.          return true;
  81.       }
  82.       
  83.       public static function FindIncidentEdge(param1:Array, param2:b2PolyShape, param3:int, param4:b2PolyShape) : void
  84.       {
  85.          var _loc21_:int = 0;
  86.          var _loc22_:int = 0;
  87.          var _loc25_:ClipVertex = null;
  88.          var _loc26_:int = 0;
  89.          var _loc27_:int = 0;
  90.          var _loc28_:Number = NaN;
  91.          var _loc29_:Number = NaN;
  92.          var _loc30_:Number = NaN;
  93.          var _loc5_:int = param2.m_vertexCount;
  94.          var _loc6_:Array = param2.m_vertices;
  95.          var _loc7_:int = param4.m_vertexCount;
  96.          var _loc8_:Array = param4.m_vertices;
  97.          var _loc9_:int = param3;
  98.          var _loc10_:int = param3 + 1 == _loc5_ ? 0 : param3 + 1;
  99.          var _loc11_:b2Vec2;
  100.          var _loc12_:Number = (_loc11_ = _loc6_[_loc10_]).x;
  101.          var _loc13_:Number = _loc11_.y;
  102.          _loc11_ = _loc6_[_loc9_];
  103.          _loc12_ -= _loc11_.x;
  104.          _loc13_ -= _loc11_.y;
  105.          var _loc14_:Number = _loc12_;
  106.          _loc12_ = _loc13_;
  107.          _loc13_ = -_loc14_;
  108.          var _loc15_:Number = 1 / Math.sqrt(_loc12_ * _loc12_ + _loc13_ * _loc13_);
  109.          _loc12_ *= _loc15_;
  110.          _loc13_ *= _loc15_;
  111.          var _loc16_:Number = _loc12_;
  112.          var _loc17_:Number = _loc13_;
  113.          _loc14_ = _loc16_;
  114.          var _loc18_:b2Mat22;
  115.          _loc16_ = (_loc18_ = param2.m_R).col1.x * _loc14_ + _loc18_.col2.x * _loc17_;
  116.          _loc17_ = _loc18_.col1.y * _loc14_ + _loc18_.col2.y * _loc17_;
  117.          var _loc19_:Number = _loc16_;
  118.          var _loc20_:Number = _loc17_;
  119.          _loc18_ = param4.m_R;
  120.          _loc14_ = _loc19_ * _loc18_.col1.x + _loc20_ * _loc18_.col1.y;
  121.          _loc20_ = _loc19_ * _loc18_.col2.x + _loc20_ * _loc18_.col2.y;
  122.          _loc19_ = _loc14_;
  123.          var _loc23_:Number = Number.MAX_VALUE;
  124.          var _loc24_:int = 0;
  125.          while(_loc24_ < _loc7_)
  126.          {
  127.             _loc26_ = _loc24_;
  128.             _loc27_ = _loc24_ + 1 < _loc7_ ? _loc24_ + 1 : 0;
  129.             _loc28_ = (_loc11_ = _loc8_[_loc27_]).x;
  130.             _loc29_ = _loc11_.y;
  131.             _loc11_ = _loc8_[_loc26_];
  132.             _loc28_ -= _loc11_.x;
  133.             _loc29_ -= _loc11_.y;
  134.             _loc14_ = _loc28_;
  135.             _loc28_ = _loc29_;
  136.             _loc29_ = -_loc14_;
  137.             _loc15_ = 1 / Math.sqrt(_loc28_ * _loc28_ + _loc29_ * _loc29_);
  138.             _loc28_ *= _loc15_;
  139.             _loc29_ *= _loc15_;
  140.             if((_loc30_ = _loc28_ * _loc19_ + _loc29_ * _loc20_) < _loc23_)
  141.             {
  142.                _loc23_ = _loc30_;
  143.                _loc21_ = _loc26_;
  144.                _loc22_ = _loc27_;
  145.             }
  146.             _loc24_++;
  147.          }
  148.          (_loc11_ = (_loc25_ = param1[0]).v).SetV(_loc8_[_loc21_]);
  149.          _loc11_.MulM(param4.m_R);
  150.          _loc11_.Add(param4.m_position);
  151.          _loc25_.id.features.referenceFace = param3;
  152.          _loc25_.id.features.incidentEdge = _loc21_;
  153.          _loc25_.id.features.incidentVertex = _loc21_;
  154.          (_loc11_ = (_loc25_ = param1[1]).v).SetV(_loc8_[_loc22_]);
  155.          _loc11_.MulM(param4.m_R);
  156.          _loc11_.Add(param4.m_position);
  157.          _loc25_.id.features.referenceFace = param3;
  158.          _loc25_.id.features.incidentEdge = _loc21_;
  159.          _loc25_.id.features.incidentVertex = _loc22_;
  160.       }
  161.       
  162.       public static function b2CollidePolyAndCircle(param1:b2Manifold, param2:b2PolyShape, param3:b2CircleShape, param4:Boolean) : void
  163.       {
  164.          var _loc5_:b2ContactPoint = null;
  165.          var _loc6_:Number = NaN;
  166.          var _loc7_:Number = NaN;
  167.          var _loc12_:Number = NaN;
  168.          var _loc23_:Number = NaN;
  169.          var _loc24_:Number = NaN;
  170.          var _loc25_:Number = NaN;
  171.          var _loc26_:b2Vec2 = null;
  172.          param1.pointCount = 0;
  173.          var _loc8_:Number = param3.m_position.x - param2.m_position.x;
  174.          var _loc9_:Number = param3.m_position.y - param2.m_position.y;
  175.          var _loc10_:b2Mat22 = param2.m_R;
  176.          var _loc11_:Number = _loc8_ * _loc10_.col1.x + _loc9_ * _loc10_.col1.y;
  177.          _loc9_ = _loc8_ * _loc10_.col2.x + _loc9_ * _loc10_.col2.y;
  178.          _loc8_ = _loc11_;
  179.          var _loc13_:int = 0;
  180.          var _loc14_:Number = -Number.MAX_VALUE;
  181.          var _loc15_:Number = param3.m_radius;
  182.          var _loc16_:int = 0;
  183.          while(_loc16_ < param2.m_vertexCount)
  184.          {
  185.             if((_loc25_ = param2.m_normals[_loc16_].x * (_loc8_ - param2.m_vertices[_loc16_].x) + param2.m_normals[_loc16_].y * (_loc9_ - param2.m_vertices[_loc16_].y)) > _loc15_)
  186.             {
  187.                return;
  188.             }
  189.             if(_loc25_ > _loc14_)
  190.             {
  191.                _loc14_ = _loc25_;
  192.                _loc13_ = _loc16_;
  193.             }
  194.             _loc16_++;
  195.          }
  196.          if(_loc14_ < Number.MIN_VALUE)
  197.          {
  198.             param1.pointCount = 1;
  199.             _loc26_ = param2.m_normals[_loc13_];
  200.             param1.normal.x = _loc10_.col1.x * _loc26_.x + _loc10_.col2.x * _loc26_.y;
  201.             param1.normal.y = _loc10_.col1.y * _loc26_.x + _loc10_.col2.y * _loc26_.y;
  202.             (_loc5_ = param1.points[0]).id.features.incidentEdge = _loc13_;
  203.             _loc5_.id.features.incidentVertex = b2_nullFeature;
  204.             _loc5_.id.features.referenceFace = b2_nullFeature;
  205.             _loc5_.id.features.flip = 0;
  206.             _loc5_.position.x = param3.m_position.x - _loc15_ * param1.normal.x;
  207.             _loc5_.position.y = param3.m_position.y - _loc15_ * param1.normal.y;
  208.             _loc5_.separation = _loc14_ - _loc15_;
  209.             return;
  210.          }
  211.          var _loc17_:int;
  212.          var _loc18_:int = (_loc17_ = _loc13_) + 1 < param2.m_vertexCount ? _loc17_ + 1 : 0;
  213.          var _loc19_:Number = param2.m_vertices[_loc18_].x - param2.m_vertices[_loc17_].x;
  214.          var _loc20_:Number = param2.m_vertices[_loc18_].y - param2.m_vertices[_loc17_].y;
  215.          var _loc21_:Number = Math.sqrt(_loc19_ * _loc19_ + _loc20_ * _loc20_);
  216.          _loc19_ /= _loc21_;
  217.          _loc20_ /= _loc21_;
  218.          if(_loc21_ < Number.MIN_VALUE)
  219.          {
  220.             _loc6_ = _loc8_ - param2.m_vertices[_loc17_].x;
  221.             _loc7_ = _loc9_ - param2.m_vertices[_loc17_].y;
  222.             _loc12_ = Math.sqrt(_loc6_ * _loc6_ + _loc7_ * _loc7_);
  223.             _loc6_ /= _loc12_;
  224.             _loc7_ /= _loc12_;
  225.             if(_loc12_ > _loc15_)
  226.             {
  227.                return;
  228.             }
  229.             param1.pointCount = 1;
  230.             param1.normal.Set(_loc10_.col1.x * _loc6_ + _loc10_.col2.x * _loc7_,_loc10_.col1.y * _loc6_ + _loc10_.col2.y * _loc7_);
  231.             (_loc5_ = param1.points[0]).id.features.incidentEdge = b2_nullFeature;
  232.             _loc5_.id.features.incidentVertex = _loc17_;
  233.             _loc5_.id.features.referenceFace = b2_nullFeature;
  234.             _loc5_.id.features.flip = 0;
  235.             _loc5_.position.x = param3.m_position.x - _loc15_ * param1.normal.x;
  236.             _loc5_.position.y = param3.m_position.y - _loc15_ * param1.normal.y;
  237.             _loc5_.separation = _loc12_ - _loc15_;
  238.             return;
  239.          }
  240.          var _loc22_:Number = (_loc8_ - param2.m_vertices[_loc17_].x) * _loc19_ + (_loc9_ - param2.m_vertices[_loc17_].y) * _loc20_;
  241.          (_loc5_ = param1.points[0]).id.features.incidentEdge = b2_nullFeature;
  242.          _loc5_.id.features.incidentVertex = b2_nullFeature;
  243.          _loc5_.id.features.referenceFace = b2_nullFeature;
  244.          _loc5_.id.features.flip = 0;
  245.          if(_loc22_ <= 0)
  246.          {
  247.             _loc23_ = Number(param2.m_vertices[_loc17_].x);
  248.             _loc24_ = Number(param2.m_vertices[_loc17_].y);
  249.             _loc5_.id.features.incidentVertex = _loc17_;
  250.          }
  251.          else if(_loc22_ >= _loc21_)
  252.          {
  253.             _loc23_ = Number(param2.m_vertices[_loc18_].x);
  254.             _loc24_ = Number(param2.m_vertices[_loc18_].y);
  255.             _loc5_.id.features.incidentVertex = _loc18_;
  256.          }
  257.          else
  258.          {
  259.             _loc23_ = _loc19_ * _loc22_ + param2.m_vertices[_loc17_].x;
  260.             _loc24_ = _loc20_ * _loc22_ + param2.m_vertices[_loc17_].y;
  261.             _loc5_.id.features.incidentEdge = _loc17_;
  262.          }
  263.          _loc6_ = _loc8_ - _loc23_;
  264.          _loc7_ = _loc9_ - _loc24_;
  265.          _loc12_ = Math.sqrt(_loc6_ * _loc6_ + _loc7_ * _loc7_);
  266.          _loc6_ /= _loc12_;
  267.          _loc7_ /= _loc12_;
  268.          if(_loc12_ > _loc15_)
  269.          {
  270.             return;
  271.          }
  272.          param1.pointCount = 1;
  273.          param1.normal.Set(_loc10_.col1.x * _loc6_ + _loc10_.col2.x * _loc7_,_loc10_.col1.y * _loc6_ + _loc10_.col2.y * _loc7_);
  274.          _loc5_.position.x = param3.m_position.x - _loc15_ * param1.normal.x;
  275.          _loc5_.position.y = param3.m_position.y - _loc15_ * param1.normal.y;
  276.          _loc5_.separation = _loc12_ - _loc15_;
  277.       }
  278.       
  279.       public static function FindMaxSeparation(param1:Array, param2:b2PolyShape, param3:b2PolyShape, param4:Boolean) : Number
  280.       {
  281.          var _loc18_:int = 0;
  282.          var _loc19_:Number = NaN;
  283.          var _loc20_:int = 0;
  284.          var _loc21_:Number = NaN;
  285.          var _loc5_:int = param2.m_vertexCount;
  286.          var _loc6_:Number = param3.m_position.x - param2.m_position.x;
  287.          var _loc7_:Number = param3.m_position.y - param2.m_position.y;
  288.          var _loc8_:Number = _loc6_ * param2.m_R.col1.x + _loc7_ * param2.m_R.col1.y;
  289.          var _loc9_:Number = _loc6_ * param2.m_R.col2.x + _loc7_ * param2.m_R.col2.y;
  290.          var _loc10_:int = 0;
  291.          var _loc11_:Number = -Number.MAX_VALUE;
  292.          var _loc12_:int = 0;
  293.          while(_loc12_ < _loc5_)
  294.          {
  295.             if((_loc21_ = param2.m_normals[_loc12_].x * _loc8_ + param2.m_normals[_loc12_].y * _loc9_) > _loc11_)
  296.             {
  297.                _loc11_ = _loc21_;
  298.                _loc10_ = _loc12_;
  299.             }
  300.             _loc12_++;
  301.          }
  302.          var _loc13_:Number;
  303.          if((_loc13_ = EdgeSeparation(param2,_loc10_,param3)) > 0 && param4 == false)
  304.          {
  305.             return _loc13_;
  306.          }
  307.          var _loc14_:int = _loc10_ - 1 >= 0 ? _loc10_ - 1 : _loc5_ - 1;
  308.          var _loc15_:Number;
  309.          if((_loc15_ = EdgeSeparation(param2,_loc14_,param3)) > 0 && param4 == false)
  310.          {
  311.             return _loc15_;
  312.          }
  313.          var _loc16_:int = _loc10_ + 1 < _loc5_ ? _loc10_ + 1 : 0;
  314.          var _loc17_:Number;
  315.          if((_loc17_ = EdgeSeparation(param2,_loc16_,param3)) > 0 && param4 == false)
  316.          {
  317.             return _loc17_;
  318.          }
  319.          if(_loc15_ > _loc13_ && _loc15_ > _loc17_)
  320.          {
  321.             _loc20_ = -1;
  322.             _loc18_ = _loc14_;
  323.             _loc19_ = _loc15_;
  324.          }
  325.          else
  326.          {
  327.             if(_loc17_ <= _loc13_)
  328.             {
  329.                param1[0] = _loc10_;
  330.                return _loc13_;
  331.             }
  332.             _loc20_ = 1;
  333.             _loc18_ = _loc16_;
  334.             _loc19_ = _loc17_;
  335.          }
  336.          while(true)
  337.          {
  338.             if(_loc20_ == -1)
  339.             {
  340.                _loc10_ = _loc18_ - 1 >= 0 ? _loc18_ - 1 : _loc5_ - 1;
  341.             }
  342.             else
  343.             {
  344.                _loc10_ = _loc18_ + 1 < _loc5_ ? _loc18_ + 1 : 0;
  345.             }
  346.             if((_loc13_ = EdgeSeparation(param2,_loc10_,param3)) > 0 && param4 == false)
  347.             {
  348.                break;
  349.             }
  350.             if(_loc13_ <= _loc19_)
  351.             {
  352.                param1[0] = _loc18_;
  353.                return _loc19_;
  354.             }
  355.             _loc18_ = _loc10_;
  356.             _loc19_ = _loc13_;
  357.          }
  358.          return _loc13_;
  359.       }
  360.       
  361.       public static function ClipSegmentToLine(param1:Array, param2:Array, param3:b2Vec2, param4:Number) : int
  362.       {
  363.          var _loc7_:b2Vec2 = null;
  364.          var _loc8_:Number = NaN;
  365.          var _loc10_:Number = NaN;
  366.          var _loc11_:b2Vec2 = null;
  367.          var _loc5_:int = 0;
  368.          var _loc6_:b2Vec2 = param2[0].v;
  369.          _loc7_ = param2[1].v;
  370.          _loc8_ = b2Math.b2Dot(param3,param2[0].v) - param4;
  371.          var _loc9_:Number = b2Math.b2Dot(param3,param2[1].v) - param4;
  372.          if(_loc8_ <= 0)
  373.          {
  374.             var _loc12_:*;
  375.             param1[_loc12_ = _loc5_++] = param2[0];
  376.          }
  377.          if(_loc9_ <= 0)
  378.          {
  379.             param1[_loc12_ = _loc5_++] = param2[1];
  380.          }
  381.          if(_loc8_ * _loc9_ < 0)
  382.          {
  383.             _loc10_ = _loc8_ / (_loc8_ - _loc9_);
  384.             (_loc11_ = param1[_loc5_].v).x = _loc6_.x + _loc10_ * (_loc7_.x - _loc6_.x);
  385.             _loc11_.y = _loc6_.y + _loc10_ * (_loc7_.y - _loc6_.y);
  386.             if(_loc8_ > 0)
  387.             {
  388.                param1[_loc5_].id = param2[0].id;
  389.             }
  390.             else
  391.             {
  392.                param1[_loc5_].id = param2[1].id;
  393.             }
  394.             _loc5_++;
  395.          }
  396.          return _loc5_;
  397.       }
  398.       
  399.       public static function b2CollidePoly(param1:b2Manifold, param2:b2PolyShape, param3:b2PolyShape, param4:Boolean) : void
  400.       {
  401.          var _loc11_:b2PolyShape = null;
  402.          var _loc12_:b2PolyShape = null;
  403.          var _loc13_:int = 0;
  404.          var _loc14_:int = 0;
  405.          var _loc40_:int = 0;
  406.          var _loc43_:b2Vec2 = null;
  407.          var _loc44_:Number = NaN;
  408.          var _loc45_:b2ContactPoint = null;
  409.          param1.pointCount = 0;
  410.          var _loc5_:int;
  411.          var _loc6_:Array = [_loc5_ = 0];
  412.          var _loc7_:Number = FindMaxSeparation(_loc6_,param2,param3,param4);
  413.          _loc5_ = int(_loc6_[0]);
  414.          if(_loc7_ > 0 && param4 == false)
  415.          {
  416.             return;
  417.          }
  418.          var _loc8_:int;
  419.          var _loc9_:Array = [_loc8_ = 0];
  420.          var _loc10_:Number = FindMaxSeparation(_loc9_,param3,param2,param4);
  421.          _loc8_ = int(_loc9_[0]);
  422.          if(_loc10_ > 0 && param4 == false)
  423.          {
  424.             return;
  425.          }
  426.          var _loc15_:Number = 0.98;
  427.          var _loc16_:Number = 0.001;
  428.          if(_loc10_ > _loc15_ * _loc7_ + _loc16_)
  429.          {
  430.             _loc11_ = param3;
  431.             _loc12_ = param2;
  432.             _loc13_ = _loc8_;
  433.             _loc14_ = 1;
  434.          }
  435.          else
  436.          {
  437.             _loc11_ = param2;
  438.             _loc12_ = param3;
  439.             _loc13_ = _loc5_;
  440.             _loc14_ = 0;
  441.          }
  442.          var _loc17_:Array = [new ClipVertex(),new ClipVertex()];
  443.          FindIncidentEdge(_loc17_,_loc11_,_loc13_,_loc12_);
  444.          var _loc18_:int = _loc11_.m_vertexCount;
  445.          var _loc19_:Array;
  446.          var _loc20_:b2Vec2 = (_loc19_ = _loc11_.m_vertices)[_loc13_];
  447.          var _loc21_:b2Vec2;
  448.          var _loc22_:Number = (_loc21_ = _loc13_ + 1 < _loc18_ ? _loc19_[_loc13_ + 1] : _loc19_[0]).x - _loc20_.x;
  449.          var _loc23_:Number = _loc21_.y - _loc20_.y;
  450.          var _loc24_:Number = _loc21_.x - _loc20_.x;
  451.          var _loc25_:Number = _loc21_.y - _loc20_.y;
  452.          var _loc26_:Number = _loc24_;
  453.          var _loc27_:b2Mat22;
  454.          _loc24_ = (_loc27_ = _loc11_.m_R).col1.x * _loc26_ + _loc27_.col2.x * _loc25_;
  455.          _loc25_ = _loc27_.col1.y * _loc26_ + _loc27_.col2.y * _loc25_;
  456.          var _loc28_:Number = 1 / Math.sqrt(_loc24_ * _loc24_ + _loc25_ * _loc25_);
  457.          _loc24_ *= _loc28_;
  458.          _loc25_ *= _loc28_;
  459.          var _loc29_:Number = _loc24_;
  460.          var _loc30_:Number = _loc25_;
  461.          _loc26_ = _loc29_;
  462.          _loc29_ = _loc30_;
  463.          _loc30_ = -_loc26_;
  464.          var _loc31_:Number = _loc20_.x;
  465.          var _loc32_:Number = _loc20_.y;
  466.          _loc26_ = _loc31_;
  467.          _loc31_ = (_loc27_ = _loc11_.m_R).col1.x * _loc26_ + _loc27_.col2.x * _loc32_;
  468.          _loc32_ = _loc27_.col1.y * _loc26_ + _loc27_.col2.y * _loc32_;
  469.          _loc31_ += _loc11_.m_position.x;
  470.          _loc32_ += _loc11_.m_position.y;
  471.          var _loc33_:Number = _loc21_.x;
  472.          var _loc34_:Number = _loc21_.y;
  473.          _loc26_ = _loc33_;
  474.          _loc33_ = (_loc27_ = _loc11_.m_R).col1.x * _loc26_ + _loc27_.col2.x * _loc34_;
  475.          _loc34_ = _loc27_.col1.y * _loc26_ + _loc27_.col2.y * _loc34_;
  476.          _loc33_ += _loc11_.m_position.x;
  477.          _loc34_ += _loc11_.m_position.y;
  478.          var _loc35_:Number = _loc29_ * _loc31_ + _loc30_ * _loc32_;
  479.          var _loc36_:Number = -(_loc24_ * _loc31_ + _loc25_ * _loc32_);
  480.          var _loc37_:Number = _loc24_ * _loc33_ + _loc25_ * _loc34_;
  481.          var _loc38_:Array = [new ClipVertex(),new ClipVertex()];
  482.          var _loc39_:Array = [new ClipVertex(),new ClipVertex()];
  483.          b2CollidePolyTempVec.Set(-_loc24_,-_loc25_);
  484.          if((_loc40_ = ClipSegmentToLine(_loc38_,_loc17_,b2CollidePolyTempVec,_loc36_)) < 2)
  485.          {
  486.             return;
  487.          }
  488.          b2CollidePolyTempVec.Set(_loc24_,_loc25_);
  489.          if((_loc40_ = ClipSegmentToLine(_loc39_,_loc38_,b2CollidePolyTempVec,_loc37_)) < 2)
  490.          {
  491.             return;
  492.          }
  493.          if(_loc14_)
  494.          {
  495.             param1.normal.Set(-_loc29_,-_loc30_);
  496.          }
  497.          else
  498.          {
  499.             param1.normal.Set(_loc29_,_loc30_);
  500.          }
  501.          var _loc41_:int = 0;
  502.          var _loc42_:int = 0;
  503.          while(_loc42_ < b2Settings.b2_maxManifoldPoints)
  504.          {
  505.             _loc43_ = _loc39_[_loc42_].v;
  506.             if((_loc44_ = _loc29_ * _loc43_.x + _loc30_ * _loc43_.y - _loc35_) <= 0 || param4 == true)
  507.             {
  508.                (_loc45_ = param1.points[_loc41_]).separation = _loc44_;
  509.                _loc45_.position.SetV(_loc39_[_loc42_].v);
  510.                _loc45_.id.Set(_loc39_[_loc42_].id);
  511.                _loc45_.id.features.flip = _loc14_;
  512.                _loc41_++;
  513.             }
  514.             _loc42_++;
  515.          }
  516.          param1.pointCount = _loc41_;
  517.       }
  518.       
  519.       public static function b2CollideCircle(param1:b2Manifold, param2:b2CircleShape, param3:b2CircleShape, param4:Boolean) : void
  520.       {
  521.          var _loc9_:Number = NaN;
  522.          var _loc11_:Number = NaN;
  523.          var _loc12_:Number = NaN;
  524.          param1.pointCount = 0;
  525.          var _loc5_:Number = param3.m_position.x - param2.m_position.x;
  526.          var _loc6_:Number = param3.m_position.y - param2.m_position.y;
  527.          var _loc7_:Number = _loc5_ * _loc5_ + _loc6_ * _loc6_;
  528.          var _loc8_:Number = param2.m_radius + param3.m_radius;
  529.          if(_loc7_ > _loc8_ * _loc8_ && param4 == false)
  530.          {
  531.             return;
  532.          }
  533.          if(_loc7_ < Number.MIN_VALUE)
  534.          {
  535.             _loc9_ = -_loc8_;
  536.             param1.normal.Set(0,1);
  537.          }
  538.          else
  539.          {
  540.             _loc9_ = (_loc11_ = Math.sqrt(_loc7_)) - _loc8_;
  541.             _loc12_ = 1 / _loc11_;
  542.             param1.normal.x = _loc12_ * _loc5_;
  543.             param1.normal.y = _loc12_ * _loc6_;
  544.          }
  545.          param1.pointCount = 1;
  546.          var _loc10_:b2ContactPoint;
  547.          (_loc10_ = param1.points[0]).id.key = 0;
  548.          _loc10_.separation = _loc9_;
  549.          _loc10_.position.x = param3.m_position.x - param3.m_radius * param1.normal.x;
  550.          _loc10_.position.y = param3.m_position.y - param3.m_radius * param1.normal.y;
  551.       }
  552.    }
  553. }
  554.