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