home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / Never_End.swf / scripts / game / Room.as < prev    next >
Encoding:
Text File  |  2008-09-23  |  28.2 KB  |  933 lines
  1. package game
  2. {
  3.    import elements.*;
  4.    import flash.display.Bitmap;
  5.    import flash.display.BitmapData;
  6.    import flash.display.MovieClip;
  7.    import flash.events.Event;
  8.    import flash.geom.Point;
  9.    import flash.utils.getDefinitionByName;
  10.    import flash.utils.setTimeout;
  11.    import groups.*;
  12.    
  13.    public class Room extends MovieClip
  14.    {
  15.        
  16.       
  17.       private var yBorder:Number = 240;
  18.       
  19.       private var sdManager:SoundManager;
  20.       
  21.       private var _type:String;
  22.       
  23.       private var rotateCounter:uint = 60;
  24.       
  25.       private var gridWidth:Number;
  26.       
  27.       private var tY:Number;
  28.       
  29.       private var tkeys:Array;
  30.       
  31.       private var tX:Number;
  32.       
  33.       private var entranceId:int = -1;
  34.       
  35.       private var doors:Array;
  36.       
  37.       public var container:MovieClip;
  38.       
  39.       private var tdoors:Array;
  40.       
  41.       private var hiddedRoom:MovieClip;
  42.       
  43.       private var manPosition:Array;
  44.       
  45.       public var topContainer:MovieClip;
  46.       
  47.       public var itemContainer:MovieClip;
  48.       
  49.       public var books:Array;
  50.       
  51.       private var xBorder:Number = 237;
  52.       
  53.       private var doorToRemove:*;
  54.       
  55.       public var _keys:Array;
  56.       
  57.       public var player:ManGroup;
  58.       
  59.       public var exits:Array;
  60.       
  61.       public var spikes:Array;
  62.       
  63.       private var broadCaster:BroadCaster;
  64.       
  65.       private var rotate:Number;
  66.       
  67.       private var allGroup:Array;
  68.       
  69.       public var winds:Array;
  70.       
  71.       public var allStaticItems:Array;
  72.       
  73.       public var screenShot:Bitmap;
  74.       
  75.       private var cRoomId:uint;
  76.       
  77.       public var _doors:Array;
  78.       
  79.       public var hiddenRoom:Group;
  80.       
  81.       private var roomWidth:Number;
  82.       
  83.       public var _books:Array;
  84.       
  85.       private var rotateOffset:Number = 0;
  86.       
  87.       private var roomHeight:Number;
  88.       
  89.       public var roomContainer:MovieClip;
  90.       
  91.       public var SpecialDoor:SpecialGroup;
  92.       
  93.       public var keys:Array;
  94.       
  95.       public var allActiveItems:Array;
  96.       
  97.       public function Room(param1:uint, param2:int = -1)
  98.       {
  99.          var _loc3_:Object = null;
  100.          var _loc4_:Model = null;
  101.          var _loc5_:Object = null;
  102.          var _loc6_:* = undefined;
  103.          var _loc7_:int = 0;
  104.          var _loc8_:* = undefined;
  105.          var _loc9_:MovieClip = null;
  106.          var _loc10_:Array = null;
  107.          var _loc11_:Array = null;
  108.          var _loc12_:int = 0;
  109.          var _loc13_:* = undefined;
  110.          var _loc14_:Boolean = false;
  111.          var _loc15_:* = undefined;
  112.          var _loc16_:* = undefined;
  113.          var _loc17_:* = undefined;
  114.          var _loc18_:* = undefined;
  115.          var _loc19_:Boolean = false;
  116.          var _loc20_:* = undefined;
  117.          rotateOffset = 0;
  118.          rotateCounter = 60;
  119.          xBorder = 237;
  120.          yBorder = 240;
  121.          entranceId = -1;
  122.          super();
  123.          entranceId = param2;
  124.          param2 = param2 < 0 && param2 >= -1 ? 0 : param2;
  125.          _loc3_ = Model.getInstance().getData(param1);
  126.          broadCaster = BroadCaster.getInstance();
  127.          sdManager = SoundManager.getInstance();
  128.          gridWidth = _loc3_.gridWidth;
  129.          Model.gridWidth = gridWidth;
  130.          _type = _loc3_.type;
  131.          cRoomId = param1;
  132.          roomContainer = new MovieClip();
  133.          addChild(roomContainer);
  134.          itemContainer = new MovieClip();
  135.          addChild(itemContainer);
  136.          container = new MovieClip();
  137.          roomContainer.addChild(container);
  138.          topContainer = new MovieClip();
  139.          addChild(topContainer);
  140.          if(_type == "map")
  141.          {
  142.             _loc9_ = new (_loc8_ = getDefinitionByName("Map"))();
  143.             container.addChild(_loc9_);
  144.             hiddedRoom = _loc9_.getChildByName("hiddenRoom") as MovieClip;
  145.             _loc9_.x = _loc9_.y = gridWidth / 2;
  146.          }
  147.          else if(param2 < 0)
  148.          {
  149.             manPosition = null;
  150.          }
  151.          else
  152.          {
  153.             manPosition = _loc3_.manPositions[param2] == null ? [1,1] : _loc3_.manPositions[param2];
  154.          }
  155.          _loc5_ = (_loc4_ = Model.getInstance()).currentData["room" + param1];
  156.          _books = Model.books;
  157.          _loc6_ = (_loc6_ = _loc4_.currentData.hasP) == null ? false : _loc6_;
  158.          Model.hasP = _loc6_;
  159.          _books = _books == null ? new Array() : _books;
  160.          if(_loc5_ != null)
  161.          {
  162.             _doors = _loc5_.doors;
  163.             _keys = _loc5_.keys;
  164.          }
  165.          tkeys = new Array();
  166.          tdoors = new Array();
  167.          allGroup = new Array();
  168.          keys = new Array();
  169.          doors = new Array();
  170.          winds = new Array();
  171.          spikes = new Array();
  172.          books = new Array();
  173.          exits = new Array();
  174.          allActiveItems = new Array();
  175.          allStaticItems = new Array();
  176.          _loc7_ = 0;
  177.          while(_loc7_ < 18)
  178.          {
  179.             _loc10_ = new Array();
  180.             _loc11_ = new Array();
  181.             _loc12_ = 0;
  182.             while(_loc12_ < 18)
  183.             {
  184.                _loc10_.push(new Array());
  185.                _loc11_.push(new Array());
  186.                _loc12_++;
  187.             }
  188.             allActiveItems.push(_loc10_);
  189.             allStaticItems.push(_loc11_);
  190.             _loc7_++;
  191.          }
  192.          roomWidth = _loc3_.xGrid * gridWidth;
  193.          roomHeight = _loc3_.yGrid * gridWidth;
  194.          this.x = xBorder;
  195.          this.y = yBorder;
  196.          roomContainer.x = -roomWidth / 2;
  197.          container.x = gridWidth / 2;
  198.          itemContainer.x = topContainer.x = -roomWidth / 2 + gridWidth / 2;
  199.          roomContainer.y = -roomHeight / 2;
  200.          container.y = gridWidth / 2;
  201.          itemContainer.y = topContainer.y = -roomHeight / 2 + gridWidth / 2;
  202.          if(_loc5_ == null)
  203.          {
  204.             for each(_loc13_ in _loc3_.data)
  205.             {
  206.                if(!(Model.hasP && _loc13_.type == "wind"))
  207.                {
  208.                   if(_loc13_.type == "book")
  209.                   {
  210.                      _loc14_ = false;
  211.                      for each(_loc15_ in _books)
  212.                      {
  213.                         if(_loc15_ == _loc13_.extra)
  214.                         {
  215.                            _loc14_ = true;
  216.                            break;
  217.                         }
  218.                      }
  219.                      if(_loc14_)
  220.                      {
  221.                         continue;
  222.                      }
  223.                   }
  224.                   addGroup(_loc13_.points,_loc13_.type,_loc13_.isStatic,_loc13_.extra);
  225.                }
  226.             }
  227.          }
  228.          else
  229.          {
  230.             for each(_loc16_ in _loc3_.data)
  231.             {
  232.                if(!(_loc16_.type == "door" || _loc16_.type == "key"))
  233.                {
  234.                   if(!(Model.hasP && _loc16_.type == "wind"))
  235.                   {
  236.                      if(_loc16_.type == "book")
  237.                      {
  238.                         _loc19_ = false;
  239.                         for each(_loc20_ in _books)
  240.                         {
  241.                            if(_loc20_ == _loc16_.extra)
  242.                            {
  243.                               _loc19_ = true;
  244.                               break;
  245.                            }
  246.                         }
  247.                         if(_loc19_)
  248.                         {
  249.                            continue;
  250.                         }
  251.                      }
  252.                      addGroup(_loc16_.points,_loc16_.type,_loc16_.isStatic,_loc16_.extra);
  253.                   }
  254.                }
  255.             }
  256.             for each(_loc17_ in _keys)
  257.             {
  258.                addGroup(_loc17_.points,"key",_loc17_.isStatic);
  259.             }
  260.             for each(_loc18_ in _doors)
  261.             {
  262.                addGroup(_loc18_.points,"door",_loc18_.isStatic,_loc18_.rotation);
  263.             }
  264.          }
  265.          _doors = tdoors;
  266.          _keys = tkeys;
  267.          rotateRoom();
  268.          initASpeed(Model.rotation);
  269.       }
  270.       
  271.       public function setRotation(param1:Number) : void
  272.       {
  273.          var _loc2_:BitmapData = null;
  274.          if(_type != "map")
  275.          {
  276.             Model.disableKeyBoard = true;
  277.             rotateOffset = param1;
  278.             rotateCounter = 0;
  279.             Model.rotation = (this.rotation + param1 + 360) % 360;
  280.             _loc2_ = new BitmapData(480,480,true,0);
  281.             _loc2_.draw(roomContainer);
  282.             screenShot = new Bitmap(_loc2_);
  283.             screenShot.x = roomContainer.x;
  284.             screenShot.y = roomContainer.y;
  285.             addChild(screenShot);
  286.             roomContainer.visible = false;
  287.             sdManager.playSound("mapRotate",SoundManager.TYPE_ITEM);
  288.             this.addEventListener(Event.ENTER_FRAME,changeRotation);
  289.             setAspeed(param1);
  290.          }
  291.       }
  292.       
  293.       private function alphaToMax(param1:Event) : void
  294.       {
  295.          this.alpha += 0.02;
  296.          if(this.alpha >= 1)
  297.          {
  298.             removeEventListener(Event.ENTER_FRAME,alphaToMax);
  299.             initASpeed(Model.rotation);
  300.             broadCaster.run("onMapReady","");
  301.          }
  302.       }
  303.       
  304.       public function removeMap() : void
  305.       {
  306.          this.addEventListener(Event.ENTER_FRAME,alphaToMin);
  307.       }
  308.       
  309.       public function removeDoor(param1:*) : void
  310.       {
  311.          var _loc2_:int = 0;
  312.          var _loc3_:* = undefined;
  313.          var _loc4_:int = 0;
  314.          var _loc5_:* = undefined;
  315.          var _loc6_:Number = NaN;
  316.          _loc2_ = 0;
  317.          while(_loc2_ < doors.length)
  318.          {
  319.             if(doors[_loc2_] == param1)
  320.             {
  321.                doors.splice(_loc2_,1);
  322.                tdoors.splice(_loc2_,1);
  323.                break;
  324.             }
  325.             _loc2_++;
  326.          }
  327.          for each(_loc3_ in allStaticItems)
  328.          {
  329.             for each(_loc5_ in _loc3_)
  330.             {
  331.                if((_loc6_ = Number(_loc5_.indexOf(param1.items[0]))) >= 0)
  332.                {
  333.                   _loc5_.splice(_loc6_,1);
  334.                }
  335.             }
  336.          }
  337.          _loc4_ = 0;
  338.          while(_loc4_ < allGroup.length)
  339.          {
  340.             if(allGroup[_loc4_] == param1)
  341.             {
  342.                allGroup.splice(_loc4_,1);
  343.             }
  344.             _loc4_++;
  345.          }
  346.       }
  347.       
  348.       public function resetPlayerPosition(param1:Number, param2:Number) : void
  349.       {
  350.          player.resetPosition(param1,param2);
  351.       }
  352.       
  353.       private function scaleBackToTarget(param1:Event) : void
  354.       {
  355.          this.scaleX -= 0.1;
  356.          this.scaleY -= 0.1;
  357.          this.x += tX / 50;
  358.          this.y += tY / 50;
  359.          if(this.scaleX <= 1)
  360.          {
  361.             this.scaleX = 1;
  362.             this.scaleY = 1;
  363.             this.x = xBorder;
  364.             this.y = yBorder;
  365.             removeEventListener(Event.ENTER_FRAME,scaleBackToTarget);
  366.             Model.isSleep = false;
  367.             Model.disableKeyBoard = false;
  368.          }
  369.       }
  370.       
  371.       public function addGroup(param1:Array, param2:String, param3:Boolean, param4:* = null) : void
  372.       {
  373.          var g:* = undefined;
  374.          var itemClass:* = undefined;
  375.          var _container:MovieClip = null;
  376.          var e:* = undefined;
  377.          var head:HeadItem = null;
  378.          var item:* = undefined;
  379.          var sideCounter:uint = 0;
  380.          var besideTable:Object = null;
  381.          var cld:MovieClip = null;
  382.          var k:* = undefined;
  383.          var points:Array = param1;
  384.          var type:String = param2;
  385.          var isStatic:Boolean = param3;
  386.          var txt:* = param4;
  387.          _container = container;
  388.          switch(type)
  389.          {
  390.             case "wall":
  391.                itemClass = RectItem;
  392.                g = new Group(type,isStatic);
  393.                break;
  394.             case "piston":
  395.                itemClass = ActiveItem;
  396.                g = new PistonGroup(type,isStatic);
  397.                break;
  398.             case "key":
  399.                _container = itemContainer;
  400.                itemClass = KeyItem;
  401.                g = new KeyGroup(type,isStatic);
  402.                tkeys.push({
  403.                   "points":points,
  404.                   "isStatic":isStatic
  405.                });
  406.                keys.push(g);
  407.                break;
  408.             case "book":
  409.                _container = itemContainer;
  410.                itemClass = BookItem;
  411.                g = new BookGroup(type,isStatic);
  412.                g.text = txt;
  413.                books.push(g);
  414.                break;
  415.             case "door":
  416.                itemClass = DoorItem;
  417.                _container = topContainer;
  418.                txt = txt == null ? 0 : txt;
  419.                g = new DoorGroup(type,isStatic,txt);
  420.                tdoors.push({
  421.                   "points":points,
  422.                   "isStatic":isStatic,
  423.                   "rotation":txt
  424.                });
  425.                doors.push(g);
  426.                break;
  427.             case "spike":
  428.                itemClass = SpikeItem;
  429.                txt = txt == null ? 0 : txt;
  430.                g = new SpikeGroup(type,isStatic,txt);
  431.                spikes.push(g);
  432.                break;
  433.             case "halfWall":
  434.                itemClass = HalfWall;
  435.                txt = txt == null ? 0 : txt;
  436.                g = new SpikeGroup(type,isStatic,txt);
  437.                break;
  438.             case "virtual":
  439.                itemClass = VirtualItem;
  440.                g = new Group(type,isStatic);
  441.                if(txt != null)
  442.                {
  443.                   hiddenRoom = g;
  444.                }
  445.                break;
  446.             case "exit":
  447.                _container = itemContainer;
  448.                itemClass = ExitItem;
  449.                g = new ExitGroup(type,isStatic,txt);
  450.                exits.push(g);
  451.                break;
  452.             case "specialDoor":
  453.                _container = topContainer;
  454.                itemClass = SpecialItem;
  455.                g = new SpecialGroup(type,isStatic,txt);
  456.                SpecialDoor = g;
  457.                break;
  458.             case "wind":
  459.                _container = topContainer;
  460.                itemClass = WindItem;
  461.                g = new WindGroup(type,isStatic);
  462.                winds.push(g);
  463.                break;
  464.             case "man":
  465.                itemClass = ManItem;
  466.                _container = topContainer;
  467.                g = new ManGroup(type,isStatic);
  468.                head = new HeadItem(points[0][1] * gridWidth,points[0][0] * gridWidth);
  469.                container.addChild(head);
  470.                g.addItem(head);
  471.                player = g;
  472.                break;
  473.             default:
  474.                itemClass = RectItem;
  475.                g = new Group(type,isStatic);
  476.          }
  477.          for each(e in points)
  478.          {
  479.             item = new itemClass(e[1] * gridWidth,e[0] * gridWidth);
  480.             if(type == "piston")
  481.             {
  482.                sideCounter = 0;
  483.                besideTable = new Object();
  484.                cld = item.getChildByName("rock") as MovieClip;
  485.                for each(k in points)
  486.                {
  487.                   if(k[0] == e[0] && k[1] == e[1] + 1)
  488.                   {
  489.                      besideTable["R"] = true;
  490.                      sideCounter++;
  491.                   }
  492.                   else if(k[0] == e[0] + 1 && k[1] == e[1])
  493.                   {
  494.                      besideTable["B"] = true;
  495.                      sideCounter++;
  496.                   }
  497.                   else if(k[0] == e[0] && k[1] == e[1] - 1)
  498.                   {
  499.                      besideTable["L"] = true;
  500.                      sideCounter++;
  501.                   }
  502.                   else if(k[0] == e[0] - 1 && k[1] == e[1])
  503.                   {
  504.                      besideTable["T"] = true;
  505.                      sideCounter++;
  506.                   }
  507.                }
  508.                switch(sideCounter)
  509.                {
  510.                   case 0:
  511.                      cld.gotoAndStop(5);
  512.                      break;
  513.                   case 1:
  514.                      cld.gotoAndStop(4);
  515.                      if(besideTable["L"] == true)
  516.                      {
  517.                         cld.rotation = -90;
  518.                      }
  519.                      else if(besideTable["R"] == true)
  520.                      {
  521.                         cld.rotation = 90;
  522.                      }
  523.                      else if(besideTable["B"] == true)
  524.                      {
  525.                         cld.rotation = 180;
  526.                      }
  527.                      else if(besideTable["T"] == true)
  528.                      {
  529.                         cld.rotation = 0;
  530.                      }
  531.                      break;
  532.                   case 2:
  533.                      if(besideTable["L"] == true && besideTable["R"] == true)
  534.                      {
  535.                         cld.gotoAndStop(3);
  536.                         cld.rotation = 90;
  537.                      }
  538.                      else if(besideTable["B"] == true && besideTable["T"] == true)
  539.                      {
  540.                         cld.gotoAndStop(3);
  541.                      }
  542.                      else if(besideTable["L"] == true && Boolean(besideTable["B"]))
  543.                      {
  544.                         cld.gotoAndStop(2);
  545.                         cld.rotation = 90;
  546.                      }
  547.                      else if(besideTable["L"] == true && Boolean(besideTable["T"]))
  548.                      {
  549.                         cld.gotoAndStop(2);
  550.                         cld.rotation = 180;
  551.                      }
  552.                      else if(besideTable["R"] == true && Boolean(besideTable["B"]))
  553.                      {
  554.                         cld.gotoAndStop(2);
  555.                      }
  556.                      else if(besideTable["R"] == true && Boolean(besideTable["T"]))
  557.                      {
  558.                         cld.gotoAndStop(2);
  559.                         cld.rotation = -90;
  560.                      }
  561.                      break;
  562.                   case 3:
  563.                      cld.gotoAndStop(1);
  564.                      if(besideTable["L"] != true)
  565.                      {
  566.                         cld.rotation = -90;
  567.                      }
  568.                      else if(besideTable["R"] != true)
  569.                      {
  570.                         cld.rotation = 90;
  571.                      }
  572.                      else if(besideTable["B"] != true)
  573.                      {
  574.                         cld.rotation = 180;
  575.                      }
  576.                      else if(besideTable["T"] != true)
  577.                      {
  578.                         cld.rotation = 0;
  579.                      }
  580.                      break;
  581.                   case 4:
  582.                      cld.gotoAndStop(6);
  583.                }
  584.             }
  585.             _container.addChild(item);
  586.             if(isStatic)
  587.             {
  588.                try
  589.                {
  590.                   allStaticItems[e[0]][e[1]].push(item);
  591.                }
  592.                catch(E:Error)
  593.                {
  594.                }
  595.             }
  596.             g.allActiveItems = allActiveItems;
  597.             g.allStaticItems = allStaticItems;
  598.             g.addItem(item);
  599.          }
  600.          allGroup.push(g);
  601.       }
  602.       
  603.       public function remove() : void
  604.       {
  605.          if(loaderInfo != null)
  606.          {
  607.             parent.removeChild(this);
  608.          }
  609.       }
  610.       
  611.       private function scaleToMin(param1:Event) : void
  612.       {
  613.          this.scaleX -= 7 / 9 / 50;
  614.          this.scaleY -= 7 / 9 / 50;
  615.          this.x -= tX / 50;
  616.          this.y -= tY / 50;
  617.          if(this.scaleX <= 2 / 9)
  618.          {
  619.             setTimeout(parent.removeChild,1000,this);
  620.             removeEventListener(Event.ENTER_FRAME,scaleToMin);
  621.             broadCaster.run("onRoomRemoved","");
  622.          }
  623.       }
  624.       
  625.       public function removeWind(param1:*) : void
  626.       {
  627.          var _loc2_:int = 0;
  628.          var _loc3_:int = 0;
  629.          _loc2_ = 0;
  630.          while(_loc2_ < winds.length)
  631.          {
  632.             if(winds[_loc2_] == param1)
  633.             {
  634.                broadCaster.run("onFindWind","");
  635.                sdManager.playSound("getItem",SoundManager.TYPE_ITEM);
  636.                winds.splice(_loc2_,1);
  637.                break;
  638.             }
  639.             _loc2_++;
  640.          }
  641.          _loc3_ = 0;
  642.          while(_loc3_ < allGroup.length)
  643.          {
  644.             if(allGroup[_loc3_] == param1)
  645.             {
  646.                allGroup.splice(_loc3_,1);
  647.             }
  648.             _loc3_++;
  649.          }
  650.          Model.hasP = true;
  651.       }
  652.       
  653.       public function update() : void
  654.       {
  655.          var _loc1_:int = 0;
  656.          var _loc2_:* = undefined;
  657.          var _loc3_:int = 0;
  658.          if(Model.isSleep)
  659.          {
  660.             player.updateSpeed();
  661.             player.hitTest();
  662.             return;
  663.          }
  664.          _loc1_ = 0;
  665.          while(_loc1_ < 18)
  666.          {
  667.             _loc3_ = 0;
  668.             while(_loc3_ < 18)
  669.             {
  670.                allActiveItems[_loc1_][_loc3_] = new Array();
  671.                _loc3_++;
  672.             }
  673.             _loc1_++;
  674.          }
  675.          for each(_loc2_ in allGroup)
  676.          {
  677.             _loc2_.updateSpeed();
  678.          }
  679.          hitTest();
  680.       }
  681.       
  682.       private function hitTest() : void
  683.       {
  684.          var e:* = undefined;
  685.          for each(e in allGroup)
  686.          {
  687.             try
  688.             {
  689.                e.hitTest();
  690.             }
  691.             catch(e:Error)
  692.             {
  693.             }
  694.          }
  695.       }
  696.       
  697.       private function rotateRoom() : void
  698.       {
  699.          player.rotation = Model.rotation;
  700.          this.rotation = Model.rotation;
  701.          if(_type == "map")
  702.          {
  703.             hiddedRoom.y = Model.hiddedRoomLocation.point[0] * 50 - 25;
  704.             hiddedRoom.x = Model.hiddedRoomLocation.point[1] * 50 - 24;
  705.          }
  706.          else if((cRoomId == 23 || cRoomId == 25) && Model.hiddedRoomLocation == Model.getInstance().hiddenRoomSets[8])
  707.          {
  708.             SpecialDoor.open();
  709.          }
  710.          else if((cRoomId == 26 || cRoomId == 25) && Model.hiddedRoomLocation == Model.getInstance().hiddenRoomSets[0])
  711.          {
  712.             SpecialDoor.open();
  713.          }
  714.          else if(SpecialDoor != null)
  715.          {
  716.             SpecialDoor.close();
  717.          }
  718.       }
  719.       
  720.       private function alphaToMin(param1:Event) : void
  721.       {
  722.          this.alpha -= 0.02;
  723.          if(this.alpha <= 0)
  724.          {
  725.             parent.removeChild(this);
  726.             removeEventListener(Event.ENTER_FRAME,alphaToMin);
  727.             broadCaster.run("onMapRemoved","");
  728.          }
  729.       }
  730.       
  731.       public function showMap() : void
  732.       {
  733.          this.addEventListener(Event.ENTER_FRAME,alphaToMax);
  734.       }
  735.       
  736.       public function getBorder() : Object
  737.       {
  738.          return {
  739.             "x":xBorder + container.x,
  740.             "y":yBorder + container.y
  741.          };
  742.       }
  743.       
  744.       public function removeKey(param1:*) : void
  745.       {
  746.          var _loc2_:int = 0;
  747.          var _loc3_:* = undefined;
  748.          var _loc4_:int = 0;
  749.          var _loc5_:* = undefined;
  750.          var _loc6_:Number = NaN;
  751.          _loc2_ = 0;
  752.          while(_loc2_ < keys.length)
  753.          {
  754.             if(keys[_loc2_] == param1)
  755.             {
  756.                Model.disableKeyBoard = true;
  757.                keys.splice(_loc2_,1);
  758.                tkeys.splice(_loc2_,1);
  759.                doorToRemove = doors[_loc2_];
  760.                scaleTo();
  761.                break;
  762.             }
  763.             _loc2_++;
  764.          }
  765.          for each(_loc3_ in allStaticItems)
  766.          {
  767.             for each(_loc5_ in _loc3_)
  768.             {
  769.                if((_loc6_ = Number(_loc5_.indexOf(param1.items[0]))) >= 0)
  770.                {
  771.                   _loc5_.splice(_loc6_,1);
  772.                }
  773.             }
  774.          }
  775.          _loc4_ = 0;
  776.          while(_loc4_ < allGroup.length)
  777.          {
  778.             if(allGroup[_loc4_] == param1)
  779.             {
  780.                allGroup.splice(_loc4_,1);
  781.             }
  782.             _loc4_++;
  783.          }
  784.       }
  785.       
  786.       private function changeRotation(param1:Event = null) : void
  787.       {
  788.          var e:Event = param1;
  789.          ++rotateCounter;
  790.          this.rotation += rotateOffset / 61;
  791.          if(rotateCounter >= 61)
  792.          {
  793.             roomContainer.visible = true;
  794.             removeChild(screenShot);
  795.             screenShot.bitmapData.dispose();
  796.             screenShot = null;
  797.             rotateRoom();
  798.             Model.disableKeyBoard = false;
  799.             try
  800.             {
  801.                removeEventListener(Event.ENTER_FRAME,changeRotation);
  802.             }
  803.             catch(e:Error)
  804.             {
  805.             }
  806.          }
  807.       }
  808.       
  809.       public function scaleBack() : void
  810.       {
  811.          sdManager.playSound("scaleMin",SoundManager.TYPE_ITEM);
  812.          this.addEventListener(Event.ENTER_FRAME,scaleBackToTarget,false,0,true);
  813.       }
  814.       
  815.       private function scaleToTarget(param1:Event) : void
  816.       {
  817.          this.scaleX += 0.1;
  818.          this.scaleY += 0.1;
  819.          this.x -= tX / 50;
  820.          this.y -= tY / 50;
  821.          if(this.scaleX >= 5)
  822.          {
  823.             sdManager.playSound("doorOpen",SoundManager.TYPE_ITEM);
  824.             removeEventListener(Event.ENTER_FRAME,scaleToTarget);
  825.             doorToRemove.removeAllItems();
  826.             doorToRemove = null;
  827.          }
  828.       }
  829.       
  830.       public function showRoom() : void
  831.       {
  832.          tX = this.x - xBorder;
  833.          tY = this.y - yBorder;
  834.          sdManager.playSound("scaleMax",SoundManager.TYPE_ITEM);
  835.          this.addEventListener(Event.ENTER_FRAME,scaleToMax);
  836.       }
  837.       
  838.       private function scaleTo() : void
  839.       {
  840.          var _loc1_:Point = null;
  841.          _loc1_ = doorToRemove.items[0].localToGlobal(new Point(0,0));
  842.          tX = (_loc1_.x - xBorder) * 5;
  843.          tY = (_loc1_.y - yBorder) * 5;
  844.          sdManager.playSound("scaleMax",SoundManager.TYPE_ITEM);
  845.          this.addEventListener(Event.ENTER_FRAME,scaleToTarget,false,0,true);
  846.       }
  847.       
  848.       public function removeRoom(param1:Number, param2:Number) : void
  849.       {
  850.          tX = xBorder - param1;
  851.          tY = yBorder - param2;
  852.          sdManager.playSound("scaleMin",SoundManager.TYPE_ITEM);
  853.          this.addEventListener(Event.ENTER_FRAME,scaleToMin);
  854.       }
  855.       
  856.       public function setAspeed(param1:Number) : void
  857.       {
  858.          var _loc2_:* = undefined;
  859.          for each(_loc2_ in allGroup)
  860.          {
  861.             _loc2_.resetASpeed(param1);
  862.          }
  863.       }
  864.       
  865.       private function initASpeed(param1:Number) : void
  866.       {
  867.          var _loc2_:* = undefined;
  868.          for each(_loc2_ in allGroup)
  869.          {
  870.             _loc2_.setASpeed(param1);
  871.          }
  872.       }
  873.       
  874.       public function removeBook(param1:*) : void
  875.       {
  876.          var _loc2_:int = 0;
  877.          var _loc3_:int = 0;
  878.          _loc2_ = 0;
  879.          while(_loc2_ < books.length)
  880.          {
  881.             if(books[_loc2_] == param1)
  882.             {
  883.                broadCaster.run("onFindFile",books[_loc2_].text);
  884.                sdManager.playSound("getItem",SoundManager.TYPE_ITEM);
  885.                books.splice(_loc2_,1);
  886.                Model.isSleep = false;
  887.                break;
  888.             }
  889.             _loc2_++;
  890.          }
  891.          _loc3_ = 0;
  892.          while(_loc3_ < allGroup.length)
  893.          {
  894.             if(allGroup[_loc3_] == param1)
  895.             {
  896.                allGroup.splice(_loc3_,1);
  897.             }
  898.             _loc3_++;
  899.          }
  900.       }
  901.       
  902.       private function scaleToMax(param1:Event) : void
  903.       {
  904.          this.scaleX += 7 / 9 / 50;
  905.          this.scaleY += 7 / 9 / 50;
  906.          this.x -= tX / 50;
  907.          this.y -= tY / 50;
  908.          if(this.scaleX >= 1)
  909.          {
  910.             this.scaleX = this.scaleY = 1;
  911.             this.x = xBorder;
  912.             this.y = yBorder;
  913.             removeEventListener(Event.ENTER_FRAME,scaleToMax);
  914.             initASpeed(Model.rotation);
  915.             broadCaster.run("onRoomReady","");
  916.          }
  917.       }
  918.       
  919.       public function setPlayer(param1:String) : void
  920.       {
  921.          if(entranceId >= 0 && cRoomId != 1)
  922.          {
  923.             exits[entranceId].setEnter();
  924.          }
  925.          player.InitPlayer(param1);
  926.          if(_type != "map" && manPosition != null)
  927.          {
  928.             player.resetPosition(manPosition[1] * gridWidth,manPosition[0] * gridWidth);
  929.          }
  930.       }
  931.    }
  932. }
  933.