game.java

经典的一个小游戏；用java编写；适合在手机上移植

package example.tictactoe;

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

// The game logic for TicTacToe
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) {
      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;
  }
}