game.java~4~

一个很好玩的手机游戏

import java.util.Random;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;


// The game logic for SVSB
class Game
{
    private static final int[] WINS =
    {
        // horizontals
        bit(0) | bit(1) | bit(2),     //
        bit(3) | bit(4) | bit(5),     //
        bit(6) | bit(7) | bit(8),
        // verticals
        bit(0) | bit(3) | bit(6),
        bit(1) | bit(4) | bit(7),
        bit(2) | bit(5) | bit(8),
        // diagonals
        bit(0) | bit(4) | bit(8),
        bit(2) | bit(4) | bit(6)
    };
    private static final int DRAWN_GAME =  //
        bit(0) | bit(1) | bit(2) |
        bit(3) | bit(4) | bit(5) |
        bit(6) | bit(7) | bit(8);

    private int playerState;
    private int computerState;
    private Random random;


    Game(Random random)
    {
        this.random = random;
        initialize();
    }


    void initialize()
    {
        playerState = 0;
        computerState = 0;
    }


    boolean isFree(int position)
    {
        int bit = bit(position);
        return (((playerState & bit) == 0) && ((computerState & bit) == 0));
    }


    // The 'Contract' is that caller will always make valid moves.
    // We don't check that it's the player's turn.
    void makePlayerMove(int position)
    {
        playerState |= bit(position);
    }


    // The 'Contract' is that we will be called only when there is still
    // at least one free square.
    int makeComputerMove()
    {
        int move = getWinningComputerMove();
        if (move == -1)
        {
            // can't win
            move = getRequiredBlockingComputerMove();
            if (move == -1)
            {
                // don't need to block
                move = getRandomComputerMove();
            }
        }

        computerState |= bit(move);

        return move;
    }


    boolean isGameOver()
    {
        return isPlayerWinner() | isComputerWinner() | isGameDrawn();
    }


    boolean isPlayerWinner()
    {
        return isWin(playerState);
    }


    boolean isComputerWinner()
    {
        return isWin(computerState);
    }


    boolean isGameDrawn()
    {
        return (playerState | computerState) == DRAWN_GAME;
    }


    // Return a winning move if there is at least one, otherwise return -1
    private int getWinningComputerMove()
    {
        int move = -1;
        for (int i = 0; i < 9; ++i)//\u00D6\u00BB\u00D1\u00AD\u00BB·8\u00B4\u00CE\u00B5\u00C4\u00D4\u00AD\u00D2ò\u00CA\u00C7\u00CA\u00FD×éwins[]\u00D6\u00BB\u00D3\u00D0°\u00CB\u00B8\u00F6\u00D4\u00AA\u00CB\u00D8\u00A3\u00BB
        {
            if (isFree(i) && isWin(computerState | bit(i)))
            {
                move = i;
                break;
            }
        }
        return move;
    }


    // Return a required blocking move if there is at least one (more
    // than one and we've inevitably lost), otherwise return -1
    private int getRequiredBlockingComputerMove()
    {
        int move = -1;
        for (int i = 0; i < 9; ++i)
        {
            if (isFree(i) && isWin(playerState | bit(i)))
            {
                move = i;
                break;
            }
        }
        return move;
    }


    // Return a random move in a free square,
    // or return -1 if none are available
    private int getRandomComputerMove()
    {
        int move = -1;

        // determine how many possible moves there are
        int numFreeSquares = 0;
        for (int i = 0; i < 9; ++i)
        {
            if (isFree(i))
            {
                numFreeSquares++;
            }
        }

        // if there is at least one possible move, pick randomly
        if (numFreeSquares > 0)
        {
            // shift twice to get rid of sign bit, then modulo numFreeSquares
            int pick = ((random.nextInt()<<1)>>>1) % numFreeSquares;

            // now find the chosen free square by counting pick down to zero
            for (int i = 0; i < 9; ++i)
            {
                if (isFree(i))
                {
                    if (pick == 0)
                    {
                        move = i;
                        break;
                    }
                    pick--;
                }
            }
        }

        return move;
    }


    private static boolean isWin(int state)
    {
        boolean isWinner = false;
        for (int i = 0; i < WINS.length; ++i)
        {
            if ((state & WINS[i]) == WINS[i])
            {
                isWinner = true;
                break;
            }
        }
        return isWinner;
    }


    private static int bit(int i)
    {
        return 1 << i;
    }
}