I'm making a version of Martian Chess in java with AI and so far I THINK my
move searching is semi-working, it seems to work alright for some depths but if I use a depth of 3 it returns a
move for the opposite side...now the game is a bit weird because when a piece crosses half of the board, it becomes property of the other player so I think this is part of the problem. I'd be really greatful if someone could look over my code and point out any errors you think are there! (pls note that my evaluation function isn't nearly complete lol)
MoveSearch.java
public class MoveSearch {
private Evaluation evaluate = new Evaluation();
private int blackPlayerScore, whitePlayerScore;
public MoveContent bestMove;
public MoveSearch(int blackScore, int whiteScore) {
blackPlayerScore = blackScore;
whitePlayerScore = whiteScore;
}
private Vector<Position> EvaluateMoves(Board board) {
Vector<Position> positions = new Vector<Position>();
for (int i = 0; i < 32; i++) {
Piece piece = null;
if (!board.chessBoard[i].square.isEmpty()) {
// store the piece
piece = board.chessBoard[i].square.firstElement();
}
// skip empty squares
if (piece == null) {
continue;
}
// skip the other players pieces
if (piece.pieceColour != board.whosMove) {
continue;
}
// generate valid moves for the piece
PieceValidMoves validMoves = new PieceValidMoves(board.chessBoard, i, board.whosMove);
validMoves.generateMoves();
// for each valid
move
for (int j = 0; j < piece.validMoves.size(); j++) {
// store it as a position
Position
move = new Position();
move.startPosition = i;
move.endPosition = piece.validMoves.elementAt(j);
Piece pieceAttacked = null;
if (!board.chessBoard[move.endPosition].square.isEmpty()) {
// if the end position is not empty, store the attacked piece
pieceAttacked = board.chessBoard[move.endPosition].square.firstElement();
}
// if a piece is attacked
if (pieceAttacked != null) {
// append its value to the
move score
move.score += pieceAttacked.pieceValue;
// if the moving pieces value is less than the value of the attacked piece
if (piece.pieceValue < pieceAttacked.pieceValue) {
// score extra points
move.score += pieceAttacked.pieceValue - piece.pieceValue;
}
}
// add the
move to the set of positions
positions.add(move);
}
}
return positions;
} // EvaluateMoves()
private int SideToMoveScore(int score, PieceColour colour) {
if (colour == PieceColour.Black){
return -score;
} else {
return score;
}
}
public int AlphaBeta(Board board, int depth, int alpha, int beta) {
//int best = -9999;
// if the depth is 0, return the score of the current board
if (depth <= 0) {
board.printBoard();
System.out.println("Score: " + evaluate.EvaluateBoardScore(board));
System.out.println("");
int boardScore = evaluate.EvaluateBoardScore(board);
return SideToMoveScore(boardScore, board.whosMove);
}
// fill the positions with valid moves
Vector<Position> positions = EvaluateMoves(board);
// if there are no available positions
if (positions.size() == 0) {
// and its blacks
move
if (board.whosMove == PieceColour.Black) {
if (blackPlayerScore > whitePlayerScore) {
// and they are winning, return a high number
return 9999;
} else if (whitePlayerScore == blackPlayerScore) {
// if its a draw, lower number
return 500;
} else {
// if they are losing, return a very low number
return -9999;
}
}
if (board.whosMove == PieceColour.White) {
if (whitePlayerScore > blackPlayerScore) {
return 9999;
} else if (blackPlayerScore == whitePlayerScore) {
return 500;
} else {
return -9999;
}
}
}
// for each position
for (int i = 0; i < positions.size(); i++) {
// store the position
Position
move = positions.elementAt(i);
// temporarily copy the board
Board temp = board.copyBoard(board);
// make the
move
temp.makeMove(move.startPosition,
move.endPosition);
for (int x = 0; x < 32; x++) {
if (!temp.chessBoard[x].square.isEmpty()) {
PieceValidMoves validMoves = new PieceValidMoves(temp.chessBoard, x, temp.whosMove);
validMoves.generateMoves();
}
}
// repeat the process recursively, decrementing the depth
int val = -AlphaBeta(temp, depth - 1, -beta, -alpha);
// if the value returned is better than the current best score, replace it
if (val >= beta) {
// beta cut-off
return beta;
}
if (val > alpha) {
alpha = val;
bestMove = new MoveContent(alpha,
move.startPosition,
move.endPosition);
}
}
// return the best score
return alpha;
} // AlphaBeta()
}
This is the makeMove method
public void makeMove(int startPosition, int endPosition) {
// quick reference to selected piece and attacked piece
Piece selectedPiece = null;
if (!(chessBoard[startPosition].square.isEmpty())) {
selectedPiece = chessBoard[startPosition].square.firstElement();
}
Piece attackedPiece = null;
if (!(chessBoard[endPosition].square.isEmpty())) {
attackedPiece = chessBoard[endPosition].square.firstElement();
}
// if a piece is taken, amend score
if (!(chessBoard[endPosition].square.isEmpty()) && attackedPiece != null) {
if (attackedPiece.pieceColour == PieceColour.White) {
blackScore = blackScore + attackedPiece.pieceValue;
}
if (attackedPiece.pieceColour == PieceColour.Black) {
whiteScore = whiteScore + attackedPiece.pieceValue;
}
}
// actually
move the piece
chessBoard[endPosition].square.removeAllElements();
chessBoard[endPosition].addPieceToSquare(selectedPiece);
chessBoard[startPosition].square.removeAllElements();
// changing piece colour based on position
if (endPosition > 15) {
selectedPiece.pieceColour = PieceColour.White;
}
if (endPosition <= 15) {
selectedPiece.pieceColour = PieceColour.Black;
}
//change to other player
if (whosMove == PieceColour.Black) whosMove = PieceColour.White;
else if (whosMove == PieceColour.White) whosMove = PieceColour.Black;
} // makeMove()
