home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / Never_End.swf / scripts / game / Main.as < prev    next >
Encoding:
Text File  |  2008-09-23  |  18.9 KB  |  594 lines
  1. package game
  2. {
  3.    import flash.display.MovieClip;
  4.    import flash.display.Sprite;
  5.    import flash.events.DataEvent;
  6.    import flash.events.Event;
  7.    import flash.events.KeyboardEvent;
  8.    import flash.events.MouseEvent;
  9.    import flash.geom.Point;
  10.    
  11.    public class Main extends MovieClip
  12.    {
  13.        
  14.       
  15.       private var frameSpr:Sprite;
  16.       
  17.       public var endMovie:EndMovie;
  18.       
  19.       private var cld:*;
  20.       
  21.       private var sdManager:SoundManager;
  22.       
  23.       private var frameRater:FrameRate;
  24.       
  25.       private var model:Model;
  26.       
  27.       private var currentRoomId:uint;
  28.       
  29.       private var loading:MovieClip;
  30.       
  31.       private var currentExit:Object;
  32.       
  33.       public var toolBar:ToolBar;
  34.       
  35.       private var broadCaster:BroadCaster;
  36.       
  37.       private var cookie:Cookie;
  38.       
  39.       private var nextRoom:int;
  40.       
  41.       public var splash:MovieClip;
  42.       
  43.       public var mMenu:MainMenu;
  44.       
  45.       public var settingField:*;
  46.       
  47.       private var _frameRate:Number = 30;
  48.       
  49.       private var selectList:UserMenu;
  50.       
  51.       private var currentData:Object;
  52.       
  53.       private var manDir:String = "right";
  54.       
  55.       private var roomContainer:MovieClip;
  56.       
  57.       public function Main()
  58.       {
  59.          _frameRate = 30;
  60.          manDir = "right";
  61.          super();
  62.          frameSpr = new Sprite();
  63.          addChild(frameSpr);
  64.          frameRater = new FrameRate(frameSpr);
  65.          stop();
  66.          stage.tabChildren = false;
  67.          stage.showDefaultContextMenu = false;
  68.          stage.scaleMode = "noScale";
  69.          Language.language = 1;
  70.          loading = new Loading();
  71.          loading.addEventListener("onLoadDone",init,false,0,true);
  72.          addChild(loading);
  73.       }
  74.       
  75.       private function activeRoom(param1:Event) : void
  76.       {
  77.          Model.state = "normal";
  78.          Model.isSleep = false;
  79.          model.currentRoom = cld;
  80.          currentRoomId = nextRoom;
  81.          model.currentRoomId = currentRoomId;
  82.       }
  83.       
  84.       private function movePlayer(param1:KeyboardEvent) : void
  85.       {
  86.          switch(param1.keyCode)
  87.          {
  88.             case 37:
  89.                Model._KEY_LEFT = true;
  90.                break;
  91.             case 38:
  92.                Model._KEY_UP = true;
  93.                break;
  94.             case 39:
  95.                Model._KEY_RIGHT = true;
  96.                break;
  97.             case 40:
  98.                Model._KEY_DOWN = true;
  99.          }
  100.       }
  101.       
  102.       private function init(param1:Event) : void
  103.       {
  104.          removeChild(loading);
  105.          loading.removeEventListener("onLoadDone",init);
  106.          loading = null;
  107.          this.gotoAndStop(3);
  108.          this.gotoAndStop(1);
  109.          sdManager = SoundManager.getInstance();
  110.          sdManager.loadSounds();
  111.          cookie = Cookie.getInstance();
  112.          addEventListener(Event.ENTER_FRAME,motion);
  113.          model = Model.getInstance();
  114.          broadCaster = BroadCaster.getInstance();
  115.          broadCaster.addEventListener("onSplashDone",setToolBar,false,0,true);
  116.          broadCaster.addEventListener("onGameWin",removeRoom,false,0,true);
  117.          broadCaster.addEventListener("onRoomRemoved",showMap,false,0,true);
  118.          broadCaster.addEventListener("onMapRemoved",showLevel,false,0,true);
  119.          broadCaster.addEventListener("onMapReady",activeMap,false,0,true);
  120.          broadCaster.addEventListener("onRoomReady",activeRoom,false,0,true);
  121.          broadCaster.addEventListener("onEnterRoom",enterNextlevel,false,0,true);
  122.          broadCaster.addEventListener("onGameOver",onGameOver,false,0,true);
  123.          broadCaster.addEventListener("onEnterGame",enterGame,false,0,true);
  124.          broadCaster.addEventListener("onQuitGame",initGame,false,0,true);
  125.          broadCaster.addEventListener("doorRemoved",scaleBack,false,0,true);
  126.          broadCaster.addEventListener("onEnterNewRoom",setCurrentRoom,false,0,true);
  127.          broadCaster.addEventListener("onFindFile",addNewFile,false,0,true);
  128.          broadCaster.addEventListener("onPlayerDied",onPlayerDied,false,0,true);
  129.          stage.addEventListener(MouseEvent.MOUSE_MOVE,dragTT);
  130.          stage.addEventListener(MouseEvent.MOUSE_UP,stopddd);
  131.          stage.addEventListener(KeyboardEvent.KEY_UP,changeRotation);
  132.          stage.addEventListener(KeyboardEvent.KEY_DOWN,movePlayer);
  133.          initGame();
  134.       }
  135.       
  136.       private function saveValue(param1:String, param2:Number) : void
  137.       {
  138.          var _loc3_:* = undefined;
  139.          _loc3_ = currentData[param1];
  140.          _loc3_ = _loc3_ == null ? 0 : _loc3_;
  141.          _loc3_ += param2;
  142.          currentData[param1] = _loc3_;
  143.       }
  144.       
  145.       private function showMap(param1:Event) : void
  146.       {
  147.          Model.state = "";
  148.          cld.alpha = 0.1;
  149.          cld.setPlayer(manDir);
  150.          cld.resetPlayerPosition(currentExit.x,currentExit.y);
  151.          cld.showMap();
  152.       }
  153.       
  154.       private function setCurrentRoom(param1:DataEvent) : void
  155.       {
  156.          toolBar.maps.setCurrentRoom(param1);
  157.       }
  158.       
  159.       private function initGame(param1:Event = null) : void
  160.       {
  161.          var e:Event = param1;
  162.          try
  163.          {
  164.             Model.state = "";
  165.             model.currentRoom.remove();
  166.             model.clearState();
  167.             removeChild(toolBar);
  168.             removeChild(roomContainer);
  169.             roomContainer = null;
  170.             toolBar = null;
  171.          }
  172.          catch(e:Error)
  173.          {
  174.          }
  175.          sdManager.clearAllSounds();
  176.          selectList = new UserMenu();
  177.          addChild(selectList);
  178.          stage.focus = stage;
  179.       }
  180.       
  181.       private function removeData() : void
  182.       {
  183.          var _loc1_:* = undefined;
  184.          var _loc2_:Array = null;
  185.          var _loc3_:Object = null;
  186.          var _loc4_:Object = null;
  187.          var _loc5_:Object = null;
  188.          var _loc6_:Object = null;
  189.          var _loc7_:Object = null;
  190.          var _loc8_:Number = NaN;
  191.          var _loc9_:Number = NaN;
  192.          var _loc10_:Number = NaN;
  193.          var _loc11_:Number = NaN;
  194.          var _loc12_:Number = NaN;
  195.          var _loc13_:int = 0;
  196.          var _loc14_:int = 0;
  197.          var _loc15_:Number = NaN;
  198.          var _loc16_:Number = NaN;
  199.          var _loc17_:Number = NaN;
  200.          var _loc18_:Number = NaN;
  201.          var _loc19_:Number = NaN;
  202.          var _loc20_:Object = null;
  203.          var _loc21_:Object = null;
  204.          var _loc22_:Array = null;
  205.          _loc1_ = currentData.cleared;
  206.          _loc1_ = _loc1_ == null ? 0 : _loc1_;
  207.          _loc1_++;
  208.          currentData.cleared = _loc1_;
  209.          _loc2_ = new Array();
  210.          _loc3_ = {
  211.             "time":0,
  212.             "die":0,
  213.             "run":0,
  214.             "rotate":0,
  215.             "jump":0
  216.          };
  217.          _loc4_ = currentData.data1;
  218.          _loc5_ = currentData.data2;
  219.          _loc6_ = currentData.data3;
  220.          _loc7_ = currentData.data4;
  221.          _loc2_.push(_loc4_ == null ? _loc3_ : _loc4_);
  222.          _loc2_.push(_loc5_ == null ? _loc3_ : _loc5_);
  223.          _loc2_.push(_loc6_ == null ? _loc3_ : _loc6_);
  224.          _loc2_.push(_loc7_ == null ? _loc3_ : _loc7_);
  225.          _loc8_ = Number(currentData.time);
  226.          _loc9_ = Number(currentData.died);
  227.          _loc10_ = Number(currentData.ran);
  228.          _loc11_ = Number(currentData.rotated);
  229.          _loc12_ = Number(currentData.jumped);
  230.          _loc9_ = isNaN(_loc9_) ? 0 : _loc9_;
  231.          _loc13_ = 0;
  232.          while(_loc13_ < _loc2_.length)
  233.          {
  234.             if(_loc13_ != -nextRoom - 1)
  235.             {
  236.                _loc8_ -= _loc2_[_loc13_].time;
  237.                _loc9_ -= _loc2_[_loc13_].die;
  238.                _loc10_ -= _loc2_[_loc13_].run;
  239.                _loc11_ -= _loc2_[_loc13_].rotate;
  240.                _loc12_ -= _loc2_[_loc13_].jump;
  241.             }
  242.             _loc13_++;
  243.          }
  244.          _loc14_ = -nextRoom - 1;
  245.          _loc15_ = _loc8_ - _loc2_[_loc14_].time;
  246.          _loc16_ = _loc9_ - _loc2_[_loc14_].die;
  247.          _loc17_ = _loc10_ - _loc2_[_loc14_].run;
  248.          _loc18_ = _loc11_ - _loc2_[_loc14_].rotate;
  249.          _loc19_ = _loc12_ - _loc2_[_loc14_].jump;
  250.          _loc20_ = currentData["minData" + -nextRoom];
  251.          _loc21_ = new Object();
  252.          _loc22_ = new Array();
  253.          _loc21_.newData = _loc22_;
  254.          getMinData(_loc20_,_loc21_,_loc15_,"time");
  255.          getMinData(_loc20_,_loc21_,_loc16_,"die");
  256.          getMinData(_loc20_,_loc21_,_loc17_,"run");
  257.          getMinData(_loc20_,_loc21_,_loc18_,"rotate");
  258.          getMinData(_loc20_,_loc21_,_loc19_,"jump");
  259.          _loc21_.time = _loc20_ != null && _loc20_.time < _loc15_ ? _loc20_.time : _loc15_;
  260.          _loc21_.die = _loc20_ != null && _loc20_.die < _loc16_ ? _loc20_.die : _loc16_;
  261.          _loc21_.run = _loc20_ != null && _loc20_.run < _loc17_ ? _loc20_.run : _loc17_;
  262.          _loc21_.rotate = _loc20_ != null && _loc20_.rotate < _loc18_ ? _loc20_.rotate : _loc18_;
  263.          _loc21_.jump = _loc20_ != null && _loc20_.jump < _loc19_ ? _loc20_.jump : _loc19_;
  264.          _loc21_.id = -nextRoom;
  265.          Model.ExitData = _loc21_;
  266.          currentData["data" + -nextRoom] = {
  267.             "time":_loc8_,
  268.             "die":_loc9_,
  269.             "run":_loc10_,
  270.             "rotate":_loc11_,
  271.             "jump":_loc12_
  272.          };
  273.          currentData["minData" + -nextRoom] = Model.ExitData;
  274.          cookie.saveData();
  275.          cookie.saveValue(null,"currentRoom");
  276.          Model.cData = null;
  277.       }
  278.       
  279.       private function scaleBack(param1:Event) : void
  280.       {
  281.          model.currentRoom.scaleBack();
  282.       }
  283.       
  284.       private function changeRotation(param1:KeyboardEvent) : void
  285.       {
  286.          if(model.currentRoom != null && !Model.disableKeyBoard && !Model.isGameOver)
  287.          {
  288.             switch(param1.keyCode)
  289.             {
  290.                case 88:
  291.                   if(Model.state == "normal" && Model.isStatic)
  292.                   {
  293.                      ++Model.rotated;
  294.                      model.clearState(false);
  295.                      this.toolBar.maps.setRotation(90);
  296.                      model.currentRoom.setRotation(90);
  297.                   }
  298.                   break;
  299.                case 90:
  300.                   if(Model.state == "normal" && Model.isStatic)
  301.                   {
  302.                      ++Model.rotated;
  303.                      model.clearState(false);
  304.                      model.currentRoom.setRotation(-90);
  305.                      this.toolBar.maps.setRotation(-90);
  306.                   }
  307.             }
  308.          }
  309.          switch(param1.keyCode)
  310.          {
  311.             case 37:
  312.                Model._KEY_LEFT = false;
  313.                break;
  314.             case 38:
  315.                Model._KEY_UP = false;
  316.                break;
  317.             case 39:
  318.                Model._KEY_RIGHT = false;
  319.                break;
  320.             case 40:
  321.                Model._KEY_DOWN = false;
  322.          }
  323.       }
  324.       
  325.       private function showLevel(param1:Event) : void
  326.       {
  327.       }
  328.       
  329.       private function enterNextlevel(param1:DataEvent) : void
  330.       {
  331.          var _loc2_:Array = null;
  332.          var _loc3_:uint = 0;
  333.          var _loc4_:* = undefined;
  334.          var _loc5_:Object = null;
  335.          var _loc6_:Point = null;
  336.          Model.state = "";
  337.          _loc2_ = param1.data.split(":");
  338.          nextRoom = Number(_loc2_[0]);
  339.          _loc3_ = Number(_loc2_[1]);
  340.          if(nextRoom >= 0)
  341.          {
  342.             model.currentRoom.removeMap();
  343.             _loc4_ = model.currentRoom.getBorder();
  344.             _loc5_ = model.getRoomLocation(nextRoom);
  345.             cld = new Room(nextRoom,_loc3_);
  346.             cld.setPlayer(manDir);
  347.             Model.cData.roomId = nextRoom;
  348.             Model.cData.entranceId = _loc3_;
  349.             Model.cData.rotation = Model.rotation;
  350.             Model.cData.ateBooks = toolBar.files.files;
  351.             cookie.saveValue(Model.cData,"currentRoom");
  352.             broadCaster.run("onEnterNewRoom",String(nextRoom));
  353.             roomContainer.addChild(cld);
  354.             _loc6_ = model.currentRoom.container.localToGlobal(new Point(_loc5_.x * 50,_loc5_.y * 50));
  355.             cld.x = _loc6_.x;
  356.             cld.y = _loc6_.y;
  357.             cld.scaleX = cld.scaleY = 2 / 9;
  358.             model.clearState();
  359.             cld.showRoom();
  360.          }
  361.          else
  362.          {
  363.             onGameWin();
  364.          }
  365.       }
  366.       
  367.       private function removeRoom(param1:DataEvent) : void
  368.       {
  369.          var _loc2_:Object = null;
  370.          var _loc3_:Array = null;
  371.          var _loc4_:* = undefined;
  372.          var _loc5_:Point = null;
  373.          saveData();
  374.          _loc2_ = model.getRoomLocation(currentRoomId);
  375.          _loc3_ = param1.data.split(":");
  376.          manDir = _loc3_[1];
  377.          currentExit = model.getExit(currentRoomId,_loc3_[0]);
  378.          cld = new Room(0);
  379.          cld.alpha = 0;
  380.          roomContainer.addChild(cld);
  381.          _loc4_ = cld.getBorder();
  382.          _loc5_ = cld.container.localToGlobal(new Point(_loc2_.x * 50,_loc2_.y * 50));
  383.          model.currentRoom.removeRoom(_loc5_.x,_loc5_.y);
  384.          model.clearState();
  385.       }
  386.       
  387.       private function activeMap(param1:Event) : void
  388.       {
  389.          Model.state = "map";
  390.          model.currentRoom = cld;
  391.       }
  392.       
  393.       private function setToolBar(param1:Event = null) : void
  394.       {
  395.          frameRater.cFrameRate = 60;
  396.          removeChild(splash);
  397.          splash = null;
  398.          toolBar = new ToolBar();
  399.          settingField = toolBar.settting;
  400.          sdManager.playSound("mainBg",SoundManager.TYPE_BG);
  401.          roomContainer = new MovieClip();
  402.          addChild(roomContainer);
  403.          addChild(toolBar);
  404.          startGame();
  405.       }
  406.       
  407.       private function addNewFile(param1:DataEvent) : void
  408.       {
  409.          toolBar.files.addNewFile(param1);
  410.       }
  411.       
  412.       private function stopddd(param1:MouseEvent) : void
  413.       {
  414.          var e:MouseEvent = param1;
  415.          try
  416.          {
  417.             toolBar.files._stopDrag();
  418.          }
  419.          catch(e:Error)
  420.          {
  421.          }
  422.       }
  423.       
  424.       private function showScore(param1:Event) : void
  425.       {
  426.          var _loc2_:MovieClip = null;
  427.          endMovie.removeEventListener("onEndMovieDone",showScore);
  428.          removeChild(endMovie);
  429.          endMovie = null;
  430.          _loc2_ = new GameWin();
  431.          addChild(_loc2_);
  432.          _loc2_.addEventListener("onGameWinMovieDone",initGame,false,0,true);
  433.       }
  434.       
  435.       private function onPlayerDied(param1:DataEvent) : void
  436.       {
  437.          Model.isGameOver = true;
  438.          Model.getInstance().clearState(false);
  439.          model.currentRoom.player.onPlayerDied();
  440.       }
  441.       
  442.       private function dragTT(param1:MouseEvent) : void
  443.       {
  444.          var e:MouseEvent = param1;
  445.          try
  446.          {
  447.             toolBar.files.setTxt();
  448.          }
  449.          catch(e:Error)
  450.          {
  451.          }
  452.       }
  453.       
  454.       private function motion(param1:Event) : void
  455.       {
  456.          var e:Event = param1;
  457.          try
  458.          {
  459.             settingField.update();
  460.          }
  461.          catch(e:Error)
  462.          {
  463.          }
  464.          if(model.currentRoom != null && !Model.disableKeyBoard)
  465.          {
  466.             Model.isStatic = true;
  467.             model.currentRoom.update();
  468.             if(Model.isGameOver)
  469.             {
  470.                Model.isSleep = false;
  471.             }
  472.             else if(Model.isStatic)
  473.             {
  474.                Model.isSleep = true;
  475.             }
  476.          }
  477.       }
  478.       
  479.       private function onGameWin() : void
  480.       {
  481.          removeData();
  482.          Model.state = "";
  483.          model.currentRoom.remove();
  484.          model.clearState();
  485.          removeChild(toolBar);
  486.          removeChild(roomContainer);
  487.          roomContainer = null;
  488.          toolBar = null;
  489.          sdManager.clearAllSounds();
  490.          endMovie = new EndMovie();
  491.          endMovie.x = 320;
  492.          endMovie.y = 240;
  493.          frameRater.cFrameRate = 30;
  494.          addChild(endMovie);
  495.          endMovie.addEventListener("onEndMovieDone",showScore,false,0,true);
  496.       }
  497.       
  498.       private function saveData() : void
  499.       {
  500.          var _loc1_:Room = null;
  501.          _loc1_ = model.currentRoom;
  502.          saveValue("jumped",Model.jumped);
  503.          saveValue("rotated",Model.rotated);
  504.          saveValue("died",Model.died);
  505.          saveValue("ran",Model.ran);
  506.          toolBar.files.saveBook();
  507.          currentData.hasP = Model.hasP;
  508.          currentData["room" + currentRoomId] = {
  509.             "keys":_loc1_._keys,
  510.             "doors":_loc1_._doors
  511.          };
  512.          toolBar.maps.saveHiddenMap();
  513.          toolBar.maps.setPrevRoom(String(currentRoomId));
  514.          saveTime();
  515.          cookie.saveData();
  516.          Model.resetData();
  517.       }
  518.       
  519.       private function startGame(param1:Event = null) : void
  520.       {
  521.          var _loc2_:int = 0;
  522.          var _loc3_:Room = null;
  523.          stage.focus = stage;
  524.          Model.isGameOver = false;
  525.          if(Model.cData == null)
  526.          {
  527.             currentRoomId = 1;
  528.             _loc2_ = -2;
  529.             Model.rotation = 0;
  530.             Model.cData = {
  531.                "roomId":currentRoomId,
  532.                "entranceId":_loc2_,
  533.                "rotation":Model.rotation
  534.             };
  535.          }
  536.          else
  537.          {
  538.             currentRoomId = Model.cData.roomId;
  539.             _loc2_ = int(Model.cData.entranceId);
  540.             Model.rotation = Model.cData.rotation;
  541.          }
  542.          model.currentRoomId = currentRoomId;
  543.          Model.state = "normal";
  544.          toolBar.reset();
  545.          _loc3_ = new Room(currentRoomId,_loc2_);
  546.          _loc3_.setPlayer(manDir);
  547.          broadCaster.run("onEnterNewRoom",String(currentRoomId));
  548.          roomContainer.addChild(_loc3_);
  549.          model.currentRoom = _loc3_;
  550.       }
  551.       
  552.       private function onGameOver(param1:DataEvent) : void
  553.       {
  554.          ++Model.died;
  555.          Model.disableKeyBoard = false;
  556.          Model.state = "";
  557.          model.currentRoom.remove();
  558.          model.clearState();
  559.          startGame();
  560.       }
  561.       
  562.       private function getMinData(param1:Object, param2:Object, param3:*, param4:String) : void
  563.       {
  564.          if(param1 == null || param3 < param1[param4])
  565.          {
  566.             param2[param4] = param3;
  567.             param2.newData.push(param4);
  568.          }
  569.          else
  570.          {
  571.             param2[param4] = param1[param4];
  572.          }
  573.       }
  574.       
  575.       private function enterGame(param1:Event) : void
  576.       {
  577.          currentData = model.getCurrentData();
  578.          Model.cData = cookie.getValue("currentRoom");
  579.          selectList = null;
  580.          splash = new SplashMovie();
  581.          frameRater.cFrameRate = 30;
  582.          addChild(splash);
  583.          sdManager.playSound("splash",SoundManager.TYPE_BG);
  584.          Model.resetData();
  585.          stage.focus = stage;
  586.       }
  587.       
  588.       private function saveTime() : void
  589.       {
  590.          toolBar.settting.saveTime();
  591.       }
  592.    }
  593. }
  594.