home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / HexiomConnect.swf / scripts / Board.as < prev    next >
Encoding:
Text File  |  2008-08-29  |  17.1 KB  |  576 lines
  1. package
  2. {
  3.    import flash.display.Sprite;
  4.    import flash.events.Event;
  5.    
  6.    public class Board extends Sprite
  7.    {
  8.       
  9.       public static const MAX_SIZE:int = 7;
  10.       
  11.       public static const MAX_LOCKED:Number = 0.5;
  12.       
  13.       public static const MIN_CONNECTIONS:Number = 0.2;
  14.       
  15.       public static const MIN_SIZE:int = 2;
  16.       
  17.       public static const DEFAULT_LOCKED:Number = 0.2;
  18.       
  19.       private static var BoardGfx:Class = Board_BoardGfx;
  20.       
  21.       public static const MIN_LOCKED:Number = 0;
  22.       
  23.       public static const MAX_CONNECTIONS:Number = 1;
  24.       
  25.       public static const DEFAULT_COLORS:int = 4;
  26.       
  27.       public static const DEFAULT_CONNECTIONS:Number = 0.35;
  28.        
  29.       
  30.       public var size:int;
  31.       
  32.       public var tileLayer:Sprite;
  33.       
  34.       public var tiles:Array;
  35.       
  36.       private var randomConnections:Number;
  37.       
  38.       private var randomColors:int;
  39.       
  40.       public var scaleFraction:Number = 1;
  41.       
  42.       public var background:Sprite;
  43.       
  44.       public var slotLayer:Sprite;
  45.       
  46.       private var randomLocked:Number;
  47.       
  48.       public var slots:Array;
  49.       
  50.       public var fullScale:Number = 1;
  51.       
  52.       public function Board(param1:int)
  53.       {
  54.          var _loc2_:Slot = null;
  55.          var _loc3_:Tile = null;
  56.          var _loc6_:int = 0;
  57.          super();
  58.          this.size = param1;
  59.          slots = new Array();
  60.          tiles = new Array();
  61.          background = new BoardGfx();
  62.          addChild(background);
  63.          background.scaleX = background.scaleY = (param1 * 2 + 0.75 - Math.sqrt(param1)) * 3.05;
  64.          slotLayer = new Sprite();
  65.          addChild(slotLayer);
  66.          tileLayer = new Sprite();
  67.          addChild(tileLayer);
  68.          _loc2_ = new Slot(0,0);
  69.          slots.push(_loc2_);
  70.          var _loc4_:int = 1;
  71.          while(_loc4_ < param1)
  72.          {
  73.             _loc6_ = int(slots.length - 1);
  74.             while(_loc6_ >= 0)
  75.             {
  76.                expand(slots[_loc6_]);
  77.                _loc6_--;
  78.             }
  79.             _loc4_++;
  80.          }
  81.          var _loc5_:int = int(slots.length - 1);
  82.          while(_loc5_ >= 0)
  83.          {
  84.             _loc2_ = slots[_loc5_];
  85.             slotLayer.addChild(_loc2_);
  86.             _loc3_ = new Tile(_loc2_);
  87.             tileLayer.addChild(_loc3_);
  88.             tiles.push(_loc3_);
  89.             _loc3_.buttonMode = true;
  90.             _loc5_--;
  91.          }
  92.       }
  93.       
  94.       public static function loadFromText(param1:String) : Board
  95.       {
  96.          var _loc4_:Tile = null;
  97.          var _loc5_:int = 0;
  98.          var _loc6_:int = 0;
  99.          var _loc7_:int = 0;
  100.          var _loc8_:Tile = null;
  101.          while(param1.charAt(0) == " ")
  102.          {
  103.             param1 = param1.substr(1);
  104.          }
  105.          param1 = Encrypt.decrypt(param1);
  106.          var _loc2_:int = int(param1.charAt(0));
  107.          if(_loc2_ < MIN_SIZE || _loc2_ > MAX_SIZE)
  108.          {
  109.             return null;
  110.          }
  111.          var _loc3_:Board = new Board(_loc2_);
  112.          param1 = param1.substr(1);
  113.          for each(_loc4_ in _loc3_.tiles)
  114.          {
  115.             if(param1.charAt(0) == "1")
  116.             {
  117.                _loc4_.lock();
  118.             }
  119.             param1 = param1.substr(1);
  120.             _loc5_ = param1.indexOf("_");
  121.             _loc6_ = int(param1.substr(0,_loc5_));
  122.             _loc4_.startSlot = _loc3_.slots[_loc6_];
  123.             param1 = param1.substr(_loc5_ + 1);
  124.             if((_loc7_ = int(param1.charAt(0))) >= Tile.COLORS.length)
  125.             {
  126.                return null;
  127.             }
  128.             _loc4_.setN(_loc7_);
  129.             if((_loc7_ = int(param1.charAt(1))) >= Tile.COLORS.length)
  130.             {
  131.                return null;
  132.             }
  133.             _loc4_.setNE(_loc7_);
  134.             if((_loc7_ = int(param1.charAt(2))) >= Tile.COLORS.length)
  135.             {
  136.                return null;
  137.             }
  138.             _loc4_.setSE(_loc7_);
  139.             if((_loc7_ = int(param1.charAt(3))) >= Tile.COLORS.length)
  140.             {
  141.                return null;
  142.             }
  143.             _loc4_.setS(_loc7_);
  144.             if((_loc7_ = int(param1.charAt(4))) >= Tile.COLORS.length)
  145.             {
  146.                return null;
  147.             }
  148.             _loc4_.setSW(_loc7_);
  149.             if((_loc7_ = int(param1.charAt(5))) >= Tile.COLORS.length)
  150.             {
  151.                return null;
  152.             }
  153.             _loc4_.setNW(_loc7_);
  154.             param1 = param1.substr(6);
  155.          }
  156.          for each(_loc4_ in _loc3_.tiles)
  157.          {
  158.             for each(_loc8_ in _loc3_.tiles)
  159.             {
  160.                if(_loc8_ != _loc4_ && _loc8_.startSlot == _loc4_.startSlot)
  161.                {
  162.                   return null;
  163.                }
  164.             }
  165.             if(Boolean(_loc4_.n) && (!_loc4_.slot.n || _loc4_.slot.n.tile.s != _loc4_.n))
  166.             {
  167.                return null;
  168.             }
  169.             if(Boolean(_loc4_.ne) && (!_loc4_.slot.ne || _loc4_.slot.ne.tile.sw != _loc4_.ne))
  170.             {
  171.                return null;
  172.             }
  173.             if(Boolean(_loc4_.se) && (!_loc4_.slot.se || _loc4_.slot.se.tile.nw != _loc4_.se))
  174.             {
  175.                return null;
  176.             }
  177.             if(Boolean(_loc4_.s) && (!_loc4_.slot.s || _loc4_.slot.s.tile.n != _loc4_.s))
  178.             {
  179.                return null;
  180.             }
  181.             if(Boolean(_loc4_.sw) && (!_loc4_.slot.sw || _loc4_.slot.sw.tile.ne != _loc4_.sw))
  182.             {
  183.                return null;
  184.             }
  185.             if(Boolean(_loc4_.nw) && (!_loc4_.slot.nw || _loc4_.slot.nw.tile.se != _loc4_.nw))
  186.             {
  187.                return null;
  188.             }
  189.          }
  190.          _loc3_.startPositions();
  191.          return _loc3_;
  192.       }
  193.       
  194.       public function redoRandomFill() : void
  195.       {
  196.          var _loc1_:Tile = null;
  197.          homePositions();
  198.          for each(_loc1_ in tiles)
  199.          {
  200.             if(_loc1_.locked)
  201.             {
  202.                _loc1_.unlock();
  203.             }
  204.             if(_loc1_.confirmed)
  205.             {
  206.                _loc1_.unconfirm();
  207.             }
  208.             _loc1_.setN(0);
  209.             _loc1_.setNE(0);
  210.             _loc1_.setSE(0);
  211.             _loc1_.setS(0);
  212.             _loc1_.setSW(0);
  213.             _loc1_.setNW(0);
  214.             _loc1_.startSlot = _loc1_.slot;
  215.          }
  216.          if(!randomColors)
  217.          {
  218.             randomFill();
  219.          }
  220.          else
  221.          {
  222.             randomFill(randomConnections,randomLocked,randomColors);
  223.          }
  224.          shuffleStart();
  225.       }
  226.       
  227.       public function setScale(param1:Number) : void
  228.       {
  229.          fullScale = scaleX = scaleY = param1;
  230.       }
  231.       
  232.       public function shrink() : void
  233.       {
  234.          SoundBar.playSound(SoundBar.EXIT_LEVEL_SOUND,mouseX / Game.MIDX - 1);
  235.          scaleFraction = 1;
  236.          addEventListener(Event.ENTER_FRAME,shrinkStep,false,0,true);
  237.       }
  238.       
  239.       public function homePositions() : void
  240.       {
  241.          var _loc1_:Tile = null;
  242.          for each(_loc1_ in tiles)
  243.          {
  244.             _loc1_.slot = _loc1_.homeSlot;
  245.             _loc1_.slot.tile = _loc1_;
  246.             _loc1_.snapToSlot();
  247.          }
  248.          for each(_loc1_ in tiles)
  249.          {
  250.             _loc1_.checkNeighbours();
  251.          }
  252.       }
  253.       
  254.       private function expand(param1:Slot) : void
  255.       {
  256.          var _loc2_:Slot = null;
  257.          if(!param1)
  258.          {
  259.             return;
  260.          }
  261.          if(!param1.n)
  262.          {
  263.             _loc2_ = new Slot(param1.x + Slot.N.x,param1.y + Slot.N.y);
  264.             slots.push(_loc2_);
  265.             param1.n = _loc2_;
  266.             _loc2_.s = param1;
  267.             if(param1.nw)
  268.             {
  269.                param1.nw.ne = _loc2_;
  270.                _loc2_.sw = param1.nw;
  271.                if(param1.nw.n)
  272.                {
  273.                   param1.nw.n.se = _loc2_;
  274.                   _loc2_.nw = param1.nw.n;
  275.                }
  276.             }
  277.             if(param1.ne)
  278.             {
  279.                param1.ne.nw = _loc2_;
  280.                _loc2_.se = param1.ne;
  281.                if(param1.ne.n)
  282.                {
  283.                   param1.ne.n.sw = _loc2_;
  284.                   _loc2_.ne = param1.ne.n;
  285.                }
  286.             }
  287.          }
  288.          if(!param1.ne)
  289.          {
  290.             _loc2_ = new Slot(param1.x + Slot.NE.x,param1.y + Slot.NE.y);
  291.             slots.push(_loc2_);
  292.             param1.ne = _loc2_;
  293.             _loc2_.sw = param1;
  294.             if(param1.n)
  295.             {
  296.                param1.n.se = _loc2_;
  297.                _loc2_.nw = param1.n;
  298.                if(param1.n.ne)
  299.                {
  300.                   param1.n.ne.s = _loc2_;
  301.                   _loc2_.n = param1.n.ne;
  302.                }
  303.             }
  304.             if(param1.se)
  305.             {
  306.                param1.se.n = _loc2_;
  307.                _loc2_.s = param1.se;
  308.                if(param1.se.ne)
  309.                {
  310.                   param1.se.ne.nw = _loc2_;
  311.                   _loc2_.se = param1.se.ne;
  312.                }
  313.             }
  314.          }
  315.          if(!param1.se)
  316.          {
  317.             _loc2_ = new Slot(param1.x + Slot.SE.x,param1.y + Slot.SE.y);
  318.             slots.push(_loc2_);
  319.             param1.se = _loc2_;
  320.             _loc2_.nw = param1;
  321.             if(param1.ne)
  322.             {
  323.                param1.ne.s = _loc2_;
  324.                _loc2_.n = param1.ne;
  325.                if(param1.ne.se)
  326.                {
  327.                   param1.ne.se.sw = _loc2_;
  328.                   _loc2_.ne = param1.ne.se;
  329.                }
  330.             }
  331.             if(param1.s)
  332.             {
  333.                param1.s.ne = _loc2_;
  334.                _loc2_.sw = param1.s;
  335.                if(param1.s.se)
  336.                {
  337.                   param1.s.se.n = _loc2_;
  338.                   _loc2_.s = param1.s.se;
  339.                }
  340.             }
  341.          }
  342.          if(!param1.s)
  343.          {
  344.             _loc2_ = new Slot(param1.x + Slot.S.x,param1.y + Slot.S.y);
  345.             slots.push(_loc2_);
  346.             param1.s = _loc2_;
  347.             _loc2_.n = param1;
  348.             if(param1.se)
  349.             {
  350.                param1.se.sw = _loc2_;
  351.                _loc2_.ne = param1.se;
  352.                if(param1.se.s)
  353.                {
  354.                   param1.se.s.nw = _loc2_;
  355.                   _loc2_.se = param1.se.s;
  356.                }
  357.             }
  358.             if(param1.sw)
  359.             {
  360.                param1.sw.se = _loc2_;
  361.                _loc2_.nw = param1.sw;
  362.                if(param1.sw.s)
  363.                {
  364.                   param1.sw.s.ne = _loc2_;
  365.                   _loc2_.sw = param1.sw.s;
  366.                }
  367.             }
  368.          }
  369.          if(!param1.sw)
  370.          {
  371.             _loc2_ = new Slot(param1.x + Slot.SW.x,param1.y + Slot.SW.y);
  372.             slots.push(_loc2_);
  373.             param1.sw = _loc2_;
  374.             _loc2_.ne = param1;
  375.             if(param1.s)
  376.             {
  377.                param1.s.nw = _loc2_;
  378.                _loc2_.se = param1.s;
  379.                if(param1.s.sw)
  380.                {
  381.                   param1.s.sw.n = _loc2_;
  382.                   _loc2_.s = param1.s.sw;
  383.                }
  384.             }
  385.             if(param1.nw)
  386.             {
  387.                param1.nw.s = _loc2_;
  388.                _loc2_.n = param1.nw;
  389.                if(param1.nw.sw)
  390.                {
  391.                   param1.nw.sw.se = _loc2_;
  392.                   _loc2_.nw = param1.nw.sw;
  393.                }
  394.             }
  395.          }
  396.          if(!param1.nw)
  397.          {
  398.             _loc2_ = new Slot(param1.x + Slot.NW.x,param1.y + Slot.NW.y);
  399.             slots.push(_loc2_);
  400.             param1.nw = _loc2_;
  401.             _loc2_.se = param1;
  402.             if(param1.sw)
  403.             {
  404.                param1.sw.n = _loc2_;
  405.                _loc2_.s = param1.sw;
  406.                if(param1.sw.nw)
  407.                {
  408.                   param1.sw.nw.ne = _loc2_;
  409.                   _loc2_.sw = param1.sw.nw;
  410.                }
  411.             }
  412.             if(param1.n)
  413.             {
  414.                param1.n.sw = _loc2_;
  415.                _loc2_.ne = param1.n;
  416.                if(param1.n.nw)
  417.                {
  418.                   param1.n.nw.s = _loc2_;
  419.                   _loc2_.n = param1.n.nw;
  420.                }
  421.             }
  422.          }
  423.       }
  424.       
  425.       public function grow() : void
  426.       {
  427.          SoundBar.playSound(SoundBar.ENTER_LEVEL_SOUND,mouseX / Game.MIDX - 1);
  428.          scaleFraction = 0;
  429.          scaleX = scaleY = 0;
  430.          addEventListener(Event.ENTER_FRAME,growStep,false,0,true);
  431.       }
  432.       
  433.       public function saveToText() : String
  434.       {
  435.          var _loc2_:Tile = null;
  436.          var _loc1_:* = "" + size;
  437.          for each(_loc2_ in tiles)
  438.          {
  439.             if(_loc2_.locked)
  440.             {
  441.                _loc1_ += "1";
  442.             }
  443.             else
  444.             {
  445.                _loc1_ += "0";
  446.             }
  447.             _loc1_ += slots.lastIndexOf(_loc2_.startSlot) + "_";
  448.             _loc1_ += _loc2_.n;
  449.             _loc1_ += _loc2_.ne;
  450.             _loc1_ += _loc2_.se;
  451.             _loc1_ += _loc2_.s;
  452.             _loc1_ += _loc2_.sw;
  453.             _loc1_ += _loc2_.nw;
  454.          }
  455.          return Encrypt.encrypt(_loc1_);
  456.       }
  457.       
  458.       public function startPositions() : void
  459.       {
  460.          var _loc1_:Tile = null;
  461.          for each(_loc1_ in tiles)
  462.          {
  463.             _loc1_.slot = _loc1_.startSlot;
  464.             _loc1_.slot.tile = _loc1_;
  465.             _loc1_.snapToSlot();
  466.          }
  467.          for each(_loc1_ in tiles)
  468.          {
  469.             _loc1_.checkNeighbours();
  470.          }
  471.       }
  472.       
  473.       public function shuffleStart() : void
  474.       {
  475.          var _loc2_:Tile = null;
  476.          var _loc3_:Tile = null;
  477.          var _loc1_:int = tiles.length * 2;
  478.          while(_loc1_ >= 0)
  479.          {
  480.             _loc2_ = tiles[int(Math.random() * tiles.length)];
  481.             _loc3_ = tiles[int(Math.random() * tiles.length)];
  482.             if(!(_loc2_ == _loc3_ || _loc2_.locked || _loc3_.locked))
  483.             {
  484.                _loc2_.slot.swapTiles(_loc3_.slot);
  485.                _loc2_.startSlot = _loc2_.slot;
  486.                _loc3_.startSlot = _loc3_.slot;
  487.             }
  488.             _loc1_--;
  489.          }
  490.       }
  491.       
  492.       private function shrinkStep(param1:Event) : void
  493.       {
  494.          scaleFraction = Math.max(0,scaleFraction - 0.1);
  495.          scaleX = scaleY = scaleFraction * scaleFraction * fullScale;
  496.          if(scaleFraction == 0)
  497.          {
  498.             removeEventListener(Event.ENTER_FRAME,shrinkStep);
  499.             dispatchEvent(new HexEvent(HexEvent.SHRUNK,false,false,this));
  500.          }
  501.       }
  502.       
  503.       public function randomFill(param1:Number = 0.35, param2:Number = 0.2, param3:int = 4) : void
  504.       {
  505.          var _loc4_:Tile = null;
  506.          var _loc5_:Slot = null;
  507.          var _loc9_:int = 0;
  508.          randomConnections = param1;
  509.          randomLocked = param2;
  510.          randomColors = param3;
  511.          var _loc6_:int = Math.min(tiles.length - 3,Math.floor(param2 * tiles.length));
  512.          while(_loc6_ > 0)
  513.          {
  514.             if((_loc4_ = tiles[int(Math.random() * tiles.length)]).locked)
  515.             {
  516.                _loc6_++;
  517.             }
  518.             else
  519.             {
  520.                _loc4_.lock();
  521.             }
  522.             _loc6_--;
  523.          }
  524.          var _loc7_:int = 0;
  525.          var _loc8_:int = 0;
  526.          for each(_loc5_ in slots)
  527.          {
  528.             if(_loc5_.n && !(_loc5_.tile.locked && _loc5_.n.tile.locked) && (Math.random() < param1 || _loc7_ / (_loc7_ + _loc8_) < param1 * 0.8) && _loc7_ / (_loc7_ + _loc8_) < param1 * 1.1)
  529.             {
  530.                _loc9_ = int(Math.random() * param3) + 1;
  531.                _loc5_.tile.setN(_loc9_);
  532.                _loc5_.n.tile.setS(_loc9_);
  533.                _loc7_++;
  534.             }
  535.             else
  536.             {
  537.                _loc8_++;
  538.             }
  539.             if(_loc5_.ne && !(_loc5_.tile.locked && _loc5_.ne.tile.locked) && (Math.random() < param1 || _loc7_ / (_loc7_ + _loc8_) < param1 * 0.8) && _loc7_ / (_loc7_ + _loc8_) < param1 * 1.1)
  540.             {
  541.                _loc9_ = int(Math.random() * param3) + 1;
  542.                _loc5_.tile.setNE(_loc9_);
  543.                _loc5_.ne.tile.setSW(_loc9_);
  544.                _loc7_++;
  545.             }
  546.             else
  547.             {
  548.                _loc8_++;
  549.             }
  550.             if(_loc5_.nw && !(_loc5_.tile.locked && _loc5_.nw.tile.locked) && (Math.random() < param1 || _loc7_ / (_loc7_ + _loc8_) < param1 * 0.8) && _loc7_ / (_loc7_ + _loc8_) < param1 * 1.1)
  551.             {
  552.                _loc9_ = int(Math.random() * param3) + 1;
  553.                _loc5_.tile.setNW(_loc9_);
  554.                _loc5_.nw.tile.setSE(_loc9_);
  555.                _loc7_++;
  556.             }
  557.             else
  558.             {
  559.                _loc8_++;
  560.             }
  561.          }
  562.       }
  563.       
  564.       private function growStep(param1:Event) : void
  565.       {
  566.          scaleFraction = Math.min(1,scaleFraction + 0.1);
  567.          scaleX = scaleY = scaleFraction * scaleFraction * fullScale;
  568.          if(scaleFraction == 1)
  569.          {
  570.             removeEventListener(Event.ENTER_FRAME,growStep);
  571.             dispatchEvent(new HexEvent(HexEvent.GROWN,false,false,this));
  572.          }
  573.       }
  574.    }
  575. }
  576.