home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / org / cove / ape / Group.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  6.4 KB  |  247 lines
  1. package org.cove.ape
  2. {
  3.    public class Group extends AbstractCollection
  4.    {
  5.        
  6.       
  7.       private var _collideInternal:Boolean;
  8.       
  9.       private var _composites:Array;
  10.       
  11.       private var _collisionList:Array;
  12.       
  13.       public function Group(param1:Boolean = false)
  14.       {
  15.          super();
  16.          _composites = new Array();
  17.          _collisionList = new Array();
  18.          this.collideInternal = param1;
  19.       }
  20.       
  21.       internal function checkCollisions() : void
  22.       {
  23.          var _loc1_:int = 0;
  24.          var _loc2_:int = 0;
  25.          var _loc3_:Group = null;
  26.          if(collideInternal)
  27.          {
  28.             checkCollisionGroupInternal();
  29.          }
  30.          _loc1_ = int(collisionList.length);
  31.          _loc2_ = 0;
  32.          while(_loc2_ < _loc1_)
  33.          {
  34.             _loc3_ = collisionList[_loc2_];
  35.             checkCollisionVsGroup(_loc3_);
  36.             _loc2_++;
  37.          }
  38.       }
  39.       
  40.       public function get composites() : Array
  41.       {
  42.          return _composites;
  43.       }
  44.       
  45.       override public function init() : void
  46.       {
  47.          var _loc1_:int = 0;
  48.          super.init();
  49.          _loc1_ = 0;
  50.          while(_loc1_ < composites.length)
  51.          {
  52.             composites[_loc1_].init();
  53.             _loc1_++;
  54.          }
  55.       }
  56.       
  57.       public function removeCollidable(param1:Group) : void
  58.       {
  59.          var _loc2_:int = 0;
  60.          _loc2_ = collisionList.indexOf(param1);
  61.          if(_loc2_ == -1)
  62.          {
  63.             return;
  64.          }
  65.          collisionList.splice(_loc2_,1);
  66.       }
  67.       
  68.       private function checkCollisionVsGroup(param1:Group) : void
  69.       {
  70.          var _loc2_:int = 0;
  71.          var _loc3_:int = 0;
  72.          var _loc4_:int = 0;
  73.          var _loc5_:Composite = null;
  74.          var _loc6_:int = 0;
  75.          var _loc7_:Composite = null;
  76.          checkCollisionsVsCollection(param1);
  77.          _loc2_ = int(_composites.length);
  78.          _loc3_ = int(param1.composites.length);
  79.          _loc4_ = 0;
  80.          while(_loc4_ < _loc2_)
  81.          {
  82.             (_loc5_ = _composites[_loc4_]).checkCollisionsVsCollection(param1);
  83.             _loc6_ = 0;
  84.             while(_loc6_ < _loc3_)
  85.             {
  86.                _loc7_ = param1.composites[_loc6_];
  87.                _loc5_.checkCollisionsVsCollection(_loc7_);
  88.                _loc6_++;
  89.             }
  90.             _loc4_++;
  91.          }
  92.          _loc6_ = 0;
  93.          while(_loc6_ < _loc3_)
  94.          {
  95.             _loc7_ = param1.composites[_loc6_];
  96.             checkCollisionsVsCollection(_loc7_);
  97.             _loc6_++;
  98.          }
  99.       }
  100.       
  101.       override internal function satisfyConstraints() : void
  102.       {
  103.          var _loc1_:int = 0;
  104.          var _loc2_:int = 0;
  105.          var _loc3_:Composite = null;
  106.          super.satisfyConstraints();
  107.          _loc1_ = int(_composites.length);
  108.          _loc2_ = 0;
  109.          while(_loc2_ < _loc1_)
  110.          {
  111.             _loc3_ = _composites[_loc2_];
  112.             _loc3_.satisfyConstraints();
  113.             _loc2_++;
  114.          }
  115.       }
  116.       
  117.       public function get collideInternal() : Boolean
  118.       {
  119.          return _collideInternal;
  120.       }
  121.       
  122.       override public function paint() : void
  123.       {
  124.          var _loc1_:int = 0;
  125.          var _loc2_:int = 0;
  126.          var _loc3_:Composite = null;
  127.          super.paint();
  128.          _loc1_ = int(_composites.length);
  129.          _loc2_ = 0;
  130.          while(_loc2_ < _loc1_)
  131.          {
  132.             _loc3_ = _composites[_loc2_];
  133.             _loc3_.paint();
  134.             _loc2_++;
  135.          }
  136.       }
  137.       
  138.       public function addCollidableList(param1:Array) : void
  139.       {
  140.          var _loc2_:int = 0;
  141.          var _loc3_:Group = null;
  142.          _loc2_ = 0;
  143.          while(_loc2_ < param1.length)
  144.          {
  145.             _loc3_ = param1[_loc2_];
  146.             collisionList.push(_loc3_);
  147.             _loc2_++;
  148.          }
  149.       }
  150.       
  151.       public function removeComposite(param1:Composite) : void
  152.       {
  153.          var _loc2_:int = 0;
  154.          _loc2_ = composites.indexOf(param1);
  155.          if(_loc2_ == -1)
  156.          {
  157.             return;
  158.          }
  159.          composites.splice(_loc2_,1);
  160.          param1.isParented = false;
  161.          param1.cleanup();
  162.       }
  163.       
  164.       override public function cleanup() : void
  165.       {
  166.          var _loc1_:int = 0;
  167.          super.cleanup();
  168.          _loc1_ = 0;
  169.          while(_loc1_ < composites.length)
  170.          {
  171.             composites[_loc1_].cleanup();
  172.             _loc1_++;
  173.          }
  174.       }
  175.       
  176.       public function addCollidable(param1:Group) : void
  177.       {
  178.          collisionList.push(param1);
  179.       }
  180.       
  181.       public function get collisionList() : Array
  182.       {
  183.          return _collisionList;
  184.       }
  185.       
  186.       override internal function integrate(param1:Number) : void
  187.       {
  188.          var _loc2_:int = 0;
  189.          var _loc3_:int = 0;
  190.          var _loc4_:Composite = null;
  191.          super.integrate(param1);
  192.          _loc2_ = int(_composites.length);
  193.          _loc3_ = 0;
  194.          while(_loc3_ < _loc2_)
  195.          {
  196.             (_loc4_ = _composites[_loc3_]).integrate(param1);
  197.             _loc3_++;
  198.          }
  199.       }
  200.       
  201.       override public function getAll() : Array
  202.       {
  203.          return particles.concat(constraints).concat(composites);
  204.       }
  205.       
  206.       public function addComposite(param1:Composite) : void
  207.       {
  208.          composites.push(param1);
  209.          param1.isParented = true;
  210.          if(isParented)
  211.          {
  212.             param1.init();
  213.          }
  214.       }
  215.       
  216.       private function checkCollisionGroupInternal() : void
  217.       {
  218.          var _loc1_:int = 0;
  219.          var _loc2_:int = 0;
  220.          var _loc3_:Composite = null;
  221.          var _loc4_:int = 0;
  222.          var _loc5_:Composite = null;
  223.          checkInternalCollisions();
  224.          _loc1_ = int(_composites.length);
  225.          _loc2_ = 0;
  226.          while(_loc2_ < _loc1_)
  227.          {
  228.             _loc3_ = _composites[_loc2_];
  229.             _loc3_.checkCollisionsVsCollection(this);
  230.             _loc4_ = _loc2_ + 1;
  231.             while(_loc4_ < _loc1_)
  232.             {
  233.                _loc5_ = _composites[_loc4_];
  234.                _loc3_.checkCollisionsVsCollection(_loc5_);
  235.                _loc4_++;
  236.             }
  237.             _loc2_++;
  238.          }
  239.       }
  240.       
  241.       public function set collideInternal(param1:Boolean) : void
  242.       {
  243.          _collideInternal = param1;
  244.       }
  245.    }
  246. }
  247.