home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Puzzle / blobs.swf / scripts / DefineSprite_22 / frame_2 / DoAction.as
Encoding:
Text File  |  2006-06-13  |  5.3 KB  |  250 lines
  1. function buildPuzzle()
  2. {
  3.    blockcount = 0;
  4.    var startx = 0;
  5.    var starty = 0;
  6.    blocksize = 300 / puzzlesize;
  7.    y = 0;
  8.    while(y < puzzlesize)
  9.    {
  10.       x = 0;
  11.       while(x < puzzlesize)
  12.       {
  13.          newname = "block" + y + x;
  14.          duplicateMovieClip("block",newname,16384 + ++block_count);
  15.          this[newname]._x = startx + blocksize * x;
  16.          this[newname]._y = starty + blocksize * y;
  17.          this[newname].x = x;
  18.          this[newname].y = y;
  19.          this[newname].photo.gotoAndStop(_parent.preview._currentframe);
  20.          this[newname].photo._x = blocksize * x * -1;
  21.          this[newname].photo._y = blocksize * y * -1;
  22.          this[newname].gotoAndStop(puzzlesize - 2);
  23.          x++;
  24.       }
  25.       y++;
  26.    }
  27.    this[newname]._alpha = 0;
  28.    this[newname]._visible = false;
  29.    blankblock = newname;
  30. }
  31. function checkPuzzle()
  32. {
  33.    wrong = 0;
  34.    y = 0;
  35.    while(y < puzzlesize)
  36.    {
  37.       x = 0;
  38.       while(x < puzzlesize)
  39.       {
  40.          if(puzzlearray[y][x] != "block" + y + x)
  41.          {
  42.             wrong++;
  43.          }
  44.          x++;
  45.       }
  46.       y++;
  47.    }
  48.    _parent.percentcompleted = Math.round(100 * ((puzzlesize * puzzlesize - wrong) / (puzzlesize * puzzlesize))) + "%";
  49.    if(0 < wrong)
  50.    {
  51.       return false;
  52.    }
  53.    return true;
  54. }
  55. function reset()
  56. {
  57.    y = 0;
  58.    while(y < puzzlesize)
  59.    {
  60.       x = 0;
  61.       while(x < puzzlesize)
  62.       {
  63.          this["block" + y + x].removeMovieClip();
  64.          x++;
  65.       }
  66.       y++;
  67.    }
  68.    _parent.movecount = 0;
  69.    _parent.percentcompleted = "";
  70. }
  71. function slide(b)
  72. {
  73.    if(solved == true)
  74.    {
  75.       return undefined;
  76.    }
  77.    if(this[b].motion == true)
  78.    {
  79.       return undefined;
  80.    }
  81.    if(b == blankblock)
  82.    {
  83.       return undefined;
  84.    }
  85.    var cx = this[b].x;
  86.    var cy = this[b].y;
  87.    var bx = this[blankblock].x;
  88.    var by = this[blankblock].y;
  89.    if(cx == bx)
  90.    {
  91.       if(by < cy)
  92.       {
  93.          swapBlocks(0,1,b);
  94.       }
  95.       else if(cy < by)
  96.       {
  97.          swapBlocks(0,-1,b);
  98.       }
  99.    }
  100.    else
  101.    {
  102.       if(cy != by)
  103.       {
  104.          return undefined;
  105.       }
  106.       if(bx < cx)
  107.       {
  108.          swapBlocks(1,0,b);
  109.       }
  110.       else if(cx < bx)
  111.       {
  112.          swapBlocks(-1,0,b);
  113.       }
  114.    }
  115.    _parent.movecount = _parent.movecount + 1;
  116.    if(checkPuzzle())
  117.    {
  118.       this[blankblock].reveal = true;
  119.       solved = true;
  120.       RevealPicture();
  121.       _parent.sounds.gotoAndPlay("win");
  122.    }
  123. }
  124. function RevealPicture()
  125. {
  126.    y = 0;
  127.    while(y < puzzlesize)
  128.    {
  129.       x = 0;
  130.       while(x < puzzlesize)
  131.       {
  132.          this["block" + y + x].outline.gotoAndPlay("fade");
  133.          x++;
  134.       }
  135.       y++;
  136.    }
  137. }
  138. function swapBlocks(x, y, b)
  139. {
  140.    var bx = this[blankblock].x;
  141.    var by = this[blankblock].y;
  142.    var swapblock = puzzlearray[by + y][bx + x];
  143.    var tempx = this[blankblock]._x;
  144.    var tempy = this[blankblock]._y;
  145.    this[blankblock]._x = this[swapblock]._x;
  146.    this[blankblock]._y = this[swapblock]._y;
  147.    this[swapblock].newx = tempx;
  148.    this[swapblock].newy = tempy;
  149.    this[swapblock].x = bx;
  150.    this[swapblock].y = by;
  151.    this[swapblock].motion = true;
  152.    this[swapblock].mx = x;
  153.    this[swapblock].my = y;
  154.    this[blankblock].x = bx + x;
  155.    this[blankblock].y = by + y;
  156.    puzzlearray[by][bx] = swapblock;
  157.    puzzlearray[by + y][bx + x] = blankblock;
  158.    if(swapblock != b)
  159.    {
  160.       swapBlocks(x,y,b);
  161.    }
  162. }
  163. function shuffle()
  164. {
  165.    shufflecomplete = false;
  166.    j = 0;
  167.    while(100 >= j)
  168.    {
  169.       bx = this[blankblock].x;
  170.       by = this[blankblock].y;
  171.       do
  172.       {
  173.          xory = random(2);
  174.          if(xory == 0)
  175.          {
  176.             rx = bx;
  177.             ry = random(2);
  178.             if(ry == 0)
  179.             {
  180.                ry = by - 1;
  181.             }
  182.             else
  183.             {
  184.                ry = by + 1;
  185.             }
  186.          }
  187.          else
  188.          {
  189.             ry = by;
  190.             rx = random(2);
  191.             if(rx == 0)
  192.             {
  193.                rx = bx - 1;
  194.             }
  195.             else
  196.             {
  197.                rx = bx + 1;
  198.             }
  199.          }
  200.       }
  201.       while(rx >= puzzlesize or rx < 0 or ry < 0 or ry >= puzzlesize);
  202.       
  203.       swapblock = puzzlearray[ry][rx];
  204.       puzzlearray[ry][rx] = blankblock;
  205.       this[blankblock].x = rx;
  206.       this[blankblock].y = ry;
  207.       puzzlearray[by][bx] = swapblock;
  208.       this[swapblock].x = bx;
  209.       this[swapblock].y = by;
  210.       j++;
  211.    }
  212.    shufflecomplete = true;
  213.    y = 0;
  214.    while(y < puzzlesize)
  215.    {
  216.       x = 0;
  217.       while(x < puzzlesize)
  218.       {
  219.          this[puzzlearray[y][x]]._x = blocksize * x;
  220.          this[puzzlearray[y][x]]._y = blocksize * y;
  221.          x++;
  222.       }
  223.       y++;
  224.    }
  225.    checkPuzzle();
  226.    solved = false;
  227.    _parent.timerclip.startTime = getTimer();
  228.    _parent.timerclip.seconds = 0;
  229.    _parent.timerclip.minutes = 0;
  230. }
  231. function BuildArray()
  232. {
  233.    puzzlearray = new Array();
  234.    y = 0;
  235.    while(y < puzzlesize)
  236.    {
  237.       puzzlearray[y] = new Array();
  238.       x = 0;
  239.       while(x < puzzlesize)
  240.       {
  241.          thisblock = "block" + y + x;
  242.          tx = this[thisblock].x;
  243.          ty = this[thisblock].y;
  244.          puzzlearray[ty][tx] = this[thisblock]._name;
  245.          x++;
  246.       }
  247.       y++;
  248.    }
  249. }
  250.