home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / HexiomConnect.swf / scripts / Editor.as < prev    next >
Encoding:
Text File  |  2008-08-29  |  17.6 KB  |  585 lines
  1. package
  2. {
  3.    import flash.display.Shape;
  4.    import flash.display.Sprite;
  5.    import flash.events.Event;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.MouseEvent;
  8.    
  9.    public class Editor extends Level
  10.    {
  11.       
  12.       private static const TEST_MODE:int = 2;
  13.       
  14.       private static const colorSize:Number = 18;
  15.       
  16.       private static const ARRANGE_MODE:int = 1;
  17.       
  18.       private static const CONNECTIONS_MODE:int = 0;
  19.       
  20.       protected static var EditInstructions:Class = Editor_EditInstructions;
  21.        
  22.       
  23.       private var shift:Boolean = false;
  24.       
  25.       private var arrangeButton:TextButton;
  26.       
  27.       private var tunnelGhost:Sprite;
  28.       
  29.       private var shuffleButton:TextButton;
  30.       
  31.       private var colorHighlight:Shape;
  32.       
  33.       private var mode:int = 0;
  34.       
  35.       private var instructions:Sprite;
  36.       
  37.       private var minusButton:TextButton;
  38.       
  39.       private var helpButton:TextButton;
  40.       
  41.       private var modeHighlight:Shape;
  42.       
  43.       private var colorPanel:Sprite;
  44.       
  45.       private var color:int;
  46.       
  47.       private var testButton:TextButton;
  48.       
  49.       private var plusButton:TextButton;
  50.       
  51.       private var connButton:TextButton;
  52.       
  53.       public function Editor(param1:Board = null)
  54.       {
  55.          var _loc2_:TextButton = null;
  56.          tunnelGhost = Tile.getTunnelGhost();
  57.          super(param1,CUSTOM,true,false);
  58.          connButton = _loc2_ = new TextButton(TextButton.LONG,"Connections");
  59.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  60.          _loc2_.x = 45;
  61.          _loc2_.y = 15;
  62.          _loc2_.addEventListener(MouseEvent.CLICK,connMode,false,0,true);
  63.          addChild(_loc2_);
  64.          arrangeButton = _loc2_ = new TextButton(TextButton.LONG,"Arrange");
  65.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  66.          _loc2_.x = 45;
  67.          _loc2_.y = 35;
  68.          _loc2_.addEventListener(MouseEvent.CLICK,arrangeMode,false,0,true);
  69.          addChild(_loc2_);
  70.          testButton = _loc2_ = new TextButton(TextButton.LONG,"Test");
  71.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  72.          _loc2_.x = 45;
  73.          _loc2_.y = 55;
  74.          _loc2_.addEventListener(MouseEvent.CLICK,testMode,false,0,true);
  75.          addChild(_loc2_);
  76.          shuffleButton = _loc2_ = new TextButton(TextButton.LONG,"Shuffle");
  77.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  78.          _loc2_.x = 127;
  79.          _loc2_.y = 15;
  80.          _loc2_.addEventListener(MouseEvent.CLICK,shuffleClick,false,0,true);
  81.          addChild(_loc2_);
  82.          plusButton = _loc2_ = new TextButton(TextButton.SQUARE,"-");
  83.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  84.          _loc2_.x = 97;
  85.          _loc2_.y = 15;
  86.          _loc2_.addEventListener(MouseEvent.CLICK,minusClick,false,0,true);
  87.          addChild(_loc2_);
  88.          minusButton = _loc2_ = new TextButton(TextButton.SQUARE,"+");
  89.          _loc2_.scaleX = _loc2_.scaleY = 0.8;
  90.          _loc2_.x = 119;
  91.          _loc2_.y = 15;
  92.          _loc2_.addEventListener(MouseEvent.CLICK,plusClick,false,0,true);
  93.          addChild(_loc2_);
  94.          helpButton = _loc2_ = new TextButton(TextButton.SQUARE,"?");
  95.          _loc2_.scaleX = _loc2_.scaleY = 0.76;
  96.          _loc2_.x = 96;
  97.          _loc2_.y = 35;
  98.          _loc2_.addEventListener(MouseEvent.CLICK,helpClick,false,0,true);
  99.          addChild(_loc2_);
  100.          color = 1;
  101.          colorPanel = new Sprite();
  102.          colorPanel.y = 70;
  103.          colorPanel.x = 5;
  104.          var _loc3_:int = 1;
  105.          while(_loc3_ < Tile.COLORS.length)
  106.          {
  107.             colorPanel.graphics.beginFill(Tile.colorRGB(_loc3_,0.85));
  108.             colorPanel.graphics.drawRect((_loc3_ - 1) * colorSize,0,colorSize,colorSize);
  109.             colorPanel.graphics.endFill();
  110.             _loc3_++;
  111.          }
  112.          addChild(colorPanel);
  113.          colorPanel.buttonMode = true;
  114.          colorPanel.addEventListener(MouseEvent.CLICK,colorClick,false,0,true);
  115.          colorHighlight = new Shape();
  116.          colorHighlight.graphics.lineStyle(0,16777181);
  117.          colorHighlight.graphics.drawRect(0,0,colorSize - 1,colorSize - 1);
  118.          colorPanel.addChild(colorHighlight);
  119.          modeHighlight = new Shape();
  120.          modeHighlight.graphics.lineStyle(0,16777181);
  121.          modeHighlight.graphics.drawRect(-40,-10,79,19);
  122.          addChild(modeHighlight);
  123.          instructions = new EditInstructions();
  124.          _loc2_ = new TextButton(TextButton.LONG,"Close");
  125.          _loc2_.x = 200;
  126.          _loc2_.y = 355;
  127.          _loc2_.addEventListener(MouseEvent.CLICK,closeHelpClick,false,0,true);
  128.          instructions.addChild(_loc2_);
  129.          setMode(CONNECTIONS_MODE);
  130.          if(!Game.cookie.data.editHelpShown)
  131.          {
  132.             showHelp();
  133.          }
  134.       }
  135.       
  136.       private function shuffleClick(param1:MouseEvent) : void
  137.       {
  138.          board.shuffleStart();
  139.       }
  140.       
  141.       override protected function victory() : void
  142.       {
  143.          var _loc1_:Tile = null;
  144.          SoundBar.playSound(SoundBar.VICTORY_SOUND,0);
  145.          for each(_loc1_ in tiles)
  146.          {
  147.             _loc1_.flash();
  148.          }
  149.       }
  150.       
  151.       private function plusClick(param1:MouseEvent) : void
  152.       {
  153.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  154.          var _loc2_:int = board.size + 1;
  155.          if(_loc2_ > Board.MAX_SIZE)
  156.          {
  157.             return;
  158.          }
  159.          disableMouse();
  160.          removeBoard();
  161.          addBoard(new Board(_loc2_));
  162.          enableMouse();
  163.       }
  164.       
  165.       override protected function disableMouse() : void
  166.       {
  167.          var _loc1_:Slot = null;
  168.          super.disableMouse();
  169.          for each(_loc1_ in slots)
  170.          {
  171.             _loc1_.removeEventListener(MouseEvent.MOUSE_DOWN,slotDown);
  172.          }
  173.       }
  174.       
  175.       private function keyDown(param1:KeyboardEvent) : void
  176.       {
  177.          switch(param1.keyCode)
  178.          {
  179.             case 16:
  180.                shift = true;
  181.          }
  182.       }
  183.       
  184.       override protected function addedToStage(param1:Event) : void
  185.       {
  186.          super.addedToStage(param1);
  187.          stage.addEventListener(KeyboardEvent.KEY_DOWN,keyDown,false,0,true);
  188.          stage.addEventListener(KeyboardEvent.KEY_UP,keyUp,false,0,true);
  189.       }
  190.       
  191.       public function setMode(param1:int) : void
  192.       {
  193.          var _loc2_:Tile = null;
  194.          for each(_loc2_ in tiles)
  195.          {
  196.             if(_loc2_.confirmed)
  197.             {
  198.                _loc2_.unconfirm();
  199.             }
  200.          }
  201.          mode = param1;
  202.          switch(mode)
  203.          {
  204.             case CONNECTIONS_MODE:
  205.                Game.background.setColor(Background.GREEN);
  206.                modeHighlight.x = connButton.x;
  207.                modeHighlight.y = connButton.y;
  208.                board.homePositions();
  209.                break;
  210.             case ARRANGE_MODE:
  211.                Game.background.setColor(Background.YELLOW);
  212.                modeHighlight.x = arrangeButton.x;
  213.                modeHighlight.y = arrangeButton.y;
  214.                board.startPositions();
  215.                break;
  216.             case TEST_MODE:
  217.                Game.background.setColor(Background.ORANGE);
  218.                modeHighlight.x = testButton.x;
  219.                modeHighlight.y = testButton.y;
  220.                board.startPositions();
  221.          }
  222.          shuffleButton.visible = mode == ARRANGE_MODE;
  223.          plusButton.visible = mode == CONNECTIONS_MODE;
  224.          minusButton.visible = mode == CONNECTIONS_MODE;
  225.          colorPanel.visible = mode == CONNECTIONS_MODE;
  226.          board.slotLayer.mouseChildren = mode == CONNECTIONS_MODE;
  227.       }
  228.       
  229.       private function closeHelpClick(param1:MouseEvent) : void
  230.       {
  231.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  232.          if(instructions.parent == this)
  233.          {
  234.             removeChild(instructions);
  235.          }
  236.       }
  237.       
  238.       override protected function checkWin() : void
  239.       {
  240.          if(mode == TEST_MODE)
  241.          {
  242.             super.checkWin();
  243.          }
  244.       }
  245.       
  246.       private function slotDown(param1:MouseEvent) : void
  247.       {
  248.          var _loc2_:Slot = null;
  249.          var _loc3_:Tile = null;
  250.          if(mode == CONNECTIONS_MODE)
  251.          {
  252.             _loc2_ = param1.currentTarget as Slot;
  253.             if(!_loc2_)
  254.             {
  255.                return;
  256.             }
  257.             _loc3_ = _loc2_.tile;
  258.             if(!_loc3_)
  259.             {
  260.                return;
  261.             }
  262.             editTile(_loc3_,param1.shiftKey);
  263.          }
  264.       }
  265.       
  266.       override protected function addBoard(param1:Board) : void
  267.       {
  268.          super.addBoard(param1);
  269.          param1.addChild(tunnelGhost);
  270.       }
  271.       
  272.       protected function helpClick(param1:MouseEvent) : void
  273.       {
  274.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  275.          showHelp();
  276.       }
  277.       
  278.       override public function update(param1:Event) : void
  279.       {
  280.          var _loc3_:Tile = null;
  281.          var _loc4_:Number = NaN;
  282.          if(mode != CONNECTIONS_MODE)
  283.          {
  284.             tunnelGhost.visible = false;
  285.             super.update(param1);
  286.             return;
  287.          }
  288.          tileGhost.visible = false;
  289.          tunnelGhost.visible = false;
  290.          if(shift)
  291.          {
  292.             return;
  293.          }
  294.          var _loc2_:Slot = overSlot();
  295.          if(_loc2_)
  296.          {
  297.             _loc3_ = _loc2_.tile;
  298.          }
  299.          if(_loc3_)
  300.          {
  301.             tunnelGhost.visible = true;
  302.             tunnelGhost.x = _loc3_.x;
  303.             tunnelGhost.y = _loc3_.y;
  304.             _loc4_ = Math.atan2(_loc3_.mouseY,_loc3_.mouseX);
  305.             tunnelGhost.rotation = Math.floor(_loc4_ * 180 / Math.PI / 60) * 60 - 60;
  306.             if(_loc4_ > Math.PI * 2 / 3)
  307.             {
  308.                if(!_loc3_.slot.sw)
  309.                {
  310.                   tunnelGhost.visible = false;
  311.                }
  312.             }
  313.             else if(_loc4_ > Math.PI / 3)
  314.             {
  315.                if(!_loc3_.slot.s)
  316.                {
  317.                   tunnelGhost.visible = false;
  318.                }
  319.             }
  320.             else if(_loc4_ > 0)
  321.             {
  322.                if(!_loc3_.slot.se)
  323.                {
  324.                   tunnelGhost.visible = false;
  325.                }
  326.             }
  327.             else if(_loc4_ > -Math.PI / 3)
  328.             {
  329.                if(!_loc3_.slot.ne)
  330.                {
  331.                   tunnelGhost.visible = false;
  332.                }
  333.             }
  334.             else if(_loc4_ > -Math.PI * 2 / 3)
  335.             {
  336.                if(!_loc3_.slot.n)
  337.                {
  338.                   tunnelGhost.visible = false;
  339.                }
  340.             }
  341.             else if(!_loc3_.slot.nw)
  342.             {
  343.                tunnelGhost.visible = false;
  344.             }
  345.          }
  346.       }
  347.       
  348.       private function testMode(param1:MouseEvent = null) : void
  349.       {
  350.          setMode(TEST_MODE);
  351.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  352.       }
  353.       
  354.       private function keyUp(param1:KeyboardEvent) : void
  355.       {
  356.          switch(param1.keyCode)
  357.          {
  358.             case 16:
  359.                shift = false;
  360.          }
  361.       }
  362.       
  363.       private function showHelp() : void
  364.       {
  365.          Game.cookie.data.editHelpShown = true;
  366.          addChild(instructions);
  367.       }
  368.       
  369.       private function editTile(param1:Tile, param2:Boolean) : void
  370.       {
  371.          var _loc3_:Tile = null;
  372.          var _loc4_:Number = NaN;
  373.          var _loc5_:int = 0;
  374.          if(param2)
  375.          {
  376.             if(param1.locked)
  377.             {
  378.                param1.unlock();
  379.             }
  380.             else
  381.             {
  382.                for each(_loc3_ in tiles)
  383.                {
  384.                   if(_loc3_ != param1 && _loc3_.startSlot == param1.homeSlot)
  385.                   {
  386.                      _loc3_.startSlot = param1.startSlot;
  387.                      param1.startSlot = param1.homeSlot;
  388.                      break;
  389.                   }
  390.                }
  391.                param1.lock();
  392.             }
  393.             SoundBar.playSound(SoundBar.LOCK_SOUND,mouseX / Game.MIDX - 1);
  394.          }
  395.          else
  396.          {
  397.             _loc4_ = Math.atan2(param1.mouseY,param1.mouseX);
  398.             _loc5_ = color;
  399.             if(_loc4_ > Math.PI * 2 / 3)
  400.             {
  401.                if(param1.slot.sw)
  402.                {
  403.                   if(param1.sw == color)
  404.                   {
  405.                      _loc5_ = 0;
  406.                   }
  407.                   param1.setSW(_loc5_);
  408.                   param1.slot.sw.tile.setNE(_loc5_);
  409.                }
  410.             }
  411.             else if(_loc4_ > Math.PI / 3)
  412.             {
  413.                if(param1.slot.s)
  414.                {
  415.                   if(param1.s == color)
  416.                   {
  417.                      _loc5_ = 0;
  418.                   }
  419.                   param1.setS(_loc5_);
  420.                   param1.slot.s.tile.setN(_loc5_);
  421.                }
  422.             }
  423.             else if(_loc4_ > 0)
  424.             {
  425.                if(param1.slot.se)
  426.                {
  427.                   if(param1.se == color)
  428.                   {
  429.                      _loc5_ = 0;
  430.                   }
  431.                   param1.setSE(_loc5_);
  432.                   param1.slot.se.tile.setNW(_loc5_);
  433.                }
  434.             }
  435.             else if(_loc4_ > -Math.PI / 3)
  436.             {
  437.                if(param1.slot.ne)
  438.                {
  439.                   if(param1.ne == color)
  440.                   {
  441.                      _loc5_ = 0;
  442.                   }
  443.                   param1.setNE(_loc5_);
  444.                   param1.slot.ne.tile.setSW(_loc5_);
  445.                }
  446.             }
  447.             else if(_loc4_ > -Math.PI * 2 / 3)
  448.             {
  449.                if(param1.slot.n)
  450.                {
  451.                   if(param1.n == color)
  452.                   {
  453.                      _loc5_ = 0;
  454.                   }
  455.                   param1.setN(_loc5_);
  456.                   param1.slot.n.tile.setS(_loc5_);
  457.                }
  458.             }
  459.             else if(param1.slot.nw)
  460.             {
  461.                if(param1.nw == color)
  462.                {
  463.                   _loc5_ = 0;
  464.                }
  465.                param1.setNW(_loc5_);
  466.                param1.slot.nw.tile.setSE(_loc5_);
  467.             }
  468.             SoundBar.playSound(SoundBar.PICKUP_SOUND,mouseX / Game.MIDX - 1);
  469.          }
  470.       }
  471.       
  472.       override protected function enableMouse() : void
  473.       {
  474.          var _loc1_:Slot = null;
  475.          super.enableMouse();
  476.          for each(_loc1_ in slots)
  477.          {
  478.             _loc1_.buttonMode = true;
  479.             _loc1_.addEventListener(MouseEvent.MOUSE_DOWN,slotDown,false,0,true);
  480.          }
  481.       }
  482.       
  483.       private function colorClick(param1:MouseEvent) : void
  484.       {
  485.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  486.          color = Math.max(1,Math.min(Tile.COLORS.length,colorPanel.mouseX / colorPanel.width * (Tile.COLORS.length - 1) + 1));
  487.          colorHighlight.x = colorSize * (color - 1);
  488.       }
  489.       
  490.       override protected function swapSlots(param1:Slot, param2:Slot) : void
  491.       {
  492.          super.swapSlots(param1,param2);
  493.          if(mode == ARRANGE_MODE)
  494.          {
  495.             if(param1.tile)
  496.             {
  497.                param1.tile.startSlot = param1;
  498.             }
  499.             if(param2.tile)
  500.             {
  501.                param2.tile.startSlot = param2;
  502.             }
  503.          }
  504.       }
  505.       
  506.       private function connMode(param1:MouseEvent = null) : void
  507.       {
  508.          setMode(CONNECTIONS_MODE);
  509.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  510.       }
  511.       
  512.       override protected function tileDown(param1:MouseEvent) : void
  513.       {
  514.          var _loc2_:Tile = param1.currentTarget as Tile;
  515.          if(!_loc2_)
  516.          {
  517.             return;
  518.          }
  519.          switch(mode)
  520.          {
  521.             case CONNECTIONS_MODE:
  522.                editTile(_loc2_,param1.shiftKey);
  523.                break;
  524.             case TEST_MODE:
  525.             case ARRANGE_MODE:
  526.                super.tileDown(param1);
  527.          }
  528.       }
  529.       
  530.       override protected function removedFromStage(param1:Event) : void
  531.       {
  532.          super.removedFromStage(param1);
  533.          stage.removeEventListener(KeyboardEvent.KEY_DOWN,keyDown);
  534.          stage.removeEventListener(KeyboardEvent.KEY_UP,keyUp);
  535.       }
  536.       
  537.       private function arrangeMode(param1:MouseEvent = null) : void
  538.       {
  539.          setMode(ARRANGE_MODE);
  540.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  541.       }
  542.       
  543.       private function minusClick(param1:MouseEvent) : void
  544.       {
  545.          SoundBar.playSound(SoundBar.BUTTON_CLICK_SOUND,mouseX / Game.MIDX - 1);
  546.          var _loc2_:int = board.size - 1;
  547.          if(_loc2_ < Board.MIN_SIZE)
  548.          {
  549.             return;
  550.          }
  551.          disableMouse();
  552.          removeBoard();
  553.          addBoard(new Board(_loc2_));
  554.          enableMouse();
  555.       }
  556.       
  557.       override protected function resetClick(param1:MouseEvent) : void
  558.       {
  559.          var _loc2_:Tile = null;
  560.          var _loc3_:int = 0;
  561.          SoundBar.playSound(SoundBar.RESET_LEVEL_SOUND,0);
  562.          if(mode == CONNECTIONS_MODE)
  563.          {
  564.             _loc3_ = board.size;
  565.             disableMouse();
  566.             removeBoard();
  567.             addBoard(new Board(_loc3_));
  568.             enableMouse();
  569.          }
  570.          else if(mode == TEST_MODE)
  571.          {
  572.             reset();
  573.          }
  574.          else
  575.          {
  576.             board.homePositions();
  577.          }
  578.          for each(_loc2_ in tiles)
  579.          {
  580.             _loc2_.flash();
  581.          }
  582.       }
  583.    }
  584. }
  585.