home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / org / cove / ape / CollisionDetector.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  8.8 KB  |  262 lines
  1. package org.cove.ape
  2. {
  3.    internal final class CollisionDetector
  4.    {
  5.        
  6.       
  7.       public function CollisionDetector()
  8.       {
  9.          super();
  10.       }
  11.       
  12.       private static function testOBBvsCircle(param1:RectangleParticle, param2:CircleParticle) : Boolean
  13.       {
  14.          var _loc3_:Vector = null;
  15.          var _loc4_:Number = NaN;
  16.          var _loc5_:Array = null;
  17.          var _loc6_:int = 0;
  18.          var _loc7_:Number = NaN;
  19.          var _loc8_:Vector = null;
  20.          var _loc9_:Number = NaN;
  21.          var _loc10_:Vector = null;
  22.          var _loc11_:Number = NaN;
  23.          _loc4_ = Number.POSITIVE_INFINITY;
  24.          _loc5_ = new Array(2);
  25.          _loc6_ = 0;
  26.          while(_loc6_ < 2)
  27.          {
  28.             _loc8_ = param1.axes[_loc6_];
  29.             if((_loc9_ = testIntervals(param1.getProjection(_loc8_),param2.getProjection(_loc8_))) == 0)
  30.             {
  31.                return false;
  32.             }
  33.             if(Math.abs(_loc9_) < Math.abs(_loc4_))
  34.             {
  35.                _loc3_ = _loc8_;
  36.                _loc4_ = _loc9_;
  37.             }
  38.             _loc5_[_loc6_] = _loc9_;
  39.             _loc6_++;
  40.          }
  41.          _loc7_ = param2.radius;
  42.          if(Math.abs(_loc5_[0]) < _loc7_ && Math.abs(_loc5_[1]) < _loc7_)
  43.          {
  44.             _loc3_ = (_loc10_ = closestVertexOnOBB(param2.samp,param1)).minus(param2.samp);
  45.             _loc11_ = _loc3_.magnitude();
  46.             if((_loc4_ = _loc7_ - _loc11_) <= 0)
  47.             {
  48.                return false;
  49.             }
  50.             _loc3_.divEquals(_loc11_);
  51.          }
  52.          CollisionResolver.resolveParticleParticle(param1,param2,_loc3_,_loc4_);
  53.          return true;
  54.       }
  55.       
  56.       internal static function test(param1:AbstractParticle, param2:AbstractParticle) : void
  57.       {
  58.          if(param1.fixed && param2.fixed)
  59.          {
  60.             return;
  61.          }
  62.          if(param1.multisample == 0 && param2.multisample == 0)
  63.          {
  64.             normVsNorm(param1,param2);
  65.          }
  66.          else if(param1.multisample > 0 && param2.multisample == 0)
  67.          {
  68.             sampVsNorm(param1,param2);
  69.          }
  70.          else if(param2.multisample > 0 && param1.multisample == 0)
  71.          {
  72.             sampVsNorm(param2,param1);
  73.          }
  74.          else if(param1.multisample == param2.multisample)
  75.          {
  76.             sampVsSamp(param1,param2);
  77.          }
  78.          else
  79.          {
  80.             normVsNorm(param1,param2);
  81.          }
  82.       }
  83.       
  84.       private static function testIntervals(param1:Interval, param2:Interval) : Number
  85.       {
  86.          var _loc3_:Number = NaN;
  87.          var _loc4_:Number = NaN;
  88.          if(param1.max < param2.min)
  89.          {
  90.             return 0;
  91.          }
  92.          if(param2.max < param1.min)
  93.          {
  94.             return 0;
  95.          }
  96.          _loc3_ = param2.max - param1.min;
  97.          _loc4_ = param2.min - param1.max;
  98.          return Math.abs(_loc3_) < Math.abs(_loc4_) ? _loc3_ : _loc4_;
  99.       }
  100.       
  101.       private static function normVsNorm(param1:AbstractParticle, param2:AbstractParticle) : void
  102.       {
  103.          param1.samp.copy(param1.curr);
  104.          param2.samp.copy(param2.curr);
  105.          testTypes(param1,param2);
  106.       }
  107.       
  108.       private static function testCirclevsCircle(param1:CircleParticle, param2:CircleParticle) : Boolean
  109.       {
  110.          var _loc3_:Number = NaN;
  111.          var _loc4_:Number = NaN;
  112.          var _loc5_:Vector = null;
  113.          var _loc6_:Number = NaN;
  114.          var _loc7_:Number = NaN;
  115.          _loc3_ = testIntervals(param1.getIntervalX(),param2.getIntervalX());
  116.          if(_loc3_ == 0)
  117.          {
  118.             return false;
  119.          }
  120.          if((_loc4_ = testIntervals(param1.getIntervalY(),param2.getIntervalY())) == 0)
  121.          {
  122.             return false;
  123.          }
  124.          _loc6_ = (_loc5_ = param1.samp.minus(param2.samp)).magnitude();
  125.          if((_loc7_ = param1.radius + param2.radius - _loc6_) > 0)
  126.          {
  127.             _loc5_.divEquals(_loc6_);
  128.             CollisionResolver.resolveParticleParticle(param1,param2,_loc5_,_loc7_);
  129.             return true;
  130.          }
  131.          return false;
  132.       }
  133.       
  134.       private static function testTypes(param1:AbstractParticle, param2:AbstractParticle) : Boolean
  135.       {
  136.          if(param1 is RectangleParticle && param2 is RectangleParticle)
  137.          {
  138.             return testOBBvsOBB(param1 as RectangleParticle,param2 as RectangleParticle);
  139.          }
  140.          if(param1 is CircleParticle && param2 is CircleParticle)
  141.          {
  142.             return testCirclevsCircle(param1 as CircleParticle,param2 as CircleParticle);
  143.          }
  144.          if(param1 is RectangleParticle && param2 is CircleParticle)
  145.          {
  146.             return testOBBvsCircle(param1 as RectangleParticle,param2 as CircleParticle);
  147.          }
  148.          if(param1 is CircleParticle && param2 is RectangleParticle)
  149.          {
  150.             return testOBBvsCircle(param2 as RectangleParticle,param1 as CircleParticle);
  151.          }
  152.          return false;
  153.       }
  154.       
  155.       private static function sampVsNorm(param1:AbstractParticle, param2:AbstractParticle) : void
  156.       {
  157.          var _loc3_:Number = NaN;
  158.          var _loc4_:Number = NaN;
  159.          var _loc5_:int = 0;
  160.          _loc3_ = 1 / (param1.multisample + 1);
  161.          _loc4_ = _loc3_;
  162.          param2.samp.copy(param2.curr);
  163.          _loc5_ = 0;
  164.          while(_loc5_ <= param1.multisample)
  165.          {
  166.             param1.samp.setTo(param1.prev.x + _loc4_ * (param1.curr.x - param1.prev.x),param1.prev.y + _loc4_ * (param1.curr.y - param1.prev.y));
  167.             if(testTypes(param1,param2))
  168.             {
  169.                return;
  170.             }
  171.             _loc4_ += _loc3_;
  172.             _loc5_++;
  173.          }
  174.       }
  175.       
  176.       private static function closestVertexOnOBB(param1:Vector, param2:RectangleParticle) : Vector
  177.       {
  178.          var _loc3_:Vector = null;
  179.          var _loc4_:Vector = null;
  180.          var _loc5_:int = 0;
  181.          var _loc6_:Number = NaN;
  182.          _loc3_ = param1.minus(param2.samp);
  183.          _loc4_ = new Vector(param2.samp.x,param2.samp.y);
  184.          _loc5_ = 0;
  185.          while(_loc5_ < 2)
  186.          {
  187.             if((_loc6_ = _loc3_.dot(param2.axes[_loc5_])) >= 0)
  188.             {
  189.                _loc6_ = Number(param2.extents[_loc5_]);
  190.             }
  191.             else if(_loc6_ < 0)
  192.             {
  193.                _loc6_ = -param2.extents[_loc5_];
  194.             }
  195.             _loc4_.plusEquals(param2.axes[_loc5_].mult(_loc6_));
  196.             _loc5_++;
  197.          }
  198.          return _loc4_;
  199.       }
  200.       
  201.       private static function testOBBvsOBB(param1:RectangleParticle, param2:RectangleParticle) : Boolean
  202.       {
  203.          var _loc3_:Vector = null;
  204.          var _loc4_:Number = NaN;
  205.          var _loc5_:int = 0;
  206.          var _loc6_:Vector = null;
  207.          var _loc7_:Number = NaN;
  208.          var _loc8_:Vector = null;
  209.          var _loc9_:Number = NaN;
  210.          var _loc10_:Number = NaN;
  211.          var _loc11_:Number = NaN;
  212.          var _loc12_:* = false;
  213.          _loc4_ = Number.POSITIVE_INFINITY;
  214.          _loc5_ = 0;
  215.          while(_loc5_ < 2)
  216.          {
  217.             _loc6_ = param1.axes[_loc5_];
  218.             if((_loc7_ = testIntervals(param1.getProjection(_loc6_),param2.getProjection(_loc6_))) == 0)
  219.             {
  220.                return false;
  221.             }
  222.             _loc8_ = param2.axes[_loc5_];
  223.             if((_loc9_ = testIntervals(param1.getProjection(_loc8_),param2.getProjection(_loc8_))) == 0)
  224.             {
  225.                return false;
  226.             }
  227.             _loc10_ = Math.abs(_loc7_);
  228.             _loc11_ = Math.abs(_loc9_);
  229.             if(_loc10_ < Math.abs(_loc4_) || _loc11_ < Math.abs(_loc4_))
  230.             {
  231.                _loc3_ = (_loc12_ = _loc10_ < _loc11_) ? _loc6_ : _loc8_;
  232.                _loc4_ = _loc12_ ? _loc7_ : _loc9_;
  233.             }
  234.             _loc5_++;
  235.          }
  236.          CollisionResolver.resolveParticleParticle(param1,param2,_loc3_,_loc4_);
  237.          return true;
  238.       }
  239.       
  240.       private static function sampVsSamp(param1:AbstractParticle, param2:AbstractParticle) : void
  241.       {
  242.          var _loc3_:Number = NaN;
  243.          var _loc4_:Number = NaN;
  244.          var _loc5_:int = 0;
  245.          _loc3_ = 1 / (param1.multisample + 1);
  246.          _loc4_ = _loc3_;
  247.          _loc5_ = 0;
  248.          while(_loc5_ <= param1.multisample)
  249.          {
  250.             param1.samp.setTo(param1.prev.x + _loc4_ * (param1.curr.x - param1.prev.x),param1.prev.y + _loc4_ * (param1.curr.y - param1.prev.y));
  251.             param2.samp.setTo(param2.prev.x + _loc4_ * (param2.curr.x - param2.prev.x),param2.prev.y + _loc4_ * (param2.curr.y - param2.prev.y));
  252.             if(testTypes(param1,param2))
  253.             {
  254.                return;
  255.             }
  256.             _loc4_ += _loc3_;
  257.             _loc5_++;
  258.          }
  259.       }
  260.    }
  261. }
  262.