Browse Source

Version 1.4.2

Now possible to undo, save games, restore positions, and view statistics when the computer plays.
master
djib 16 years ago
parent
commit
ed438e593a
  1. 107
      src/suicideChess/Board.java
  2. 67
      src/suicideChess/Piece.java
  3. 32
      src/suicideChess/Rules.java
  4. 10
      src/suicideChess/SuicideChess.java
  5. 9
      src/suicideChess/XBoardProtocol.java

107
src/suicideChess/Board.java

@ -35,7 +35,10 @@ public class Board {
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
*/
@ -145,6 +148,73 @@ public class Board {
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
}
numberOfBlackPieces = 0;
numberOfWhitePieces = 0;
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 (pieceToAdd.getColor()==Piece.BLACK) {
numberOfBlackPieces++;
} else {
numberOfWhitePieces++;
}
}
}
}
boardValue = getBoardValue();
}
/*================*
* PUBLIC METHODS *
*================*/
@ -315,51 +385,51 @@ public class Board {
if (displayPiece(Piece.BLACK_PAWN,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.PAWN_CHAR)+"'|";
display+="'"+Piece.BLACK_PAWN_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_QUEEN,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.QUEEN_CHAR)+"'|";
display+="'"+Piece.BLACK_QUEEN_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_KING,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.KING_CHAR)+"'|";
display+="'"+Piece.BLACK_KING_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_KNIGHT,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.KNIGHT_CHAR)+"'|";
display+="'"+Piece.BLACK_KNIGHT_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_ROOK,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.ROOK_CHAR)+"'|";
display+="'"+Piece.BLACK_ROOK_CHAR+"'|";
}
if (displayPiece(Piece.BLACK_BISHOP,mask)) {
displayedSomething=true;
display+="'"+Character.toUpperCase(Piece.BISHOP_CHAR)+"'|";
display+="'"+Piece.BLACK_BISHOP_CHAR+"'|";
}
if (displayPiece(Piece.WHITE_PAWN,mask)) {
displayedSomething=true;
display+=" "+Piece.PAWN_CHAR+" |";
display+=" "+Piece.WHITE_PAWN_CHAR+" |";
}
if (displayPiece(Piece.WHITE_QUEEN,mask)) {
displayedSomething=true;
display+=" "+Piece.QUEEN_CHAR+" |";
display+=" "+Piece.WHITE_QUEEN_CHAR+" |";
}
if (displayPiece(Piece.WHITE_KING,mask)) {
displayedSomething=true;
display+=" "+Piece.KING_CHAR+" |";
display+=" "+Piece.WHITE_KING_CHAR+" |";
}
if (displayPiece(Piece.WHITE_KNIGHT,mask)) {
displayedSomething=true;
display+=" "+Piece.KNIGHT_CHAR+" |";
display+=" "+Piece.WHITE_KNIGHT_CHAR+" |";
}
if (displayPiece(Piece.WHITE_ROOK,mask)) {
displayedSomething=true;
display+=" "+Piece.ROOK_CHAR+" |";
display+=" "+Piece.WHITE_ROOK_CHAR+" |";
}
if (displayPiece(Piece.WHITE_BISHOP,mask)) {
displayedSomething=true;
display+=" "+Piece.BISHOP_CHAR+" |";
display+=" "+Piece.WHITE_BISHOP_CHAR+" |";
}
if (!displayedSomething)
display+=" |";
@ -438,14 +508,11 @@ public class Board {
boardValue = numberOfBlackPieces - numberOfWhitePieces;
}
}
Rules.legalMovesForPlayer(this);
if ((Rules.getLegalMovesCapture().size()==0)&&(Rules.getLegalMovesNonCapture().size()==0)) {
// The following line is NOT an error !!!
// After move from WHITE, if there is no moves for BLACK, BLACK won.
if (move.getMovingPiece().getColor()==Piece.WHITE) {
boardValue = BLACK_WINS;
} else {
if (Rules.isThereALegalMovesForPlayer(this)) {
if (currentPlayer==Piece.WHITE) {
boardValue = WHITE_WINS;
} else {
boardValue = BLACK_WINS;
}
}
}

67
src/suicideChess/Piece.java

@ -56,8 +56,21 @@ public class Piece {
public static final char BISHOP_CHAR='b';
public static final char KNIGHT_CHAR='n';
public static final char ROOK_CHAR='r';
//may be useful
public static final char PAWN_CHAR='p';
public static final char PAWN_CHAR='p';
public static final char WHITE_KING_CHAR='K';
public static final char WHITE_QUEEN_CHAR='Q';
public static final char WHITE_BISHOP_CHAR='B';
public static final char WHITE_KNIGHT_CHAR='N';
public static final char WHITE_ROOK_CHAR='R';
public static final char WHITE_PAWN_CHAR='P';
public static final char BLACK_KING_CHAR='k';
public static final char BLACK_QUEEN_CHAR='q';
public static final char BLACK_BISHOP_CHAR='b';
public static final char BLACK_KNIGHT_CHAR='n';
public static final char BLACK_ROOK_CHAR='r';
public static final char BLACK_PAWN_CHAR='p';
/*==============*
* PRIVATE DATA *
@ -79,7 +92,7 @@ public class Piece {
}
/**
* Construcs a Piece given its color and its standard algebaic name
* Construcs a Piece given its color and its standard algebraic name
* (declared as constants in this file)
* @param piece A character used to represent the Piece.
* @param color The color of the piece. (See declared constants)
@ -107,7 +120,53 @@ public class Piece {
break;
}
}
/**
* Construcs a Piece given its standard algebraic name
* uppercase is white and lowercase is black
*/
public Piece(char piece) {
pieceNumber = NONE;
switch (piece) {
case WHITE_PAWN_CHAR:
pieceNumber = 2*(PAWN+1) + WHITE;
break;
case WHITE_KING_CHAR:
pieceNumber = 2*(KING+1) + WHITE;
break;
case WHITE_QUEEN_CHAR:
pieceNumber = 2*(QUEEN+1) + WHITE;
break;
case WHITE_BISHOP_CHAR:
pieceNumber = 2*(BISHOP+1) + WHITE;
break;
case WHITE_KNIGHT_CHAR:
pieceNumber = 2*(KNIGHT+1) + WHITE;
break;
case WHITE_ROOK_CHAR:
pieceNumber = 2*(ROOK+1) + WHITE;
break;
case BLACK_PAWN_CHAR:
pieceNumber = 2*(PAWN+1) + BLACK;
break;
case BLACK_KING_CHAR:
pieceNumber = 2*(KING+1) + BLACK;
break;
case BLACK_QUEEN_CHAR:
pieceNumber = 2*(QUEEN+1) + BLACK;
break;
case BLACK_BISHOP_CHAR:
pieceNumber = 2*(BISHOP+1) + BLACK;
break;
case BLACK_KNIGHT_CHAR:
pieceNumber = 2*(KNIGHT+1) + BLACK;
break;
case BLACK_ROOK_CHAR:
pieceNumber = 2*(ROOK+1) + BLACK;
break;
}
}
/*=========*
* METHODS *
*=========*/

32
src/suicideChess/Rules.java

@ -35,7 +35,6 @@ public class Rules {
* Computes the possible moves according to the current status of the {@link Board} and the
* color of the current player.
* @param board The current board position.
* @param color The color of the current player.
* @throws NotAValidSquare If the program throws this exception then there is a bug.
* @throws UnexpectedError This should never happen.
* @see Square
@ -55,18 +54,47 @@ public class Rules {
}
}
/**
* Looks for one legal move according to the current status of the {@link Board} and the
* color of the current player.
* @param board The current board position.
* @throws NotAValidSquare If the program throws this exception then there is a bug.
* @throws UnexpectedError This should never happen.
* @see Square
* @see Board
*/
public static boolean isThereALegalMovesForPlayer(Board board) throws NotAValidSquare {
legalMovesNonCapture = new ArrayList<Move>();
legalMovesCapture = new ArrayList<Move>();
Square square;
for(int squareNb = 0; squareNb < Board.NB_OF_SQUARES; squareNb++) {
square = new Square(squareNb);
if (board.isEmpty(square, new Piece(board.getCurrentPlayer()))) {
continue;
}
if ((legalMovesNonCapture.size()!=0)||(legalMovesCapture.size()!=0)) {
return true; //found a legal move
}
}
return false;
}
/**
* Computes the possible moves from a given {@link Square}
* according to the current status of the {@link Board}
* @param fromSquare The square from which the move must start
* @param board The current board position.
* @param fast If this boolean is set to true then the program only searches if there is ONE legal move.
* @return boolean Stating if there is or not a legal move.
* @throws NotAValidSquare If the program throws this exception then there is a bug.
* @throws UnexpectedError This should never happen.
* @see Square
* @see Board
*/
public static void legalMovesFromSquare(Square fromSquare, Board board) throws NotAValidSquare {
private static void legalMovesFromSquare(Square fromSquare, Board board) throws NotAValidSquare {
Move validMove;
Square toSquare;
Piece movingPiece = board.getPiece(fromSquare);

10
src/suicideChess/SuicideChess.java

@ -134,7 +134,7 @@ public class SuicideChess {
try {
String whatMove= moveInput.readLine();
boolean playedALegalMove = false;
int xBoardCommand = XBoardProtocol.getCommand(whatMove);
switch (xBoardCommand) {
@ -185,6 +185,11 @@ public class SuicideChess {
case XBoardProtocol.NOPOST:
post=false;
break;
case XBoardProtocol.SETBOARD:
bitboard=new Board(whatMove.substring(9));
if(ASCII_GAME)
bitboard.display();
break;
case XBoardProtocol.UNKNOWN:
if (acceptedUsermove) {
System.out.println("Error (unknown command): "+whatMove);
@ -315,6 +320,5 @@ public class SuicideChess {
break;
}
}
}
}
}

9
src/suicideChess/XBoardProtocol.java

@ -82,6 +82,10 @@ public class XBoardProtocol {
* Xboard asks NOT to display thinking output
*/
public static final int NOPOST = 16;
/**
* XBoard changes the board position
*/
public static final int SETBOARD = 17;
/**
* Unknown command
*/
@ -98,7 +102,7 @@ public class XBoardProtocol {
System.out.println("feature myname=\"djib's Suicide Chess\"");
System.out.println("feature sigint=0 sigterm=0"); //do not interrupt me
System.out.println("feature variants=\"suicide\"");
System.out.println("feature ping=1");
System.out.println("feature ping=1 setboard=1");
System.out.println("feature time=0 draw=0 reuse=0 analyze=0 colors=0");
System.out.println("feature done=1");
if (SuicideChess.ASCII_GAME)
@ -154,9 +158,10 @@ public class XBoardProtocol {
return POST;
} else if (command.equals("nopost")) {
return NOPOST;
} else if (command.startsWith("setboard")) {
return SETBOARD;
}
return UNKNOWN;
}
}
Loading…
Cancel
Save