home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / target_s.swf / scripts / sceneEngine.as < prev    next >
Encoding:
Text File  |  2008-11-13  |  13.9 KB  |  441 lines
  1. package
  2. {
  3.    import assets.buildings.*;
  4.    import assets.objects.*;
  5.    import assets.walls.*;
  6.    import flash.display.*;
  7.    import flash.events.*;
  8.    
  9.    public class sceneEngine extends Sprite
  10.    {
  11.        
  12.       
  13.       private var distance:Number = 0;
  14.       
  15.       public var element:Sprite;
  16.       
  17.       private var travel:Number = 0;
  18.       
  19.       private var course:Number;
  20.       
  21.       private var fmark:Number = 0;
  22.       
  23.       private var elementSource:Array;
  24.       
  25.       private var backscape:MovieClip;
  26.       
  27.       private var fChance:Number = 50;
  28.       
  29.       public var foreground:Sprite;
  30.       
  31.       private var pmark:Number = 0;
  32.       
  33.       private var skyscape:Sprite;
  34.       
  35.       public var scope:Object;
  36.       
  37.       private var foreArray:Array;
  38.       
  39.       private var eFrequency:Number = 1000;
  40.       
  41.       private var foregroundSource:Array;
  42.       
  43.       private var forescape:Sprite;
  44.       
  45.       private var fFrequency:Number = 1000;
  46.       
  47.       private var finish:Boolean = false;
  48.       
  49.       public var groundscape:MovieClip;
  50.       
  51.       private var nearscape:MovieClip;
  52.       
  53.       private var emark:Number = 0;
  54.       
  55.       public var landscape:Sprite;
  56.       
  57.       public var elementArray:Array;
  58.       
  59.       private var pFrequency:Number = 5;
  60.       
  61.       private var midscape:MovieClip;
  62.       
  63.       public var foregroundArray:Array;
  64.       
  65.       private var foreSource:Array;
  66.       
  67.       private var eChance:Number = 20;
  68.       
  69.       public function sceneEngine(param1:*)
  70.       {
  71.          travel = 0;
  72.          emark = 0;
  73.          fmark = 0;
  74.          pmark = 0;
  75.          distance = 0;
  76.          finish = false;
  77.          eFrequency = 1000;
  78.          eChance = 20;
  79.          fFrequency = 1000;
  80.          fChance = 50;
  81.          pFrequency = 5;
  82.          foreSource = new Array();
  83.          foreArray = new Array();
  84.          elementSource = new Array();
  85.          elementArray = new Array();
  86.          foregroundSource = new Array();
  87.          foregroundArray = new Array();
  88.          super();
  89.          scope = param1;
  90.          setData();
  91.       }
  92.       
  93.       private function elementAdd() : *
  94.       {
  95.          var _loc1_:* = undefined;
  96.          var _loc2_:* = undefined;
  97.          _loc1_ = Math.round(Math.random() * (elementSource[course - 1].length - 1));
  98.          _loc2_ = new elementSource[course - 1][_loc1_](this);
  99.          _loc2_.x = 1000 + _loc2_.wide;
  100.          elementArray.push(_loc2_);
  101.          element.addChild(_loc2_);
  102.       }
  103.       
  104.       private function setData() : *
  105.       {
  106.          var _loc1_:* = undefined;
  107.          var _loc2_:* = undefined;
  108.          var _loc3_:* = undefined;
  109.          var _loc4_:* = undefined;
  110.          var _loc5_:* = undefined;
  111.          var _loc6_:* = undefined;
  112.          _loc1_ = [building1,building2,building3,shop1,shop2,shop3,wall_block2,woodfence1,wall_chainlink1];
  113.          _loc2_ = [building4,building5,building6,building7,building8,wall_block1,woodfence2,wall_chainlink1];
  114.          foreSource.push(_loc1_);
  115.          foreSource.push(_loc2_);
  116.          _loc3_ = [grate1,manhole1,hole1];
  117.          _loc4_ = [barrier1,manhole1,hole1,dirtpile1];
  118.          elementSource.push(_loc3_);
  119.          elementSource.push(_loc4_);
  120.          _loc5_ = [hydrant,bikerack,gaspipe1,trashcan1,sign1];
  121.          _loc6_ = [hydrant,gaspipe2,trashcan1,sign1,oildrum];
  122.          foregroundSource.push(_loc5_);
  123.          foregroundSource.push(_loc6_);
  124.       }
  125.       
  126.       public function elementToForeground(param1:*, param2:*, param3:*, param4:*) : *
  127.       {
  128.          var _loc5_:* = undefined;
  129.          var _loc6_:* = undefined;
  130.          _loc5_ = 0;
  131.          while(_loc5_ < elementArray.length)
  132.          {
  133.             if(elementArray[_loc5_].name == param4.name)
  134.             {
  135.                element.removeChild(elementArray[_loc5_]);
  136.                elementArray.splice(_loc5_,1);
  137.                break;
  138.             }
  139.             _loc5_++;
  140.          }
  141.          (_loc6_ = new param1(this)).x = param2;
  142.          _loc6_.y = param3;
  143.          foregroundArray.push(_loc6_);
  144.          foreground.addChildAt(_loc6_,0);
  145.       }
  146.       
  147.       public function setScene() : *
  148.       {
  149.          var _loc1_:* = undefined;
  150.          course = scope.course;
  151.          scope.stats.travelBar.scaleX = 0;
  152.          landscape = new Sprite();
  153.          forescape = new Sprite();
  154.          element = new Sprite();
  155.          foreground = new Sprite();
  156.          switch(course)
  157.          {
  158.             case 1:
  159.                distance = 50000;
  160.                skyscape = new Sprite();
  161.                skyscape.graphics.beginFill(10079487);
  162.                skyscape.graphics.drawRect(0,0,700,100);
  163.                groundscape = new sidewalk(scope);
  164.                groundscape.x = -100;
  165.                groundscape.y = 330;
  166.                backscape = new cityscape_back1();
  167.                midscape = new cityscape_mid1();
  168.                nearscape = new cityscape_near1();
  169.                backscape.y = 210;
  170.                midscape.y = 240;
  171.                nearscape.y = 280;
  172.                forescape.x = -150;
  173.                element.x = -150;
  174.                foreground.x = -150;
  175.                break;
  176.             case 2:
  177.                distance = 100000;
  178.                skyscape = new Sprite();
  179.                skyscape.graphics.beginFill(16764006);
  180.                skyscape.graphics.drawRect(0,0,700,100);
  181.                groundscape = new sidewalk(scope);
  182.                groundscape.x = -100;
  183.                groundscape.y = 330;
  184.                backscape = new cityscape_back2();
  185.                midscape = new cityscape_mid2();
  186.                nearscape = new cityscape_near2();
  187.                backscape.y = 210;
  188.                midscape.y = 240;
  189.                nearscape.y = 280;
  190.                forescape.x = -150;
  191.                element.x = -150;
  192.                foreground.x = -150;
  193.          }
  194.          forescapeAdd();
  195.          landscape.addChild(skyscape);
  196.          landscape.addChild(backscape);
  197.          landscape.addChild(midscape);
  198.          landscape.addChild(nearscape);
  199.          landscape.addChild(forescape);
  200.          scope.addChild(groundscape);
  201.          scope.addChild(landscape);
  202.          scope.addChild(element);
  203.          scope.addChild(foreground);
  204.          _loc1_ = new finishline(this,false);
  205.          _loc1_.x = 250 + 150;
  206.          elementArray.push(_loc1_);
  207.          element.addChild(_loc1_);
  208.       }
  209.       
  210.       public function process() : *
  211.       {
  212.          var _loc1_:* = undefined;
  213.          var _loc2_:* = undefined;
  214.          var _loc3_:* = undefined;
  215.          var _loc4_:* = undefined;
  216.          var _loc5_:* = undefined;
  217.          var _loc6_:* = undefined;
  218.          var _loc7_:* = undefined;
  219.          var _loc8_:Number = NaN;
  220.          var _loc9_:* = undefined;
  221.          var _loc10_:* = undefined;
  222.          travel += Math.round(scope.vx);
  223.          fmark += Math.round(scope.vx);
  224.          emark += Math.round(scope.vx);
  225.          scope.stats.travelBar.scaleX = travel / distance;
  226.          if(travel >= distance)
  227.          {
  228.             scope.stats.travelBar.scaleX = 1;
  229.             if(!finish)
  230.             {
  231.                finish = true;
  232.                (_loc5_ = new finishline(this,true)).x = 1000 + _loc5_.wide;
  233.                elementArray.push(_loc5_);
  234.                element.addChild(_loc5_);
  235.             }
  236.          }
  237.          if(emark >= eFrequency && !finish)
  238.          {
  239.             if(Math.round(Math.random() * 100) < eChance)
  240.             {
  241.                elementAdd();
  242.             }
  243.             emark = 0;
  244.          }
  245.          if(fmark >= fFrequency && !finish)
  246.          {
  247.             if(pmark == pFrequency)
  248.             {
  249.                foregroundAdd(true);
  250.                pmark = -1;
  251.                fmark = 0;
  252.             }
  253.             else if(Math.round(Math.random() * 100) < fChance)
  254.             {
  255.                foregroundAdd(false);
  256.             }
  257.             ++pmark;
  258.             fmark = 0;
  259.          }
  260.          groundscape.process();
  261.          if(backscape.x <= -700)
  262.          {
  263.             backscape.x += -1 * backscape.x;
  264.          }
  265.          if(midscape.x <= -700)
  266.          {
  267.             midscape.x += -1 * midscape.x;
  268.          }
  269.          if(nearscape.x <= -700)
  270.          {
  271.             nearscape.x += -1 * nearscape.x;
  272.          }
  273.          backscape.x -= scope.vx * ((backscape.y - scope.pp.y) / scope.pp.y);
  274.          midscape.x -= scope.vx * ((midscape.y - scope.pp.y) / scope.pp.y);
  275.          nearscape.x -= scope.vx * ((nearscape.y - scope.pp.y) / scope.pp.y);
  276.          _loc1_ = scope.vx * ((forescape.y + 330 - scope.pp.y) / scope.pp.y);
  277.          if(foreArray[0].x + foreArray[0].wide <= 0)
  278.          {
  279.             forescape.removeChild(foreArray[0]);
  280.             foreArray.shift();
  281.          }
  282.          if(foreArray[foreArray.length - 1].x - foreArray[foreArray.length - 1].wide <= 850)
  283.          {
  284.             forescapeAdd();
  285.          }
  286.          _loc2_ = 0;
  287.          while(_loc2_ < foreArray.length)
  288.          {
  289.             foreArray[_loc2_].x -= _loc1_;
  290.             _loc6_ = foreArray[_loc2_].x - 500;
  291.             foreArray[_loc2_].dist = Math.abs(_loc6_);
  292.             _loc2_++;
  293.          }
  294.          _loc3_ = foreArray.slice();
  295.          _loc3_.sortOn("dist",Array.DESCENDING | Array.NUMERIC);
  296.          _loc4_ = 0;
  297.          while(_loc4_ < _loc3_.length)
  298.          {
  299.             forescape.addChild(_loc3_[_loc4_]);
  300.             _loc4_++;
  301.          }
  302.          if(elementArray.length > 0)
  303.          {
  304.             if(elementArray[0].x + elementArray[0].wide <= 0)
  305.             {
  306.                element.removeChild(elementArray[0]);
  307.                elementArray.shift();
  308.             }
  309.             _loc7_ = 0;
  310.             while(_loc7_ < elementArray.length)
  311.             {
  312.                switch(elementArray[_loc7_].objType)
  313.                {
  314.                   case 0:
  315.                      _loc8_ = scope.vx * ((elementArray[_loc7_].y - elementArray[_loc7_].deep / 2 - scope.pp.y) / scope.pp.y);
  316.                      break;
  317.                   case 1:
  318.                      _loc8_ = scope.vx * ((elementArray[_loc7_].y - scope.pp.y) / scope.pp.y);
  319.                      break;
  320.                   case 2:
  321.                      _loc8_ = scope.vx * ((elementArray[_loc7_].y - elementArray[_loc7_].deep / 2 - scope.pp.y) / scope.pp.y);
  322.                      break;
  323.                   default:
  324.                      _loc8_ = scope.vx * ((elementArray[_loc7_].y - scope.pp.y) / scope.pp.y);
  325.                      break;
  326.                }
  327.                elementArray[_loc7_].x -= _loc8_;
  328.                _loc7_++;
  329.             }
  330.          }
  331.          if(foregroundArray.length > 0)
  332.          {
  333.             if(foregroundArray[0].x + foregroundArray[0].wide <= 0)
  334.             {
  335.                foreground.removeChild(foregroundArray[0]);
  336.                foregroundArray.shift();
  337.             }
  338.             _loc9_ = 0;
  339.             while(_loc9_ < foregroundArray.length)
  340.             {
  341.                _loc10_ = scope.vx * ((foregroundArray[_loc9_].y - scope.pp.y) / scope.pp.y);
  342.                foregroundArray[_loc9_].x -= _loc10_;
  343.                _loc9_++;
  344.             }
  345.          }
  346.       }
  347.       
  348.       private function foregroundAdd(param1:*) : *
  349.       {
  350.          var _loc2_:MovieClip = null;
  351.          var _loc3_:* = undefined;
  352.          if(param1)
  353.          {
  354.             _loc2_ = new powerpole1(this);
  355.          }
  356.          else
  357.          {
  358.             _loc3_ = Math.round(Math.random() * (foregroundSource[course - 1].length - 1));
  359.             _loc2_ = new foregroundSource[course - 1][_loc3_](this);
  360.          }
  361.          _loc2_.x = 1000 + _loc2_.wide;
  362.          foregroundArray.push(_loc2_);
  363.          foreground.addChild(_loc2_);
  364.       }
  365.       
  366.       private function forescapeAdd() : *
  367.       {
  368.          var _loc1_:* = undefined;
  369.          var _loc2_:* = undefined;
  370.          var _loc3_:Number = NaN;
  371.          while(foreArray.length == 0 || foreArray[foreArray.length - 1].x <= 1200)
  372.          {
  373.             _loc1_ = Math.round(Math.random() * (foreSource[course - 1].length - 1));
  374.             _loc2_ = new foreSource[course - 1][_loc1_](this);
  375.             if(foreArray.length == 0)
  376.             {
  377.                _loc2_.x = _loc2_.wide;
  378.             }
  379.             else
  380.             {
  381.                if(foreArray[foreArray.length - 1].space == 0)
  382.                {
  383.                   _loc3_ = 0;
  384.                }
  385.                else
  386.                {
  387.                   _loc3_ = Number(_loc2_.space);
  388.                }
  389.                _loc2_.x = _loc2_.wide + _loc3_ + foreArray[foreArray.length - 1].x + foreArray[foreArray.length - 1].wide;
  390.             }
  391.             _loc2_.y = 330;
  392.             _loc2_.addElements();
  393.             foreArray.push(_loc2_);
  394.             forescape.addChild(_loc2_);
  395.          }
  396.       }
  397.       
  398.       public function resetScene() : *
  399.       {
  400.          var _loc1_:* = undefined;
  401.          var _loc2_:* = undefined;
  402.          var _loc3_:* = undefined;
  403.          travel = 0;
  404.          emark = 0;
  405.          fmark = 0;
  406.          pmark = 0;
  407.          finish = false;
  408.          _loc1_ = 0;
  409.          while(_loc1_ < foreArray.length)
  410.          {
  411.             forescape.removeChild(foreArray[_loc1_]);
  412.             _loc1_++;
  413.          }
  414.          _loc2_ = 0;
  415.          while(_loc2_ < elementArray.length)
  416.          {
  417.             element.removeChild(elementArray[_loc2_]);
  418.             _loc2_++;
  419.          }
  420.          _loc3_ = 0;
  421.          while(_loc3_ < foregroundArray.length)
  422.          {
  423.             foreground.removeChild(foregroundArray[_loc3_]);
  424.             _loc3_++;
  425.          }
  426.          foreArray.splice(0);
  427.          elementArray.splice(0);
  428.          foregroundArray.splice(0);
  429.          landscape.removeChild(skyscape);
  430.          landscape.removeChild(backscape);
  431.          landscape.removeChild(midscape);
  432.          landscape.removeChild(nearscape);
  433.          landscape.removeChild(forescape);
  434.          scope.removeChild(groundscape);
  435.          scope.removeChild(landscape);
  436.          scope.removeChild(element);
  437.          scope.removeChild(foreground);
  438.       }
  439.    }
  440. }
  441.