home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / zombietypocalypse.swf / scripts / game / Level.as < prev    next >
Encoding:
Text File  |  2008-09-15  |  37.0 KB  |  1,138 lines
  1. package game
  2. {
  3.    import flash.display.MovieClip;
  4.    import flash.display.Sprite;
  5.    import flash.events.Event;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.TimerEvent;
  8.    import flash.text.TextField;
  9.    import flash.text.TextFormat;
  10.    import flash.utils.Timer;
  11.    import flash.utils.clearTimeout;
  12.    import flash.utils.getDefinitionByName;
  13.    import flash.utils.getTimer;
  14.    import flash.utils.setTimeout;
  15.    import game.Guns.Gun;
  16.    import game.panel.ComboPanel;
  17.    import game.panel.Dock;
  18.    import game.panel.Energy;
  19.    import game.panel.NoAmmo;
  20.    import game.powerUps.Ammo;
  21.    import game.powerUps.Bomb;
  22.    import game.powerUps.FirstAid;
  23.    import game.powerUps.Money;
  24.    import game.powerUps.PowerUp;
  25.    import game.powerUps.SlowDown;
  26.    import game.upgrades.ElectricFence;
  27.    import game.upgrades.Grenade;
  28.    
  29.    public class Level extends Sprite
  30.    {
  31.        
  32.       
  33.       internal var inputText:TextField;
  34.       
  35.       public var addBombTimer:Timer;
  36.       
  37.       internal var speedUpInterval:uint;
  38.       
  39.       internal var front:MovieClip;
  40.       
  41.       public var addCashTimer:Timer;
  42.       
  43.       internal var dock:Dock;
  44.       
  45.       public var hintFreezer:Boolean = false;
  46.       
  47.       internal var levelZombieSpred:Number;
  48.       
  49.       public var levelZombiesQuestions:Array;
  50.       
  51.       internal var levelTime:int = 110000;
  52.       
  53.       internal var nextTarget:GameZombie;
  54.       
  55.       public var zombieFromHolePropability:Number;
  56.       
  57.       internal var levelOver:Boolean;
  58.       
  59.       internal var levelAddZombieTimeSpred:Number;
  60.       
  61.       public var energy:Energy;
  62.       
  63.       public var zombieDoubleFoodPropability:Number;
  64.       
  65.       public var hintBody:Boolean = false;
  66.       
  67.       internal var synchroniser:int = 0;
  68.       
  69.       public var elcticFence:ElectricFence;
  70.       
  71.       internal var player:Player;
  72.       
  73.       public var levelZombies:Array;
  74.       
  75.       public var zombieCounter:int;
  76.       
  77.       internal var highLitedRed:TextFormat;
  78.       
  79.       public var lives:*;
  80.       
  81.       internal var toZombieShot:Boolean;
  82.       
  83.       internal var isOver:Boolean;
  84.       
  85.       internal var levelAddZombieTimeOffset:Number;
  86.       
  87.       public var addFirstAidTimer:Timer;
  88.       
  89.       internal var levelStartTime:int;
  90.       
  91.       internal var background:GameBackground;
  92.       
  93.       internal var comboPanel:ComboPanel;
  94.       
  95.       public var isHiding:Boolean = false;
  96.       
  97.       internal var questions:QuestionsList;
  98.       
  99.       internal var curretTarget:GameZombie;
  100.       
  101.       internal var ammoContainer:MovieClip;
  102.       
  103.       internal var addZombieTimer:Timer;
  104.       
  105.       public var zombieIsFemalePropability:Number;
  106.       
  107.       internal var ixMinmumOffset:int;
  108.       
  109.       public var addAmmoTimer:Timer;
  110.       
  111.       internal var currentLevel:int;
  112.       
  113.       internal var levelPowerUps:Array;
  114.       
  115.       public var hintZombie:Boolean = false;
  116.       
  117.       internal var combo:int;
  118.       
  119.       public var addSlowDownTimer:Timer;
  120.       
  121.       private var itrvalID:*;
  122.       
  123.       internal var sManager:SoundManager;
  124.       
  125.       public var zombieID:int;
  126.       
  127.       internal var nextZ:Number = 0;
  128.       
  129.       public var zombieSpeed:int;
  130.       
  131.       internal var lastTarget:GameZombie;
  132.       
  133.       internal var zetMinmumOffset:int;
  134.       
  135.       internal var zombieTypes:Array;
  136.       
  137.       internal var levelZombieOffset:Number;
  138.       
  139.       public function Level()
  140.       {
  141.          levelZombies = new Array();
  142.          levelPowerUps = new Array();
  143.          levelZombiesQuestions = new Array();
  144.          zombieTypes = new Array();
  145.          isHiding = false;
  146.          hintZombie = false;
  147.          hintBody = false;
  148.          hintFreezer = false;
  149.          nextZ = 0;
  150.          levelTime = 110000;
  151.          synchroniser = 0;
  152.          super();
  153.          comboPanel = new ComboPanel();
  154.          questions = new QuestionsList();
  155.          player = ThisGameManager.getInstance().player;
  156.          front = MovieClip(ThisGameManager.getInstance().getChildByName("frontGround"));
  157.          front.addChild(comboPanel);
  158.          ammoContainer = MovieClip(ThisGameManager.getInstance().getChildByName("ammo"));
  159.          inputText = TextField(ThisGameManager.getInstance().getChildByName("inputTextt"));
  160.          inputText.text = "";
  161.          inputText.embedFonts = true;
  162.          inputText.defaultTextFormat.font = ThisGameManager.getInstance().Bold.fontName;
  163.          highLitedRed = inputText.defaultTextFormat;
  164.          highLitedRed.color = 16711680;
  165.          ThisGameManager.getInstance().gameOver = false;
  166.          nextZ = Math.random();
  167.          zombieID = 0;
  168.          ThisGameManager.getInstance().currentLevel = 1;
  169.          energy = new Energy();
  170.          dock = Dock(ThisGameManager.getInstance().getChildByName("dockk"));
  171.          ThisGameManager.getInstance().guns[1].addEventListener(Gun.SHOT,dock.updateHand);
  172.          ThisGameManager.getInstance().guns[2].addEventListener(Gun.SHOT,dock.updateMachine);
  173.          ThisGameManager.getInstance().guns[3].addEventListener(Gun.SHOT,dock.updateMachine);
  174.          ThisGameManager.getInstance().guns[4].addEventListener(Gun.SHOT,dock.updateBazooka);
  175.          ThisGameManager.getInstance().guns[5].addEventListener(Gun.SHOT,dock.updateBazooka);
  176.          swapGuns(0);
  177.          background = ThisGameManager.getInstance().background;
  178.          zombieTypes.push("Zombie_standard");
  179.          zombieTypes.push("Zombie_chick");
  180.          zombieTypes.push("Zombie_fat");
  181.          zombieTypes.push("Zombie_groovie");
  182.          zombieTypes.push("Zombie_nerd");
  183.          zombieTypes.push("Zombie_beheaded");
  184.          sManager = ThisGameManager.getInstance().soundManager;
  185.          levelZombieSpred = 600;
  186.          levelZombieOffset = 100;
  187.          levelAddZombieTimeSpred = 2000;
  188.          levelAddZombieTimeOffset = 2000;
  189.          ixMinmumOffset = 300;
  190.          zetMinmumOffset = 250000;
  191.          MovieClip(ThisGameManager.getInstance().getChildByName("gameContainer")).addChild(this);
  192.          addZombieTimer = new Timer(1,1);
  193.          addZombieTimer.addEventListener(TimerEvent.TIMER,addZombie);
  194.          addAmmoTimer = new Timer(5000,1);
  195.          addAmmoTimer.addEventListener(TimerEvent.TIMER,addAmmo);
  196.          addBombTimer = new Timer(15000 + Math.random() * 10000,1);
  197.          addBombTimer.addEventListener(TimerEvent.TIMER,addSomePowerUp);
  198.          addFirstAidTimer = new Timer(15000 + Math.random() * 20000,1);
  199.          addFirstAidTimer.addEventListener(TimerEvent.TIMER,addSomePowerUp);
  200.          addSlowDownTimer = new Timer(25000 + Math.random() * 10000,1);
  201.          addSlowDownTimer.addEventListener(TimerEvent.TIMER,addSomePowerUp);
  202.          addCashTimer = new Timer(15000 + Math.random() * 25000,1);
  203.          addCashTimer.addEventListener(TimerEvent.TIMER,addSomePowerUp);
  204.       }
  205.       
  206.       private function zombieSpeedDown() : void
  207.       {
  208.          var _loc1_:int = 0;
  209.          sManager.givePowerUpSound(5);
  210.          _loc1_ = 0;
  211.          while(_loc1_ < levelZombies.length)
  212.          {
  213.             GameZombie(levelZombies[_loc1_]).speed = 15 - 2.5 * player.flypaperCanonLevel;
  214.             _loc1_++;
  215.          }
  216.          ThisGameManager.getInstance().level.zombieSpeed = 15 - 2.5 * player.flypaperCanonLevel;
  217.          speedUpInterval = setTimeout(zombieSpeedUp,5000 + 10000 * (player.flypaperCanonLevel / 2));
  218.       }
  219.       
  220.       private function powerUpsOnBottom() : void
  221.       {
  222.          var _loc1_:int = 0;
  223.          _loc1_ = 0;
  224.          while(_loc1_ < levelPowerUps.length)
  225.          {
  226.             ammoContainer.addChildAt(levelPowerUps[_loc1_],0);
  227.             _loc1_++;
  228.          }
  229.       }
  230.       
  231.       private function clearALL() : void
  232.       {
  233.          var _loc1_:int = 0;
  234.          var _loc2_:int = 0;
  235.          _loc1_ = 0;
  236.          while(_loc1_ < levelZombies.length)
  237.          {
  238.             GameZombie(levelZombies[_loc1_]).cloud.clearHighLight();
  239.             _loc1_++;
  240.          }
  241.          _loc2_ = 0;
  242.          while(_loc2_ < levelPowerUps.length)
  243.          {
  244.             PowerUp(levelPowerUps[_loc2_]).cloud.clearHighLight();
  245.             _loc2_++;
  246.          }
  247.       }
  248.       
  249.       private function addZombie(param1:TimerEvent) : void
  250.       {
  251.          var _loc2_:Boolean = false;
  252.          var _loc3_:* = undefined;
  253.          var _loc4_:Class = null;
  254.          var _loc5_:int = 0;
  255.          var _loc6_:GameZombie = null;
  256.          var _loc7_:* = undefined;
  257.          var _loc8_:* = undefined;
  258.          var _loc9_:int = 0;
  259.          var _loc10_:int = 0;
  260.          var _loc11_:Array = null;
  261.          var _loc12_:int = 0;
  262.          var _loc13_:Number = NaN;
  263.          var _loc14_:int = 0;
  264.          var _loc15_:int = 0;
  265.          if(zombieCounter - levelZombies.length <= 0)
  266.          {
  267.             return;
  268.          }
  269.          addZombieTimer.delay = Math.random() * levelAddZombieTimeSpred + levelAddZombieTimeOffset;
  270.          addZombieTimer.reset();
  271.          addZombieTimer.start();
  272.          _loc2_ = true;
  273.          _loc3_ = 0;
  274.          while(true)
  275.          {
  276.             _loc7_ = Math.random() * levelZombieSpred + levelZombieOffset - background.getVanishingPoint().x;
  277.             _loc2_ = true;
  278.             _loc8_ = 0;
  279.             while(_loc8_ < levelZombies.length)
  280.             {
  281.                if(Math.abs(GameZombie(levelZombies[_loc8_]).posinton.X - _loc7_) < ixMinmumOffset && Math.abs(GameZombie(levelZombies[_loc8_]).posinton.Z - GameZombie(levelZombies[_loc8_]).startZ) < zetMinmumOffset)
  282.                {
  283.                   _loc2_ = false;
  284.                }
  285.                _loc8_++;
  286.             }
  287.             if(++_loc3_ > 30)
  288.             {
  289.                break;
  290.             }
  291.             if(_loc2_)
  292.             {
  293.                _loc5_ = Math.floor(Math.random() * zombieTypes.length);
  294.                (_loc6_ = new (_loc4_ = getDefinitionByName(zombieTypes[_loc5_]) as Class)()).setIsFemale(_loc5_ == 0 || _loc5_ == 1);
  295.                if(nextZ > zombieFromHolePropability)
  296.                {
  297.                   nextZ = Math.random();
  298.                   if(!_loc6_.setZombie(currentLevel - player.dumbifierLevel,false,_loc7_))
  299.                   {
  300.                      _loc6_.deleteMe();
  301.                      return;
  302.                   }
  303.                   this.addChildAt(_loc6_,0);
  304.                }
  305.                else
  306.                {
  307.                   if(nextZ < 0)
  308.                   {
  309.                      _loc9_ = 1;
  310.                   }
  311.                   else
  312.                   {
  313.                      _loc9_ = Math.floor(Math.random() * 3);
  314.                   }
  315.                   nextZ = Math.random();
  316.                   _loc10_ = this.numChildren;
  317.                   _loc11_ = background.getFloorHole()[background.getCurrntBackground() - 1];
  318.                   _loc2_ = true;
  319.                   _loc12_ = _loc9_;
  320.                   while(_loc12_ < _loc9_ + 3)
  321.                   {
  322.                      _loc2_ = true;
  323.                      _loc15_ = 0;
  324.                      while(_loc15_ < levelZombies.length)
  325.                      {
  326.                         if(Math.abs(GameZombie(levelZombies[_loc15_]).posinton.X - _loc11_[_loc12_ % 3].X) < ixMinmumOffset && Math.abs(GameZombie(levelZombies[_loc15_]).posinton.Z - _loc11_[_loc12_ % 3].Z) < zetMinmumOffset)
  327.                         {
  328.                            _loc2_ = false;
  329.                         }
  330.                         _loc15_++;
  331.                      }
  332.                      if(_loc2_)
  333.                      {
  334.                         _loc9_ = _loc12_ % 3;
  335.                         break;
  336.                      }
  337.                      _loc12_++;
  338.                   }
  339.                   if(!_loc2_)
  340.                   {
  341.                      _loc6_.deleteMe();
  342.                      return;
  343.                   }
  344.                   _loc13_ = Number(background.getFloorHole()[background.getCurrntBackground() - 1][_loc9_].Z);
  345.                   _loc7_ = background.getFloorHole()[background.getCurrntBackground() - 1][_loc9_].X;
  346.                   if(!_loc6_.setZombie(currentLevel - player.dumbifierLevel,true,_loc7_,_loc13_))
  347.                   {
  348.                      _loc6_.deleteMe();
  349.                      return;
  350.                   }
  351.                   _loc14_ = 0;
  352.                   while(_loc14_ < this.numChildren)
  353.                   {
  354.                      if(this.getChildAt(_loc14_) == elcticFence)
  355.                      {
  356.                         if(ElectricFence(this.getChildAt(_loc14_)).posinton.Z < _loc13_)
  357.                         {
  358.                            _loc10_ = _loc14_;
  359.                            break;
  360.                         }
  361.                      }
  362.                      else if(GameZombie(this.getChildAt(_loc14_)).posinton.Z < _loc13_)
  363.                      {
  364.                         _loc10_ = _loc14_;
  365.                         break;
  366.                      }
  367.                      _loc14_++;
  368.                   }
  369.                   this.addChildAt(_loc6_,_loc10_);
  370.                }
  371.                _loc6_.addEventListener(GameZombie.DELETE,deleteZombie);
  372.                levelZombies.push(_loc6_);
  373.                return;
  374.             }
  375.          }
  376.       }
  377.       
  378.       public function zombieSpeedUp() : void
  379.       {
  380.          var _loc1_:int = 0;
  381.          sManager.givePowerUpSound(6);
  382.          _loc1_ = 0;
  383.          while(_loc1_ < levelZombies.length)
  384.          {
  385.             GameZombie(levelZombies[_loc1_]).speed = 15;
  386.             _loc1_++;
  387.          }
  388.          ThisGameManager.getInstance().level.zombieSpeed = 15;
  389.       }
  390.       
  391.       public function setLevel(param1:int) : void
  392.       {
  393.          var _loc2_:int = 0;
  394.          var _loc3_:int = 0;
  395.          var _loc4_:int = 0;
  396.          comboPanel.visible = false;
  397.          questions = new QuestionsList();
  398.          levelOver = false;
  399.          combo = 1;
  400.          elcticFence = null;
  401.          zombieSpeed = 15;
  402.          swapGuns(0);
  403.          addZombieTimer.delay = 1000;
  404.          isOver = false;
  405.          currentLevel = param1;
  406.          levelAddZombieTimeOffset -= 100;
  407.          zombieFromHolePropability = (7 - param1) * 0.15;
  408.          zombieIsFemalePropability = (param1 - 1) * 0.06;
  409.          zombieDoubleFoodPropability = (param1 - 2) * 0.052;
  410.          _loc2_ = 100;
  411.          _loc3_ = 200;
  412.          _loc4_ = 10;
  413.          energy.gotoAndStop(1);
  414.          this.parent.addChild(energy);
  415.          ThisGameManager.getInstance().guns[0].bullets = _loc2_;
  416.          ThisGameManager.getInstance().guns[1].bullets = _loc2_;
  417.          ThisGameManager.getInstance().guns[2].bullets = _loc3_;
  418.          ThisGameManager.getInstance().guns[3].bullets = _loc3_;
  419.          ThisGameManager.getInstance().guns[4].bullets = _loc4_;
  420.          ThisGameManager.getInstance().guns[5].bullets = _loc4_;
  421.          lives = 4;
  422.          background.setBackground(int((param1 - 1) / 2) + 1);
  423.          levelZombies = new Array();
  424.          levelZombiesQuestions = new Array();
  425.          levelPowerUps = new Array();
  426.          zombieCounter = 15 + int(1.4 * param1);
  427.          ThisGameManager.getInstance().stage.removeEventListener(KeyboardEvent.KEY_DOWN,nextLeter);
  428.       }
  429.       
  430.       private function getPowerUp(param1:PowerUp) : void
  431.       {
  432.          param1.giveMeWhatYouHave();
  433.          clearALL();
  434.          param1.cloud.setHighLight(param1.myText);
  435.          setTimeout(param1.deleteMe,500);
  436.          clearText();
  437.       }
  438.       
  439.       public function stopAll() : void
  440.       {
  441.          var _loc1_:int = 0;
  442.          addZombieTimer.stop();
  443.          _loc1_ = 0;
  444.          while(_loc1_ < levelZombies.length)
  445.          {
  446.             GameZombie(levelZombies[_loc1_]).stopMoving();
  447.             _loc1_++;
  448.          }
  449.       }
  450.       
  451.       private function nextLevel() : void
  452.       {
  453.          var _loc1_:int = 0;
  454.          finishLevel();
  455.          _loc1_ = levelTime + 10000 * currentLevel - (getTimer() - levelStartTime) / 500;
  456.          ThisGameManager.getInstance().gun1.removeEventListener(Gun.FIRE_CPLT,synchroGuns);
  457.          ThisGameManager.getInstance().gun2.removeEventListener(Gun.FIRE_CPLT,synchroGuns);
  458.          ThisGameManager.getInstance().stage.removeEventListener(KeyboardEvent.KEY_DOWN,nextLeter);
  459.          ++ThisGameManager.getInstance().currentLevel;
  460.          if(ThisGameManager.getInstance().currentLevel > 10)
  461.          {
  462.             ThisGameManager.getInstance().gameOver = true;
  463.             ThisGameManager.getInstance().currentLevel = 1;
  464.          }
  465.          ThisGameManager.getInstance().play();
  466.       }
  467.       
  468.       public function waitToSpeedUp(param1:int) : void
  469.       {
  470.          itrvalID = setTimeout(zombieSpeedUp,param1);
  471.       }
  472.       
  473.       public function start() : void
  474.       {
  475.          var _loc1_:Array = null;
  476.          var _loc2_:int = 0;
  477.          var _loc3_:int = 0;
  478.          _loc1_ = ThisGameManager.getInstance().guns;
  479.          _loc2_ = 0;
  480.          _loc3_ = 0;
  481.          while(_loc3_ < _loc1_.length)
  482.          {
  483.             Gun(_loc1_[_loc3_]).visible = false;
  484.             _loc3_++;
  485.          }
  486.          ThisGameManager.getInstance().gun1 = Gun(_loc1_[_loc2_ * 2]);
  487.          ThisGameManager.getInstance().gun2 = Gun(_loc1_[_loc2_ * 2 + 1]);
  488.          ThisGameManager.getInstance().gun1.visible = true;
  489.          ThisGameManager.getInstance().gun2.visible = true;
  490.          player.currentGunID = _loc2_;
  491.          player.currentBulletsIDs[0] = 0;
  492.          dock.setAll();
  493.          levelStartTime = getTimer();
  494.          addZombieTimer.start();
  495.          addAmmoTimer.start();
  496.          addBombTimer.start();
  497.          addFirstAidTimer.start();
  498.          addSlowDownTimer.start();
  499.          addCashTimer.start();
  500.          unLockGuns(null);
  501.          clearText();
  502.          this.addEventListener(Event.ENTER_FRAME,sortZombieByZ);
  503.       }
  504.       
  505.       private function deletePowerUp(param1:Event) : void
  506.       {
  507.          var _loc2_:Number = NaN;
  508.          var _loc3_:int = 0;
  509.          _loc2_ = levelPowerUps.length;
  510.          while(_loc2_ >= 0)
  511.          {
  512.             if(levelPowerUps[_loc2_] == param1.target)
  513.             {
  514.                levelPowerUps.splice(_loc2_,1);
  515.                break;
  516.             }
  517.             _loc3_ = 0;
  518.             while(_loc3_ < PowerUp.getPlaces().length)
  519.             {
  520.                if(PowerUp(param1.target).posinton.Z == PowerUp.getPlaces()[_loc3_][1])
  521.                {
  522.                   PowerUp.getPlaces()[_loc3_][2] = false;
  523.                   break;
  524.                }
  525.                _loc3_++;
  526.             }
  527.             _loc2_--;
  528.          }
  529.       }
  530.       
  531.       private function shotSomeWhere() : void
  532.       {
  533.          lockGuns();
  534.          ThisGameManager.getInstance().gun1.fireInAir(inputText.text.length);
  535.          ThisGameManager.getInstance().gun2.fireInAir(inputText.text.length);
  536.          clearALL();
  537.       }
  538.       
  539.       private function synchroGuns(param1:Event) : void
  540.       {
  541.          ++synchroniser;
  542.          if(synchroniser == 2)
  543.          {
  544.             unLockGuns(null);
  545.          }
  546.       }
  547.       
  548.       public function getQuestions() : QuestionsList
  549.       {
  550.          return questions;
  551.       }
  552.       
  553.       private function addPowerUp(param1:PowerUp) : void
  554.       {
  555.          ammoContainer.addChild(param1);
  556.          levelPowerUps.push(param1);
  557.          levelPowerUps.sort(compareAmmo);
  558.          powerUpsOnBottom();
  559.          param1.addEventListener(PowerUp.DELETE,deletePowerUp);
  560.       }
  561.       
  562.       private function finishLevel() : void
  563.       {
  564.          var _loc1_:int = 0;
  565.          var _loc2_:int = 0;
  566.          this.removeEventListener(Event.ENTER_FRAME,sortZombieByZ);
  567.          levelOver = true;
  568.          isOver = true;
  569.          addZombieTimer.stop();
  570.          if(addAmmoTimer.running)
  571.          {
  572.             addAmmoTimer.stop();
  573.          }
  574.          if(addBombTimer.running)
  575.          {
  576.             addBombTimer.stop();
  577.          }
  578.          if(addFirstAidTimer.running)
  579.          {
  580.             addFirstAidTimer.stop();
  581.          }
  582.          if(addSlowDownTimer.running)
  583.          {
  584.             addSlowDownTimer.stop();
  585.          }
  586.          if(addCashTimer.running)
  587.          {
  588.             addCashTimer.stop();
  589.          }
  590.          if(elcticFence != null)
  591.          {
  592.             elcticFence.kill();
  593.          }
  594.          clearTimeout(itrvalID);
  595.          clearTimeout(speedUpInterval);
  596.          ThisGameManager.getInstance().level.zombieSpeed = 15;
  597.          _loc1_ = int(levelZombies.length - 1);
  598.          while(_loc1_ >= 0)
  599.          {
  600.             GameZombie(levelZombies[_loc1_]).deleteMe();
  601.             _loc1_--;
  602.          }
  603.          _loc2_ = int(levelPowerUps.length - 1);
  604.          while(_loc2_ >= 0)
  605.          {
  606.             PowerUp(levelPowerUps[_loc2_]).killMySlef();
  607.             _loc2_--;
  608.          }
  609.          ThisGameManager.getInstance().stage.removeEventListener(KeyboardEvent.KEY_DOWN,nextLeter);
  610.          inputText.text = "";
  611.          ThisGameManager.getInstance().gun1.removeEventListener(Gun.FIRE_CPLT,synchroGuns);
  612.          ThisGameManager.getInstance().gun2.removeEventListener(Gun.FIRE_CPLT,synchroGuns);
  613.       }
  614.       
  615.       public function unLockGuns(param1:Event) : void
  616.       {
  617.          synchroniser = 0;
  618.          curretTarget = null;
  619.          if(nextTarget != null)
  620.          {
  621.             if(player.bullets[player.currentGunID][player.currentBulletsIDs[player.currentGunID]] > 0)
  622.             {
  623.                killZombie(nextTarget);
  624.             }
  625.             else
  626.             {
  627.                sManager.giveCyngielSound();
  628.                inputText.text = "";
  629.                clearALL();
  630.                front.addChild(new NoAmmo());
  631.             }
  632.          }
  633.          ThisGameManager.getInstance().stage.addEventListener(KeyboardEvent.KEY_DOWN,nextLeter);
  634.       }
  635.       
  636.       private function bulletsChange(param1:int) : void
  637.       {
  638.          var _loc2_:* = undefined;
  639.          var _loc3_:int = 0;
  640.          var _loc4_:int = 0;
  641.          _loc2_ = player.currentBulletsIDs[player.currentGunID];
  642.          _loc3_ = 4;
  643.          if(player.currentGunID == 2)
  644.          {
  645.             _loc3_ = 2;
  646.          }
  647.          _loc4_ = param1;
  648.          while(_loc4_ != 2 * _loc3_ && _loc4_ != -2 * _loc3_)
  649.          {
  650.             if(player.bullets[player.currentGunID][(_loc2_ + Math.abs(_loc4_)) % _loc3_] > 0)
  651.             {
  652.                player.currentBulletsIDs[player.currentGunID] = (_loc2_ + Math.abs(_loc4_)) % _loc3_;
  653.                dock.setAll();
  654.                return;
  655.             }
  656.             _loc4_ += param1;
  657.          }
  658.       }
  659.       
  660.       private function nextLeter(param1:KeyboardEvent) : void
  661.       {
  662.          var _loc2_:String = null;
  663.          var _loc3_:Boolean = false;
  664.          var _loc4_:int = 0;
  665.          var _loc5_:int = 0;
  666.          if(param1.charCode > 48 && param1.charCode < 55)
  667.          {
  668.             swapGuns(param1.charCode - 49);
  669.             return;
  670.          }
  671.          _loc2_ = String.fromCharCode(param1.charCode);
  672.          if(_loc2_ == "]" || _loc2_ == "}")
  673.          {
  674.             bulletsChange(1);
  675.             return;
  676.          }
  677.          if(_loc2_ == "[" || _loc2_ == "{")
  678.          {
  679.             bulletsChange(-1);
  680.             return;
  681.          }
  682.          if(!(param1.charCode > 64 && param1.charCode < 91 || param1.charCode > 96 && param1.charCode < 124) && _loc2_ != "\'" && _loc2_ != " " && _loc2_ != "!" && _loc2_ != "?" && _loc2_ != ":" && _loc2_ != ",")
  683.          {
  684.             return;
  685.          }
  686.          toZombieShot = false;
  687.          inputText.text = inputText.text.concat(String.fromCharCode(param1.charCode)).toLowerCase();
  688.          if(player.bullets[player.currentGunID][player.currentBulletsIDs[player.currentGunID]] > 0)
  689.          {
  690.             _loc4_ = 0;
  691.             while(true)
  692.             {
  693.                if(_loc4_ < levelZombies.length)
  694.                {
  695.                   _loc3_ = true;
  696.                   _loc5_ = 0;
  697.                   while(_loc5_ < inputText.text.length)
  698.                   {
  699.                      if(GameZombie(levelZombies[_loc4_]).myText.length < inputText.text.length || GameZombie(levelZombies[_loc4_]).myText.charAt(_loc5_) != inputText.text.charAt(_loc5_))
  700.                      {
  701.                         _loc3_ = false;
  702.                         break;
  703.                      }
  704.                      _loc5_++;
  705.                   }
  706.                   continue;
  707.                }
  708.             }
  709.             GameZombie(levelZombies[_loc4_]).cloud.setHighLight(inputText.text);
  710.             lastTarget = GameZombie(levelZombies[_loc4_]);
  711.             if(GameZombie(levelZombies[_loc4_]).myText.length == inputText.text.length)
  712.             {
  713.                tryToKillZombie(GameZombie(levelZombies[_loc4_]));
  714.             }
  715.             return;
  716.          }
  717.          _loc4_ = 0;
  718.          while(true)
  719.          {
  720.             if(_loc4_ >= levelPowerUps.length)
  721.             {
  722.                if(!_loc3_ && player.bullets[player.currentGunID][player.currentBulletsIDs[player.currentGunID]] <= 0)
  723.                {
  724.                   sManager.giveCyngielSound();
  725.                   inputText.text = "";
  726.                   front.addChild(new NoAmmo());
  727.                   return;
  728.                }
  729.                if(!_loc3_)
  730.                {
  731.                   dontKillZombie(lastTarget);
  732.                   inputText.setTextFormat(highLitedRed,inputText.text.length - 1,inputText.text.length);
  733.                   if(!ThisGameManager.getInstance().mute)
  734.                   {
  735.                      sManager.wrongLeter.play();
  736.                   }
  737.                }
  738.                return;
  739.             }
  740.             _loc3_ = true;
  741.             _loc5_ = 0;
  742.             while(_loc5_ < inputText.text.length)
  743.             {
  744.                if(PowerUp(levelPowerUps[_loc4_]).myText.length < inputText.text.length || PowerUp(levelPowerUps[_loc4_]).myText.charAt(_loc5_) != inputText.text.charAt(_loc5_))
  745.                {
  746.                   _loc3_ = false;
  747.                   break;
  748.                }
  749.                _loc5_++;
  750.             }
  751.             if(_loc3_)
  752.             {
  753.                break;
  754.             }
  755.             _loc4_++;
  756.          }
  757.          PowerUp(levelPowerUps[_loc4_]).cloud.setHighLight(inputText.text);
  758.          if(PowerUp(levelPowerUps[_loc4_]).myText.length == inputText.text.length)
  759.          {
  760.             getPowerUp(PowerUp(levelPowerUps[_loc4_]));
  761.          }
  762.       }
  763.       
  764.       public function moveZombieBack(param1:Event) : void
  765.       {
  766.          var _loc2_:int = 0;
  767.          if(toZombieShot)
  768.          {
  769.             _loc2_ = 0;
  770.             while(_loc2_ < levelZombies.length)
  771.             {
  772.                GameZombie(levelZombies[_loc2_]).posinton.Z = GameZombie(levelZombies[_loc2_]).posinton.Z + 50000;
  773.                if(GameZombie(levelZombies[_loc2_]).posinton.Z > 450000)
  774.                {
  775.                   GameZombie(levelZombies[_loc2_]).posinton.Z = 450000;
  776.                }
  777.                _loc2_++;
  778.             }
  779.          }
  780.       }
  781.       
  782.       private function sortZombieByZ(param1:Event) : void
  783.       {
  784.          var _loc2_:Boolean = false;
  785.          var _loc3_:int = 0;
  786.          levelZombies.sort(compareZombie,Array.DESCENDING);
  787.          _loc2_ = false;
  788.          if(elcticFence == null)
  789.          {
  790.             _loc2_ = true;
  791.          }
  792.          _loc3_ = 0;
  793.          while(_loc3_ < levelZombies.length)
  794.          {
  795.             if(!_loc2_ && GameZombie(levelZombies[_loc3_]).posinton.Z < elcticFence.posinton.Z)
  796.             {
  797.                this.addChild(elcticFence);
  798.                _loc2_ = true;
  799.             }
  800.             this.addChild(levelZombies[_loc3_]);
  801.             _loc3_++;
  802.          }
  803.       }
  804.       
  805.       private function lockGuns() : void
  806.       {
  807.          ThisGameManager.getInstance().gun1.addEventListener(Gun.FIRE_CPLT,synchroGuns);
  808.          ThisGameManager.getInstance().gun2.addEventListener(Gun.FIRE_CPLT,synchroGuns);
  809.       }
  810.       
  811.       private function killNearest(param1:GameZombie) : void
  812.       {
  813.          var _loc2_:int = 0;
  814.          var _loc3_:GameZombie = null;
  815.          var _loc4_:int = 0;
  816.          if(levelZombies[0] != param1)
  817.          {
  818.             _loc3_ = levelZombies[0];
  819.             _loc2_ = Math.abs(param1.posinton.Z - levelZombies[0].posinton.Z);
  820.          }
  821.          else
  822.          {
  823.             if(levelZombies.length <= 1)
  824.             {
  825.                return;
  826.             }
  827.             _loc3_ = levelZombies[1];
  828.             _loc2_ = Math.abs(param1.posinton.Z - levelZombies[1].posinton.Z);
  829.          }
  830.          _loc4_ = 1;
  831.          while(_loc4_ < levelZombies.length)
  832.          {
  833.             if(levelZombies[_loc4_] != param1 && Math.abs(param1.posinton.Z - levelZombies[_loc4_].posinton.Z) < _loc2_)
  834.             {
  835.                _loc2_ = Math.abs(param1.posinton.Z - levelZombies[_loc4_].posinton.Z);
  836.                _loc3_ = levelZombies[_loc4_];
  837.             }
  838.             _loc4_++;
  839.          }
  840.          _loc3_.blowMeUp();
  841.       }
  842.       
  843.       private function clearText() : void
  844.       {
  845.          inputText.text = "";
  846.       }
  847.       
  848.       public function addAmmo(param1:TimerEvent) : void
  849.       {
  850.          var _loc2_:Ammo = null;
  851.          addAmmoTimer.delay = Math.random() * 10000 + 15000;
  852.          addAmmoTimer.reset();
  853.          _loc2_ = new Ammo();
  854.          if(!_loc2_.setMe(currentLevel - 1))
  855.          {
  856.             addAmmoTimer.start();
  857.             return;
  858.          }
  859.          if(Ammo.getCounter() < 3)
  860.          {
  861.             addAmmoTimer.start();
  862.          }
  863.          addPowerUp(_loc2_);
  864.       }
  865.       
  866.       private function killZombie(param1:GameZombie) : void
  867.       {
  868.          var _loc2_:* = undefined;
  869.          if(param1.isKillingMe)
  870.          {
  871.             lockGuns();
  872.             clearALL();
  873.             combo = 1;
  874.             comboPanel.visible = false;
  875.             setTimeout(unLockGuns,500,null);
  876.             setTimeout(clearText,500);
  877.             curretTarget = null;
  878.             nextTarget = null;
  879.             return;
  880.          }
  881.          curretTarget = param1;
  882.          nextTarget = null;
  883.          _loc2_ = 1;
  884.          if(combo > 3 && combo < 7)
  885.          {
  886.             _loc2_ = 2;
  887.          }
  888.          if(combo > 6)
  889.          {
  890.             _loc2_ = 3;
  891.          }
  892.          player.cash += 50 * _loc2_;
  893.          inputText.text = "";
  894.          if(combo == 3)
  895.          {
  896.             comboPanel.visible = true;
  897.          }
  898.          comboPanel.setNum(combo);
  899.          ++combo;
  900.          toZombieShot = true;
  901.          lockGuns();
  902.          ThisGameManager.getInstance().gun1.fireTo(param1.x,param1.y - param1.height / 2,inputText.text.length);
  903.          ThisGameManager.getInstance().gun2.fireTo(param1.x,param1.y - param1.height / 2,inputText.text.length);
  904.          if(ThisGameManager.getInstance().gun1 == ThisGameManager.getInstance().guns[4])
  905.          {
  906.             if(player.currentBulletsIDs[2] == 1)
  907.             {
  908.                killNearest(param1);
  909.             }
  910.             moveZombieBack(null);
  911.          }
  912.          clearALL();
  913.          param1.cloud.setHighLight(param1.myText);
  914.          param1.shotMe(null);
  915.       }
  916.       
  917.       private function getAmmo(param1:AmmoCase) : void
  918.       {
  919.          var _loc2_:int = 0;
  920.          var _loc3_:int = 0;
  921.          lockGuns();
  922.          if(ThisGameManager.getInstance().gun1 == ThisGameManager.getInstance().guns[0])
  923.          {
  924.             _loc2_ = 0;
  925.             _loc3_ = 100;
  926.          }
  927.          if(ThisGameManager.getInstance().gun1 == ThisGameManager.getInstance().guns[2])
  928.          {
  929.             _loc2_ = 1;
  930.             _loc3_ = 200;
  931.          }
  932.          if(ThisGameManager.getInstance().gun1 == ThisGameManager.getInstance().guns[4])
  933.          {
  934.             _loc2_ = 2;
  935.             _loc3_ = 20;
  936.          }
  937.          ThisGameManager.getInstance().gun1.bullets = ThisGameManager.getInstance().gun1.bullets + _loc3_;
  938.          ThisGameManager.getInstance().gun2.bullets = ThisGameManager.getInstance().gun2.bullets + _loc3_;
  939.          ThisGameManager.getInstance().gun1.fireTo(param1.x,param1.y - param1.height / 2,1);
  940.          ThisGameManager.getInstance().gun2.fireTo(param1.x,param1.y - param1.height / 2,1);
  941.          if(levelPowerUps.length < 3)
  942.          {
  943.             addAmmoTimer.start();
  944.          }
  945.       }
  946.       
  947.       private function tryToKillZombie(param1:GameZombie) : void
  948.       {
  949.          if(curretTarget == null)
  950.          {
  951.             killZombie(param1);
  952.          }
  953.          else if(nextTarget == null && param1 != curretTarget)
  954.          {
  955.             nextTarget = param1;
  956.          }
  957.       }
  958.       
  959.       private function compareAmmo(param1:PowerUp, param2:PowerUp) : int
  960.       {
  961.          if(param1.posinton.Z > param2.posinton.Z)
  962.          {
  963.             return 1;
  964.          }
  965.          if(param1.posinton.Z < param2.posinton.Z)
  966.          {
  967.             return -1;
  968.          }
  969.          return 0;
  970.       }
  971.       
  972.       private function swapGuns(param1:int) : void
  973.       {
  974.          var _loc2_:Array = null;
  975.          var _loc3_:int = 0;
  976.          if(param1 == 5)
  977.          {
  978.             if(player.flypaper[0] > 0)
  979.             {
  980.                --player.flypaper[0];
  981.                dock.updateFlypaper();
  982.                zombieSpeedDown();
  983.             }
  984.             return;
  985.          }
  986.          if(param1 == 3)
  987.          {
  988.             if(player.granades[0] > 0)
  989.             {
  990.                --player.granades[0];
  991.                dock.updateGrenades();
  992.                front.addChild(new Grenade());
  993.                lockGuns();
  994.             }
  995.             return;
  996.          }
  997.          if(param1 == 4)
  998.          {
  999.             if(elcticFence == null && player.fence[0] > 0)
  1000.             {
  1001.                --player.fence[0];
  1002.                dock.updateFence();
  1003.                new ElectricFence();
  1004.             }
  1005.             return;
  1006.          }
  1007.          if(curretTarget != null)
  1008.          {
  1009.             return;
  1010.          }
  1011.          if(player.currentGunID == param1)
  1012.          {
  1013.             bulletsChange(1);
  1014.             return;
  1015.          }
  1016.          if(param1 == 1 && !player.machineGunEnable)
  1017.          {
  1018.             return;
  1019.          }
  1020.          if(param1 == 2 && !player.rocketLauncherEnable)
  1021.          {
  1022.             return;
  1023.          }
  1024.          _loc2_ = ThisGameManager.getInstance().guns;
  1025.          _loc3_ = 0;
  1026.          while(_loc3_ < _loc2_.length)
  1027.          {
  1028.             Gun(_loc2_[_loc3_]).visible = false;
  1029.             _loc3_++;
  1030.          }
  1031.          ThisGameManager.getInstance().gun1 = Gun(_loc2_[param1 * 2]);
  1032.          ThisGameManager.getInstance().gun2 = Gun(_loc2_[param1 * 2 + 1]);
  1033.          ThisGameManager.getInstance().gun1.visible = true;
  1034.          ThisGameManager.getInstance().gun2.visible = true;
  1035.          player.currentGunID = param1;
  1036.       }
  1037.       
  1038.       private function compareZombie(param1:GameZombie, param2:GameZombie) : int
  1039.       {
  1040.          if(param1.posinton.Z > param2.posinton.Z)
  1041.          {
  1042.             return 1;
  1043.          }
  1044.          if(param1.posinton.Z < param2.posinton.Z)
  1045.          {
  1046.             return -1;
  1047.          }
  1048.          return 0;
  1049.       }
  1050.       
  1051.       public function killMe() : void
  1052.       {
  1053.          combo = 1;
  1054.          comboPanel.visible = false;
  1055.          --lives;
  1056.          energy.nextFrame();
  1057.          if(lives == 0)
  1058.          {
  1059.             finishLevel();
  1060.             player.saveLevel = ThisGameManager.getInstance().currentLevel;
  1061.             ThisGameManager.getInstance().currentLevel = 1;
  1062.             ThisGameManager.getInstance().gotoAndPlay("2Menu");
  1063.             return;
  1064.          }
  1065.       }
  1066.       
  1067.       private function addSomePowerUp(param1:TimerEvent) : void
  1068.       {
  1069.          var _loc2_:PowerUp = null;
  1070.          Timer(param1.target).delay = int(10000 + 30000 * Math.random());
  1071.          Timer(param1.target).reset();
  1072.          Timer(param1.target).start();
  1073.          if(param1.target == addBombTimer)
  1074.          {
  1075.             _loc2_ = new Bomb();
  1076.          }
  1077.          if(param1.target == addFirstAidTimer)
  1078.          {
  1079.             _loc2_ = new FirstAid();
  1080.          }
  1081.          if(param1.target == addSlowDownTimer)
  1082.          {
  1083.             _loc2_ = new SlowDown();
  1084.          }
  1085.          if(param1.target == addCashTimer)
  1086.          {
  1087.             _loc2_ = new Money();
  1088.          }
  1089.          if(!_loc2_.setMe(currentLevel - 1))
  1090.          {
  1091.             return;
  1092.          }
  1093.          addPowerUp(_loc2_);
  1094.       }
  1095.       
  1096.       private function dontKillZombie(param1:GameZombie) : void
  1097.       {
  1098.          combo = 1;
  1099.          comboPanel.visible = false;
  1100.          lockGuns();
  1101.          clearALL();
  1102.          setTimeout(clearText,500);
  1103.       }
  1104.       
  1105.       private function deleteZombie(param1:Event) : void
  1106.       {
  1107.          var _loc2_:Number = NaN;
  1108.          _loc2_ = 0;
  1109.          while(_loc2_ < levelZombies.length)
  1110.          {
  1111.             if(levelZombies[_loc2_] == param1.target)
  1112.             {
  1113.                GameZombie(levelZombies[_loc2_]).removeEventListener(GameZombie.DELETE,deleteZombie);
  1114.                levelZombies.splice(_loc2_,1);
  1115.                --zombieCounter;
  1116.                if(zombieCounter <= 0 && levelZombies.length == 0 && !isOver)
  1117.                {
  1118.                   nextLevel();
  1119.                }
  1120.             }
  1121.             _loc2_++;
  1122.          }
  1123.       }
  1124.       
  1125.       public function startAll() : void
  1126.       {
  1127.          var _loc1_:int = 0;
  1128.          addZombieTimer.start();
  1129.          _loc1_ = 0;
  1130.          while(_loc1_ < levelZombies.length)
  1131.          {
  1132.             GameZombie(levelZombies[_loc1_]).startMovig();
  1133.             _loc1_++;
  1134.          }
  1135.       }
  1136.    }
  1137. }
  1138.