home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Acao / midnightstrike1.swf / scripts / __Packages / com / neodelight / v2D / World.as < prev   
Encoding:
Text File  |  2007-04-02  |  11.9 KB  |  376 lines
  1. class com.neodelight.v2D.World
  2. {
  3.    var objects;
  4.    var raster;
  5.    var tmpCellsRect;
  6.    var levelMc;
  7.    var layers;
  8.    var arrayStyleLevels;
  9.    var arrayStyleLevel;
  10.    var arrayStyleLevelPointer;
  11.    function World(raster, levelMc)
  12.    {
  13.       _global.world = this;
  14.       this.objects = new Array();
  15.       this.raster = raster;
  16.       this.tmpCellsRect = new com.neodelight.std.Rect(new com.neodelight.std.Vector(0,0),new com.neodelight.std.Vector(0,0));
  17.       this.levelMc = levelMc;
  18.       this.layers = new Array();
  19.       this.arrayStyleLevels = new Array();
  20.    }
  21.    function init(levelMc, layers)
  22.    {
  23.       if(levelMc)
  24.       {
  25.          this.levelMc = levelMc;
  26.       }
  27.       if(layers)
  28.       {
  29.          this.layers = layers;
  30.       }
  31.       this.layers = [_root.bg0];
  32.       this.reset();
  33.    }
  34.    function reset()
  35.    {
  36.       for(var _loc2_ in this.objects)
  37.       {
  38.          delete this.objects[_loc2_];
  39.       }
  40.       com.neodelight.std.Canvas.getCanvas(this.levelMc.shotsMc,"shots").reset();
  41.       com.neodelight.std.Canvas.getCanvas(this.levelMc.explosionsMc,"explosions").reset();
  42.       com.neodelight.std.Canvas.getCanvas(this.levelMc.dynosdMc,"dynosd").reset();
  43.       com.neodelight.game.EventScript.reset();
  44.    }
  45.    function prepare()
  46.    {
  47.       this.levelMc.gotoAndStop("clear");
  48.       for(var _loc2_ in this.layers)
  49.       {
  50.          this.layers[_loc2_].gotoAndStop("clear");
  51.       }
  52.    }
  53.    function setLevel()
  54.    {
  55.       this.levelMc.gotoAndStop(_global.game.actLevel + 1);
  56.       for(var _loc3_ in this.layers)
  57.       {
  58.          this.layers[_loc3_].gotoAndStop(_global.game.actLevel + 1);
  59.       }
  60.    }
  61.    function readLevel(levelMc)
  62.    {
  63.       if(!levelMc)
  64.       {
  65.          levelMc = this.levelMc;
  66.       }
  67.       this.reset();
  68.       for(var _loc6_ in levelMc)
  69.       {
  70.          var _loc2_ = levelMc[_loc6_];
  71.          if(typeof _loc2_ == "movieclip")
  72.          {
  73.             if(_loc2_.blueprint)
  74.             {
  75.                com.neodelight.std.Blueprint.apply(_loc2_);
  76.             }
  77.             if(_loc2_.id)
  78.             {
  79.                _loc2_._name = _loc2_.id;
  80.             }
  81.          }
  82.       }
  83.       for(_loc6_ in levelMc)
  84.       {
  85.          _loc2_ = levelMc[_loc6_];
  86.          if(typeof _loc2_ == "movieclip")
  87.          {
  88.             var _loc4_ = com.neodelight.std.ClassLib.getClass(_loc2_.behaviour);
  89.             if(_loc4_)
  90.             {
  91.                var _loc5_ = new _loc4_(_loc2_);
  92.             }
  93.          }
  94.       }
  95.    }
  96.    function arrayStyleAddLevel(data)
  97.    {
  98.       this.arrayStyleLevels[data.id] = data;
  99.    }
  100.    function arrayStyleInitLevel()
  101.    {
  102.       this.arrayStyleLevel = this.arrayStyleLevels[_global.game.actLevel];
  103.       this.arrayStyleLevelPointer = 0;
  104.       for(var _loc3_ in this.levelMc)
  105.       {
  106.          if(typeof this.levelMc[_loc3_] == "movieclip")
  107.          {
  108.             this.levelMc[_loc3_].removeMovieClip();
  109.          }
  110.       }
  111.       this.levelMc._x = 0;
  112.       this.levelMc._y = 0;
  113.       this.levelMc._xscale = this.levelMc._yscale = 100;
  114.    }
  115.    function arrayStyleCreateNextSprites(x)
  116.    {
  117.       if(x == undefined)
  118.       {
  119.          trace("#ERROR: World.arrayStyleCreateNextSprites(): x == undefined");
  120.          return undefined;
  121.       }
  122.       var _loc5_ = this.arrayStyleLevel.data;
  123.       while(this.arrayStyleLevelPointer < _loc5_.length && _loc5_[this.arrayStyleLevelPointer].x <= x)
  124.       {
  125.          var _loc2_ = _loc5_[this.arrayStyleLevelPointer];
  126.          if(_loc2_.blueprint)
  127.          {
  128.             com.neodelight.std.Blueprint.apply(_loc2_);
  129.          }
  130.          if(!_loc2_.libId || _loc2_.x == undefined || _loc2_.y == undefined)
  131.          {
  132.             trace("#ERROR: World.arrayStyleLevelPointer(): leveldata contains object without libId || x || y: " + com.neodelight.std.XString.dump(_loc2_));
  133.             break;
  134.          }
  135.          var _loc3_ = this.levelMc.attachMovie(_loc2_.libId,!_loc2_.id ? com.neodelight.std.Unique.getKey() : _loc2_.id,this.levelMc.getNextHighestDepth());
  136.          for(var _loc7_ in _loc2_)
  137.          {
  138.             _loc3_[_loc7_] = _loc2_[_loc7_];
  139.          }
  140.          _loc3_.id = _loc3_._name;
  141.          _loc3_._x = _loc2_.x;
  142.          _loc3_._y = _loc2_.y;
  143.          var _loc4_ = com.neodelight.std.ClassLib.getClass(_loc2_.behaviour);
  144.          if(!_loc4_)
  145.          {
  146.             trace("#ERROR: World.arrayStyleLevelPointer(): leveldata contains object unknown class: " + _loc2_.behaviour);
  147.             break;
  148.          }
  149.          var _loc6_ = new _loc4_(_loc3_);
  150.          this.arrayStyleLevelPointer = this.arrayStyleLevelPointer + 1;
  151.       }
  152.    }
  153.    function register(o, groups)
  154.    {
  155.       for(var _loc6_ in groups)
  156.       {
  157.          if(!this.objects[groups[_loc6_]])
  158.          {
  159.             this.objects[groups[_loc6_]] = new Array();
  160.          }
  161.       }
  162.       var _loc7_ = o.getTotalBoundingRect();
  163.       o.cellsRect.p0.x = Math.floor(_loc7_.p0.x / this.raster);
  164.       o.cellsRect.p1.x = Math.floor(_loc7_.p1.x / this.raster);
  165.       o.cellsRect.p0.y = Math.floor(_loc7_.p0.y / this.raster);
  166.       o.cellsRect.p1.y = Math.floor(_loc7_.p1.y / this.raster);
  167.       for(_loc6_ in groups)
  168.       {
  169.          var _loc6_ = groups[_loc6_];
  170.          o.groups[_loc6_] = true;
  171.          var _loc4_ = o.cellsRect.p0.x;
  172.          while(_loc4_ <= o.cellsRect.p1.x)
  173.          {
  174.             var _loc2_ = o.cellsRect.p0.y;
  175.             while(_loc2_ <= o.cellsRect.p1.y)
  176.             {
  177.                if(!this.objects[_loc6_][_loc4_ + "_" + _loc2_])
  178.                {
  179.                   this.objects[_loc6_][_loc4_ + "_" + _loc2_] = new Array();
  180.                }
  181.                this.objects[_loc6_][_loc4_ + "_" + _loc2_][o.id] = o;
  182.                o.cells[_loc4_ + "_" + _loc2_] = true;
  183.                _loc2_ = _loc2_ + 1;
  184.             }
  185.             _loc4_ = _loc4_ + 1;
  186.          }
  187.       }
  188.    }
  189.    function deregister(o)
  190.    {
  191.       var _loc5_ = false;
  192.       for(var _loc6_ in o.groups)
  193.       {
  194.          _loc5_ = true;
  195.          if(!this.objects[o.groups[_loc6_]])
  196.          {
  197.             this.objects[o.groups[_loc6_]] = new Array();
  198.          }
  199.       }
  200.       if(!_loc5_)
  201.       {
  202.          return undefined;
  203.       }
  204.       var _loc7_ = o.getTotalBoundingRect();
  205.       for(_loc6_ in o.groups)
  206.       {
  207.          var _loc6_ = o.groups[_loc6_];
  208.          delete o.groups[_loc6_];
  209.          var _loc4_ = o.cellsRect.p0.x;
  210.          while(_loc4_ <= o.cellsRect.p1.x)
  211.          {
  212.             var _loc3_ = o.cellsRect.p0.y;
  213.             while(_loc3_ <= o.cellsRect.p1.y)
  214.             {
  215.                delete this.objects[_loc6_][_loc4_ + "_" + _loc3_][o.id];
  216.                delete o.cells[_loc4_ + "_" + _loc3_];
  217.                _loc3_ = _loc3_ + 1;
  218.             }
  219.             _loc4_ = _loc4_ + 1;
  220.          }
  221.       }
  222.    }
  223.    function registerUpdate(o, groups)
  224.    {
  225.       var _loc8_ = o.getBoundingRect();
  226.       this.tmpCellsRect.p0.x = Math.floor(_loc8_.p0.x / this.raster);
  227.       this.tmpCellsRect.p1.x = Math.floor(_loc8_.p1.x / this.raster);
  228.       this.tmpCellsRect.p0.y = Math.floor(_loc8_.p0.y / this.raster);
  229.       this.tmpCellsRect.p1.y = Math.floor(_loc8_.p1.y / this.raster);
  230.       if(this.tmpCellsRect.p0.x != o.cellsRect.p0.x || this.tmpCellsRect.p1.x != o.cellsRect.p1.x || this.tmpCellsRect.p0.y != o.cellsRect.p0.y || this.tmpCellsRect.p1.y != o.cellsRect.p1.y)
  231.       {
  232.          for(var _loc7_ in groups)
  233.          {
  234.             o.groups[_loc7_] = true;
  235.             var _loc5_ = o.cellsRect.p0.x;
  236.             while(_loc5_ <= o.cellsRect.p1.x)
  237.             {
  238.                var _loc4_ = o.cellsRect.p0.y;
  239.                while(_loc4_ <= o.cellsRect.p1.y)
  240.                {
  241.                   delete this.objects[_loc7_][_loc5_ + "_" + _loc4_][o.id];
  242.                   o.cells[_loc5_ + "_" + _loc4_] = false;
  243.                   _loc4_ = _loc4_ + 1;
  244.                }
  245.                _loc5_ = _loc5_ + 1;
  246.             }
  247.          }
  248.          var _loc9_ = this.tmpCellsRect;
  249.          this.tmpCellsRect = o.cellsRect;
  250.          o.cellsRect = _loc9_;
  251.          for(_loc7_ in groups)
  252.          {
  253.             o.groups[_loc7_] = true;
  254.             _loc5_ = o.cellsRect.p0.x;
  255.             while(_loc5_ <= o.cellsRect.p1.x)
  256.             {
  257.                _loc4_ = o.cellsRect.p0.y;
  258.                while(_loc4_ <= o.cellsRect.p1.y)
  259.                {
  260.                   if(isNaN(_loc4_))
  261.                   {
  262.                      _root.gotoAndStop("debug");
  263.                      return undefined;
  264.                   }
  265.                   if(!this.objects[_loc7_][_loc5_ + "_" + _loc4_])
  266.                   {
  267.                      this.objects[_loc7_][_loc5_ + "_" + _loc4_] = new Array();
  268.                   }
  269.                   this.objects[_loc7_][_loc5_ + "_" + _loc4_][o.id] = o;
  270.                   o.cells[_loc5_ + "_" + _loc4_] = true;
  271.                   _loc4_ = _loc4_ + 1;
  272.                }
  273.                _loc5_ = _loc5_ + 1;
  274.             }
  275.          }
  276.       }
  277.    }
  278.    function getCollisionGroup(groupId, rect, caller)
  279.    {
  280.       var _loc6_ = caller.id;
  281.       var _loc8_ = this.objects[groupId];
  282.       var _loc12_ = Math.floor(rect.p0.x / this.raster);
  283.       var _loc11_ = Math.ceil(rect.p1.x / this.raster);
  284.       var _loc10_ = Math.floor(rect.p0.y / this.raster);
  285.       var _loc9_ = Math.ceil(rect.p1.y / this.raster);
  286.       var _loc4_ = undefined;
  287.       var _loc2_ = undefined;
  288.       var _loc5_ = _loc12_;
  289.       while(_loc5_ < _loc11_)
  290.       {
  291.          var _loc3_ = _loc10_;
  292.          while(_loc3_ < _loc9_)
  293.          {
  294.             _loc2_ = _loc8_[_loc5_ + "_" + _loc3_];
  295.             for(var _loc7_ in _loc2_)
  296.             {
  297.                if(!(_loc7_ == _loc6_ || _loc2_[_loc7_].inactive))
  298.                {
  299.                   if(!_loc4_)
  300.                   {
  301.                      _loc4_ = new Array();
  302.                   }
  303.                   _loc4_[_loc7_] = _loc2_[_loc7_];
  304.                }
  305.             }
  306.             _loc3_ = _loc3_ + 1;
  307.          }
  308.          _loc5_ = _loc5_ + 1;
  309.       }
  310.       return _loc4_;
  311.    }
  312.    function getCollisionGroups(caller, groups, rect)
  313.    {
  314.       var _loc9_ = caller.id;
  315.       var _loc4_ = undefined;
  316.       for(var _loc14_ in groups)
  317.       {
  318.          var _loc6_ = this.objects[groups[_loc14_]];
  319.          var _loc12_ = Math.floor(rect.p0.x / this.raster);
  320.          var _loc10_ = Math.ceil(rect.p1.x / this.raster);
  321.          var _loc8_ = Math.floor(rect.p0.y / this.raster);
  322.          var _loc7_ = Math.ceil(rect.p1.y / this.raster);
  323.          var _loc2_ = undefined;
  324.          var _loc5_ = _loc12_;
  325.          while(_loc5_ < _loc10_)
  326.          {
  327.             var _loc3_ = _loc8_;
  328.             while(_loc3_ < _loc7_)
  329.             {
  330.                _loc2_ = _loc6_[_loc5_ + "_" + _loc3_];
  331.                for(_loc14_ in _loc2_)
  332.                {
  333.                   if(!(_loc14_ == _loc9_ || _loc2_[_loc14_].inactive))
  334.                   {
  335.                      if(!_loc4_)
  336.                      {
  337.                         _loc4_ = new Array();
  338.                      }
  339.                      _loc4_[_loc14_] = _loc2_[_loc14_];
  340.                   }
  341.                }
  342.                _loc3_ = _loc3_ + 1;
  343.             }
  344.             _loc5_ = _loc5_ + 1;
  345.          }
  346.       }
  347.       return _loc4_;
  348.    }
  349.    function areaDamage70(caller, groups, rect, damageMin, damageMax)
  350.    {
  351.       var _loc4_ = this.getCollisionGroups(caller,groups,rect);
  352.       for(var _loc6_ in _loc4_)
  353.       {
  354.          var _loc2_ = _loc4_[_loc6_];
  355.          var _loc3_ = _loc2_.collisionCheck70(rect);
  356.          if(_loc3_ > 0)
  357.          {
  358.             _loc2_.damage(damageMax);
  359.          }
  360.       }
  361.    }
  362.    function areaDamage71(caller, groups, circleBounding, damageMin, damageMax)
  363.    {
  364.       var _loc4_ = this.getCollisionGroups(caller,groups,circleBounding);
  365.       for(var _loc7_ in _loc4_)
  366.       {
  367.          var _loc3_ = _loc4_[_loc7_];
  368.          var _loc2_ = _loc3_.collisionCheck71(circleBounding);
  369.          if(_loc2_ > 0)
  370.          {
  371.             _loc3_.damage((damageMax - damageMin) * _loc2_ + damageMin);
  372.          }
  373.       }
  374.    }
  375. }
  376.