home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / org / cove / ape / APEngine.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  4.6 KB  |  189 lines
  1. package org.cove.ape
  2. {
  3.    import flash.display.DisplayObjectContainer;
  4.    
  5.    public final class APEngine
  6.    {
  7.       
  8.       private static var _container:DisplayObjectContainer;
  9.       
  10.       private static var _damping:Number;
  11.       
  12.       private static var _constraintCollisionCycles:int;
  13.       
  14.       private static var groups:Array;
  15.       
  16.       internal static var masslessForce:Vector;
  17.       
  18.       private static var _constraintCycles:int;
  19.       
  20.       internal static var force:Vector;
  21.       
  22.       private static var timeStep:Number;
  23.       
  24.       private static var numGroups:int;
  25.        
  26.       
  27.       public function APEngine()
  28.       {
  29.          super();
  30.       }
  31.       
  32.       public static function get container() : DisplayObjectContainer
  33.       {
  34.          return _container;
  35.       }
  36.       
  37.       public static function get constraintCollisionCycles() : int
  38.       {
  39.          return _constraintCollisionCycles;
  40.       }
  41.       
  42.       public static function set damping(param1:Number) : void
  43.       {
  44.          _damping = param1;
  45.       }
  46.       
  47.       public static function step() : void
  48.       {
  49.          var _loc1_:int = 0;
  50.          var _loc2_:int = 0;
  51.          integrate();
  52.          _loc1_ = 0;
  53.          while(_loc1_ < _constraintCycles)
  54.          {
  55.             satisfyConstraints();
  56.             _loc1_++;
  57.          }
  58.          _loc2_ = 0;
  59.          while(_loc2_ < _constraintCollisionCycles)
  60.          {
  61.             satisfyConstraints();
  62.             checkCollisions();
  63.             _loc2_++;
  64.          }
  65.       }
  66.       
  67.       public static function init(param1:Number = 0.25) : void
  68.       {
  69.          timeStep = param1 * param1;
  70.          numGroups = 0;
  71.          groups = new Array();
  72.          force = new Vector(0,0);
  73.          masslessForce = new Vector(0,0);
  74.          damping = 1;
  75.          _constraintCycles = 0;
  76.          _constraintCollisionCycles = 1;
  77.       }
  78.       
  79.       public static function get constraintCycles() : int
  80.       {
  81.          return _constraintCycles;
  82.       }
  83.       
  84.       public static function set constraintCollisionCycles(param1:int) : void
  85.       {
  86.          _constraintCollisionCycles = param1;
  87.       }
  88.       
  89.       public static function set constraintCycles(param1:int) : void
  90.       {
  91.          _constraintCycles = param1;
  92.       }
  93.       
  94.       public static function addForce(param1:Vector) : void
  95.       {
  96.          force.plusEquals(param1);
  97.       }
  98.       
  99.       public static function get damping() : Number
  100.       {
  101.          return _damping;
  102.       }
  103.       
  104.       public static function set container(param1:DisplayObjectContainer) : void
  105.       {
  106.          _container = param1;
  107.       }
  108.       
  109.       public static function addGroup(param1:Group) : void
  110.       {
  111.          groups.push(param1);
  112.          param1.isParented = true;
  113.          ++numGroups;
  114.          param1.init();
  115.       }
  116.       
  117.       public static function removeGroup(param1:Group) : void
  118.       {
  119.          var _loc2_:int = 0;
  120.          _loc2_ = groups.indexOf(param1);
  121.          if(_loc2_ == -1)
  122.          {
  123.             return;
  124.          }
  125.          groups.splice(_loc2_,1);
  126.          param1.isParented = false;
  127.          --numGroups;
  128.          param1.cleanup();
  129.       }
  130.       
  131.       public static function paint() : void
  132.       {
  133.          var _loc1_:int = 0;
  134.          var _loc2_:Group = null;
  135.          _loc1_ = 0;
  136.          while(_loc1_ < numGroups)
  137.          {
  138.             _loc2_ = groups[_loc1_];
  139.             _loc2_.paint();
  140.             _loc1_++;
  141.          }
  142.       }
  143.       
  144.       private static function checkCollisions() : void
  145.       {
  146.          var _loc1_:int = 0;
  147.          var _loc2_:Group = null;
  148.          _loc1_ = 0;
  149.          while(_loc1_ < numGroups)
  150.          {
  151.             _loc2_ = groups[_loc1_];
  152.             _loc2_.checkCollisions();
  153.             _loc1_++;
  154.          }
  155.       }
  156.       
  157.       private static function integrate() : void
  158.       {
  159.          var _loc1_:int = 0;
  160.          var _loc2_:Group = null;
  161.          _loc1_ = 0;
  162.          while(_loc1_ < numGroups)
  163.          {
  164.             _loc2_ = groups[_loc1_];
  165.             _loc2_.integrate(timeStep);
  166.             _loc1_++;
  167.          }
  168.       }
  169.       
  170.       private static function satisfyConstraints() : void
  171.       {
  172.          var _loc1_:int = 0;
  173.          var _loc2_:Group = null;
  174.          _loc1_ = 0;
  175.          while(_loc1_ < numGroups)
  176.          {
  177.             _loc2_ = groups[_loc1_];
  178.             _loc2_.satisfyConstraints();
  179.             _loc1_++;
  180.          }
  181.       }
  182.       
  183.       public static function addMasslessForce(param1:Vector) : void
  184.       {
  185.          masslessForce.plusEquals(param1);
  186.       }
  187.    }
  188. }
  189.