home *** CD-ROM | disk | FTP | other *** search
/ Champak 109 / Vol 109.iso / games / flash_ch.swf / scripts / frame_4 / DoAction.as
Encoding:
Text File  |  2008-11-12  |  23.7 KB  |  936 lines
  1. function MovementRules()
  2. {
  3.    this.up = 0;
  4.    this.down = 0;
  5.    this.left = 0;
  6.    this.right = 0;
  7.    this.up_left = 0;
  8.    this.up_right = 0;
  9.    this.down_left = 0;
  10.    this.down_right = 0;
  11.    this.isKnight = false;
  12.    this.isPawn = false;
  13. }
  14. function Move(firstPosX, firstPosY, lastPosX, lastPosY)
  15. {
  16.    this.fPX = firstPosX;
  17.    this.fPY = firstPosY;
  18.    this.lPX = lastPosX;
  19.    this.lPY = lastPosY;
  20. }
  21. function rulesFor(piece)
  22. {
  23.    if(piece == PAWN_W || piece == PAWN_B)
  24.    {
  25.       return pawnRules;
  26.    }
  27.    if(piece == KNIGHT_W || piece == KNIGHT_B)
  28.    {
  29.       return knightRules;
  30.    }
  31.    if(piece == ROOK_W || piece == ROOK_B)
  32.    {
  33.       return rookRules;
  34.    }
  35.    if(piece == BISSHOP_W || piece == BISSHOP_B)
  36.    {
  37.       return bisshopRules;
  38.    }
  39.    if(piece == QUEEN_W || piece == QUEEN_B)
  40.    {
  41.       return queenRules;
  42.    }
  43.    if(piece == KING_W || piece == KING_B)
  44.    {
  45.       return kingRules;
  46.    }
  47. }
  48. function initChessBoard()
  49. {
  50.    chessBoard = new Array(8);
  51.    chessBoard[0] = new Array(ROOK_B,KNIGHT_B,BISSHOP_B,QUEEN_B,KING_B,BISSHOP_B,KNIGHT_B,ROOK_B);
  52.    chessBoard[1] = new Array(PAWN_B,PAWN_B,PAWN_B,PAWN_B,PAWN_B,PAWN_B,PAWN_B,PAWN_B);
  53.    chessBoard[2] = new Array(VOID,VOID,VOID,VOID,VOID,VOID,VOID,VOID);
  54.    chessBoard[3] = new Array(VOID,VOID,VOID,VOID,VOID,VOID,VOID,VOID);
  55.    chessBoard[4] = new Array(VOID,VOID,VOID,VOID,VOID,VOID,VOID,VOID);
  56.    chessBoard[5] = new Array(VOID,VOID,VOID,VOID,VOID,VOID,VOID,VOID);
  57.    chessBoard[6] = new Array(PAWN_W,PAWN_W,PAWN_W,PAWN_W,PAWN_W,PAWN_W,PAWN_W,PAWN_W);
  58.    chessBoard[7] = new Array(ROOK_W,KNIGHT_W,BISSHOP_W,QUEEN_W,KING_W,BISSHOP_W,KNIGHT_W,ROOK_W);
  59.    var i = 0;
  60.    while(i < 8)
  61.    {
  62.       var j = 0;
  63.       while(j < 8)
  64.       {
  65.          _root["piece_" + i + "_" + j].showPiece(chessBoard[i][j]);
  66.          _root["piece_" + i + "_" + j].row = i;
  67.          _root["piece_" + i + "_" + j].col = j;
  68.          j++;
  69.       }
  70.       i++;
  71.    }
  72. }
  73. function calculateMoves(row, col, side)
  74. {
  75.    if(chessBoard[row][col] == VOID)
  76.    {
  77.       trace("Error:  no piece to calculate moves for !!");
  78.       return null;
  79.    }
  80.    var poMo = new Array();
  81.    rules = rulesFor(chessBoard[row][col]);
  82.    var poTa;
  83.    if(rules.isKnight)
  84.    {
  85.       var x = row - 1;
  86.       var y = col + 2;
  87.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  88.       {
  89.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  90.          {
  91.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  92.          }
  93.       }
  94.       x = row - 1;
  95.       y = col - 2;
  96.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  97.       {
  98.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  99.          {
  100.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  101.          }
  102.       }
  103.       x = row + 1;
  104.       y = col + 2;
  105.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  106.       {
  107.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  108.          {
  109.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  110.          }
  111.       }
  112.       x = row + 1;
  113.       y = col - 2;
  114.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  115.       {
  116.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  117.          {
  118.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  119.          }
  120.       }
  121.       x = row - 2;
  122.       y = col + 1;
  123.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  124.       {
  125.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  126.          {
  127.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  128.          }
  129.       }
  130.       x = row - 2;
  131.       y = col - 1;
  132.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  133.       {
  134.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  135.          {
  136.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  137.          }
  138.       }
  139.       x = row + 2;
  140.       y = col - 1;
  141.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  142.       {
  143.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  144.          {
  145.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  146.          }
  147.       }
  148.       x = row + 2;
  149.       y = col + 1;
  150.       if(x >= 0 && x < 8 && y >= 0 && y < 8)
  151.       {
  152.          if(chessBoard[x][y] == VOID || side != (chessBoard[x][y] & 1))
  153.          {
  154.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  155.          }
  156.       }
  157.    }
  158.    else if(rules.isPawn)
  159.    {
  160.       if(side == SIDE_PLAYER)
  161.       {
  162.          var possibleEmpassant = false;
  163.          var i = row - 1;
  164.          if(chessBoard[i][col] == VOID)
  165.          {
  166.             poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  167.             possibleEmpassant = true;
  168.          }
  169.          if(row == 6 && possibleEmpassant)
  170.          {
  171.             i--;
  172.             if(chessBoard[i][col] == VOID)
  173.             {
  174.                poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  175.             }
  176.          }
  177.          var x = row - 1;
  178.          var y = col - 1;
  179.          if(x >= 0 && x < 8 && y >= 0 && y < 8 && (chessBoard[x][y] != VOID && side != (chessBoard[x][y] & 1)))
  180.          {
  181.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  182.          }
  183.          var x = row - 1;
  184.          var y = col + 1;
  185.          if(x >= 0 && x < 8 && y >= 0 && y < 8 && (chessBoard[x][y] != VOID && side != (chessBoard[x][y] & 1)))
  186.          {
  187.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  188.          }
  189.       }
  190.       else
  191.       {
  192.          var possibleEmpassant = false;
  193.          var i = row + 1;
  194.          if(chessBoard[i][col] == VOID)
  195.          {
  196.             poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  197.             possibleEmpassant = true;
  198.          }
  199.          if(row == 1 && possibleEmpassant)
  200.          {
  201.             i++;
  202.             if(chessBoard[i][col] == VOID)
  203.             {
  204.                poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  205.             }
  206.          }
  207.          x = row + 1;
  208.          y = col - 1;
  209.          if(x >= 0 && x < 8 && y >= 0 && y < 8 && (chessBoard[x][y] != VOID && side != (chessBoard[x][y] & 1)))
  210.          {
  211.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  212.          }
  213.          x = row + 1;
  214.          y = col + 1;
  215.          if(x >= 0 && x < 8 && y >= 0 && y < 8 && (chessBoard[x][y] != VOID && side != (chessBoard[x][y] & 1)))
  216.          {
  217.             poMo[poMo.length] = row << 9 | col << 6 | x << 3 | y;
  218.          }
  219.       }
  220.    }
  221.    else
  222.    {
  223.       var delta = rules.up;
  224.       var i = row - 1;
  225.       while(0 < delta && i >= 0)
  226.       {
  227.          if(!(chessBoard[i][col] == VOID || side != (chessBoard[i][col] & 1)))
  228.          {
  229.             break;
  230.          }
  231.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  232.          if(chessBoard[i][col] != VOID)
  233.          {
  234.             break;
  235.          }
  236.          i--;
  237.          delta--;
  238.       }
  239.       var delta = rules.down;
  240.       var i = row + 1;
  241.       while(0 < delta && i < 8)
  242.       {
  243.          if(!(chessBoard[i][col] == VOID || side != (chessBoard[i][col] & 1)))
  244.          {
  245.             break;
  246.          }
  247.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | col;
  248.          if(chessBoard[i][col] != VOID)
  249.          {
  250.             break;
  251.          }
  252.          i++;
  253.          delta--;
  254.       }
  255.       var delta = rules.left;
  256.       var j = col - 1;
  257.       while(0 < delta && j >= 0)
  258.       {
  259.          if(!(chessBoard[row][j] == VOID || side != (chessBoard[row][j] & 1)))
  260.          {
  261.             break;
  262.          }
  263.          poMo[poMo.length] = row << 9 | col << 6 | row << 3 | j;
  264.          if(chessBoard[row][j] != VOID)
  265.          {
  266.             break;
  267.          }
  268.          j--;
  269.          delta--;
  270.       }
  271.       var delta = rules.right;
  272.       var j = col + 1;
  273.       while(0 < delta && j < 8)
  274.       {
  275.          if(!(chessBoard[row][j] == VOID || side != (chessBoard[row][j] & 1)))
  276.          {
  277.             break;
  278.          }
  279.          poMo[poMo.length] = row << 9 | col << 6 | row << 3 | j;
  280.          if(chessBoard[row][j] != VOID)
  281.          {
  282.             break;
  283.          }
  284.          j++;
  285.          delta--;
  286.       }
  287.       var delta = rules.up_left;
  288.       var i = row - 1;
  289.       var j = col - 1;
  290.       while(0 < delta && j >= 0 && i >= 0)
  291.       {
  292.          if(!(chessBoard[i][j] == VOID || side != (chessBoard[i][j] & 1)))
  293.          {
  294.             break;
  295.          }
  296.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | j;
  297.          if(chessBoard[i][j] != VOID)
  298.          {
  299.             break;
  300.          }
  301.          i--;
  302.          j--;
  303.          delta--;
  304.       }
  305.       var delta = rules.up_right;
  306.       var i = row - 1;
  307.       var j = col + 1;
  308.       while(0 < delta && j < 8 && i >= 0)
  309.       {
  310.          if(!(chessBoard[i][j] == VOID || side != (chessBoard[i][j] & 1)))
  311.          {
  312.             break;
  313.          }
  314.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | j;
  315.          if(chessBoard[i][j] != VOID)
  316.          {
  317.             break;
  318.          }
  319.          i--;
  320.          j++;
  321.          delta--;
  322.       }
  323.       var delta = rules.down_left;
  324.       var i = row + 1;
  325.       var j = col - 1;
  326.       while(0 < delta && j >= 0 && i < 8)
  327.       {
  328.          if(!(chessBoard[i][j] == VOID || side != (chessBoard[i][j] & 1)))
  329.          {
  330.             break;
  331.          }
  332.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | j;
  333.          if(chessBoard[i][j] != VOID)
  334.          {
  335.             break;
  336.          }
  337.          i++;
  338.          j--;
  339.          delta--;
  340.       }
  341.       var delta = rules.down_right;
  342.       var i = row + 1;
  343.       var j = col + 1;
  344.       while(0 < delta && j < 8 && i < 8)
  345.       {
  346.          if(!(chessBoard[i][j] == VOID || side != (chessBoard[i][j] & 1)))
  347.          {
  348.             break;
  349.          }
  350.          poMo[poMo.length] = row << 9 | col << 6 | i << 3 | j;
  351.          if(chessBoard[i][j] != VOID)
  352.          {
  353.             break;
  354.          }
  355.          i++;
  356.          j++;
  357.          delta--;
  358.       }
  359.    }
  360.    return poMo;
  361. }
  362. function checkChessState(side)
  363. {
  364.    var row;
  365.    var col;
  366.    var i = 0;
  367.    while(i < 8)
  368.    {
  369.       var j = 0;
  370.       while(j < 8)
  371.       {
  372.          if((chessBoard[i][j] & 1) == getOpponent(side) && chessBoard[i][j] != VOID)
  373.          {
  374.             compMoves = calculateMoves(i,j,getOpponent(side));
  375.             var k = 0;
  376.             while(k < compMoves.length)
  377.             {
  378.                row = compMoves[k] >> 3 & 7;
  379.                col = compMoves[k] & 7;
  380.                if(chessBoard[row][col] == KING_W && side == SIDE_PLAYER || chessBoard[row][col] == KING_B && side == SIDE_COMPUTER)
  381.                {
  382.                   if(side == SIDE_PLAYER)
  383.                   {
  384.                      kingInChess(row,col,side);
  385.                   }
  386.                   return false;
  387.                }
  388.                k++;
  389.             }
  390.          }
  391.          j++;
  392.       }
  393.       i++;
  394.    }
  395.    if(side == SIDE_PLAYER)
  396.    {
  397.       var totalMoves = 0;
  398.       var i = 0;
  399.       while(i < 8)
  400.       {
  401.          var j = 0;
  402.          while(j < 8)
  403.          {
  404.             if((chessBoard[i][j] & 1) == SIDE_PLAYER && chessBoard[i][j] != VOID)
  405.             {
  406.                totalMoves += select(i,j,true);
  407.             }
  408.             j++;
  409.          }
  410.          i++;
  411.       }
  412.       if(totalMoves == 0)
  413.       {
  414.          invalidateAll();
  415.          messages.gotoAndStop("Pat");
  416.       }
  417.    }
  418.    return true;
  419. }
  420. function computerLoose()
  421. {
  422.    trace("ComputerLost");
  423.    invalidateAll();
  424.    messages.gotoAndStop(2);
  425.    stop();
  426. }
  427. function deselect(piece)
  428. {
  429.    resetAllSelection();
  430.    pieceSelected = null;
  431.    possiblePositions = null;
  432. }
  433. function displayMove(move, side)
  434. {
  435.    var fPX = move >> 9 & 7;
  436.    var fPY = move >> 6 & 7;
  437.    var lPX = move >> 3 & 7;
  438.    var lPY = move & 7;
  439.    var text = " ";
  440.    if(side == SIDE_COMPUTER)
  441.    {
  442.       text += "Comp: ";
  443.    }
  444.    else
  445.    {
  446.       text += "You:    ";
  447.    }
  448.    text += letters[fPY];
  449.    text += 9 - (fPX + 1);
  450.    text += "  - ";
  451.    text += letters[lPY];
  452.    text += 9 - (lPX + 1);
  453.    _root.myscroll.appendText(text);
  454. }
  455. function do_move(move, side)
  456. {
  457.    var pieceCaptured = VOID;
  458.    var fPX = move >> 9 & 7;
  459.    var fPY = move >> 6 & 7;
  460.    var lPX = move >> 3 & 7;
  461.    var lPY = move & 7;
  462.    if(side == SIDE_COMPUTER)
  463.    {
  464.       if(chessBoard[lPX][lPY] != VOID)
  465.       {
  466.          pieceCaptured = chessBoard[lPX][lPY];
  467.          playerScore -= chessBoard[lPX][lPY] >> 1;
  468.          computerScore += chessBoard[lPX][lPY] >> 1;
  469.       }
  470.       chessBoard[lPX][lPY] = chessBoard[fPX][fPY];
  471.       chessBoard[fPX][fPY] = VOID;
  472.       return pieceCaptured;
  473.    }
  474.    if(chessBoard[lPX][lPY] != VOID)
  475.    {
  476.       pieceCaptured = chessBoard[lPX][lPY];
  477.       playerScore += chessBoard[lPX][lPY] >> 1;
  478.       computerScore -= chessBoard[lPX][lPY] >> 1;
  479.    }
  480.    chessBoard[lPX][lPY] = chessBoard[fPX][fPY];
  481.    chessBoard[fPX][fPY] = VOID;
  482.    return pieceCaptured;
  483. }
  484. function invalidateAll()
  485. {
  486.    var i = 0;
  487.    while(i < 8)
  488.    {
  489.       var j = 0;
  490.       while(j < 8)
  491.       {
  492.          _root["piece_" + i + "_" + j].marker.gotoAndStop("disabled");
  493.          j++;
  494.       }
  495.       i++;
  496.    }
  497. }
  498. function movePlayer()
  499. {
  500.    messages.gotoAndStop(0);
  501.    resetAllSelection();
  502.    checkChessState(SIDE_PLAYER);
  503.    signal.gotoAndStop("player");
  504. }
  505. function moveRealPlayer(move, side)
  506. {
  507.    var fPX = move >> 9 & 7;
  508.    var fPY = move >> 6 & 7;
  509.    var lPX = move >> 3 & 7;
  510.    var lPY = move & 7;
  511.    if(pieceSelected == null)
  512.    {
  513.       trace("ERROR: no piece selected");
  514.       return undefined;
  515.    }
  516.    if(chessBoard[fPX][fPY] == KING_W && chessBoard[lPX][lPY] == ROOK_W)
  517.    {
  518.       trace("rocade");
  519.       possibleRocade = false;
  520.       chessBoard[fPX][fPY] = VOID;
  521.       chessBoard[lPX][lPY] = VOID;
  522.       if(fPY < lPY)
  523.       {
  524.          chessBoard[fPX][fPY + 2] = KING_W;
  525.          chessBoard[fPX][fPY + 1] = ROOK_W;
  526.          _root["piece_" + fPX + "_" + (fPY + 1)].showPiece(chessBoard[fPX][fPY + 1]);
  527.          _root["piece_" + fPX + "_" + (fPY + 2)].showPiece(chessBoard[fPX][fPY + 2]);
  528.       }
  529.       else
  530.       {
  531.          chessBoard[fPX][fPY - 2] = KING_W;
  532.          chessBoard[fPX][fPY - 1] = ROOK_W;
  533.          _root["piece_" + fPX + "_" + (fPY - 1)].showPiece(chessBoard[fPX][fPY - 1]);
  534.          _root["piece_" + fPX + "_" + (fPY - 2)].showPiece(chessBoard[fPX][fPY - 2]);
  535.       }
  536.       _root["piece_" + lPX + "_" + lPY].showPiece(chessBoard[lPX][lPY]);
  537.       _root["piece_" + fPX + "_" + fPY].showPiece(chessBoard[fPX][fPY]);
  538.    }
  539.    else
  540.    {
  541.       if(chessBoard[fPX][fPY] == KING_W || chessBoard[fPX][fPY] == ROOK_W)
  542.       {
  543.          possibleRocade = false;
  544.       }
  545.       var target = chessBoard[lPX][lPY];
  546.       if((target & 1) == SIDE_COMPUTER && target != VOID)
  547.       {
  548.          trace("capture the computer piece");
  549.       }
  550.       chessBoard[lPX][lPY] = chessBoard[fPX][fPY];
  551.       chessBoard[fPX][fPY] = VOID;
  552.       _root["piece_" + lPX + "_" + lPY].showPiece(chessBoard[lPX][lPY]);
  553.       _root["piece_" + fPX + "_" + fPY].showPiece(VOID);
  554.    }
  555.    invalidateAll();
  556.    if(lPX == 0 && chessBoard[lPX][lPY] == PAWN_W)
  557.    {
  558.       trace("promotion");
  559.       chessBoard[lPX][lPY] = QUEEN_W;
  560.       _root["piece_" + lPX + "_" + lPY].showPiece(QUEEN_W);
  561.    }
  562.    displayMove(move,SIDE_PLAYER);
  563.    gotoAndPlay(7);
  564. }
  565. function moveRealComputer(move)
  566. {
  567.    var fPX = move >> 9 & 7;
  568.    var fPY = move >> 6 & 7;
  569.    var lPX = move >> 3 & 7;
  570.    var lPY = move & 7;
  571.    var target = chessBoard[lPX][lPY];
  572.    if((target & 1) == SIDE_PLAYER && target != VOID)
  573.    {
  574.       trace("captures the player piece");
  575.    }
  576.    chessBoard[lPX][lPY] = chessBoard[fPX][fPY];
  577.    chessBoard[fPX][fPY] = VOID;
  578.    _root["piece_" + lPX + "_" + lPY].showPiece(chessBoard[lPX][lPY]);
  579.    _root["piece_" + fPX + "_" + fPY].showPiece(VOID);
  580.    if(lPX == 7 && chessBoard[lPX][lPY] == PAWN_B)
  581.    {
  582.       trace("promotion");
  583.       chessBoard[lPX][lPY] = QUEEN_B;
  584.       _root["piece_" + lPX + "_" + lPY].showPiece(QUEEN_B);
  585.    }
  586.    displayMove(move,SIDE_COMPUTER);
  587.    movePlayer();
  588. }
  589. function resetAllSelection()
  590. {
  591.    var i = 0;
  592.    while(i < 8)
  593.    {
  594.       var j = 0;
  595.       while(j < 8)
  596.       {
  597.          if(chessBoard[i][j] == VOID || (chessBoard[i][j] & 1) == SIDE_COMPUTER)
  598.          {
  599.             _root["piece_" + i + "_" + j].marker.gotoAndStop("disabled");
  600.          }
  601.          else
  602.          {
  603.             _root["piece_" + i + "_" + j].marker.gotoAndStop("normal");
  604.          }
  605.          j++;
  606.       }
  607.       i++;
  608.    }
  609. }
  610. function select(row, col, real)
  611. {
  612.    resetAllSelection();
  613.    var possibleMoves = calculateMoves(row,col,SIDE_PLAYER);
  614.    if(possibleRocade && real != true)
  615.    {
  616.       if(chessBoard[row][col] == KING_W)
  617.       {
  618.          var k = col;
  619.          var adv = true;
  620.          while(adv)
  621.          {
  622.             k++;
  623.             if(chessBoard[row][k] != VOID)
  624.             {
  625.                if(chessBoard[row][k] == ROOK_W)
  626.                {
  627.                   if(verifyKingState(row << 9 | col << 6 | row << 3 | col + 2,SIDE_PLAYER))
  628.                   {
  629.                      possibleMoves[possibleMoves.length] = row << 9 | col << 6 | row << 3 | k;
  630.                   }
  631.                }
  632.                adv = false;
  633.             }
  634.          }
  635.          k = col;
  636.          adv = true;
  637.          while(adv)
  638.          {
  639.             k--;
  640.             if(chessBoard[row][k] != VOID)
  641.             {
  642.                if(chessBoard[row][k] == ROOK_W)
  643.                {
  644.                   if(verifyKingState(row << 9 | col << 6 | row << 3 | col - 2,SIDE_PLAYER))
  645.                   {
  646.                      possibleMoves[possibleMoves.length] = row << 9 | col << 6 | row << 3 | k;
  647.                   }
  648.                }
  649.                adv = false;
  650.             }
  651.          }
  652.       }
  653.    }
  654.    var validMoves = new Array();
  655.    var i = 0;
  656.    while(i < possibleMoves.length)
  657.    {
  658.       if(verifyKingState(possibleMoves[i],SIDE_PLAYER))
  659.       {
  660.          validMoves[validMoves.length] = possibleMoves[i];
  661.       }
  662.       i++;
  663.    }
  664.    if(real != true)
  665.    {
  666.       var i = 0;
  667.       while(i < validMoves.length)
  668.       {
  669.          _root["piece_" + (validMoves[i] >> 3 & 7) + "_" + (validMoves[i] & 7)].marker.gotoAndStop("selectedTo");
  670.          i++;
  671.       }
  672.       pieceSelected = _root["piece_" + row + "_" + col];
  673.    }
  674.    return validMoves.length;
  675. }
  676. function kingInChess(rowKing, colKing, side)
  677. {
  678.    trace("  >>>>  CHESS " + side);
  679.    possibleRocade = false;
  680.    if(side == SIDE_PLAYER)
  681.    {
  682.       messages.gotoAndStop("playerChess");
  683.    }
  684.    else
  685.    {
  686.       messages.gotoAndStop("computerChess");
  687.    }
  688.    var possibleMoves;
  689.    var isChessMat = true;
  690.    var i = 0;
  691.    while(i < 8)
  692.    {
  693.       var j = 0;
  694.       while(j < 8)
  695.       {
  696.          if((chessBoard[i][j] & 1) == side && chessBoard[i][j] != VOID)
  697.          {
  698.             possibleMoves = calculateMoves(i,j,side);
  699.             disabled = true;
  700.             var k = 0;
  701.             while(k < possibleMoves.length)
  702.             {
  703.                if(verifyKingState(possibleMoves[k],side))
  704.                {
  705.                   isChessMat = false;
  706.                }
  707.                k++;
  708.             }
  709.          }
  710.          j++;
  711.       }
  712.       i++;
  713.    }
  714.    if(isChessMat)
  715.    {
  716.       loose(side);
  717.    }
  718. }
  719. function loose(side)
  720. {
  721.    if(side == SIDE_COMPUTER)
  722.    {
  723.       computerLoose();
  724.    }
  725.    else
  726.    {
  727.       playerLoose();
  728.    }
  729. }
  730. function playerLoose()
  731. {
  732.    trace("Player Lost");
  733.    invalidateAll();
  734.    messages.gotoAndStop(3);
  735.    stop();
  736. }
  737. function search(side, depth, alpha, beta)
  738. {
  739.    var bestScore = - INFINITY;
  740.    var aM = new Array();
  741.    var capturedPiece = null;
  742.    var moveScore;
  743.    var compMoves;
  744.    var i = 0;
  745.    while(i < 8)
  746.    {
  747.       var j = 0;
  748.       while(j < 8)
  749.       {
  750.          if((chessBoard[i][j] & 1) == side && chessBoard[i][j] != VOID)
  751.          {
  752.             aM = aM.concat(calculateMoves(i,j,side));
  753.          }
  754.          j++;
  755.       }
  756.       i++;
  757.    }
  758.    var i = 0;
  759.    while(i < aM.length)
  760.    {
  761.       capturedPiece = do_move(aM[i],side);
  762.       if(depth == 0)
  763.       {
  764.          moveScore = side != SIDE_COMPUTER ? playerScore : computerScore;
  765.       }
  766.       else
  767.       {
  768.          moveScore = - search(getOpponent(side),depth - 1,-1 * beta,-1 * alpha);
  769.       }
  770.       undo_move(aM[i],side,capturedPiece);
  771.       if(bestScore < moveScore)
  772.       {
  773.          bestScore = moveScore;
  774.       }
  775.       if(alpha < bestScore)
  776.       {
  777.          alpha = bestScore;
  778.       }
  779.       if(alpha >= beta)
  780.       {
  781.          return alpha;
  782.       }
  783.       i++;
  784.    }
  785.    return bestScore;
  786. }
  787. function shuffle(collection)
  788. {
  789.    var nCollection = new Array();
  790.    var value;
  791.    var val;
  792.    while(collection.length != 0)
  793.    {
  794.       val = Math.round(Math.random() * (collection.length - 1));
  795.       value = collection[val];
  796.       collection.splice(val,1);
  797.       nCollection.push(value);
  798.    }
  799.    delete collection;
  800.    return nCollection;
  801. }
  802. function getOpponent(side)
  803. {
  804.    if(side == SIDE_PLAYER)
  805.    {
  806.       return SIDE_COMPUTER;
  807.    }
  808.    return SIDE_PLAYER;
  809. }
  810. function undo_move(move, side, pieceCaptured)
  811. {
  812.    var fPX = move >> 9 & 7;
  813.    var fPY = move >> 6 & 7;
  814.    var lPX = move >> 3 & 7;
  815.    var lPY = move & 7;
  816.    if(side == SIDE_COMPUTER)
  817.    {
  818.       chessBoard[fPX][fPY] = chessBoard[lPX][lPY];
  819.       if(pieceCaptured != VOID)
  820.       {
  821.          chessBoard[lPX][lPY] = pieceCaptured;
  822.          playerScore += chessBoard[lPX][lPY] >> 1;
  823.          computerScore -= chessBoard[lPX][lPY] >> 1;
  824.       }
  825.       else
  826.       {
  827.          chessBoard[lPX][lPY] = VOID;
  828.       }
  829.    }
  830.    else
  831.    {
  832.       chessBoard[fPX][fPY] = chessBoard[lPX][lPY];
  833.       if(pieceCaptured != VOID)
  834.       {
  835.          chessBoard[lPX][lPY] = pieceCaptured;
  836.          playerScore -= chessBoard[lPX][lPY] >> 1;
  837.          computerScore += chessBoard[lPX][lPY] >> 1;
  838.       }
  839.       else
  840.       {
  841.          chessBoard[lPX][lPY] = VOID;
  842.       }
  843.    }
  844. }
  845. function verifyKingState(move, side)
  846. {
  847.    var capturedPiece;
  848.    var compMoves;
  849.    var row;
  850.    var col;
  851.    capturedPiece = do_move(move,side);
  852.    var i = 0;
  853.    while(i < 8)
  854.    {
  855.       var j = 0;
  856.       while(j < 8)
  857.       {
  858.          if((chessBoard[i][j] & 1) == getOpponent(side) && chessBoard[i][j] != VOID)
  859.          {
  860.             compMoves = calculateMoves(i,j,getOpponent(side));
  861.             var k = 0;
  862.             while(k < compMoves.length)
  863.             {
  864.                row = compMoves[k] >> 3 & 7;
  865.                col = compMoves[k] & 7;
  866.                if(chessBoard[row][col] == KING_W && side == SIDE_PLAYER || chessBoard[row][col] == KING_B && side == SIDE_COMPUTER)
  867.                {
  868.                   undo_move(move,side,capturedPiece);
  869.                   return false;
  870.                }
  871.                k++;
  872.             }
  873.          }
  874.          j++;
  875.       }
  876.       i++;
  877.    }
  878.    undo_move(move,side,capturedPiece);
  879.    return true;
  880. }
  881. VOID = -1;
  882. PAWN_W = 5;
  883. KNIGHT_W = 13;
  884. ROOK_W = 21;
  885. BISSHOP_W = 17;
  886. QUEEN_W = 29;
  887. KING_W = 2001;
  888. PAWN_B = 4;
  889. KNIGHT_B = 12;
  890. ROOK_B = 20;
  891. BISSHOP_B = 16;
  892. QUEEN_B = 28;
  893. KING_B = 4000;
  894. SIDE_COMPUTER = 0;
  895. SIDE_PLAYER = 1;
  896. letters = new Array("a","b","c","d","e","f","g","h");
  897. possibleRocade = true;
  898. pawnRules = new MovementRules();
  899. pawnRules.isPawn = true;
  900. pawnRules.up = 1;
  901. knightRules = new MovementRules();
  902. knightRules.isKnight = true;
  903. rookRules = new MovementRules();
  904. rookRules.up = 8;
  905. rookRules.down = 8;
  906. rookRules.left = 8;
  907. rookRules.right = 8;
  908. bisshopRules = new MovementRules();
  909. bisshopRules.up_left = 8;
  910. bisshopRules.up_right = 8;
  911. bisshopRules.down_left = 8;
  912. bisshopRules.down_right = 8;
  913. queenRules = new MovementRules();
  914. queenRules.up = 8;
  915. queenRules.down = 8;
  916. queenRules.left = 8;
  917. queenRules.right = 8;
  918. queenRules.up_left = 8;
  919. queenRules.up_right = 8;
  920. queenRules.down_left = 8;
  921. queenRules.down_right = 8;
  922. kingRules = new MovementRules();
  923. kingRules.up = 1;
  924. kingRules.down = 1;
  925. kingRules.left = 1;
  926. kingRules.right = 1;
  927. kingRules.up_left = 1;
  928. kingRules.up_right = 1;
  929. kingRules.down_left = 1;
  930. kingRules.down_right = 1;
  931. poMo = new Array();
  932. initChessBoard();
  933. movePlayer();
  934. myscroll.clearText();
  935. stop();
  936.