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();
}