home *** CD-ROM | disk | FTP | other *** search
/ Freelog 117 / FreelogNo117-OctobreNovembre2013.iso / Theme / 8GadgetPack / 8GadgetPackSetup.msi / picturePuzzle.js_1 < prev    next >
Text (UTF-16)  |  2012-05-19  |  48KB  |  894 lines
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // THIS CODE IS NOT APPROVED FOR USE IN/ON ANY OTHER UI ELEMENT OR PRODUCT COMPONENT.
  4. // Copyright (c) 2009 Microsoft Corporation. All rights reserved.
  5. //
  6. ////////////////////////////////////////////////////////////////////////////////
  7. var L_PAUSE_TEXT = "Suspendre le minuteur";
  8. var L_SHOW_TEXT = "Afficher l’image";
  9. var L_SHUFFLE_TEXT = "Lecture aléatoire";
  10. var L_SOLVE_TEXT = "Résoudre";
  11. var L_CONGRATULATIONS_TEXT = "";
  12. var L_YOU_WIN_TEXT = "Vous avez gagné !";
  13. var toolbarTextList = new Array(L_PAUSE_TEXT, L_SHOW_TEXT, L_SOLVE_TEXT);
  14. var tile = new Array(), x, y, i;
  15. var solvedTiles = new Array();
  16. var gShuffleCount = 1000;
  17. var emptyTile = null;
  18. var gridSize = 4;
  19. var tileSize = 27;
  20. var allowEvent = true;
  21. var puzzleObject = new clsPuzzleObject();
  22. var gameStarted = System.Gadget.Settings.read("gameStarted");
  23. var puzzleDirection = new Array(4);
  24. var sourceImage = "../images/1.png";
  25. var shuffleEvent = false;
  26. var totalSeconds = System.Gadget.Settings.read("totalSeconds") || 0;
  27. var timerActive = false;
  28. var timerTick = null;
  29.  
  30. puzzleDirection[0] = "U";
  31. puzzleDirection[1] = "D";
  32. puzzleDirection[2] = "L";
  33. puzzleDirection[3] = "R";
  34.  
  35. System.Gadget.settingsUI = "settings.html"
  36. System.Gadget.onSettingsClosed = settingsClosed;
  37. ////////////////////////////////////////////////////////////////////////////////
  38. //
  39. // Load main gadget function
  40. //
  41. ////////////////////////////////////////////////////////////////////////////////
  42. function loadMain()
  43. { 
  44.     L_CONGRATULATIONS.innerHTML = L_CONGRATULATIONS_TEXT;
  45.     L_YOU_WIN.innerHTML = L_YOU_WIN_TEXT;
  46.     
  47.     if (document.getElementsByTagName("html")[0].dir != "")
  48.     {
  49.         pageDir = document.getElementsByTagName("html")[0].dir;
  50.     }
  51.     
  52.     mySettings.load();
  53.     disableToolbar();
  54.     
  55.     sourceImage = "../images/" + mySettings.imageID + ".png";
  56.     gamePicture.src = sourceImage;
  57.     
  58.     // Attaching events to the toolbar buttons
  59.     timer.attachEvent("onmousedown", function(){doTimer('stop');});
  60.     timer.attachEvent("onkeydown", function(){doTimer('stop');});
  61.     hint.attachEvent("onmousedown", function(){hintShow()});
  62.     hint.attachEvent("onmouseup", function(){hintHide();});
  63.     hint.attachEvent("onkeydown", function(){hintShow()});
  64.     hint.attachEvent("onkeyup", function(){hintHide();});
  65.     shuffle.attachEvent("onmousedown", function(){shuffleHandler('true');});
  66.     shuffle.attachEvent("onkeydown",
  67.         function()
  68.         {
  69.             if ( event.keyCode == 13 )
  70.             {
  71.                 shuffleHandler('true');
  72.             }
  73.         } );
  74.     
  75.     toolbar();
  76.     displayGame();
  77. }
  78. ////////////////////////////////////////////////////////////////////////////////
  79. //
  80. // Move tile pieces if arrow keys down
  81. //
  82. ////////////////////////////////////////////////////////////////////////////////
  83. function testKey()
  84. {
  85.     if (event.keyCode == 37 || event.keyCode == 39 ||
  86.         event.keyCode == 38 || event.keyCode == 40)
  87.     {
  88.         self.focus;document.body.focus();
  89.         testTarget();
  90.     }
  91. }
  92. ////////////////////////////////////////////////////////////////////////////////
  93. //
  94. // Validate selected target tile
  95. //
  96. ////////////////////////////////////////////////////////////////////////////////
  97. function testTarget()
  98. {
  99.     var newTile;
  100.     var tileCount = 0;
  101.     var posCount = 0;
  102.     var xCord = 1;
  103.     var yCord = 1;
  104.     
  105.     // Stop right-clicking from causing tile movement
  106.     if (allowEvent == false || (event && event.button == 2))
  107.     {
  108.         return false;
  109.     }
  110.     
  111.     // Left
  112.     if (event.keyCode == 39)
  113.     {
  114.         newTile = emptyTile.index - 1;
  115.     }
  116.     // Right
  117.     else if (event.keyCode == 37)
  118.     {
  119.         newTile = emptyTile.index + 1;
  120.     }
  121.     // Up
  122.     else if (event.keyCode == 40)
  123.     {
  124.         newTile = emptyTile.index - 4;
  125.     }
  126.     // Down
  127.     else if (event.keyCode == 38)
  128.     {
  129.         newTile = emptyTile.index + 4;
  130.     }
  131.     
  132.     // Spoof x&y coords from arrow click for position values
  133.     if (newTile && (newTile > 0) && (newTile < 17))
  134.     {
  135.         for(y = 0; y < 4; y++)
  136.         {
  137.             for(x = 0; x < 4; x++, posCount++)
  138.             {
  139.                 if ((newTile - 1) == posCount)
  140.                 {
  141.                     xCord = 1 + (tileSize * x);
  142.                     yCord = 1 + (tileSize * y);
  143.                 }
  144.             }
  145.         }
  146.     }
  147.     // Grab x&y mouse click coords
  148.     else
  149.     {
  150.         xCord = event.offsetX;
  151.         yCord = event.offsetY;
  152.     }
  153.  
  154.     isValidChoice(xCord, yCord);
  155. }
  156. ////////////////////////////////////////////////////////////////////////////////
  157. //
  158. // 
  159. //
  160. ////////////////////////////////////////////////////////////////////////////////
  161. document.onselectstart = document.ondragstart = function shutup()
  162. {
  163.     return false;
  164. }
  165. ////////////////////////////////////////////////////////////////////////////////
  166. //
  167. // Puzzle object
  168. //
  169. ////////////////////////////////////////////////////////////////////////////////
  170. function clsPuzzleObject()
  171. {
  172.     this.invalidDirection = "";
  173.     this.currentIndex = 0;
  174.     this.newIndex = 0;
  175.     this.tileArray = new Array();
  176.     
  177.     this.resetPuzzle = function()
  178.     {    
  179.         this.currentIndex = (gridSize * gridSize);
  180.         if (this.tileArray.length > 0)
  181.         {
  182.             this.tileArray.splice(0);
  183.         }
  184.         for (var i = 0; i < (gridSize * gridSize); i++)
  185.         {
  186.             this.tileArray[i] = i;
  187.         }
  188.         this.reOrderPuzzle();
  189.     }
  190.     
  191.     this.reOrderPuzzle = function()
  192.     {
  193.         
  194.         var tempArray = new Array();
  195.         for (var i = 0; i < solvedTiles.length; i++)
  196.         {
  197.             tempArray[i] = solvedTiles[i];
  198.         }
  199.         tile.splice(0,tile.length);
  200.         
  201.         // If first display of a game, shuffle
  202.         if (gameStarted != true)
  203.         {
  204.             this.shuffle();
  205.             for (var i = 0; i < this.tileArray.length; i++)
  206.             {
  207.                 tile[i] = tempArray[ this.tileArray[i] ];
  208.             }
  209.         }
  210.         // If game has been displayed but sidebar closed and re-opened,
  211.         // then display saved pattern
  212.         else
  213.         {
  214.             for (var i = 0; i < this.tileArray.length; i++)
  215.             {
  216.                 var tileIndex = System.Gadget.Settings.read("savedTile"+(i+1));
  217.                 tile[i] = tempArray[tileIndex-1];
  218.             }
  219.         }
  220.     }
  221.     
  222.     this.shuffle = function(tempArray)
  223.     {    
  224.         var hold = 0;
  225.         for (var i = 0; i < gShuffleCount; i++)
  226.         {        
  227.             puzzleDirection.sort(function()
  228.             {
  229.                 return Math.random()-0.5;
  230.             });
  231.             for (var ii=0; ii < puzzleDirection.length; ii++)
  232.             {
  233.                 if ( this.isDirectionValid( puzzleDirection[ii] ) )
  234.                 {
  235.                     this.newIndex = this.getNextMove(puzzleDirection[ii]);
  236.                     if (this.newIndex != 0)
  237.                     {
  238.                         if ( this.isNextMoveValid() )
  239.                         {
  240.                             hold = this.tileArray[this.currentIndex-1];
  241.                             this.tileArray[this.currentIndex-1] = this.tileArray[this.newIndex - 1];
  242.                             this.tileArray[this.newIndex - 1] = hold;
  243.                             this.setInvalidDirection(puzzleDirection[ii]);
  244.                             this.currentIndex = this.newIndex;
  245.                             break;
  246.                         }
  247.                     }
  248.                 }    
  249.             }
  250.         }
  251.     }
  252.     
  253.     this.setInvalidDirection = function(direction)
  254.     {
  255.         switch (direction)
  256.         {
  257.             case "U" : this.invalidDirection = "D"; break;
  258.             case "L" : this.invalidDirection = "R"; break;
  259.             case "R" : this.invalidDirection = "L"; break;
  260.             case "D" : this.invalidDirection = "U"; break;            
  261.         }    
  262.     }
  263.  
  264.     this.isNextMoveValid = function()
  265.     {
  266.         var returnVal = false;
  267.     
  268.         // Validates Up, Down, Left, and Right tiles
  269.         if ((this.currentIndex - gridSize == this.newIndex) ||
  270.             (this.currentIndex + gridSize == this.newIndex) ||
  271.             ((this.currentIndex - 1 == this.newIndex) && (this.currentIndex % gridSize != 1)) ||
  272.             ((this.currentIndex + 1 == this.newIndex) && (this.currentIndex % gridSize != 0)))
  273.             {
  274.             returnVal = true;
  275.         }
  276.         return returnVal;
  277.     }
  278.     
  279.     this.getNextMove = function( direction )
  280.     {
  281.         var index = 0;
  282.         switch (direction)
  283.         {
  284.             case "U" : index = (this.currentIndex - gridSize); break;
  285.             case "L" : index = (this.currentIndex - 1); break;
  286.             case "R" : index = (this.currentIndex + 1); break;
  287.             case "D" : index = (this.currentIndex + gridSize); break;            
  288.         }
  289.         if ( index <= 0 | index > 16)
  290.         {
  291.             index = 0;
  292.         }
  293.         return index;
  294.     }
  295.  
  296.     this.isDirectionValid = function ( direction )
  297.     {
  298.         return ( this.invalidDirection != direction );
  299.     }
  300. }
  301. ////////////////////////////////////////////////////////////////////////////////
  302. //
  303. // No Animation Shuffle
  304. //
  305. ////////////////////////////////////////////////////////////////////////////////
  306. function onShuffleNoAnimation()
  307. {    
  308.     disableEvents();
  309.     pad.filters(0).apply();
  310.     puzzleObject.resetPuzzle();
  311.     
  312.     for(y = 0, i = 0; y < gridSize; y++)
  313.     {
  314.         for(x = 0; x < gridSize; x++, i++)
  315.         {
  316.             if (tile[i])
  317.             {
  318.                 tile[i].setAttribute("index", i + 1);
  319.                 moveNoAnimation(tile[i], x * tileSize, y * tileSize);
  320.             }
  321.         }
  322.     }
  323.     
  324.     pad.filters(0).play();
  325.     emptyTile.style.display = "";
  326.     setTimeout(enableEvents, 1000);
  327.     setTimeout("hint.disabled = ''", 900);
  328.     setTimeout("shuffle.disabled = ''", 900);
  329.     System.Gadget.Settings.write("gameStarted", true);
  330. }
  331. ////////////////////////////////////////////////////////////////////////////////
  332. //
  333. // No Animation Move
  334. //
  335. ////////////////////////////////////////////////////////////////////////////////
  336. function moveNoAnimation(tileObj, x, y)
  337. {
  338.     tileObj.x = x; 
  339.     tileObj.y = y;
  340.     tileObj.runtimeStyle.left = x;
  341.     tileObj.runtimeStyle.top = y;
  342.     tileObj.runtimeStyle.zIndex = 0
  343.     
  344.     if (gameStarted != true)
  345.     {
  346.         saveTile(tileObj.index, tileObj.originalPosition);
  347.     }
  348. }
  349. ////////////////////////////////////////////////////////////////////////////////
  350. //
  351. // Settings close
  352. //
  353. ////////////////////////////////////////////////////////////////////////////////
  354. function settingsClosed(event)
  355. {
  356.     if (event.closeAction == event.Action.commit)
  357.     {
  358.         var previousPicId = mySettings.imageID;
  359.         mySettings.load();
  360.  
  361.         if ( previousPicId !== mySettings.imageID )
  362.         {
  363.             sourceImage = "../images/" + mySettings.imageID + ".png";
  364.             gamePicture.src = sourceImage;
  365.  
  366.             for (var i = 1; i < 16; i++)
  367.             {
  368.                 document.getElementById("img"+i).parentElement.style.backgroundImage = 'url('+sourceImage+')';
  369.             }
  370.  
  371.             shuffleEvent = true;
  372.             shuffleHandler(true);
  373.         }
  374.     }
  375.     else if(event.closeAction == event.Action.cancel)
  376.     {
  377.     }
  378.     event.cancel = false;
  379. }
  380. ////////////////////////////////////////////////////////////////////////////////
  381. //
  382. // Display Game
  383. //
  384. ////////////////////////////////////////////////////////////////////////////////
  385. function displayGame()
  386. {
  387.     var counter = 0;
  388.     for(y = 0; y < gridSize; y++)
  389.     {
  390.         for(x = 0; x < gridSize; x++)
  391.         {
  392.             var tileLeft = x * tileSize;
  393.             var tileTop = y * tileSize;
  394.             pad.insertAdjacentHTML("beforeEnd",
  395.                 "<div dir='ltr' id='t"+y+x+"' onclick='swapTile(this)' originalPosition='"+(++counter)+"' "+
  396.                 "style='position: absolute; width: "+tileSize+"; height: "+tileSize+"; left: "+tileLeft+"; top: "+tileTop+"; background: no-repeat -"+tileLeft+" -"+tileTop+" url("+sourceImage+");'>"+
  397.                 "<img id='img"+counter+"' style='position: absolute; left: 0; top: 0; width: "+tileSize+"; height: "+tileSize+"' src='../images/tile_bezel.png'></div>"
  398.             );
  399.             tile.push(pad.lastChild);
  400.             solvedTiles.push(pad.lastChild);
  401.         }
  402.     }
  403.  
  404.     img16.parentElement.style.background="";
  405.     img16.parentElement.disabled = true;
  406.     img16.src = "../images/tile_drop_shadow.png";
  407.     emptyTile = tile[15]; 
  408.     setTimeout(onShuffleNoAnimation,500);
  409. }
  410. ////////////////////////////////////////////////////////////////////////////////
  411. //
  412. // On Shuffle
  413. //
  414. ////////////////////////////////////////////////////////////////////////////////
  415. function onShuffle()
  416. {
  417.     if ( event !== undefined && event !== null )
  418.     {
  419.         if ( (event.button && event.button != 1) || (event.keyCode && event.keyCode != 13) )
  420.         {
  421.             return false;
  422.         }
  423.     }
  424.     
  425.     disableToolbar();
  426.     disableEvents();
  427.     pad.filters(0).apply();
  428.     gamePictureDiv.style.display = "none";
  429.     emptyTile.index = "";
  430.     puzzleObject.resetPuzzle();
  431.     
  432.     for(y = 0, i = 0; y < gridSize; y++)
  433.     {
  434.         for(x = 0; x < gridSize; x++, i++)
  435.         {
  436.             tile[i].setAttribute("index", i + 1);
  437.             moveNoAnimation(tile[i], x * tileSize, y * tileSize);
  438.         }
  439.     }
  440.     
  441.     pad.filters(0).play();
  442.     emptyTile.style.display = "";
  443.     setTimeout(enableEvents, 1000);
  444.     setTimeout("hint.disabled = ''", 900);
  445.     setTimeout("shuffle.disabled = ''", 900);
  446.     gameStarted = true;
  447.     self.focus;document.body.focus();
  448. }
  449. ////////////////////////////////////////////////////////////////////////////////
  450. //
  451. // Handler to decide whether to shuffle or solve the puzzle
  452. //
  453. ////////////////////////////////////////////////////////////////////////////////
  454. function doTimer(timerAction)
  455. {
  456.     if ( event !== undefined && event !== null )
  457.     {
  458.         if ((event.button && event.button != 1) ||
  459.             (event.keyCode && event.keyCode != 13 &&
  460.             event.keyCode != 37 && event.keyCode != 39 &&
  461.             event.keyCode != 38 && event.keyCode != 40))
  462.         {
  463.             return false;
  464.         }
  465.     }
  466.     
  467.     switch (timerAction)
  468.     {
  469.         case 'start':
  470.             timerTick = setInterval(function(){tick();}, 1000);
  471.             timerActive = true;
  472.             timer.disabled = '';
  473.             break;
  474.             
  475.         case 'stop':
  476.             clearInterval(timerTick);
  477.             timer.disabled = 'true';
  478.             timerActive = false;
  479.             break;
  480.         
  481.         case 'reset':
  482.             clearInterval(timerTick);
  483.             timer.disabled = 'true';
  484.             timerActive = false;
  485.             totalSeconds = -1;
  486.             timerTick = setInterval(function(){tick();}, 1);
  487.             setTimeout('clearInterval(timerTick)', 1);
  488.             break;
  489.         
  490.         default:
  491.             timer.disabled = 'true';
  492.             timerActive = false;
  493.             totalSeconds = totalSeconds - 1;
  494.             timerTick = setInterval(function(){tick();}, 1);
  495.             setTimeout('clearInterval(timerTick)', 1);
  496.             break;
  497.     }
  498.     
  499.     function tick()
  500.     {
  501.         var timeCount = Math.abs(++totalSeconds);
  502.         var hours = parseInt(timeCount / 3600);
  503.         var minutes = parseInt((timeCount / 60) % 60);
  504.         var seconds = parseInt(timeCount % 60);
  505.         timerCount.innerText = (hours < 10 ? "0" : "")+hours+":"+(minutes < 10 ? "0" : "")+minutes+":"+(seconds < 10 ? "0" : "")+seconds;
  506.         System.Gadget.Settings.write("totalSeconds", totalSeconds);
  507.     }
  508. }
  509. ////////////////////////////////////////////////////////////////////////////////
  510. //
  511. // Handler to decide whether to shuffle or solve the puzzle
  512. //
  513. ////////////////////////////////////////////////////////////////////////////////
  514. function shuffleHandler(action)
  515. {
  516.     if (shuffleEvent == true)
  517.     {
  518.         if (action)
  519.         {
  520.             gameStarted = false;
  521.             onShuffle();
  522.             doTimer('reset');
  523.         }
  524.         shuffleEvent = false;
  525.         shuffle.title = L_SOLVE_TEXT;
  526.     }
  527.     else
  528.     {
  529.         if (action)
  530.         {
  531.             onSolve();
  532.             doTimer('reset');
  533.         }
  534.         shuffleEvent = true;
  535.         shuffle.title = L_SHUFFLE_TEXT;
  536.     }
  537. }
  538. ////////////////////////////////////////////////////////////////////////////////
  539. //
  540. // Disable mouse clicks and key presses
  541. //
  542. ////////////////////////////////////////////////////////////////////////////////
  543. function disableEvents()
  544. {
  545.     allowEvent = false;
  546. }
  547. ////////////////////////////////////////////////////////////////////////////////
  548. //
  549. // Enable mouse clicks and key presses
  550. //
  551. ////////////////////////////////////////////////////////////////////////////////
  552. function enableEvents()
  553. {
  554.     allowEvent = true;
  555. }
  556. ////////////////////////////////////////////////////////////////////////////////
  557. //
  558. // On Solve
  559. //
  560. ////////////////////////////////////////////////////////////////////////////////
  561. function onSolve()
  562. {
  563.     if ((event.button && event.button != 1) || (event.keyCode && event.keyCode != 13))
  564.     {
  565.         return false;
  566.     }
  567.     
  568.     disableToolbar();
  569.     disableEvents();
  570.     pad.filters(0).apply();
  571.     var i = 0;
  572.     
  573.     for(var y = 0; y < gridSize; y++)
  574.     {
  575.         for(var x = 0; x < gridSize; x++)
  576.         {
  577.             var style = window["t"+y+x].runtimeStyle;
  578.             style.posLeft = x * tileSize, style.posTop = y * tileSize;
  579.             document.getElementById("t"+y+x).setAttribute("index", ++i);
  580.             tile[i-1] = document.getElementById("t"+y+x);
  581.             saveTile(tile[i-1].index, tile[i-1].originalPosition);
  582.         }
  583.     }
  584.     
  585.     pad.filters(0).play();
  586.     setTimeout('gamePictureDiv.style.display = "none"', 70);
  587.     enableEvents();
  588.     setTimeout("hint.disabled = ''", 900);
  589.     setTimeout("shuffle.disabled = ''", 900);
  590. }
  591. ////////////////////////////////////////////////////////////////////////////////
  592. //
  593. // Check For Valid Choice
  594. //
  595. ////////////////////////////////////////////////////////////////////////////////
  596. function isValidChoice(xCord, yCord)
  597. {
  598.     // Find tile in array with matching x/y coords
  599.     var tileCount = 0;
  600.     while(tileObj = tile[tileCount++])
  601.     {
  602.         var runObj = tileObj.runtimeStyle;
  603.         if(runObj.posLeft < xCord &&
  604.             runObj.posLeft + tileSize > xCord &&
  605.             runObj.posTop < yCord &&
  606.             runObj.posTop + tileSize > yCord)
  607.         {
  608.             // Validates Up, Down, Left, and Right tiles
  609.             var index = tileObj.index;
  610.             if ((index > 0) && (index < 17) &&
  611.                 ((index == emptyTile.index - gridSize) ||
  612.                 (index == emptyTile.index + gridSize) ||
  613.                 ((index == emptyTile.index - 1) && (emptyTile.index % gridSize != 1)) ||
  614.                 ((index == emptyTile.index + 1) && (emptyTile.index % gridSize != 0))))
  615.             {
  616.                 // Fire off a click for that tile
  617.                 tileObj.click();
  618.                 if (!timerActive && !isGameOver())
  619.                 {
  620.                     doTimer('start');
  621.                 }
  622.                 
  623.                 if (shuffleEvent && !isGameOver())
  624.                 {
  625.                     shuffleHandler();
  626.                 }
  627.             }
  628.         }
  629.     }
  630.  
  631.     if ((index != emptyTile.index) && (Math.ceil(index / gridSize) == Math.ceil(emptyTile.index / gridSize)))
  632.     {
  633.         // Slide multiple tiles left
  634.         if (index > emptyTile.index)
  635.         {
  636.             for (count = emptyTile.index + 1; count <= index; count++)
  637.             {
  638.                 var left = emptyTile.runtimeStyle.posLeft + (tileSize+1);
  639.                 var top = emptyTile.runtimeStyle.posTop + 1;
  640.                 isValidChoice(left, top);
  641.             }
  642.         }
  643.         else
  644.         {
  645.             // Slide multiple tiles right
  646.             for (count = emptyTile.index - 1; count >= index; count--)
  647.             {
  648.                 var left = emptyTile.runtimeStyle.posLeft - (tileSize-1);
  649.                 var top = emptyTile.runtimeStyle.posTop + 1;
  650.                 isValidChoice(left, top);
  651.             }
  652.         }
  653.     }
  654.     else if ((index != emptyTile.index) && (index % gridSize == emptyTile.index % gridSize))
  655.     {
  656.         // Slide multiple tiles up
  657.         if (index > emptyTile.index)
  658.         {
  659.             for (count = emptyTile.index + gridSize; count <= index; count = count + gridSize)
  660.             {
  661.                 var left = emptyTile.runtimeStyle.posLeft + 1;
  662.                 var top = emptyTile.runtimeStyle.posTop + (tileSize+1);
  663.                 isValidChoice(left, top);
  664.             }
  665.         }
  666.         else
  667.         {
  668.             // Slide multiple tiles down
  669.             for (count = emptyTile.index - gridSize; count >= index; count = count - gridSize)
  670.             {
  671.                 var left = emptyTile.runtimeStyle.posLeft + 1;
  672.                 var top = emptyTile.runtimeStyle.posTop - (tileSize-1);
  673.                 isValidChoice(left, top);
  674.             }
  675.         }
  676.     }
  677. }
  678. ////////////////////////////////////////////////////////////////////////////////
  679. //
  680. // Swap Tiles
  681. //
  682. ////////////////////////////////////////////////////////////////////////////////
  683. function swapTile(tileObj)
  684. {
  685.     disableEvents();
  686.     var index = "";
  687.     var increment = 9;
  688.     var count = 0;
  689.     var startTop = tileObj.runtimeStyle.posTop;
  690.     var endTop = emptyTile.runtimeStyle.posTop;
  691.     var startLeft = tileObj.runtimeStyle.posLeft;
  692.     var endLeft = emptyTile.runtimeStyle.posLeft;
  693.     var endIndex = emptyTile.index;
  694.     
  695.     // Swap tile indices
  696.     tempIndex = tileObj.index;
  697.     tileObj.index = emptyTile.index;
  698.     emptyTile.index = tempIndex;
  699.     
  700.     // Swap runtimeStyle left position
  701.     tempLeft = tileObj.runtimeStyle.posLeft;
  702.     emptyTile.runtimeStyle.posLeft = tempLeft;
  703.     
  704.     // Swap runtimeStyle top position
  705.     tempTop = tileObj.runtimeStyle.posTop;
  706.     emptyTile.runtimeStyle.posTop = tempTop;
  707.     
  708.     emptyTile.runtimeStyle.zIndex = -1;
  709.     
  710.     // Slide tiles
  711.     setTimeout(tilePosition);
  712.     
  713.     function tilePosition()
  714.     {
  715.         if (count++ < increment)
  716.         {
  717.             tileObj.runtimeStyle.posTop = tileObj.runtimeStyle.posTop - ((startTop - endTop) / increment);
  718.             tileObj.runtimeStyle.posLeft = tileObj.runtimeStyle.posLeft - ((startLeft - endLeft) / increment);
  719.             return setTimeout(tilePosition, 10);
  720.         }
  721.         else
  722.         {
  723.             enableEvents();
  724.         }
  725.     }
  726.     
  727.     // Write tile/emptyTile data, erase old tile data
  728.     saveTile(tileObj.index, tileObj.originalPosition);
  729.     System.Gadget.Settings.write("savedTile" + emptyTile.index, 16);
  730.     
  731.     if (isGameOver())
  732.     {
  733.         doTimer('stop');
  734.         winner();
  735.     }
  736. }
  737. ////////////////////////////////////////////////////////////////////////////////
  738. //
  739. // Save Tile Data
  740. //
  741. ////////////////////////////////////////////////////////////////////////////////
  742. function saveTile(currentPos, originalPos)
  743. {
  744.     // Write tile/emptyTile data, erase old tile data
  745.     System.Gadget.Settings.write("savedTile" + currentPos, originalPos);
  746. }
  747. ////////////////////////////////////////////////////////////////////////////////
  748. //
  749. // Win Game
  750. //
  751. ////////////////////////////////////////////////////////////////////////////////
  752. function winner()
  753. {
  754.     if (!shuffleEvent)
  755.     {
  756.         shuffleHandler();
  757.     }
  758.     disableToolbar();
  759.     gamePictureDiv.filters(0).apply();
  760.     gamePictureDiv.style.display = "";
  761.     gamePictureDiv.filters(0).play();
  762.     setTimeout("winMessageDisplay(100)", 1000);
  763. }
  764. ////////////////////////////////////////////////////////////////////////////////
  765. //
  766. // Win Game
  767. //
  768. ////////////////////////////////////////////////////////////////////////////////
  769. function winMessageDisplay(val)
  770. {
  771.     winMessage.style.visibility = 'visible';
  772.     
  773.     if (val > 0)
  774.     {
  775.         val--;
  776.         winMessage.style.filter = "alpha(opacity=" + val + ")";
  777.         if (val == 35)
  778.         {
  779.             shuffle.disabled = '';
  780.         }
  781.         setTimeout("winMessageDisplay(" + val + ");", 60);
  782.     }
  783.     else
  784.     {
  785.         winMessage.style.visibility = 'hidden';
  786.     }
  787. }
  788. ////////////////////////////////////////////////////////////////////////////////
  789. //
  790. // Game Over
  791. //
  792. ////////////////////////////////////////////////////////////////////////////////
  793. function isGameOver()
  794. {
  795.     var returnVal = true;
  796.     
  797.     for (var i = 0; i < tile.length; i++)
  798.     {
  799.         if (tile[i].index != tile[i].originalPosition)
  800.         {
  801.             returnVal = false;
  802.             break;
  803.         }
  804.     }
  805.     
  806.     return returnVal;
  807. }
  808. ////////////////////////////////////////////////////////////////////////////////
  809. //
  810. // Toolbar
  811. //
  812. ////////////////////////////////////////////////////////////////////////////////
  813. function toolbar()
  814. {
  815.     var imgList = bar.all.tags("img");
  816.     var i = 0;
  817.     var img;
  818.     
  819.     doTimer();
  820.     
  821.     while (img = imgList[i++])
  822.     {
  823.         with (img)
  824.         {
  825.             src = "../images/"+id+"_up.png";
  826.             title = toolbarTextList[i-1];
  827.             tabIndex = i+1;
  828.             onmouseover = function(){this.over = true; swapImage(this)}
  829.             onmouseout = function(){this.over = false; swapImage(this)}
  830.             onmousedown = function(){this.down = true; swapImage(this); this.setCapture()}
  831.             onmouseup = function()
  832.             {
  833.                 this.down = false;
  834.                 this.releaseCapture();
  835.                 var button = document.elementFromPoint(event.clientX, event.clientY);
  836.                 if (button != this)
  837.                 {
  838.                     this.over = false;
  839.                     button.fireEvent("onmouseover");
  840.                 }
  841.                 swapImage(this);
  842.             }
  843.         
  844.             function swapImage(button){
  845.                 var state = "up";
  846.                 if (button.down && !button.disabled)
  847.                 {
  848.                     state = "down";
  849.                 }
  850.                 else if (button.over && !button.disabled)
  851.                 {
  852.                     state = "over";
  853.                 }
  854.                 button.src = "../images/"+button.id+"_"+state+".png";                
  855.             }
  856.         }
  857.     }
  858. }
  859. ////////////////////////////////////////////////////////////////////////////////
  860. //
  861. // Disable toolbar buttons
  862. //
  863. ////////////////////////////////////////////////////////////////////////////////
  864. function disableToolbar()
  865. {
  866.     timer.disabled = 'true';
  867.     hint.disabled = 'true';
  868.     shuffle.disabled = 'true';
  869. }
  870. ////////////////////////////////////////////////////////////////////////////////
  871. //
  872. // Show Hint image
  873. //
  874. ////////////////////////////////////////////////////////////////////////////////
  875. function hintShow()
  876. {
  877.     if (!hint.disabled && (event.button == 1 || event.keyCode == 13))
  878.     {
  879.         gamePictureDiv.style.display = "";
  880.     }
  881. }
  882. ////////////////////////////////////////////////////////////////////////////////
  883. //
  884. // Hide Hint image
  885. //
  886. ////////////////////////////////////////////////////////////////////////////////
  887. function hintHide()
  888. {
  889.     if (!hint.disabled && (event.button == 1 || event.keyCode == 27))
  890.     {
  891.         gamePictureDiv.style.display = "none";
  892.     }
  893. }
  894.