Member Avatar for leeqiang

i wanna write a othello programm myself.i Googled a platform to test programm.that's very good i think.there is a abstract player(source attached) .i don't how to start it.any good-heart people can give me a sample?
use the alpha-beta search is i want to do.

THANKS soooooooooo much

import java.awt.Point;

abstract public class AbstractPlayer {
  /**
   * NOT_AVAILABLE indicate that it's impossible to put any chess on the
   * specified position on the chessboard.
   */
  public static final byte NOT_AVAILABLE = 3;

  /**
   * AVAILABLE indicate that the specified position on the chessboard is empty
   * at this time, and is possible to accept white or black chess in the future.
   */
  public static final byte AVAILABLE = 0;

  /**
   * BLACK indicate that the specified position on the chessboard is a black
   * chess.
   */
  public static final byte BLACK = 1;

  /**
   * WHITE indicate that the specified position on the chessboard is a white
   * chess.
   */
  public static final byte WHITE = 2;

  /**
   * This function will be called at the beginning of the game. No matter which
   * side you are.
   * 
   * @param chessContext
   *          A reference object which might be useful during the game
   * @param chessboard
   *          A byte array which contains the current chessboard,
   *          chessboard[x][y] means row y, column x;
   * @param timeLimit
   *          The maximum allow time (in milliseconds) for each step, zero if no
   *          limit
   * @param memoryLimit
   *          The maximum memory limit (in bytes) for each step, zero if no
   *          limit
   * @param color
   *          true for black side, false for white side
   * @return Undefined
   */
  abstract public int init(ChessContext chessContext, byte[][] chessboard,
      int timeLimit, int memoryLimit, boolean color);

  /**
   * This function will be whenever it's current player's turn, no matter there
   * is any available positions for current player or not.
   * 
   * @param chessboard
   *          Current chessboard, chessboard[x][y] means row y column x
   * @param availables
   *          Available positions for this turn, if there is no available
   *          position for current player, it will be an empty array (not a null
   *          pointer).
   * @param curStep
   *          the step number from the beginning
   * @param lastMove
   *          The position which the opponent choose in the last turn, null if
   *          there is no available postion in the last turn for the opponent,
   * @return If availables.length>0, the returned value must be an integer from
   *         0 to availables.length-1 (inclusive). If availables.length==0, the
   *         return value can be anything.
   */
  abstract public int myTurn(byte[][] chessboard, Point[] availables,
      int curStep, Point lastMove);
}
import java.awt.Point;

public interface ChessContext {
  /**
   * @return total steps from beginning
   */
  public int getTotalSteps();

  /**
   * @param step
   *          from 0 to getTotalSteps()-1 (inclusive)
   * @return The selected position in the specified step.
   */
  public Point getStep(int step);

  /**
   * @return available positions for current step
   */
  public Point[] getAvailablePositionsForCurrentStep();

  /**
   * @return total time limit (0 means unlimited)
   */
  public int getTotalTimeLimit();

  /**
   * @return time limit for each step (0 means unlimited)
   */
  public int getStepTimeLimit();

  /**
   * @return memory limit for each step (0 means unlimited)
   */
  public int getMemoryLimit();

  /**
   * @return total left time
   */
  public int getTotalLeftTime();

  /**
   * @return left time for current step
   */
  public int getLeftTime();

  /**
   * @return memory left for current step
   */
  public int getLeftMemory();

  /**
   * @return current chessboard
   */
  public byte[][] getChessboard();

  /**
   * @return width of the chessboard
   */
  public int getChessboardWidth();

  /**
   * @return height of the chessboard
   */
  public int getChessboardHeight();

  /**
   * @return true if color is black, false if color is white
   */
  public boolean getMyColor();
}
  • 3 Contributors
  • 2 Replies
  • 140 Views
  • 7 Hours Discussion Span
  • Latest Post Latest Post by Jishnu

Recommended Answers

All 2 Replies

Member Avatar for cms271828

Hi

I'm writing a chess program,
http://www.colin-java.co.uk/JChess2
So I might be able to help a little, you would obviously need alpha-beta pruning.
I guess you would use iterative deepening with that.
I'm not sure if Quiescent Search applies because every move is a capture, so position will never go quiet.
I think transposition tables is a good idea, I'm in the middle of putting them in now, but they are a bit fiddly.
I think the hard bit is working out how to make an evaluation function, with chess, you have lots of things, mainly the material balance, pawn structure, king safety, piece position to look at, but its more abstract in othello.
I just noticed in your AbstractPlayer file, you have a 2D array for your board, thats not necessary, I think a 1D array from 0-63 is better, then you just index x by index%8, and y by 7-index/8, or something like that.
Its a little pointless trying to express ideas using messages, it can take forever to explain something, so you can messenger me if you want at cms271828@yahoo.co.uk or colin-java@hotmail.com.

Thanks

Member Avatar for Jishnu

There is more material available for developing AI for chess. This is because it is more popular than othello. A good start would be to go through AI by Kevin & Knight. Then go through online resources for chess programming. TSCP is a really good starting point. Search for it on the web. Then, having understood the concepts in a solid way, apply them to othello. You will find it easier as evaluation function in case of othello is far less complex as compared to that of chess. I am also thinking of building AI for othello in Java after a month or so. All the best.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.