thinkerplayer.java

ParallelConnectFour是一个java小游戏

package edu.rit.cs.mlr5773.connectfour;

import java.util.*;

/**
 * A Player that chooses its moves by communicating with Thinker Processes.
 * Each Thinker process is given a board situation and asked to evaluate
 * it.  All the evaluations are scored, and the best move is chosen.
 * Each Thinker process handles one column of the board.
 *
 * @author Mark Roth
 */
public class ThinkerPlayer extends Player {
 
  /** 
   * The random number generator used to decide between moves of equal
   * values.
   */
  private Random random;

  /** The manager of all Thinker Processes */
  private ThinkerManager manager;

  /** Constants to define win, loss, and tie */
  private final int TIE = Integer.MIN_VALUE+2;
  private final int LOSE = Integer.MIN_VALUE+1;
  private final int WIN = Integer.MAX_VALUE-1;

  /** A scratch board to play with to determine next best move */
  private Board thinkBoard;

  /**
   * Creates a new Thinker Player.  The ThinkerManager, which controls
   * all the Thinker Processes, must be passed in.
   */
  public ThinkerPlayer(ConnectFourGame game, int player, 
    ThinkerManager manager ) 
  { 
    super(game, player);
    this.manager = manager;
    random = new Random();
  }

  /**
   * Processes a request from the game to choose the next move.
   */
  public void move() {
    Vector thinkers = manager.getThinkers();
    int i, numThinkers = thinkers.size();

    // Start timing
    long startTime = new Date().getTime();

    int him = (player==1) ? 2 : 1;
      thinkBoard = game.getCurrentBoard().copy();

    // Submit jobs for each move.
    for( i = 0; i < 7; i++ ) {
      ThinkerShell thinker = 
	(ThinkerShell)thinkers.elementAt( i % numThinkers );
      if( thinkBoard.isValidMove( i ) ) {
        ThinkerRequest request = new ThinkerRequest( 
	  thinkBoard.copy(), player, i );

	thinker.submitJob( request );
      }
    }

    // Choose the best move, based on the given values.
    int move = think();

    // Stop timing:
    long endTime = new Date().getTime();

    System.out.println( "Timing Results: This move took " + 
      (endTime - startTime) + " ms." );
	
    game.move( move );
  }

  /**
   * Asks each thinker for its move, and chooses the best move from the
   * ones given.
   */
  public int think() {
    int i, move = -1;
    int count = 0;
    int max = Integer.MIN_VALUE;
    int him = (player == 1) ? 2 : 1;
    int val[] = new int[7];
    thinkBoard = game.getCurrentBoard().copy();
    Vector thinkers = manager.getThinkers();
    int numThinkers = thinkers.size();

    for (i = 0; i < 7; i++) {
      ThinkerShell thinker = (ThinkerShell)thinkers.elementAt(i % numThinkers);
      game.writeMessage("Parallel Processing...");
      if (game.isValidMove(i)) {
	val[i] = value(i);
	System.out.print(val[i] + " ");
	if (val[i] > max) {
  	  max = val[i];
	  move = i;
	  count = 1;
	}
	else {
	  if (val[i] == max) {
	    count++;
	  }
	}
      }
      else {
	System.out.print("x ");
      }
    }

    System.out.println();
    if (max == WIN) {
      game.writeMessage(game.name[player] + " will win!");
    }
    else {
      if (max == LOSE) {
	game.writeMessage(game.name[him] + " can win!");
      }
      else {
	if (max == TIE) {
	  game.writeMessage("We will tie!");
	}
	else {
   	  game.writeMessage(game.name[player] + " score: " + max);
	}
      }
    }

    if (count > 1) {
      int r = (Math.abs(random.nextInt()) % count) + 1;
      for (i = 0; i < 7; i++) {
   	if (game.isValidMove(i)) {
	  if (val[i] == max) {
	    r--;
	    if (r == 0) {
	      move = i;
	      break;
	    }
	  }
	}
      }
    }

    return move;
  }

  /**
   * Retrieves the value of the given move by asking the appropriate
   * Thinker.
   */
  private int value( int i ) {
    Vector thinkers = manager.getThinkers();
    int numThinkers = thinkers.size();
    ThinkerShell thinker = 
      (ThinkerShell)thinkers.elementAt( i % numThinkers );
    return thinker.waitValue();
  }

}