339 lines
13 KiB
Java
339 lines
13 KiB
Java
package suicideChess;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.InputStreamReader;
|
|
import java.util.ArrayList;
|
|
|
|
|
|
import suicideChess.Move.NotAValidMoveException;
|
|
import suicideChess.Square.NotAValidSquare;
|
|
|
|
/**
|
|
* Main file (the game in itself)
|
|
* @author Jean-Baptiste Hétier
|
|
* @version $LastChangedRevision$, $LastChangedDate$
|
|
*/
|
|
|
|
public class SuicideChess {
|
|
|
|
/*
|
|
* Those flags are used to perform extra checks during the debugging of the
|
|
* program. They may be safely all set to false once the program is stable.
|
|
* It should improve performance a lot.
|
|
*/
|
|
/**
|
|
* does BitBoard.class removePiece function checks if removing piece is legal ?
|
|
*/
|
|
public static final boolean BITBOARD_REMOVEPIECE_CHECK_REMOVE = true;
|
|
/**
|
|
* does Square.class checks if the strings are valid (is "z9" a valid square ?)
|
|
*/
|
|
public static final boolean SQUARE_CHECK_INVALID = true;
|
|
|
|
/**
|
|
* The name to be displayed
|
|
*/
|
|
public static final String NAME = "djib's SuShi v0.5.2";
|
|
|
|
/**
|
|
* Displays informations in the console.
|
|
*/
|
|
public static final boolean ASCII_GAME = true;
|
|
|
|
/**
|
|
* Number of Plies the computes searches to
|
|
*/
|
|
public static final int PLY_DEPTH = 4;
|
|
|
|
/**
|
|
* Test and display if the board is in a winning state.
|
|
* @param bitboard A Board
|
|
* @return True or False
|
|
*/
|
|
|
|
private static boolean testWinningPosition (Board bitboard) {
|
|
if (bitboard.getBoardValue()==Board.BLACK_WINS) {
|
|
System.out.println("0-1 {Black mates}");
|
|
return true;
|
|
} else if (bitboard.getBoardValue()==Board.WHITE_WINS) {
|
|
System.out.println("1-0 {White mates}");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* If feature usermove has not been accepted by XBoard then consider all unknown commands
|
|
* as moves
|
|
*/
|
|
private static boolean acceptedUsermove = false;
|
|
|
|
/**
|
|
* This array is used for undo purposes. Positions are sorted from last to first.
|
|
*/
|
|
private static ArrayList<Board> allPlayedPositions = new ArrayList<Board>();
|
|
|
|
/**
|
|
* This function is used to add a new position to the list of all positions
|
|
* @param position A {@link Board}
|
|
* @see Board
|
|
*/
|
|
private static void addPlayedPosition (Board position) {
|
|
allPlayedPositions.add(0,new Board(position));
|
|
}
|
|
|
|
/**
|
|
* This function is used to undo the last position played
|
|
*/
|
|
private static Board removePlayedPosition () {
|
|
allPlayedPositions.remove(0);
|
|
return allPlayedPositions.get(0);
|
|
}
|
|
|
|
/**
|
|
* This variable says whether the computer should display a "thinking output"
|
|
*/
|
|
private static boolean post = true;
|
|
|
|
/**
|
|
* Should computer display thinking output or not ?
|
|
* @return boolean
|
|
*/
|
|
public static boolean postThinkingOutput() {
|
|
return post;
|
|
}
|
|
/**
|
|
* The main function
|
|
* @param args No parameters should be transmitted to this function.
|
|
* @throws NotAValidSquare
|
|
*/
|
|
public static void main(String[] args) throws NotAValidSquare {
|
|
|
|
|
|
System.out.println("Welcome to SuicideChess "+SuicideChess.NAME+"!");
|
|
if (!SuicideChess.ASCII_GAME) {
|
|
System.out.println("This game was not designed to be played in console. Please use it with XBoard, WinBoard or any compatible program.");
|
|
}
|
|
System.out.println();
|
|
|
|
|
|
BufferedReader moveInput = new BufferedReader(new InputStreamReader(System.in));
|
|
Board bitboard = new Board();
|
|
addPlayedPosition(bitboard);
|
|
|
|
if (ASCII_GAME) {
|
|
bitboard.display();
|
|
System.out.println("White: ");
|
|
}
|
|
|
|
boolean computerPlaying = true; //the computer does not play in foce mode.
|
|
|
|
boolean playing = true;
|
|
|
|
while (playing) {
|
|
try {
|
|
String whatMove= moveInput.readLine();
|
|
boolean playedALegalMove = false;
|
|
|
|
int xBoardCommand = XBoardProtocol.getCommand(whatMove);
|
|
|
|
switch (xBoardCommand) {
|
|
case XBoardProtocol.XBOARD:
|
|
break;
|
|
case XBoardProtocol.PROTOVER:
|
|
XBoardProtocol.initialise();
|
|
break;
|
|
case XBoardProtocol.NOT_ACCEPTED_SUICIDE:
|
|
System.out.println("tellusererror \"This game only plays suicide chess.\"");
|
|
playing=false;
|
|
break;
|
|
case XBoardProtocol.ACCEPTED_USERMOVE:
|
|
acceptedUsermove=true;
|
|
break;
|
|
case XBoardProtocol.NOPROTOVER:
|
|
System.out.println("tellusererror \"You must use an engine with XBoard protocol 2 or higher.\"");
|
|
playing=false;
|
|
break;
|
|
case XBoardProtocol.QUIT:
|
|
System.out.println("Goodbye!");
|
|
playing=false;
|
|
break;
|
|
case XBoardProtocol.NEW:
|
|
//System.out.println("variant suicide");
|
|
break;
|
|
case XBoardProtocol.HINT:
|
|
System.out.println("Hint: "+ComputerPlayer.doRandomMove(bitboard));
|
|
break;
|
|
case XBoardProtocol.FORCE:
|
|
computerPlaying = false;
|
|
break;
|
|
case XBoardProtocol.PING:
|
|
System.out.println("pong "+whatMove.substring(5));
|
|
break;
|
|
case XBoardProtocol.REMOVE:
|
|
removePlayedPosition();
|
|
//no break here
|
|
case XBoardProtocol.UNDO:
|
|
bitboard=new Board(removePlayedPosition());
|
|
if (ASCII_GAME) {
|
|
bitboard.display();
|
|
}
|
|
break;
|
|
case XBoardProtocol.POST:
|
|
post=true;
|
|
break;
|
|
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);
|
|
break;
|
|
}
|
|
//if XBoard did not accept usermove command we try and interpret every unknown command
|
|
//as a move.
|
|
case XBoardProtocol.MOVE:
|
|
Move theMove;
|
|
if (acceptedUsermove) {
|
|
theMove = new Move(whatMove.substring(9), bitboard);
|
|
} else {
|
|
theMove = new Move(whatMove, bitboard);
|
|
}
|
|
|
|
if (testWinningPosition(bitboard)) {
|
|
//if board was set in an illegal position
|
|
System.out.println("Illegal move: "+theMove.toString());
|
|
break;
|
|
}
|
|
|
|
|
|
boolean needToCapture = false;
|
|
int foundMoveIndex = -1;
|
|
if(theMove.getMovingPiece().getColor() == bitboard.getCurrentPlayer()) {
|
|
Rules.legalMovesForPlayer(bitboard);
|
|
ArrayList<Move> allLegalMoves = Rules.getLegalMovesCapture();
|
|
if (allLegalMoves.size()==0) {
|
|
allLegalMoves = Rules.getLegalMovesNonCapture();
|
|
} else {
|
|
needToCapture = true;
|
|
}
|
|
for (int moveIndex = 0; moveIndex < allLegalMoves.size(); moveIndex++) {
|
|
if (allLegalMoves.get(moveIndex).isSimpleEqual(theMove)) {
|
|
if(theMove.isPromotionMove()&&
|
|
theMove.getPromotionPiece().getPieceNumber()!=allLegalMoves.get(moveIndex).getPromotionPiece().getPieceNumber()) {
|
|
continue;
|
|
}
|
|
foundMoveIndex=moveIndex;
|
|
break;
|
|
}
|
|
}
|
|
if (foundMoveIndex == -1) {
|
|
if (needToCapture) {
|
|
if (ASCII_GAME)
|
|
System.out.println("Capturing is mandatory.");
|
|
}
|
|
System.out.println("Illegal move: "+theMove.toString());
|
|
} else {
|
|
bitboard.doMove(allLegalMoves.get(foundMoveIndex));
|
|
addPlayedPosition(bitboard);
|
|
if (ASCII_GAME) {
|
|
allLegalMoves.get(foundMoveIndex).display();
|
|
System.out.println("Board value: "+bitboard.getBoardValue());
|
|
bitboard.display();
|
|
}
|
|
playedALegalMove=true;
|
|
}
|
|
} else {
|
|
if (ASCII_GAME)
|
|
System.out.println("Please play a piece of the right color.");
|
|
System.out.println("Illegal move: "+theMove.toString());
|
|
}
|
|
|
|
if (testWinningPosition(bitboard)) {
|
|
computerPlaying=false;
|
|
}
|
|
|
|
if (!playedALegalMove) {
|
|
break;
|
|
}
|
|
//No break statement here on purpose.
|
|
case XBoardProtocol.GO:
|
|
//this is not really nice but it avoids having to write twice the code
|
|
//I check if I did really receive a XBoardProtocol.GO or it I just got there
|
|
//because there is no break statement.
|
|
if (xBoardCommand==XBoardProtocol.GO)
|
|
computerPlaying = true;
|
|
|
|
if (testWinningPosition(bitboard)) {
|
|
//in case an illegal position have been sent
|
|
computerPlaying=false;
|
|
break;
|
|
}
|
|
|
|
if (computerPlaying) {
|
|
Move computerMove = ComputerPlayer.doAlphaBetaMove(bitboard);
|
|
bitboard.doMove(computerMove);
|
|
addPlayedPosition(bitboard);
|
|
XBoardProtocol.doMove(computerMove);
|
|
if (ASCII_GAME) {
|
|
computerMove.display();
|
|
System.out.println("Board value: "+bitboard.getBoardValue());
|
|
bitboard.display();
|
|
}
|
|
}
|
|
|
|
if (testWinningPosition(bitboard)) {
|
|
computerPlaying=false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// if (whatMove.startsWith("hint")) {
|
|
// Rules rules = new Rules();
|
|
// rules.legalMovesForPlayer(bitboard,currentPlayerColor);
|
|
// ArrayList<Move> allLegalMoves = rules.getLegalMovesCapture();
|
|
// if (allLegalMoves.size()==0) {
|
|
// allLegalMoves = rules.getLegalMovesNonCapture();
|
|
// }
|
|
// for(int i = 0; i<allLegalMoves.size(); i++) {
|
|
// if(allLegalMoves.get(i).isPromotionMove()) {
|
|
// System.out.println(allLegalMoves.get(i).fromSquare().toString() +
|
|
// allLegalMoves.get(i).toSquare().toString() +
|
|
// allLegalMoves.get(i).getPromotionPiece().toString());
|
|
// } else {
|
|
// System.out.println(allLegalMoves.get(i).fromSquare().toString() +
|
|
// allLegalMoves.get(i).toSquare().toString());
|
|
// }
|
|
//
|
|
// }
|
|
// continue;
|
|
// }
|
|
|
|
// if (whatMove.startsWith("force")) {
|
|
// Move theMove = new Move(whatMove.substring(6,10), bitboard);
|
|
// theMove.display();
|
|
// bitboard.doMove(theMove);
|
|
// bitboard.display();
|
|
// continue;
|
|
// }
|
|
|
|
|
|
} catch (NotAValidMoveException err) {
|
|
System.out.println(err);
|
|
continue;
|
|
} catch (NotAValidSquare err) {
|
|
System.out.println(err);
|
|
continue;
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} |