Reversi GUI question, A LOT of code in here!

Question

okay, so I've been working on his code for a long time. A REAL long time, working on it bit by bit, and all I got left is the Reversi's GUI. Basically I want to use the Jbutton and have x represent black and o represent white. I'm getting stuck on how to go about it. Any ideas?
Here's alllll the code.
package com.Ozo.games.reversi;
* This utility class provides a number of static constants and
* methods that provide abstractions for player colors and moves.
* Colors and moves could be implemented as objects of separate
* classes, but instead we represent them as integers and provide
* the abstraction via these operations.
public class Reversi {
     public static final int Black = 1;
     public static final int White = 2;
     public static final int Empty = 0;
      * Gives the color of a player's opponent.
      * @param color of this player.
      * @return color of the opponent.
     public static int playerOpposite(int color) {
          if (color == Black) return White;
          if (color == White) return Black;
          throw new Error("Player must be Black or White");
      * Compare two scores and determine whether the first is better than the second.
      * Better for black means more positive.  Better for white means more negative.
      * @param colorAsking
      * @param score1
      * @param score2
      * @return whether score1 is better than score2, as far as colorAsking is concerned.
     public static boolean isBetterScore(int colorAsking, int score1, int score2) {
          if (colorAsking == Black) return score1 > score2;
          if (colorAsking == White) return score1 < score2;
          throw new Error("Player must be Black or White");
      * Encode a move from this position as an integer.
      * A "pass" move is recorded as (-1,-1).
      * @param pos the board this move is for.
      * @param row the row at which the piece is placed.
      * @param col the column at which the piece is placed.
      * @return encoded move.
     public static int newMove(ReversiPosition pos, int row, int col) {
          return row * pos.ncols() + col;
      * A "pass" move.  I.e. no piece is placed.
     public static int newMovePass(ReversiPosition pos) {
          return newMove(pos, -1, -1);
      * Find the row of an encoded move.
      * @param pos the board this move is for.
      * @param move
      * @return the row.
     public static int moveRow(ReversiPosition pos, int move) {
          return move / pos.ncols();
      * Find the column of an encoded move.
      * @param pos the board this move is for.
      * @param move
      * @return the column.
     public static int moveCol(ReversiPosition pos, int move) {
          return move % pos.ncols();
package com.Ozo.games.reversi;
* Top-level driver for a Reversi game.
public class ReversiGame {
     private ReversiPosition   _pos;
     private int               _toMoveColor;
     private ReversiTextIO     _userInterface;
     public ReversiGame(int nrows, int ncols) {
          _pos           = new ReversiPosition(nrows, ncols);
          _toMoveColor   = Reversi.Black;
          _userInterface = null;
          ReversiRules.setStartingPosition(_pos);
     public void setUserInterface(ReversiTextIO ui) {
          _userInterface = ui;
     public ReversiPosition currentPosition() { return _pos; }
     public int             toMoveColor()     { return _toMoveColor; }
     public void getHumanMoveAndApplyIt() {
          if (ReversiRules.countLegalMoves(_pos, _toMoveColor) != 0) {
               int move = _userInterface.getMove(_pos, _toMoveColor);
               _pos.applyMove(move, _toMoveColor);
          else
               _userInterface.message("You have no move.  I get another turn.");
          _toMoveColor = Reversi.playerOpposite(_toMoveColor);
     public void getComputerMoveAndApplyIt() {
          if (ReversiRules.countLegalMoves(_pos, _toMoveColor) != 0) {
               int move = ReversiStrategy.findBestMove(_pos, _toMoveColor);
               _pos.applyMove(move, _toMoveColor);
          else
               _userInterface.message("I have no move.  You get another turn.");
          _toMoveColor = Reversi.playerOpposite(_toMoveColor);
     public void play() {
          _userInterface.output(_pos);
          for (;;) {
               if (ReversiRules.isGameOver(_pos, _toMoveColor)) { gameOverMessage(); break; }
               getHumanMoveAndApplyIt();
               _userInterface.output(_pos);
               if (ReversiRules.isGameOver(_pos, _toMoveColor)) { gameOverMessage(); break; }
               getComputerMoveAndApplyIt();
               _userInterface.output(_pos);
     public void gameOverMessage() {
          _userInterface.message("Game over...");
          int winner = ReversiRules.winningColor(_pos, _toMoveColor);
          if      (winner == Reversi.Black) _userInterface.message("Black wins.");
          else if (winner == Reversi.White) _userInterface.message("White wins.");
          else    _userInterface.message("Draw.");
package com.Ozo.games.reversi;
* The main class to start a Reversi game as an application.
public class ReversiMain {
     public static void main(String[] args) {
          ReversiGame   game = new ReversiGame(8, 8);
          ReversiTextIO tui  = new ReversiTextIO(System.in, System.out);
          game.setUserInterface(tui);
          game.play();
}

Answer 1

package com.Ozo.games.reversi;
* This class provides all of the intelligence for a program to play Reversi.
* It contains all the knowledge of play strategy.  (The knowledge of the rules
* is maintained by the ReversiRules class.)
* The principal method is findBestMove, which does an exhaustive search a number
* of plys deep, and then applies a hueristic position evaluation function.
public class ReversiStrategy {
     private static int PlysToTry = 6;
      * Find the best move for the player of the given color.
      * If there is no move, then return "pass".
      * @param pos the position to be evaluated.
      * @param toMoveColor the color of player to move.
      * @param plysRemaining the depth to examine (must be >= 1).
      * @return the best move within the default horizon.
     public static int findBestMove(ReversiPosition pos, int toMoveColor) {
          return findBestMove(pos, toMoveColor, PlysToTry).move;
      * This class is used to return a pair of values:  the best move and the score it achieves
      * after the number of plys remaining are played.
     public static class BestMove {
          public int move;
          public int score;
          public BestMove(int m, int s) { move = m; score = s; }
      * Find the best move for the player of the given color within
      * the given number of plys.
      * @param pos the position to be evaluated.
      * @param toMoveColor the color of player to move.
      * @param plysRemaining the depth to examine (must be >= 1).
      * @return a BestMove object returning the best move found and the score it achieves.
     public static BestMove findBestMove(ReversiPosition pos, int toMoveColor, int plysRemaining) {
          if (plysRemaining < 1) throw new Error("findBestMove needs plysRemaining >= 1");
          // Generate the legal moves.  If there are none, then pass.
          int opponentColor = Reversi.playerOpposite(toMoveColor);
          int[] moves = ReversiRules.generateMoves(pos, toMoveColor);
          if (moves.length == 0) {
               if (plysRemaining == 1)
                    return new BestMove(Reversi.newMovePass(pos), summaryScore(pos));
               else
                    return findBestMove(pos, opponentColor, plysRemaining-1);
          // Try all the moves.  Re-use one position object to make the move.
          ReversiPosition afterMove = pos.copy();
          // Start with a hypothetical worst scenario and then look for what's better.
          afterMove.fill(opponentColor);
          int bestScore = 2*summaryScore(afterMove);  // Worse that the worst possible real score.
          int bestIndex = -1;
          for (int i = 0; i < moves.length; i++) {
               pos.copyInto(afterMove);      // Re-use the position object.
               afterMove.applyMove(moves, toMoveColor);
               int thisScore = (plysRemaining == 1) ?
                    summaryScore(afterMove) :
                    findBestMove(afterMove, opponentColor, plysRemaining - 1).score;
               if (Reversi.isBetterScore(toMoveColor, thisScore, bestScore)) {
                    bestScore = thisScore;
                    bestIndex = i;
          if (bestIndex == -1) System.out.println("Number of moves " + moves.length + " plys " + plysRemaining);
          return new BestMove(moves[bestIndex], bestScore);
     * Examine contents of square and return 1 for Black, -1 for White, 0 for Empty.
     * Useful in computing scores.
     * @param r row number.
     * @param c column number.
     * @return +1/-1/0
     private static int squareVal(ReversiPosition pos, int r, int c) {
          if (pos.getSquare(r, c) == Reversi.White) return -1;
          if (pos.getSquare(r, c) == Reversi.Black) return +1;
          return 0;
     * Count the number of black squares minus the number of white squares.
     * @return difference in number of black and white squares.
     public static int squareScore(ReversiPosition pos) {
          int nBminusW = 0;
          for (int r = 0; r < pos.nrows(); r++)
               for (int c = 0; c < pos.ncols(); c++)
                    nBminusW += squareVal(pos, r, c);
          return nBminusW;
     * Count the number of black edge squares minus the number of white ones.
     * @return difference in number of black and white squares.
     public static int edgeScore(ReversiPosition pos) {
          int nBminusW = 0;
          // East and west edges.
          for (int r = 1; r < pos.nrows()-1; r++)
               nBminusW += squareVal(pos, r, 0) + squareVal(pos, r, pos.ncols()-1);
          // North and south edges.
          for (int c = 1; c < pos.ncols()-1; c++)
               nBminusW += squareVal(pos, 0, c) + squareVal(pos, pos.nrows()-1, c);
          return nBminusW;
     * Count the number of black corner squares minus the number of white ones.
     * @return difference in number of black and white squares.
     public static int cornerScore(ReversiPosition pos) {
          int rlast = pos.nrows()-1, clast = pos.ncols()-1;
          return squareVal(pos, 0, 0) + squareVal(pos, 0, clast) +
          squareVal(pos, rlast, 0) + squareVal(pos, rlast, clast);
     * Compute a heuristic score for a given position. The more positive,
     * the better for Black. Controlling corners is weighted most heavily,
     * folowed by sides, then regular squares. In principle a different weight
     * function should be used at the end of the game, since then it is really
     * the total number of squares that counts.
     * @param pos the position to be assessed.
     * @return the numerical score, with positive being good for Black, negative good for White.
     public static int summaryScore(ReversiPosition pos) {
               return squareScore(pos) + 8*edgeScore(pos) + 20*cornerScore(pos);
}Edited by: Oozaro on Nov 19, 2009 12:41 PM