home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / Never_End.swf / scripts / groups / Group.as < prev    next >
Encoding:
Text File  |  2008-09-23  |  9.7 KB  |  367 lines
  1. package groups
  2. {
  3.    import game.Model;
  4.    
  5.    public class Group
  6.    {
  7.        
  8.       
  9.       private var Y2:Object;
  10.       
  11.       public var allStaticItems:Array;
  12.       
  13.       public var xspeedArr:Array;
  14.       
  15.       public var yspeedArr:Array;
  16.       
  17.       public var _type:String;
  18.       
  19.       public var frozen:Boolean;
  20.       
  21.       public var hitted:Array;
  22.       
  23.       public var checked:Boolean = false;
  24.       
  25.       protected var itemRotation:Number = 0;
  26.       
  27.       protected var yHitObj:Object;
  28.       
  29.       public var items:Array;
  30.       
  31.       private var X1:Object;
  32.       
  33.       protected var yHit:Object;
  34.       
  35.       private var X3:Object;
  36.       
  37.       private var X4:Object;
  38.       
  39.       private var X2:Object;
  40.       
  41.       public var allActiveItems:Array;
  42.       
  43.       private var Y3:Object;
  44.       
  45.       private var Y4:Object;
  46.       
  47.       public var counter:Number = 0;
  48.       
  49.       private var Y1:Object;
  50.       
  51.       public function Group(param1:String, param2:Boolean)
  52.       {
  53.          itemRotation = 0;
  54.          X1 = {
  55.             "a":Model.gravity.x,
  56.             "s":0,
  57.             "t":1,
  58.             "m":Model.MAX_MOVE_SPEED,
  59.             "ps":0
  60.          };
  61.          X2 = {
  62.             "a":Model.gravity.y,
  63.             "s":0,
  64.             "t":1,
  65.             "m":Model.MAX_DROP_SPEED,
  66.             "ps":0
  67.          };
  68.          X3 = {
  69.             "a":-Model.gravity.x,
  70.             "s":0,
  71.             "t":-1,
  72.             "m":Model.MAX_MOVE_SPEED,
  73.             "ps":0
  74.          };
  75.          X4 = {
  76.             "a":-Model.gravity.y,
  77.             "s":0,
  78.             "t":-1,
  79.             "m":Model.MAX_DROP_SPEED,
  80.             "ps":0
  81.          };
  82.          Y1 = {
  83.             "a":Model.gravity.y,
  84.             "s":0,
  85.             "t":1,
  86.             "m":Model.MAX_DROP_SPEED,
  87.             "ps":0
  88.          };
  89.          Y2 = {
  90.             "a":-Model.gravity.x,
  91.             "s":0,
  92.             "t":-1,
  93.             "m":Model.MAX_MOVE_SPEED,
  94.             "ps":0
  95.          };
  96.          Y3 = {
  97.             "a":-Model.gravity.y,
  98.             "s":0,
  99.             "t":-1,
  100.             "m":Model.MAX_DROP_SPEED,
  101.             "ps":0
  102.          };
  103.          Y4 = {
  104.             "a":Model.gravity.x,
  105.             "s":0,
  106.             "t":1,
  107.             "m":Model.MAX_MOVE_SPEED,
  108.             "ps":0
  109.          };
  110.          checked = false;
  111.          counter = 0;
  112.          super();
  113.          _type = param1;
  114.          xspeedArr = [X1,X2,X3,X4];
  115.          yspeedArr = [Y1,Y2,Y3,Y4];
  116.          frozen = param2;
  117.          resetASpeed(0);
  118.          items = new Array();
  119.       }
  120.       
  121.       public function set rotation(param1:Number) : void
  122.       {
  123.       }
  124.       
  125.       public function resetASpeed(param1:Number) : void
  126.       {
  127.          if(!frozen)
  128.          {
  129.             if(param1 > 0)
  130.             {
  131.                ++counter;
  132.             }
  133.             else if(param1 < 0)
  134.             {
  135.                --counter;
  136.             }
  137.             counter = (counter + 4) % 4;
  138.             xspeedArr[counter].s = 0;
  139.             yspeedArr[counter].s = 0;
  140.          }
  141.       }
  142.       
  143.       private function getMin(param1:Array) : Object
  144.       {
  145.          var _loc2_:Object = null;
  146.          var _loc3_:* = undefined;
  147.          if(param1.length < 1)
  148.          {
  149.             return {
  150.                "hit":"none",
  151.                "x":xspeedArr[counter].s,
  152.                "y":yspeedArr[counter].s
  153.             };
  154.          }
  155.          _loc2_ = {
  156.             "x":param1[0].x,
  157.             "y":param1[0].y
  158.          };
  159.          for each(_loc3_ in param1)
  160.          {
  161.             if(_loc2_.x * _loc2_.x >= _loc3_.x * _loc3_.x)
  162.             {
  163.                if(counter % 2 != 0)
  164.                {
  165.                   yHitObj = _loc3_.obj;
  166.                   yHit = _loc3_.xHit;
  167.                }
  168.                _loc2_.x = _loc3_.x;
  169.             }
  170.             if(_loc2_.y * _loc2_.y >= _loc3_.y * _loc3_.y)
  171.             {
  172.                if(counter % 2 == 0)
  173.                {
  174.                   yHitObj = _loc3_.obj;
  175.                   yHit = _loc3_.yHit;
  176.                }
  177.                _loc2_.y = _loc3_.y;
  178.             }
  179.          }
  180.          return _loc2_;
  181.       }
  182.       
  183.       private function addSpeed(param1:*) : void
  184.       {
  185.          if(Math.abs(param1.s + param1.a) <= param1.m)
  186.          {
  187.             param1.pps = param1.ps;
  188.             param1.ps = param1.s;
  189.             param1.s += param1.a;
  190.          }
  191.          else
  192.          {
  193.             param1.pps = param1.ps;
  194.             param1.ps = param1.s;
  195.             param1.s = param1.s / Math.abs(param1.s) * param1.m;
  196.          }
  197.       }
  198.       
  199.       public function removeAllItems() : void
  200.       {
  201.          var _loc1_:int = 0;
  202.          _loc1_ = 0;
  203.          while(_loc1_ < items.length)
  204.          {
  205.             items[_loc1_].remove();
  206.             _loc1_++;
  207.          }
  208.       }
  209.       
  210.       public function hitTest() : void
  211.       {
  212.          var _loc1_:Array = null;
  213.          var _loc2_:int = 0;
  214.          var _loc3_:* = undefined;
  215.          var _loc4_:* = undefined;
  216.          var _loc5_:Object = null;
  217.          if(!frozen && !checked)
  218.          {
  219.             hitted = new Array();
  220.             checked = true;
  221.             _loc1_ = new Array();
  222.             _loc2_ = int(items.length - 1);
  223.             while(_loc2_ >= 0)
  224.             {
  225.                _loc5_ = items[_loc2_].checkHit();
  226.                _loc1_.push(_loc5_);
  227.                if(_loc5_.xHit != null && counter % 2 != 0)
  228.                {
  229.                   hitted.push({
  230.                      "hit":_loc5_.xHit,
  231.                      "att":_loc5_.obj
  232.                   });
  233.                }
  234.                else if(_loc5_.yHit != null && counter % 2 == 0)
  235.                {
  236.                   hitted.push({
  237.                      "hit":_loc5_.yHit,
  238.                      "att":_loc5_.obj
  239.                   });
  240.                }
  241.                _loc2_--;
  242.             }
  243.             _loc3_ = getMin(_loc1_);
  244.             if(Math.abs(_loc3_.x) < Math.abs(xspeedArr[counter].s))
  245.             {
  246.                xspeedArr[counter].s = 0;
  247.             }
  248.             if(Math.abs(_loc3_.y) < Math.abs(yspeedArr[counter].s))
  249.             {
  250.                yspeedArr[counter].s = 0;
  251.             }
  252.             if(xspeedArr[counter].s != 0 || yspeedArr[counter].s != 0)
  253.             {
  254.                Model.isStatic = false;
  255.             }
  256.             for each(_loc4_ in items)
  257.             {
  258.                _loc4_.move(_loc3_.x,_loc3_.y);
  259.             }
  260.          }
  261.       }
  262.       
  263.       public function addItem(param1:*) : void
  264.       {
  265.          param1.group = this;
  266.          items.unshift(param1);
  267.          param1.rotation = itemRotation;
  268.       }
  269.       
  270.       public function setASpeed(param1:Number) : void
  271.       {
  272.          counter = Math.round(param1 / 90) % 4;
  273.          xspeedArr[counter].s = 0;
  274.          yspeedArr[counter].s = 0;
  275.       }
  276.       
  277.       public function stopMoving() : void
  278.       {
  279.          xspeedArr[counter].s = 0;
  280.          yspeedArr[counter].s = 0;
  281.       }
  282.       
  283.       public function updateSpeed() : void
  284.       {
  285.          var e:* = undefined;
  286.          var __i:int = 0;
  287.          var __j:int = 0;
  288.          var item0Index:int = 0;
  289.          var item1Index:int = 0;
  290.          var i:int = 0;
  291.          var j:int = 0;
  292.          var grid:Number = NaN;
  293.          var maxX:int = 0;
  294.          var minX:int = 0;
  295.          var maxY:int = 0;
  296.          var minY:int = 0;
  297.          var _i:int = 0;
  298.          var _j:int = 0;
  299.          if(!frozen)
  300.          {
  301.             if(Model.isSleep && _type == "man")
  302.             {
  303.                __i = 0;
  304.                while(__i < 18)
  305.                {
  306.                   __j = 0;
  307.                   while(__j < 18)
  308.                   {
  309.                      item0Index = int(allActiveItems[__i][__j].indexOf(items[0]));
  310.                      if(item0Index >= 0)
  311.                      {
  312.                         allActiveItems[__i][__j].splice(item0Index,1);
  313.                      }
  314.                      item1Index = int(allActiveItems[__i][__j].indexOf(items[1]));
  315.                      if(item1Index >= 0)
  316.                      {
  317.                         allActiveItems[__i][__j].splice(item1Index,1);
  318.                      }
  319.                      __j++;
  320.                   }
  321.                   __i++;
  322.                }
  323.             }
  324.             for each(e in items)
  325.             {
  326.                i = Math.round(e.tx / Model.gridWidth);
  327.                j = Math.round(e.ty / Model.gridWidth);
  328.                if(i >= 0 && i < 18 && j >= 0 && j < 18 && allActiveItems[i][j].indexOf(e) < 0)
  329.                {
  330.                   grid = Model.gridWidth;
  331.                   maxX = Math.round((e.tx + e.itemWidth / 2) / grid);
  332.                   minX = Math.round((e.tx - e.itemWidth / 2) / grid);
  333.                   maxY = Math.round((e.ty + e.itemHeight / 2) / grid);
  334.                   minY = Math.round((e.ty - e.itemHeight / 2) / grid);
  335.                   e.maxI = maxY;
  336.                   e.maxJ = maxX;
  337.                   e.minI = minY;
  338.                   e.minJ = minX;
  339.                   _i = minX;
  340.                   while(_i <= maxX)
  341.                   {
  342.                      _j = minY;
  343.                      while(_j <= maxY)
  344.                      {
  345.                         try
  346.                         {
  347.                            allActiveItems[_j][_i].push(e);
  348.                         }
  349.                         catch(e:Error)
  350.                         {
  351.                         }
  352.                         _j++;
  353.                      }
  354.                      _i++;
  355.                   }
  356.                }
  357.             }
  358.             yHitObj = null;
  359.             yHit = null;
  360.             checked = false;
  361.             addSpeed(xspeedArr[counter]);
  362.             addSpeed(yspeedArr[counter]);
  363.          }
  364.       }
  365.    }
  366. }
  367.