home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / HexiomConnect.swf / scripts / Tile.as < prev    next >
Encoding:
Text File  |  2008-08-29  |  16.9 KB  |  697 lines
  1. package
  2. {
  3.    import flash.display.MovieClip;
  4.    import flash.display.Sprite;
  5.    import flash.geom.ColorTransform;
  6.    
  7.    public class Tile extends Sprite
  8.    {
  9.       
  10.       private static var TunnelGfx1:Class = Tile_TunnelGfx1;
  11.       
  12.       private static var TunnelGfx2:Class = Tile_TunnelGfx2;
  13.       
  14.       private static var RimGfx:Class = Tile_RimGfx;
  15.       
  16.       private static var TunnelGfx3:Class = Tile_TunnelGfx3;
  17.       
  18.       private static var TunnelGfx4:Class = Tile_TunnelGfx4;
  19.       
  20.       private static var TileGfx:Class = Tile_TileGfx;
  21.       
  22.       public static const COLORS:Array = [null,new ColorTransform(1,0,0),new ColorTransform(0.3,0.3,1),new ColorTransform(0.2,0.9,0.2),new ColorTransform(1,1,0)];
  23.       
  24.       private static var TunnelGfx:Class = Tile_TunnelGfx;
  25.       
  26.       private static var CenterGfx:Class = Tile_CenterGfx;
  27.        
  28.       
  29.       public var startSlot:Slot;
  30.       
  31.       private var nTunnel:Sprite;
  32.       
  33.       public var locked:Boolean;
  34.       
  35.       public var slot:Slot;
  36.       
  37.       private var nwTunnel:Sprite;
  38.       
  39.       private var rim:MovieClip;
  40.       
  41.       public var swLight:MovieClip;
  42.       
  43.       public var neLight:MovieClip;
  44.       
  45.       private var background:Sprite;
  46.       
  47.       public var ne:int;
  48.       
  49.       private var sTunnel:Sprite;
  50.       
  51.       public var nw:int;
  52.       
  53.       public var nwLight:MovieClip;
  54.       
  55.       public var nLight:MovieClip;
  56.       
  57.       public var se:int;
  58.       
  59.       private var center:Sprite;
  60.       
  61.       private var seTunnel:Sprite;
  62.       
  63.       public var confirmed:Boolean;
  64.       
  65.       public var seLight:MovieClip;
  66.       
  67.       public var sLight:MovieClip;
  68.       
  69.       public var sw:int;
  70.       
  71.       private var swTunnel:Sprite;
  72.       
  73.       public var n:int;
  74.       
  75.       public var s:int;
  76.       
  77.       public var homeSlot:Slot;
  78.       
  79.       private var neTunnel:Sprite;
  80.       
  81.       public function Tile(param1:Slot)
  82.       {
  83.          super();
  84.          mouseChildren = false;
  85.          this.slot = param1;
  86.          homeSlot = param1;
  87.          startSlot = param1;
  88.          if(param1)
  89.          {
  90.             param1.tile = this;
  91.             snapToSlot();
  92.          }
  93.          background = new TileGfx() as Sprite;
  94.          addChild(background);
  95.          locked = false;
  96.          confirmed = false;
  97.          rim = new RimGfx() as MovieClip;
  98.          addChild(rim);
  99.          rim.stop();
  100.          rim.addFrameScript(0,stopRim);
  101.       }
  102.       
  103.       public static function getTileGhost() : Sprite
  104.       {
  105.          var _loc1_:Sprite = new Sprite();
  106.          var _loc2_:Sprite = new RimGfx() as Sprite;
  107.          while(_loc2_.numChildren)
  108.          {
  109.             _loc1_.addChild(_loc2_.getChildAt(0));
  110.          }
  111.          _loc1_.transform.colorTransform = new ColorTransform(0,0,0,0.7,255,255,255);
  112.          return _loc1_;
  113.       }
  114.       
  115.       public static function getTunnelGhost() : Sprite
  116.       {
  117.          var _loc1_:MovieClip = null;
  118.          var _loc2_:Sprite = new Sprite();
  119.          var _loc3_:Sprite = new TunnelGfx() as Sprite;
  120.          _loc1_ = _loc3_.getChildByName("light") as MovieClip;
  121.          _loc1_.stop();
  122.          _loc2_.addChild(_loc3_);
  123.          var _loc4_:Sprite;
  124.          _loc1_ = (_loc4_ = new TunnelGfx() as Sprite).getChildByName("light") as MovieClip;
  125.          _loc1_.stop();
  126.          _loc4_.rotation = 180;
  127.          _loc4_.y = 86;
  128.          _loc2_.addChild(_loc4_);
  129.          _loc2_.alpha = 0.2;
  130.          _loc2_.mouseEnabled = false;
  131.          _loc2_.mouseChildren = false;
  132.          return _loc2_;
  133.       }
  134.       
  135.       public static function colorRGB(param1:int, param2:Number = 1) : uint
  136.       {
  137.          var _loc3_:ColorTransform = COLORS[param1];
  138.          var _loc4_:uint = uint(_loc3_.redMultiplier * param2 * 255 << 16);
  139.          var _loc5_:uint = uint(_loc3_.greenMultiplier * param2 * 255 << 8);
  140.          var _loc6_:uint = _loc3_.blueMultiplier * param2 * 255;
  141.          return _loc4_ + _loc5_ + _loc6_;
  142.       }
  143.       
  144.       private function addSETunnel(param1:int) : void
  145.       {
  146.          if(seTunnel)
  147.          {
  148.             return;
  149.          }
  150.          seTunnel = addTunnel(param1,-60);
  151.          seLight = seTunnel.getChildByName("light") as MovieClip;
  152.          seLight.stop();
  153.          seLight.addFrameScript(seLight.totalFrames - 1,seLightLoop);
  154.       }
  155.       
  156.       private function removeNETunnel() : void
  157.       {
  158.          if(!neTunnel)
  159.          {
  160.             return;
  161.          }
  162.          neLight.stop();
  163.          removeChild(neTunnel);
  164.          neTunnel = null;
  165.          neLight = null;
  166.          ne = 0;
  167.          checkRemoveCenter();
  168.       }
  169.       
  170.       private function nLightLoop() : void
  171.       {
  172.          nLight.gotoAndPlay(2);
  173.       }
  174.       
  175.       public function unconfirm() : void
  176.       {
  177.          confirmed = false;
  178.          rim.alpha = 1;
  179.          background.alpha = 1;
  180.       }
  181.       
  182.       private function addNTunnel(param1:int) : void
  183.       {
  184.          if(nTunnel)
  185.          {
  186.             return;
  187.          }
  188.          nTunnel = addTunnel(param1,180);
  189.          nLight = nTunnel.getChildByName("light") as MovieClip;
  190.          nLight.stop();
  191.          nLight.addFrameScript(nLight.totalFrames - 1,nLightLoop);
  192.       }
  193.       
  194.       private function removeSTunnel() : void
  195.       {
  196.          if(!sTunnel)
  197.          {
  198.             return;
  199.          }
  200.          sLight.stop();
  201.          removeChild(sTunnel);
  202.          sTunnel = null;
  203.          sLight = null;
  204.          s = 0;
  205.          checkRemoveCenter();
  206.       }
  207.       
  208.       private function nwLightLoop() : void
  209.       {
  210.          nwLight.gotoAndPlay(2);
  211.       }
  212.       
  213.       public function snapToSlot() : void
  214.       {
  215.          x = slot.x;
  216.          y = slot.y;
  217.       }
  218.       
  219.       private function addSWTunnel(param1:int) : void
  220.       {
  221.          if(swTunnel)
  222.          {
  223.             return;
  224.          }
  225.          swTunnel = addTunnel(param1,60);
  226.          swLight = swTunnel.getChildByName("light") as MovieClip;
  227.          swLight.stop();
  228.          swLight.addFrameScript(swLight.totalFrames - 1,swLightLoop);
  229.       }
  230.       
  231.       public function checkNeighbours() : void
  232.       {
  233.          var _loc1_:Tile = null;
  234.          if(slot.n)
  235.          {
  236.             _loc1_ = slot.n.tile;
  237.             if(n)
  238.             {
  239.                if(n == _loc1_.s)
  240.                {
  241.                   nLight.gotoAndPlay(2);
  242.                   _loc1_.sLight.gotoAndPlay(2);
  243.                }
  244.                else
  245.                {
  246.                   nLight.gotoAndStop(1);
  247.                   if(_loc1_.s)
  248.                   {
  249.                      _loc1_.sLight.gotoAndStop(1);
  250.                   }
  251.                }
  252.             }
  253.             else if(_loc1_.s)
  254.             {
  255.                _loc1_.sLight.gotoAndStop(1);
  256.             }
  257.          }
  258.          else if(n)
  259.          {
  260.             nLight.gotoAndStop(1);
  261.          }
  262.          if(slot.ne)
  263.          {
  264.             _loc1_ = slot.ne.tile;
  265.             if(ne)
  266.             {
  267.                if(ne == _loc1_.sw)
  268.                {
  269.                   neLight.gotoAndPlay(2);
  270.                   _loc1_.swLight.gotoAndPlay(2);
  271.                }
  272.                else
  273.                {
  274.                   neLight.gotoAndStop(1);
  275.                   if(_loc1_.sw)
  276.                   {
  277.                      _loc1_.swLight.gotoAndStop(1);
  278.                   }
  279.                }
  280.             }
  281.             else if(_loc1_.sw)
  282.             {
  283.                _loc1_.swLight.gotoAndStop(1);
  284.             }
  285.          }
  286.          else if(ne)
  287.          {
  288.             neLight.gotoAndStop(1);
  289.          }
  290.          if(slot.se)
  291.          {
  292.             _loc1_ = slot.se.tile;
  293.             if(se)
  294.             {
  295.                if(se == _loc1_.nw)
  296.                {
  297.                   seLight.gotoAndPlay(2);
  298.                   _loc1_.nwLight.gotoAndPlay(2);
  299.                }
  300.                else
  301.                {
  302.                   seLight.gotoAndStop(1);
  303.                   if(_loc1_.nw)
  304.                   {
  305.                      _loc1_.nwLight.gotoAndStop(1);
  306.                   }
  307.                }
  308.             }
  309.             else if(_loc1_.nw)
  310.             {
  311.                _loc1_.nwLight.gotoAndStop(1);
  312.             }
  313.          }
  314.          else if(se)
  315.          {
  316.             seLight.gotoAndStop(1);
  317.          }
  318.          if(slot.s)
  319.          {
  320.             _loc1_ = slot.s.tile;
  321.             if(s)
  322.             {
  323.                if(s == _loc1_.n)
  324.                {
  325.                   sLight.gotoAndPlay(2);
  326.                   _loc1_.nLight.gotoAndPlay(2);
  327.                }
  328.                else
  329.                {
  330.                   sLight.gotoAndStop(1);
  331.                   if(_loc1_.n)
  332.                   {
  333.                      _loc1_.nLight.gotoAndStop(1);
  334.                   }
  335.                }
  336.             }
  337.             else if(_loc1_.n)
  338.             {
  339.                _loc1_.nLight.gotoAndStop(1);
  340.             }
  341.          }
  342.          else if(s)
  343.          {
  344.             sLight.gotoAndStop(1);
  345.          }
  346.          if(slot.sw)
  347.          {
  348.             _loc1_ = slot.sw.tile;
  349.             if(sw)
  350.             {
  351.                if(sw == _loc1_.ne)
  352.                {
  353.                   swLight.gotoAndPlay(2);
  354.                   _loc1_.neLight.gotoAndPlay(2);
  355.                }
  356.                else
  357.                {
  358.                   swLight.gotoAndStop(1);
  359.                   if(_loc1_.ne)
  360.                   {
  361.                      _loc1_.neLight.gotoAndStop(1);
  362.                   }
  363.                }
  364.             }
  365.             else if(_loc1_.ne)
  366.             {
  367.                _loc1_.neLight.gotoAndStop(1);
  368.             }
  369.          }
  370.          else if(sw)
  371.          {
  372.             swLight.gotoAndStop(1);
  373.          }
  374.          if(slot.nw)
  375.          {
  376.             _loc1_ = slot.nw.tile;
  377.             if(nw)
  378.             {
  379.                if(nw == _loc1_.se)
  380.                {
  381.                   nwLight.gotoAndPlay(2);
  382.                   _loc1_.seLight.gotoAndPlay(2);
  383.                }
  384.                else
  385.                {
  386.                   nwLight.gotoAndStop(1);
  387.                   if(_loc1_.se)
  388.                   {
  389.                      _loc1_.seLight.gotoAndStop(1);
  390.                   }
  391.                }
  392.             }
  393.             else if(_loc1_.se)
  394.             {
  395.                _loc1_.seLight.gotoAndStop(1);
  396.             }
  397.          }
  398.          else if(nw)
  399.          {
  400.             nwLight.gotoAndStop(1);
  401.          }
  402.       }
  403.       
  404.       private function addNETunnel(param1:int) : void
  405.       {
  406.          if(neTunnel)
  407.          {
  408.             return;
  409.          }
  410.          neTunnel = addTunnel(param1,-120);
  411.          neLight = neTunnel.getChildByName("light") as MovieClip;
  412.          neLight.stop();
  413.          neLight.addFrameScript(neLight.totalFrames - 1,neLightLoop);
  414.       }
  415.       
  416.       private function checkRemoveCenter() : void
  417.       {
  418.          if(!n && !ne && !se && !s && !sw && !nw)
  419.          {
  420.             removeCenter();
  421.          }
  422.       }
  423.       
  424.       private function sLightLoop() : void
  425.       {
  426.          sLight.gotoAndPlay(2);
  427.       }
  428.       
  429.       private function seLightLoop() : void
  430.       {
  431.          seLight.gotoAndPlay(2);
  432.       }
  433.       
  434.       private function removeNWTunnel() : void
  435.       {
  436.          if(!nwTunnel)
  437.          {
  438.             return;
  439.          }
  440.          nwLight.stop();
  441.          removeChild(nwTunnel);
  442.          nwTunnel = null;
  443.          nwLight = null;
  444.          nw = 0;
  445.          checkRemoveCenter();
  446.       }
  447.       
  448.       public function setNE(param1:int) : void
  449.       {
  450.          ne = param1;
  451.          if(!param1)
  452.          {
  453.             removeNETunnel();
  454.          }
  455.          else
  456.          {
  457.             addNETunnel(param1);
  458.             neLight.transform.colorTransform = COLORS[param1];
  459.          }
  460.          checkNeighbours();
  461.       }
  462.       
  463.       public function lock() : void
  464.       {
  465.          locked = true;
  466.          rim.visible = false;
  467.          background.visible = false;
  468.          buttonMode = false;
  469.       }
  470.       
  471.       public function setS(param1:int) : void
  472.       {
  473.          s = param1;
  474.          if(!param1)
  475.          {
  476.             removeSTunnel();
  477.          }
  478.          else
  479.          {
  480.             addSTunnel(param1);
  481.             sLight.transform.colorTransform = COLORS[param1];
  482.          }
  483.          checkNeighbours();
  484.       }
  485.       
  486.       private function addNWTunnel(param1:int) : void
  487.       {
  488.          if(nwTunnel)
  489.          {
  490.             return;
  491.          }
  492.          nwTunnel = addTunnel(param1,120);
  493.          nwLight = nwTunnel.getChildByName("light") as MovieClip;
  494.          nwLight.stop();
  495.          nwLight.addFrameScript(nwLight.totalFrames - 1,nwLightLoop);
  496.       }
  497.       
  498.       public function setNW(param1:int) : void
  499.       {
  500.          nw = param1;
  501.          if(!param1)
  502.          {
  503.             removeNWTunnel();
  504.          }
  505.          else
  506.          {
  507.             addNWTunnel(param1);
  508.             nwLight.transform.colorTransform = COLORS[param1];
  509.          }
  510.          checkNeighbours();
  511.       }
  512.       
  513.       public function confirm() : void
  514.       {
  515.          confirmed = true;
  516.          rim.alpha = 0.35;
  517.          background.alpha = 0;
  518.       }
  519.       
  520.       public function setSE(param1:int) : void
  521.       {
  522.          se = param1;
  523.          if(!param1)
  524.          {
  525.             removeSETunnel();
  526.          }
  527.          else
  528.          {
  529.             addSETunnel(param1);
  530.             seLight.transform.colorTransform = COLORS[param1];
  531.          }
  532.          checkNeighbours();
  533.       }
  534.       
  535.       public function unlock() : void
  536.       {
  537.          locked = false;
  538.          rim.visible = true;
  539.          background.visible = true;
  540.          buttonMode = true;
  541.       }
  542.       
  543.       private function stopRim() : void
  544.       {
  545.          rim.stop();
  546.       }
  547.       
  548.       public function setN(param1:int) : void
  549.       {
  550.          n = param1;
  551.          if(!param1)
  552.          {
  553.             removeNTunnel();
  554.          }
  555.          else
  556.          {
  557.             addNTunnel(param1);
  558.             nLight.transform.colorTransform = COLORS[param1];
  559.          }
  560.          checkNeighbours();
  561.       }
  562.       
  563.       private function addCenter() : void
  564.       {
  565.          if(center)
  566.          {
  567.             return;
  568.          }
  569.          center = new CenterGfx();
  570.          addChild(center);
  571.       }
  572.       
  573.       private function removeNTunnel() : void
  574.       {
  575.          if(!nTunnel)
  576.          {
  577.             return;
  578.          }
  579.          nLight.stop();
  580.          removeChild(nTunnel);
  581.          nTunnel = null;
  582.          nLight = null;
  583.          n = 0;
  584.          checkRemoveCenter();
  585.       }
  586.       
  587.       private function swLightLoop() : void
  588.       {
  589.          swLight.gotoAndPlay(2);
  590.       }
  591.       
  592.       private function removeSETunnel() : void
  593.       {
  594.          if(!seTunnel)
  595.          {
  596.             return;
  597.          }
  598.          seLight.stop();
  599.          removeChild(seTunnel);
  600.          seTunnel = null;
  601.          seLight = null;
  602.          se = 0;
  603.          checkRemoveCenter();
  604.       }
  605.       
  606.       private function addSTunnel(param1:int) : void
  607.       {
  608.          if(sTunnel)
  609.          {
  610.             return;
  611.          }
  612.          sTunnel = addTunnel(param1,0);
  613.          sLight = sTunnel.getChildByName("light") as MovieClip;
  614.          sLight.stop();
  615.          sLight.addFrameScript(sLight.totalFrames - 1,sLightLoop);
  616.       }
  617.       
  618.       public function setSW(param1:int) : void
  619.       {
  620.          sw = param1;
  621.          if(!param1)
  622.          {
  623.             removeSWTunnel();
  624.          }
  625.          else
  626.          {
  627.             addSWTunnel(param1);
  628.             swLight.transform.colorTransform = COLORS[param1];
  629.          }
  630.          checkNeighbours();
  631.       }
  632.       
  633.       private function addTunnel(param1:int, param2:Number) : Sprite
  634.       {
  635.          var _loc3_:Sprite = null;
  636.          addCenter();
  637.          if(!Game.colorBlind)
  638.          {
  639.             _loc3_ = new TunnelGfx();
  640.          }
  641.          else if(param1 == 1)
  642.          {
  643.             _loc3_ = new TunnelGfx1();
  644.          }
  645.          else if(param1 == 2)
  646.          {
  647.             _loc3_ = new TunnelGfx2();
  648.          }
  649.          else if(param1 == 3)
  650.          {
  651.             _loc3_ = new TunnelGfx3();
  652.          }
  653.          else if(param1 == 4)
  654.          {
  655.             _loc3_ = new TunnelGfx4();
  656.          }
  657.          _loc3_.rotation = param2;
  658.          addChildAt(_loc3_,getChildIndex(center));
  659.          return _loc3_;
  660.       }
  661.       
  662.       private function removeSWTunnel() : void
  663.       {
  664.          if(!swTunnel)
  665.          {
  666.             return;
  667.          }
  668.          swLight.stop();
  669.          removeChild(swTunnel);
  670.          swTunnel = null;
  671.          swLight = null;
  672.          sw = 0;
  673.          checkRemoveCenter();
  674.       }
  675.       
  676.       private function neLightLoop() : void
  677.       {
  678.          neLight.gotoAndPlay(2);
  679.       }
  680.       
  681.       public function flash() : void
  682.       {
  683.          rim.gotoAndPlay(2);
  684.       }
  685.       
  686.       private function removeCenter() : void
  687.       {
  688.          if(!center)
  689.          {
  690.             return;
  691.          }
  692.          removeChild(center);
  693.          center = null;
  694.       }
  695.    }
  696. }
  697.