home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / xwung.swf / scripts / com / lofiminds / gm / Collisions.as < prev    next >
Encoding:
Text File  |  2008-09-03  |  9.8 KB  |  278 lines
  1. package com.lofiminds.gm
  2. {
  3.    import flash.utils.Dictionary;
  4.    
  5.    public final class Collisions
  6.    {
  7.       
  8.       private static var cdLine:CollisionData = new CollisionData();
  9.       
  10.       private static var classes:Array = new Array();
  11.       
  12.       private static var gCollisionContext:CollisionContext = new CollisionContext();
  13.       
  14.       private static var groupDuplicateMap:Dictionary = new Dictionary();
  15.       
  16.       private static var groups:Array = new Array();
  17.       
  18.       private static var obbCenterDiff:Vector = new Vector();
  19.       
  20.       private static var debugCd:CollisionData;
  21.        
  22.       
  23.       public function Collisions()
  24.       {
  25.          super();
  26.       }
  27.       
  28.       private static function SeparatedOnAxis(param1:CollisionData, param2:CollisionData, param3:Vector) : Boolean
  29.       {
  30.          var _loc4_:Number = Math.abs(param3.dot(obbCenterDiff));
  31.          return GetProjectedRadius(param1,param3) + GetProjectedRadius(param2,param3) < _loc4_;
  32.       }
  33.       
  34.       internal static function drawCollisionBounds(param1:GameGraphics) : void
  35.       {
  36.          var _loc3_:Array = null;
  37.          var _loc4_:int = 0;
  38.          var _loc5_:GameObject = null;
  39.          var _loc6_:CollisionData = null;
  40.          var _loc7_:Number = NaN;
  41.          var _loc8_:Number = NaN;
  42.          var _loc9_:Number = NaN;
  43.          var _loc10_:Number = NaN;
  44.          var _loc11_:Number = NaN;
  45.          var _loc12_:Number = NaN;
  46.          param1.lineStyle(2,16711680);
  47.          var _loc2_:int = 0;
  48.          while(_loc2_ < classes.length)
  49.          {
  50.             _loc3_ = Instances.getAllOfClass(classes[_loc2_]);
  51.             if(_loc3_ != null)
  52.             {
  53.                _loc4_ = 0;
  54.                while(_loc4_ < _loc3_.length)
  55.                {
  56.                   if((_loc5_ = GameObject(_loc3_[_loc4_])).image != null)
  57.                   {
  58.                      if((_loc6_ = _loc5_.collisionData).isAABB)
  59.                      {
  60.                         param1.drawRect(_loc6_.aabbRect);
  61.                      }
  62.                      else
  63.                      {
  64.                         _loc7_ = _loc6_.obbAxisX.x * _loc6_.obbExtentX;
  65.                         _loc8_ = _loc6_.obbAxisX.y * _loc6_.obbExtentX;
  66.                         _loc9_ = _loc6_.obbAxisY.x * _loc6_.obbExtentY;
  67.                         _loc10_ = _loc6_.obbAxisY.y * _loc6_.obbExtentY;
  68.                         _loc11_ = _loc6_.obbCenterX - _loc7_ - _loc9_;
  69.                         _loc12_ = _loc6_.obbCenterY - _loc8_ - _loc10_;
  70.                         param1.moveTo(_loc11_,_loc12_);
  71.                         _loc11_ = _loc6_.obbCenterX + _loc7_ - _loc9_;
  72.                         _loc12_ = _loc6_.obbCenterY + _loc8_ - _loc10_;
  73.                         param1.lineTo(_loc11_,_loc12_);
  74.                         _loc11_ = _loc6_.obbCenterX + _loc7_ + _loc9_;
  75.                         _loc12_ = _loc6_.obbCenterY + _loc8_ + _loc10_;
  76.                         param1.lineTo(_loc11_,_loc12_);
  77.                         _loc11_ = _loc6_.obbCenterX - _loc7_ + _loc9_;
  78.                         _loc12_ = _loc6_.obbCenterY - _loc8_ + _loc10_;
  79.                         param1.lineTo(_loc11_,_loc12_);
  80.                         _loc11_ = _loc6_.obbCenterX - _loc7_ - _loc9_;
  81.                         _loc12_ = _loc6_.obbCenterY - _loc8_ - _loc10_;
  82.                         param1.lineTo(_loc11_,_loc12_);
  83.                      }
  84.                   }
  85.                   _loc4_++;
  86.                }
  87.             }
  88.             _loc2_++;
  89.          }
  90.       }
  91.       
  92.       public static function line_collision(param1:Number, param2:Number, param3:Number, param4:Number, param5:Class) : GameObject
  93.       {
  94.          var _loc12_:GameObject = null;
  95.          if(classes.indexOf(param5) == -1)
  96.          {
  97.             throw new Error("must call register on class");
  98.          }
  99.          var _loc6_:Array;
  100.          if((_loc6_ = Instances.getAllOfClass(param5)) == null)
  101.          {
  102.             return null;
  103.          }
  104.          var _loc7_:Number = GameUtil.point_distance(param1,param2,param3,param4);
  105.          var _loc8_:Number = GameUtil.point_direction(param1,param2,param3,param4);
  106.          _loc7_ *= 0.5;
  107.          cdLine.obbCenterX = param1 + GameUtil.lengthdir_x(_loc7_,_loc8_);
  108.          cdLine.obbCenterY = param2 + GameUtil.lengthdir_y(_loc7_,_loc8_);
  109.          cdLine.obbExtentX = _loc7_;
  110.          cdLine.obbExtentY = 2;
  111.          var _loc9_:Number = Math.sin(0 - _loc8_);
  112.          var _loc10_:Number = Math.cos(_loc8_);
  113.          cdLine.obbAxisX.x = _loc10_;
  114.          cdLine.obbAxisX.y = _loc9_;
  115.          cdLine.obbAxisY.x = -_loc9_;
  116.          cdLine.obbAxisY.y = _loc10_;
  117.          var _loc11_:int = 0;
  118.          while(_loc11_ < _loc6_.length)
  119.          {
  120.             if((_loc12_ = _loc6_[_loc11_] as GameObject).image != null)
  121.             {
  122.                if(testOBB_vs_OBB(cdLine,_loc12_.collisionData))
  123.                {
  124.                   return _loc12_;
  125.                }
  126.             }
  127.             _loc11_++;
  128.          }
  129.          return null;
  130.       }
  131.       
  132.       internal static function update() : void
  133.       {
  134.          var _loc3_:CollisionData = null;
  135.          var _loc4_:CollisionData = null;
  136.          var _loc5_:Array = null;
  137.          var _loc6_:int = 0;
  138.          var _loc7_:GameObject = null;
  139.          var _loc8_:CollisionGroup = null;
  140.          var _loc9_:Array = null;
  141.          var _loc10_:int = 0;
  142.          var _loc11_:int = 0;
  143.          var _loc12_:GameObject = null;
  144.          var _loc13_:Boolean = false;
  145.          var _loc1_:int = 0;
  146.          while(_loc1_ < classes.length)
  147.          {
  148.             if((_loc5_ = Instances.getAllOfClass(classes[_loc1_])) != null)
  149.             {
  150.                _loc6_ = 0;
  151.                while(_loc6_ < _loc5_.length)
  152.                {
  153.                   if((_loc7_ = GameObject(_loc5_[_loc6_])).image != null)
  154.                   {
  155.                      _loc7_.prepareCollisionData();
  156.                   }
  157.                   _loc6_++;
  158.                }
  159.             }
  160.             _loc1_++;
  161.          }
  162.          var _loc2_:CollisionContext = gCollisionContext;
  163.          _loc1_ = 0;
  164.          while(_loc1_ < groups.length)
  165.          {
  166.             _loc8_ = groups[_loc1_] as CollisionGroup;
  167.             _loc5_ = Instances.getAllOfClass(_loc8_.class1);
  168.             _loc9_ = Instances.getAllOfClass(_loc8_.class2);
  169.             if(!(_loc5_ == null || _loc9_ == null))
  170.             {
  171.                _loc6_ = 0;
  172.                while(_loc6_ < _loc5_.length)
  173.                {
  174.                   if((_loc7_ = GameObject(_loc5_[_loc6_])).image != null)
  175.                   {
  176.                      _loc3_ = _loc7_.collisionData;
  177.                      _loc11_ = _loc10_ = _loc5_ == _loc9_ ? _loc6_ + 1 : 0;
  178.                      while(_loc11_ < _loc9_.length)
  179.                      {
  180.                         if((_loc12_ = GameObject(_loc9_[_loc11_])).image != null)
  181.                         {
  182.                            _loc4_ = _loc12_.collisionData;
  183.                            if(_loc3_.isAABB && _loc4_.isAABB)
  184.                            {
  185.                               _loc13_ = _loc3_.aabbRect.intersects(_loc4_.aabbRect);
  186.                            }
  187.                            else
  188.                            {
  189.                               _loc13_ = testOBB_vs_OBB(_loc3_,_loc4_);
  190.                            }
  191.                            if(_loc13_)
  192.                            {
  193.                               _loc2_.other = _loc12_;
  194.                               _loc7_.onCollision(_loc2_);
  195.                               _loc2_.other = _loc7_;
  196.                               _loc12_.onCollision(_loc2_);
  197.                               break;
  198.                            }
  199.                         }
  200.                         _loc11_++;
  201.                      }
  202.                   }
  203.                   _loc6_++;
  204.                }
  205.             }
  206.             _loc1_++;
  207.          }
  208.       }
  209.       
  210.       private static function GetProjectedRadius(param1:CollisionData, param2:Vector) : Number
  211.       {
  212.          return param1.obbExtentX * Math.abs(param2.dot(param1.obbAxisX)) + param1.obbExtentY * Math.abs(param2.dot(param1.obbAxisY));
  213.       }
  214.       
  215.       public static function registerClass(param1:Class) : void
  216.       {
  217.          if(classes.indexOf(param1) == -1)
  218.          {
  219.             classes.push(param1);
  220.          }
  221.       }
  222.       
  223.       private static function testOBB_vs_OBB(param1:CollisionData, param2:CollisionData) : Boolean
  224.       {
  225.          obbCenterDiff.x = param1.obbCenterX - param2.obbCenterX;
  226.          obbCenterDiff.y = param1.obbCenterY - param2.obbCenterY;
  227.          if(SeparatedOnAxis(param1,param2,param1.obbAxisX))
  228.          {
  229.             return false;
  230.          }
  231.          if(SeparatedOnAxis(param1,param2,param1.obbAxisY))
  232.          {
  233.             return false;
  234.          }
  235.          if(SeparatedOnAxis(param1,param2,param2.obbAxisX))
  236.          {
  237.             return false;
  238.          }
  239.          if(SeparatedOnAxis(param1,param2,param2.obbAxisY))
  240.          {
  241.             return false;
  242.          }
  243.          return true;
  244.       }
  245.       
  246.       public static function registerGroup(param1:Class, param2:Class) : void
  247.       {
  248.          var _loc3_:String = String(param1) + String(param2);
  249.          if(groupDuplicateMap[_loc3_] != null)
  250.          {
  251.             throw new Error("duplicate collisiongroups: " + _loc3_);
  252.          }
  253.          trace("dupkey:" + _loc3_);
  254.          groupDuplicateMap[_loc3_] = 1;
  255.          registerClass(param1);
  256.          registerClass(param2);
  257.          var _loc4_:CollisionGroup;
  258.          (_loc4_ = new CollisionGroup()).class1 = param1;
  259.          _loc4_.class2 = param2;
  260.          groups.push(_loc4_);
  261.       }
  262.    }
  263. }
  264.  
  265. final class CollisionGroup
  266. {
  267.     
  268.    
  269.    internal var class1:Class;
  270.    
  271.    internal var class2:Class;
  272.    
  273.    public function CollisionGroup()
  274.    {
  275.       super();
  276.    }
  277. }
  278.