agents/java/Board.java

   1 /**
   2  * @class Board
   3  * @purpose Represent a quantum chess board
   4  */
   5
   6 import java.util.Vector;
   7
   8 class Board
   9 {
  10         public static final int WIDTH = 8;
  11         public static final int HEIGHT = 8;
  12         public  Board()
  13         {
  14
  15                 this.grid = new Square[Board.WIDTH][Board.HEIGHT];
  16                 for (int x = 0; x < Board.WIDTH; ++x)
  17                 {
  18                         for (int y = 0; y < Board.HEIGHT; ++y)
  19                         {
  20                                 this.grid[x][y] = new Square(x, y, null);
  21                                 this.grid[x][y].x = x;
  22                                 this.grid[x][y].y = y;
  23                         }
  24                 }
  25                 Piece.Colour[] colours = {Piece.Colour.BLACK, Piece.Colour.WHITE};
  26
  27                 this.white = new Vector<Piece>();
  28                 this.black = new Vector<Piece>();
  29                 for (int i = 0; i < colours.length; ++i)
  30                 {
  31                         Vector<Piece> p = pieces(colours[i]);
  32
  33                         // add pawns
  34                         int y = (i == 0) ? 1 : Board.HEIGHT-2;
  35                         for (int x = 0; x < Board.WIDTH; ++x)
  36                         {
  37                                 p.add(new Piece(x, y, colours[i], Piece.Type.PAWN, Piece.Type.UNKNOWN));
  38                         }
  39
  40                         // add major pieces
  41                         y = (i == 0) ? 1 : Board.HEIGHT-1;
  42
  43                         p.add(new Piece(0, y, colours[i], Piece.Type.ROOK, Piece.Type.UNKNOWN));
  44                         p.add(new Piece(1, y, colours[i], Piece.Type.KNIGHT, Piece.Type.UNKNOWN));
  45                         p.add(new Piece(2, y, colours[i], Piece.Type.BISHOP, Piece.Type.UNKNOWN));
  46                         Piece k = new Piece(3, y, colours[i], Piece.Type.KING, Piece.Type.KING);
  47                         p.add(k);
  48                         if (i == 0)
  49                                 white_king = k;
  50                         else
  51                                 black_king = k;
  52                         p.add(new Piece(4, y, colours[i], Piece.Type.QUEEN, Piece.Type.UNKNOWN));
  53                         p.add(new Piece(5, y, colours[i], Piece.Type.BISHOP, Piece.Type.UNKNOWN));
  54                         p.add(new Piece(6, y, colours[i], Piece.Type.KNIGHT, Piece.Type.UNKNOWN));
  55                         p.add(new Piece(7, y, colours[i], Piece.Type.ROOK, Piece.Type.UNKNOWN));
  56
  57                         for (int j = 0; j < p.size(); ++j)
  58                         {
  59                                 Piece pp = p.get(j);
  60                                 grid[pp.x][pp.y].piece = pp;
  61                         }
  62
  63                 }
  64
  65         }
  66
  67
  68         public  Vector<Piece> pieces(Piece.Colour colour)
  69         {
  70                 return ((colour == Piece.Colour.WHITE) ? white : black);
  71         }
  72         public  Piece king(Piece.Colour colour)
  73         {
  74                 return ((colour == Piece.Colour.WHITE) ? white_king : black_king);
  75         }
  76
  77         public  void Update_move(int x, int y, int x2, int y2)
  78         {
  79                 Square s1 = grid[x][y];
  80                 Square s2 = grid[x2][y2];
  81                 if (s2.piece != null)
  82                 {
  83                         Vector<Piece> v = pieces(s2.piece.colour);
  84                         v.remove(s2.piece);
  85
  86                         if (s2.piece == king(s2.piece.colour))
  87                         {
  88                                 if (s2.piece.colour == Piece.Colour.WHITE)
  89                                         white_king = null;
  90                                 else
  91                                         black_king = null;
  92                         }
  93                 }
  94
  95                 s1.piece.x = x2;
  96                 s1.piece.y = y2;
  97                 s2.piece = s1.piece;
  98                 s1.piece = null;
  99         }
 100         public  void Update_select(int x, int y, int index, String type) throws Exception
 101         {
 102                 Square s = grid[x][y];
 103                 s.piece.type_index = index;
 104                 s.piece.types[index] = Piece.str2type(type);
 105                 s.piece.current_type = s.piece.types[index];
 106
 107         }
 108
 109         public  Square Get_square(int x, int y)
 110         {
 111                 return grid[x][y]; // get square on board
 112         }
 113
 114         public void Get_moves(Piece p, Vector<Square> v)
 115         {
 116                 int x = p.x;
 117                 int y = p.y;
 118                 if (p.current_type == Piece.Type.KING)
 119                 {
 120                         Move(p, x+1, y, v);
 121                         Move(p, x-1, y, v);
 122                         Move(p, x, y+1, v);
 123                         Move(p, x, y-1, v);
 124                         Move(p, x+1, y+1, v);
 125                         Move(p, x+1, y-1, v);
 126                         Move(p, x-1, y+1, v);
 127                         Move(p, x-1, y-1, v);
 128                 }
 129                 else if (p.current_type == Piece.Type.KNIGHT)
 130                 {
 131                         Move(p, x+2, y+1, v);
 132                         Move(p, x+2, y-1, v);
 133                         Move(p, x-2, y+1, v);
 134                         Move(p, x-2, y-1, v);
 135                         Move(p, x+1, y+2, v);
 136                         Move(p, x-1, y+2, v);
 137                         Move(p, x+1, y-2, v);
 138                         Move(p, x-1, y-2, v);
 139                 }
 140                 else if (p.current_type == Piece.Type.PAWN)
 141                 {
 142                         int y1 = (p.colour == Piece.Colour.WHITE) ? Board.HEIGHT-2 : 1;
 143                         int y2 = (p.colour == Piece.Colour.WHITE) ? y1 - 2 : y1 + 2;
 144                         if (p.types[0] == Piece.Type.PAWN && p.y == y1)
 145                         {
 146
 147                                 Move(p, x, y2, v);
 148                         }
 149                         y2 = (p.colour == Piece.Colour.WHITE) ? y - 1 : y + 1;
 150                         Move(p, x, y2, v);
 151
 152                         if (Valid_position(x-1, y2) && grid[x-1][y2].piece != null)
 153                                 Move(p, x-1, y2, v);
 154                         if (Valid_position(x+1, y2) && grid[x+1][y2].piece != null)
 155                                 Move(p, x+1, y2, v);
 156                 }
 157                 else if (p.current_type == Piece.Type.BISHOP)
 158                 {
 159                         Scan(p, 1, 1, v);
 160                         Scan(p, 1, -1, v);
 161                         Scan(p, -1, 1, v);
 162                         Scan(p, -1, -1, v);
 163                 }
 164                 else if (p.current_type == Piece.Type.ROOK)
 165                 {
 166                         Scan(p, 1, 0, v);
 167                         Scan(p, -1, 0, v);
 168                         Scan(p, 0, 1, v);
 169                         Scan(p, 0, -1, v);
 170                 }
 171                 else if (p.current_type == Piece.Type.QUEEN)
 172                 {
 173                         Scan(p, 1, 1, v);
 174                         Scan(p, 1, -1, v);
 175                         Scan(p, -1, 1, v);
 176                         Scan(p, -1, -1, v);
 177                         Scan(p, 1, 0, v);
 178                         Scan(p, -1, 0, v);
 179                         Scan(p, 0, 1, v);
 180                         Scan(p, 0, -1, v);
 181                 }
 182
 183         }
 184
 185         // determine if position is on the board
 186         public boolean Valid_position(int x, int y)
 187         {
 188                 return (x >= 0 && x <= Board.WIDTH-1 && y >= 0 && y <= Board.HEIGHT-1);
 189         }
 190
 191         private Square[][] grid;
 192
 193
 194         private Vector<Piece> white;
 195         private Vector<Piece> black;
 196         private Piece white_king;
 197         private Piece black_king;
 198
 199                 // Add a move to the vector if it is valid
 200         private void Move(Piece p, int x, int y, Vector<Square> v)
 201         {
 202                 if (Valid_position(x, y) && (grid[x][y].piece == null || grid[x][y].piece.colour != p.colour))
 203                 {
 204                         v.add(grid[x][y]);
 205                 }
 206         }
 207
 208                 // Add all valid moves in a direction, stopping at the first invalid move
 209         private void Scan(Piece p, int vx, int vy, Vector<Square> v)
 210         {
 211                 int x = p.x + vx;
 212                 int y = p.y + vy;
 213                 while (Valid_position(x, y) && (grid[x][y].piece == null || grid[x][y].piece.colour != p.colour))
 214                 {
 215                         v.add(grid[x][y]);
 216
 217                         if (grid[x][y].piece != null)
 218                                 break;
 219                         x += vx;
 220                         y += vy;
 221                 }
 222         }
 223 }
 224