chessai

college code for ai playing chess in java
ChessPlayer.java

(5961B)
      1 package chess;
      2 
      3 import chess.utils.ChessColor;
      4 import chess.utils.ChessDirection;
      5 import chess.utils.ChessType;
      6 
      7 import java.util.ArrayList;
      8 import java.util.List;
      9 
     10 /**
     11  * Check
     12  */
     13 public class ChessPlayer {
     14 
     15     private static final String ERROR_MSG =
     16             ChessPlayer.class+": Invalid color.";
     17 
     18     private int points;
     19     private ChessColor color;
     20     private int moves;
     21 
     22     public ChessPlayer(ChessColor color) {
     23         if(color == ChessColor.NA)
     24             throw new IllegalArgumentException(ERROR_MSG);
     25 
     26         this.color = color;
     27         points = 0;
     28         moves = 0;
     29     }
     30 
     31     public ChessPlayer(int colorNo) {
     32         if(colorNo > 2 || colorNo < 1)
     33             throw new IllegalArgumentException(ERROR_MSG);
     34 
     35         ChessColor color =
     36                 colorNo==1 ? ChessColor.WHITE : ChessColor.BLACK;
     37 
     38         this.color = color;
     39         points = 0;
     40         moves = 0;
     41     }
     42 
     43     public List<ChessMove> possibleMoves(
     44             ChessCoordinate src, ChessState state) {
     45 
     46         List<ChessMove> moves = new ArrayList<ChessMove>();
     47         ChessRules.INSTANCE.setState(state);
     48         ChessRules.INSTANCE.setSrc(src);
     49 
     50         final ChessDirection[] directions =
     51                 ChessRules.INSTANCE.possibleDirections();
     52 
     53         for(ChessDirection direction : directions) {
     54             boolean valid = true;
     55             int steps = 1;
     56             while (valid) {
     57                 ChessMove move = new ChessMove(src, direction, steps);
     58                 ChessCoordinate dest = src;
     59                 dest = dest.getCoordinate(state, move);
     60                 ChessRules.INSTANCE.setDest(dest);
     61                 valid = ChessRules.INSTANCE.validMove();
     62 
     63                 if(valid) moves.add(move);
     64                 steps++;
     65             }
     66         }
     67 
     68         return moves;
     69     }
     70 
     71     public List<ChessMove> possibleMoves(List<ChessCoordinate> pieces, ChessBoard state) {
     72         List<ChessMove> moves = new ArrayList<ChessMove>();
     73         for(ChessCoordinate src : pieces) {
     74             List<ChessMove> possibleMoves = possibleMoves(src, state);
     75             for(ChessMove move : possibleMoves)
     76                 moves.add(move);
     77         }
     78         return moves;
     79     }
     80 
     81     public ChessMove bestPossibleMove(ChessBoard board) {
     82         List<ChessCoordinate> pieces = board.getPieces(color);
     83         List<ChessMove> moves = possibleMoves(pieces, board);
     84 
     85         ChessMove bestMove = null;
     86         int eval = -999999999;
     87 
     88         while(!moves.isEmpty()) {
     89             ChessMove move = moves.get(0);
     90             ChessBoard tmpBoard = new ChessBoard(board);
     91             tmpBoard.move(move);
     92             int ourscore = evaluate(move,board);
     93             int oppEval = evaluateOpponentMove(tmpBoard, ourscore);
     94 
     95             if(oppEval > eval){
     96                 bestMove=move;
     97                 eval= oppEval;
     98             }
     99 
    100             moves.remove(0);
    101         }
    102         return bestMove;
    103     }
    104 
    105     public int evaluateOpponentMove(ChessBoard board, int ourscore) {
    106 
    107         List<ChessCoordinate> pieces = board.getPieces(color.opposite());
    108         List<ChessMove> moves = possibleMoves(pieces, board);
    109 
    110         int eval = 999999999;
    111         while(!moves.isEmpty()) {
    112             ChessMove move = moves.get(0);
    113             int moveEval = ourscore - evaluate(move, board);
    114 
    115             if(eval > moveEval) {  // we have a minimum
    116                 if(eval == 999999999)
    117                     eval = moveEval;
    118                 else // prune
    119                     return moveEval;
    120             }
    121             moves.remove(0);
    122         }
    123         return eval;
    124     }
    125 
    126     private int evaluate(ChessMove move, ChessBoard board) {
    127         ChessCoordinate src = move.getCoordinate();
    128         ChessCoordinate dest = src.getCoordinate(board, move);
    129 
    130         ChessPiece srcPiece = ChessPiece.find(board.get(src));
    131         ChessPiece destPiece = ChessPiece.find(board.get(dest));
    132 
    133         ChessType srcType = srcPiece.getType();
    134         ChessType destType = destPiece.getType();
    135 
    136         int value = evaluateCapture(destType) +
    137                 evaluateMovablePieces(src, board, move) +
    138                 evaluateMovablePieces(dest, board, move);
    139 
    140 
    141         return value;
    142     }
    143 
    144     public int evaluateCapture(ChessType destType) {
    145         if(destType != ChessType.NA)
    146             return destType.getValue();
    147         return 0;
    148     }
    149 
    150     public int evaluateMovablePieces(
    151             ChessCoordinate coor,
    152             ChessBoard board,
    153             ChessMove move) {
    154 
    155         // Check if pieces around src are movable
    156         List<ChessCoordinate> coordinates = coor.surroundingCoordinates(1);
    157         List<ChessMove> moves = possibleMoves(coordinates, board);
    158         int value = 0;
    159 
    160         for(int i=0; i<moves.size(); i++) {
    161             ChessType type = ChessPiece.find(board.get(
    162                     moves.get(i).getCoordinate())).getType();
    163 
    164             if(type != ChessType.PAWN || type != ChessType.KING || type != ChessType.KNIGHT) {
    165                 if(type == ChessType.BISHOP) value -= 3;
    166                 else value -= 1;
    167             }
    168 
    169         }
    170 
    171         // Check if pieces around dest are movable
    172         ChessBoard tmpBoard = new ChessBoard(board);
    173         tmpBoard.move(move);
    174         moves.clear();
    175         moves = possibleMoves(coordinates, tmpBoard);
    176 
    177         for(int i=0; i<moves.size(); i++) {
    178             ChessType type = ChessPiece.find(board.get(
    179                     moves.get(i).getCoordinate())).getType();
    180 
    181             if(type != ChessType.PAWN || type != ChessType.KING || type != ChessType.KNIGHT) {
    182                 if(type == ChessType.BISHOP) value += 3;
    183                 else value += 1;
    184             }
    185         }
    186         return value;
    187     }
    188 
    189     public ChessColor getColor() {
    190         return color;
    191     }
    192 
    193     public int getPoints() {
    194         return points;
    195     }
    196 
    197     public int getMoves() {
    198         return moves;
    199     }
    200 
    201     public void setPoints(int points) {
    202         this.points = points;
    203     }
    204 
    205     public void incrementMoves() {
    206         this.moves++;
    207     }
    208 }