djib/Sushi
1
0
Fork 0
Code Issues 2 Pull Requests Releases 1 Activity
Files
a0ee66638d8dfed7df03c30857bf0d8d7468e447
Sushi/src/suicideChess/Board.java
djib a0ee66638d Version 0.8.0 
=============
Just before creating the external config file
2006-07-04 01:45:39 +00:00

663 lines
22 KiB
Java
Raw Blame History

package suicideChess;
import suicideChess.Square.NotAValidSquare;
/**
* This class contains the board representation.
* The board is represented using bitboards.
* <ul><li>a1 is square 0</li>
* <li>h8 is square 7</li>
* <li>a2 is square 8</li>
* <li>... and so on</li>
*
* Note that the evaluation of the board balance is in this class since I considered that it is
* very closely related to the board position.
*
* @author Jean-Baptiste H&eacute;tier
* @version $LastChangedRevision$, $LastChangedDate$
*
*/
public class Board {
/*===========*
* CONSTANTS *
*===========*/
//Some constants to make code more readable
public static final int NB_OF_RANKS = 8;
public static final int NB_OF_FILES = 8;
public static final int NB_OF_SQUARES = NB_OF_RANKS*NB_OF_FILES;
private static final int NB_OF_BITBOARDS = 14;
@SuppressWarnings("serial")
public class NoPieceOnSquare extends Exception {
NoPieceOnSquare(String s) { super(s); };
}
@SuppressWarnings("serial")
public class UnableToParseFENStringException extends Exception {
UnableToParseFENStringException(String s) { super(s); };
}
/**
* Value returned by the evaluation function when White wins
*/
public static final int WHITE_WINS = 99999;
/**
* Value representing the maximum value possible for the evaluation function
*/
public static final int MAX_VALUE = WHITE_WINS+1;
/**
* Value returned by the evaluation function when Black wins
*/
public static final int BLACK_WINS = -99999;
/**
* Value representing the minimum value possible for the evaluation function
*/
public static final int MIN_VALUE = BLACK_WINS-1;
/**
* Value representing the value of a draw position
*/
public static final int DRAW_BOARD = 0;
/**
* Importance of real mobility in position evaluation (ie. how many moves can one make compared to the other)
*/
public static final int REAL_MOBILITY_VALUE = 40; //10;
/**
* Importance of relative mobility (mobility of other pieces that may not be able to play because of a compulsory move)
*/
public static final int RELATIVE_MOBILITY_VALUE = 40; //5;
//with less than that many pawns on one side, the computer will enter endgame mode
public static final int ENDGAME_PAWNS = 3;
//with less than that many pieces on one side, the computer will enter endgame mode
public static final int ENDGAME_PIECES = 8;
public static final int[] SQUARE_WEIGHT = {
/* -20, -10, -10, -10, -10, -10, -10, -20,
-10, 0, 3, 5, 5, 3, 0, -10,
-10, 2, 15, 15, 15, 15, 2, -10,
-10, 7, 15, 25, 25, 15, 7, -10,
-10, 7, 15, 25, 25, 15, 7, -10,
-10, 2, 15, 15, 15, 15, 2, -10,
-10, 0, 3, 5, 5, 3, 0, -10,
-20, -10, -10, -10, -10, -10, -10, -20*/
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10
};
/*======*
* DATA *
*======*/
//The following table is used to map squares to bits
protected static long mapSquaresToBits[];
//static function used to initialise data
static {
mapSquaresToBits = new long[NB_OF_SQUARES];
for(int i=0; i<NB_OF_SQUARES; i++) {
mapSquaresToBits[i] = (1L << i);
}
}
//The following table contains all the bit boards
protected long bitBoards[];
private boolean enPassant=false; //is there an 'en passant pawn' on the board
private Square enPassantSquare;
//the number of each piece type will be accessed
//using the index and the piece value defined in Piece class
private int[] numberOfPieces;
//the value of each piece (used for the evaluation function)
private int boardValue = 0; //evaluation of the board value
private int currentPlayer; //color of the current player.
//starts at 1 and increment after each of black's move
private int fullmoveNumber;
//this variable holds the number of Moves since last capture or last pawn move
private int halfmoveClock;
/*=============*
* CONSTRUCTOR *
*=============*/
/**
* Constructor of the class Board
* @throws NotAValidSquare
*/
public Board() throws NotAValidSquare {
//the following line makes sure that enPassantSquare is defined at some point.
enPassantSquare = new Square("a1");
fullmoveNumber = 1;
halfmoveClock = 0;
numberOfPieces = new int[Piece.MAX_PIECE_NUMBER+1];
for (int i=0; i<=Piece.MAX_PIECE_NUMBER; i++) {
numberOfPieces[i]=0;
}
bitBoards = new long[NB_OF_BITBOARDS];
addPiece(new Square("a1"),new Piece(Piece.WHITE_ROOK));
addPiece(new Square("b1"),new Piece(Piece.WHITE_KNIGHT));
addPiece(new Square("c1"),new Piece(Piece.WHITE_BISHOP));
addPiece(new Square("d1"),new Piece(Piece.WHITE_QUEEN));
addPiece(new Square("e1"),new Piece(Piece.WHITE_KING));
addPiece(new Square("f1"),new Piece(Piece.WHITE_BISHOP));
addPiece(new Square("g1"),new Piece(Piece.WHITE_KNIGHT));
addPiece(new Square("h1"),new Piece(Piece.WHITE_ROOK));
addPiece(new Square("a2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("b2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("c2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("d2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("e2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("f2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("g2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("h2"),new Piece(Piece.WHITE_PAWN));
addPiece(new Square("a8"),new Piece(Piece.BLACK_ROOK));
addPiece(new Square("b8"),new Piece(Piece.BLACK_KNIGHT));
addPiece(new Square("c8"),new Piece(Piece.BLACK_BISHOP));
addPiece(new Square("d8"),new Piece(Piece.BLACK_QUEEN));
addPiece(new Square("e8"),new Piece(Piece.BLACK_KING));
addPiece(new Square("f8"),new Piece(Piece.BLACK_BISHOP));
addPiece(new Square("g8"),new Piece(Piece.BLACK_KNIGHT));
addPiece(new Square("h8"),new Piece(Piece.BLACK_ROOK));
addPiece(new Square("a7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("b7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("c7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("d7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("e7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("f7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("g7"),new Piece(Piece.BLACK_PAWN));
addPiece(new Square("h7"),new Piece(Piece.BLACK_PAWN));
}
/**
* A constructor that simply copies a bitboard
* @param bitboard The bitboard to be copied
*/
public Board(Board bitboard) {
numberOfPieces = new int[Piece.MAX_PIECE_NUMBER+1];
for (int i=0; i<=Piece.MAX_PIECE_NUMBER; i++) {
this.numberOfPieces[i] = bitboard.numberOfPieces[i];
}
this.fullmoveNumber = bitboard.fullmoveNumber;
this.halfmoveClock = bitboard.halfmoveClock;
this.boardValue = bitboard.boardValue;
this.bitBoards = new long[NB_OF_BITBOARDS];
for (int i=0; i<NB_OF_BITBOARDS; i++) {
this.bitBoards[i] = bitboard.bitBoards[i];
}
this.enPassant = bitboard.enPassant;
this.enPassantSquare = new Square(bitboard.enPassantSquare);
this.currentPlayer = bitboard.currentPlayer;
}
/**
* This constructor is used to create a board with a string in FEN notation
* @param command A string representing the command
* @return A {@link Board} corresponding to the FEN string
* @throws NotAValidSquare
* @throws UnableToParseFENStringException
* @see Board
*/
public Board(String command) throws NotAValidSquare, UnableToParseFENStringException {
String[] result = command.split("/|\\s");
/*
* After splitting
* 0->rank 8
* 1->rank 7
* ...
* 7->rank 1
* 8->color on move
* 9->castling (I don't care about this)
* 10->enpassant Square (if any), otherwise '-'
* 11->count of plies since the last pawn advance or capturing move
* 12->fullmove number
*/
bitBoards = new long[NB_OF_BITBOARDS];
if (result.length!=13) {
throw new UnableToParseFENStringException(command);
}
if (result[8].equals("b")) {
currentPlayer=Piece.BLACK;
} else {
currentPlayer=Piece.WHITE;
}
if (!result[10].equals("-")) {
enPassant = true;
enPassantSquare = new Square(result[10]);
} else {
enPassant = false;
enPassantSquare = new Square("a1"); //otherwise it is null
}
try {
fullmoveNumber = Integer.parseInt(result[12]);
halfmoveClock = Integer.parseInt(result[11]);
} catch (NumberFormatException e) {
System.out.println("Error (impossible to parse clock): "+command);
fullmoveNumber = 1;
halfmoveClock = 0;
}
numberOfPieces = new int[Piece.MAX_PIECE_NUMBER+1];
for(int split=0; split < 8; split++) {
int offset=0;
char[] rowToParse = result[split].toCharArray();
for (int character=0; character<rowToParse.length; character++) {
if (Character.isDigit(rowToParse[character])) {
offset+=((int)rowToParse[character]-(int)'1');
} else {
Piece pieceToAdd = new Piece(rowToParse[character]);
addPiece(new Square(character+offset+1,NB_OF_RANKS-split),pieceToAdd);
}
}
}
if (numberOfPieces[Piece.BLACK] == 0) {
boardValue = BLACK_WINS;
} else if (numberOfPieces[Piece.WHITE] == 0){
boardValue = WHITE_WINS;
} else if (!Rules.isThereALegalMovesForPlayer(this)) {
if (currentPlayer==Piece.WHITE) {
boardValue = WHITE_WINS;
} else {
boardValue = BLACK_WINS;
}
} else {
boardValue = getBoardValue();
}
}
/*================*
* PUBLIC METHODS *
*================*/
/**
* This methods takes a {@link Move} and applies it (updating the bitboard)
* @param move The move that is to be done
* @throws NoPieceOnSquare If a piece is trying to be moved from a square that does not exist.
* @throws NotAValidSquare
* @see Move
*/
public void doMove(Move move) throws NoPieceOnSquare, NotAValidSquare {
halfmoveClock++;
if (move.isCaptureMove()) {
if (move.isEnPassant()) {
removePiece(move.getEnPassantSquare(), move.getCapturedPiece());
} else {
removePiece(move.toSquare(), move.getCapturedPiece());
}
halfmoveClock=0; //reinitialise halfmoveClock since there has been a capture
}
removePiece(move.fromSquare(), move.getMovingPiece());
if (move.isPromotionMove()) {
addPiece(move.toSquare(), move.getPromotionPiece());
} else {
addPiece(move.toSquare(), move.getMovingPiece());
}
if(move.getMovingPiece().getPieceNumber()==Piece.PAWN) {
halfmoveClock = 0; //a pawn has been moved
}
this.enPassant=false;
if (move.enablesEnPassant()) {
enPassant=true;
enPassantSquare=move.getEnPassantSquare();
}
if(currentPlayer==Piece.WHITE) {
currentPlayer=Piece.BLACK;
} else {
fullmoveNumber++; //black has just played
currentPlayer=Piece.WHITE;
}
evaluateNewBoardValue(move);
}
/**
* This function searchs for what piece is on a square.
* @param onSquare The Square on which we will look for a piece.
* @return a {@link Piece}
* @see Square
* @see Piece
*/
public Piece getPiece(Square onSquare) {
//if there is a corresponding white piece.
if (!isEmpty(onSquare, new Piece(Piece.WHITE_PIECES))) {
//for every white piece bitboard, look for the piece
for (int piece = Piece.WHITE_PAWN; piece <= Piece.WHITE_ROOK; piece += 2) {
if(!isEmpty(onSquare, new Piece(piece))) {
return new Piece(piece);
}
}
} else if (!isEmpty(onSquare, new Piece(Piece.BLACK_PIECES))) {
//for every white piece bitboard, look for the piece
for (int piece = Piece.BLACK_PAWN; piece <= Piece.BLACK_ROOK; piece += 2) {
if(!isEmpty(onSquare, new Piece(piece))) {
return new Piece(piece);
}
}
}
//if no piece found
return new Piece(Piece.NONE);
}
/**
* This function returns a boolean telling if a {@link Piece} is on a {@link Square}.
* @param square The Square
* @param piece A Piece constant
* @return boolean
* @see Piece
* @see Square
*/
public boolean isEmpty(Square square, Piece piece) {
long mask = mapSquaresToBits[squareToBitBoardSquare(square)];
if ((bitBoards[piece.getPieceNumber()] & mask) == 0) {
return true;
} else {
return false;
}
}
/**
* This function converts a {@link Square} to a number representing a bitboard square
* @param square The Square to be converted
* @return int
* @see Square
*/
public static int squareToBitBoardSquare(Square square) {
//converts a square ("e2") to a BitboardSquare (
return square.getFileNb() -1 + (square.getRank()-1)*NB_OF_FILES;
}
// /**
// * This function is used to set the table to an state in which a {@link Square} is an 'en passant' Square
// * @param Square The 'en passant' Square
// * @see Square
// */
// public void setEnPassant(Square square) {
// enPassant=true;
// enPassantSquare=square;
// }
//
// /**
// * This function is used to set the table back to a state with no 'en passant' Squares.
// */
// public void clearEnPassant () {
// enPassant=false;
// }
/**
* This function returns a boolean saying if the board is in an 'en passant' state.
* @return boolean
*/
public boolean isEnPassant() {
return enPassant;
}
/**
* This function is used to return the 'en passant' Square. Don't use it unless table is in an 'en passant' state.
* @return Square
* @see Square
*/
public Square getEnPassantSquare() {
return enPassantSquare;
}
/**
* This function returns an integer representing the result of the static evaluation function
* for the current board
* @return Integer
*/
public int getBoardValue() {
return boardValue;
}
/**
* This function tells if the board is in a draw status
*/
public boolean isADraw() {
if(halfmoveClock>=Rules.NUMBER_OF_MOVES_BEFORE_DRAW) {
return true;
}
return false;
}
/**
* Used to get the halfmoveClock.
* @return the number of halfmoves since the last capture or pawn movement
*/
public int getHalfmoveClock() {
return halfmoveClock;
}
/**
* This function returns the current player color
* @return Integer
*/
public int getCurrentPlayer() {
return currentPlayer;
}
/**
* This function can be used to display the board
* Black pieces are displayed in uppercase letters.
*/
public void display(){
for (int file = NB_OF_FILES; file >= 1; file--) {
System.out.println(" +---+---+---+---+---+---+---+---+");
String display = file+" |";
for (int rank=1; rank <= NB_OF_RANKS; rank++) {
boolean displayedSomething = false;
long mask = mapSquaresToBits[rank-1+(file-1)*NB_OF_RANKS];
if (displayPiece(Piece.BLACK_PAWN,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_PAWN_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_QUEEN,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_QUEEN_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_KING,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_KING_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_KNIGHT,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_KNIGHT_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_ROOK,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_ROOK_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_BISHOP,mask)) {
displayedSomething=true;
display+="'"+Piece.BLACK_BISHOP_CHAR+"'|";
}
if (displayPiece(Piece.WHITE_PAWN,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_PAWN_CHAR+" |";
}
if (displayPiece(Piece.WHITE_QUEEN,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_QUEEN_CHAR+" |";
}
if (displayPiece(Piece.WHITE_KING,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_KING_CHAR+" |";
}
if (displayPiece(Piece.WHITE_KNIGHT,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_KNIGHT_CHAR+" |";
}
if (displayPiece(Piece.WHITE_ROOK,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_ROOK_CHAR+" |";
}
if (displayPiece(Piece.WHITE_BISHOP,mask)) {
displayedSomething=true;
display+=" "+Piece.WHITE_BISHOP_CHAR+" |";
}
if (!displayedSomething)
display+=" |";
}
System.out.println(display);
}
System.out.println(" +---+---+---+---+---+---+---+---+");
System.out.println(" a b c d e f g h");
System.out.println();
}
/*=================*
* PRIVATE METHODS *
*=================*/
/* private long getBitBoard(int bitboard_number) {
return bitBoards[bitboard_number];
}
*/
protected void addPiece(Square square, Piece piece) {
//OR :
// 0 OR a = a
// 1 OR a = 1
//add Piece to corresponding bitboard.
bitBoards[piece.getPieceNumber()] |= mapSquaresToBits[squareToBitBoardSquare(square)];
//update the bitboard of all pieces of that color
bitBoards[piece.getColor()] |= mapSquaresToBits[squareToBitBoardSquare(square)];
numberOfPieces[piece.getPieceNumber()] += 1;
numberOfPieces[piece.getColor()] += 1;
}
protected void removePiece(Square square, Piece piece) throws NoPieceOnSquare {
//XOR :
// 0 XOR a = a
// 1 XOR 0 = 1 !!! Don't remove a piece that don't exist !!!
// 1 XOR 1 = 0
//remove Piece to corresponding bitboard.
if (SuicideChess.BITBOARD_REMOVEPIECE_CHECK_REMOVE) {
if (!isEmpty(square, piece)) {
bitBoards[piece.getPieceNumber()] ^= mapSquaresToBits[squareToBitBoardSquare(square)];
} else {
throw new NoPieceOnSquare("Square: "+square + "; Piece: " + piece.getPieceNumber());
}
} else {
bitBoards[piece.getPieceNumber()] ^= mapSquaresToBits[squareToBitBoardSquare(square)];
}
//update the bitboard of all pieces of that color
bitBoards[piece.getColor()] ^= mapSquaresToBits[squareToBitBoardSquare(square)];;
numberOfPieces[piece.getPieceNumber()] -= 1;
numberOfPieces[piece.getColor()] -= 1;
}
//used by function display()
private boolean displayPiece(int whatToDisplay, long mask) {
if ((bitBoards[whatToDisplay] & mask)==0) {
return false;
} else {
return true;
}
}
//calculates player's mobility
public int mobility(int colour) throws NotAValidSquare {
Board thisCopy = new Board(this);
thisCopy.currentPlayer=colour;
Rules.legalMovesForPlayer(thisCopy);
if (Rules.getLegalMovesCapture().size()!=0) {
return Rules.getLegalMovesCapture().size()*REAL_MOBILITY_VALUE
+Rules.getLegalMovesNonCapture().size()*RELATIVE_MOBILITY_VALUE;
} else {
return Rules.getLegalMovesNonCapture().size()*REAL_MOBILITY_VALUE;
}
}
private void evaluateNewBoardValue (Move move) throws NotAValidSquare {
if (move.isCaptureMove()) {
if (numberOfPieces[Piece.BLACK] == 0) {
boardValue = BLACK_WINS;
} else if (numberOfPieces[Piece.WHITE] == 0){
boardValue = WHITE_WINS;
} else {
//this is a very very basic evaluation function that will be changed.
//boardValue = numberOfBlackPieces - numberOfWhitePieces;
boardValue = 0;
/*if((numberOfPieces[Piece.BLACK_PAWN] <= ENDGAME_PAWNS) || (numberOfPieces[Piece.WHITE_PAWN] <= ENDGAME_PAWNS)
|| (numberOfPieces[Piece.BLACK_PIECES] <= ENDGAME_PIECES) || (numberOfPieces[Piece.WHITE_PIECES] <= ENDGAME_PIECES) ) {
//System.out.println("Playing endgame");
for (int i = Piece.OFFSET; i<=Piece.MAX_PIECE_NUMBER; i++) {
boardValue += numberOfPieces[i]*Piece.PIECE_VALUE_ENDGAME[i];
}
} else {
//System.out.println("Playing midgame");
/*for (int i = Piece.OFFSET; i<=Piece.MAX_PIECE_NUMBER; i++) {
boardValue += numberOfPieces[i]*Piece.PIECE_VALUE_MIDDLEGAME[i];
}*/
for(int squareNb = 0; squareNb<NB_OF_SQUARES; squareNb++) {
Piece pieceOnSquare = getPiece(new Square(squareNb));
if(pieceOnSquare.getPieceNumber()!=Piece.NONE) {
//System.out.println(SQUARE_WEIGHT[squareNb]);
boardValue += SQUARE_WEIGHT[squareNb]*Piece.PIECE_VALUE_MIDDLEGAME[pieceOnSquare.getPieceNumber()];
}
}
//boardValue += ((mobility(Piece.WHITE)-mobility(Piece.BLACK)));
//}
}
}
if (!Rules.isThereALegalMovesForPlayer(this)) {
if (currentPlayer==Piece.WHITE) {
boardValue = WHITE_WINS;
} else {
boardValue = BLACK_WINS;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink