def read_piece_on_square(driver, pos): class_on_square = read_class_of_square(driver, pos, "piece") if class_on_square is None: return None else: if "wr" in class_on_square: return Rook(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "wn" in class_on_square: return Knight(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "wb" in class_on_square: return Bishop(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "wq" in class_on_square: return Queen(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "wk" in class_on_square: return King(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "wp" in class_on_square: return Pawn(1, pos.X, pos.Y, True) # hack autoset the id to 1 if "br" in class_on_square: return Rook(1, pos.X, pos.Y, False) # hack autoset the id to 1 if "bn" in class_on_square: return Knight(1, pos.X, pos.Y, False) # hack autoset the id to 1 if "bb" in class_on_square: return Bishop(1, pos.X, pos.Y, False) # hack autoset the id to 1 if "bq" in class_on_square: return Queen(1, pos.X, pos.Y, False) # hack autoset the id to 1 if "bk" in class_on_square: return King(1, pos.X, pos.Y, False) # hack autoset the id to 1 if "bp" in class_on_square: return Pawn(1, pos.X, pos.Y, False) # hack autoset the id to 1
def setBoard(self): self.board = [[None for i in range(8)] for i in range(8)] for piece in self.board[1]: self.board[1][self.board[1].index(piece)] = Pawn( [1, self.board[1].index(piece)], "black") for piece in self.board[6]: self.board[6][self.board[6].index(piece)] = Pawn( [6, self.board[6].index(piece)], "white") self.board[0][0] = Rook([0, 0], "black") self.board[0][7] = Rook([0, 7], "black") self.board[0][1] = Knight([0, 1], "black") # black knight self.board[0][6] = Knight([0, 6], "black") # black knight self.board[0][2] = Bishop([0, 2], "black") # black bishop self.board[0][5] = Bishop([0, 5], "black") # black bishop self.board[0][3] = Queen([0, 3], "black") # black king self.board[0][4] = King([0, 4], "black") # black queen self.board[7][0] = Rook([7, 0], "white") self.board[7][7] = Rook([7, 7], "white") self.board[7][1] = Knight([7, 1], "white") # white knight self.board[7][6] = Knight([7, 6], "white") # white knight self.board[7][2] = Bishop([7, 2], "white") # white bishop self.board[7][5] = Bishop([7, 5], "white") # white bishop self.board[7][3] = Queen([7, 3], "white") # white king self.board[7][4] = King([7, 4], "white") # white queen
def __init__(self, screen): self.screen = screen self.is_whites_turn = True self.board = [[0 for j in range(NO_OF_COLS)] for i in range(NO_OF_ROWS)] self.board[0][0] = Rook(screen, 0, 0, "black") self.board[0][1] = Knight(screen, 0, 1, "black") self.board[0][2] = Bishop(screen, 0, 2, "black") self.board[0][3] = Queen(screen, 0, 3, "black") self.board[0][4] = King(screen, 0, 4, "black") self.board[0][5] = Bishop(screen, 0, 5, "black") self.board[0][6] = Knight(screen, 0, 6, "black") self.board[0][7] = Rook(screen, 0, 7, "black") self.board[7][0] = Rook(screen, 7, 0, "white") self.board[7][1] = Knight(screen, 7, 1, "white") self.board[7][2] = Bishop(screen, 7, 2, "white") self.board[7][3] = Queen(screen, 7, 3, "white") self.board[7][4] = King(screen, 7, 4, "white") self.board[7][5] = Bishop(screen, 7, 5, "white") self.board[7][6] = Knight(screen, 7, 6, "white") self.board[7][7] = Rook(screen, 7, 7, "white") for j in range(NO_OF_COLS): self.board[1][j] = Pawn(screen, 1, j, "black") for j in range(NO_OF_COLS): self.board[6][j] = Pawn(screen, 6, j, "white") self.to_highlight = []
def __init__(self): BOARD_SIZE = 518 super().__init__([BOARD_SIZE, BOARD_SIZE]) self.COLOR_RED = [255, 0, 0] self.PADDING = 10 self.BOX_SIDE_LENGTH = 60 self.BOX_BORDER_RADIUS = 5 self.image = pygame.image.load('assets/Chess_Board.png') self.blit(self.image, [0, 0]) # board but in matrix 6x6 self.array = [ [Rook(BLACK, 0, 0), Knight(BLACK, 1, 0), Queen(BLACK, 2, 0), King(BLACK, 3, 0), Knight(BLACK, 4, 0), Rook(BLACK, 5, 0)], [Pawn(BLACK, x, 1) for x in range(6)], [None for x in range(6)], [None for x in range(6)], [Pawn(WHITE, x, 4) for x in range(6)], [Rook(WHITE, 0, 5), Knight(WHITE, 1, 5), Queen(WHITE, 2, 5), King(WHITE, 3, 5), Knight(WHITE, 4, 5), Rook(WHITE, 5, 5)] ] # flatten 2d array and get only valid pieces to draw (delete None values) self.pieces = [ piece for row in self.array for piece in row if piece is not None] # generate valid moves for white player self.generate_valid_moves_for_player_pieces(WHITE, BLACK) self.sprites_group = pygame.sprite.Group() self.sprites_group.add(self.pieces)
def create_pieces(self): header = 'XABCDEFGHX' for i in range(self.size): self.board[0][i] = EmptyField('None', [0, i], header[i]) self.board[self.size - 1][i] = EmptyField('None', [i, self.size - 1], header[i]) for i in range(1, self.size - 1, 1): self.board[i][0] = EmptyField('None', [i, 0], (self.size - 1) - i) self.board[i][self.size - 1] = EmptyField('None', [i, self.size - 1], (self.size - 1) - i) self.board[1][1] = Rook('B', [1, 1]) self.board[1][8] = Rook('B', [1, 8]) self.board[8][1] = Rook('W', [8, 1]) self.board[8][8] = Rook('W', [8, 8]) self.board[1][2] = Knight('B', [1, 2]) self.board[1][7] = Knight('B', [1, 7]) self.board[8][2] = Knight('W', [8, 2]) self.board[8][7] = Knight('W', [8, 8]) self.board[1][3] = Bishop('B', [1, 3]) self.board[1][6] = Bishop('B', [1, 6]) self.board[8][3] = Bishop('W', [8, 3]) self.board[8][6] = Bishop('W', [8, 6]) self.board[1][4] = Queen('B', [1, 4]) self.board[8][4] = Queen('W', [8, 4]) self.board[1][5] = King('B', [1, 5]) self.board[8][5] = King('W', [8, 5]) for i in range(1, self.size - 1, 1): self.board[2][i] = Pawn('B', [2, i]) self.board[7][i] = Pawn('W', [7, i])
def newPieces(self): self.wPieces = [] self.bPieces = [] self.empty = [] for i in range(8): self.wPieces.append(Pawn('w', (i, 1), 10 + i)) self.bPieces.append(Pawn('b', (i, 6), 10 + i)) for i in [0, 7]: self.wPieces.append(Rook('w', (i, 0), 20 + i)) self.bPieces.append(Rook('b', (i, 7), 20 + i)) for i in [1, 6]: self.wPieces.append(Knight('w', (i, 0), 30 + i)) self.bPieces.append(Knight('b', (i, 7), 30 + i)) for i in [2, 5]: self.wPieces.append(Bishop('w', (i, 0), 40 + i)) self.bPieces.append(Bishop('b', (i, 7), 40 + i)) self.wPieces.append(Queen('w', (3, 0), 50)) self.bPieces.append(Queen('b', (3, 7), 50)) self.wPieces.append(King('w', (4, 0), 60)) self.bPieces.append(King('b', (4, 7), 60)) for i in range(8): self.empty.append(Empty((i, 2))) self.empty.append(Empty((i, 3))) self.empty.append(Empty((i, 4))) self.empty.append(Empty((i, 5))) self.allPieces = self.wPieces + self.bPieces + self.empty
def _fill_starting_board(self): """ Create all pieces and set them to their starting positions. """ pieces = [Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook] for x, piece_cls in enumerate(pieces): piece = piece_cls(self, x, 0, WHITE) if piece_cls == King: self.white_king = piece self.white_pieces.add(piece) self.fields[0][x] = piece piece = Pawn(self, x, 1, WHITE) self.fields[1][x] = piece self.white_pieces.add(piece) piece = piece_cls(self, x, 7, BLACK) if piece_cls == King: self.black_king == piece self.fields[7][x] = piece self.black_pieces.add(piece) piece = Pawn(self, x, 6, BLACK) self.fields[6][x] = piece self.black_pieces.add(piece)
def __init__(self): self.num_rows = 8 self.num_cols = 8 self.board = np.array([ [ Rook(0, 0, 'WHITE'), Knight(1, 0, 'WHITE'), Bishop(2, 0, 'WHITE'), King(3, 0, 'WHITE'), Queen(4, 0, 'WHITE'), Bishop(5, 0, 'WHITE'), Knight(6, 0, 'WHITE'), Rook(7, 0, 'WHITE') ], [Pawn(i, 1, 'WHITE') for i in range(self.num_cols)], [None for _ in range(self.num_cols)], [None for _ in range(self.num_cols)], [None for _ in range(self.num_cols)], [None for _ in range(self.num_cols)], [Pawn(i, 6, 'BLACK') for i in range(self.num_cols)], [ Rook(0, 7, 'BLACK'), Knight(1, 7, 'BLACK'), Bishop(2, 7, 'BLACK'), King(3, 7, 'BLACK'), Queen(4, 7, 'BLACK'), Bishop(5, 7, 'BLACK'), Knight(6, 7, 'BLACK'), Rook(7, 7, 'BLACK') ], ])
def CreateNewBoard(cls, fen=None): if fen: raise NotImplementedError() else: pieces = [Pawn((i, 1), "white") for i in range(8) ] + [Pawn((i, 6), "black") for i in range(8)] pieces.extend([ Rook((0, 0), "white"), Rook((7, 0), "white"), Rook((0, 7), "black"), Rook((7, 7), "black") ]) pieces.extend([ Knight((1, 0), "white"), Knight((6, 0), "white"), Knight((1, 7), "black"), Knight((6, 7), "black") ]) pieces.extend([ Bishop((2, 0), "white"), Bishop((5, 0), "white"), Bishop((2, 7), "black"), Bishop((5, 7), "black") ]) pieces.extend([King((4, 0), "white"), King((4, 7), "black")]) pieces.extend([Queen((3, 0), "white"), Queen((3, 7), "black")]) return cls(pieces, "white")
def init_all_pieces(self, is_captured=False, p_start_pos=False, k_start_pos=False): '''Initializes all chess pieces''' # Piece attributes self.pieces = { 'w_pawns': [Pawn(i + 1, is_captured=is_captured, start_pos=p_start_pos) for i in range(8)], 'b_pawns': [Pawn(i + 1, colour='Black', is_captured=is_captured, start_pos=p_start_pos) for i in range(8)], 'w_pieces': [ Rook(1, is_captured=is_captured), Knight(1, is_captured=is_captured), Bishop(1, is_captured=is_captured), Queen(is_captured=is_captured), King(is_captured=is_captured, start_pos=k_start_pos), Bishop(2, is_captured=is_captured), Knight(2, is_captured=is_captured), Rook(2, is_captured=is_captured), ], 'b_pieces': [ Rook(1, colour='Black', is_captured=is_captured), Knight(1, colour='Black', is_captured=is_captured), Bishop(1, colour='Black', is_captured=is_captured), Queen(colour='Black', is_captured=is_captured), King(colour='Black', is_captured=is_captured, start_pos=k_start_pos), Bishop(2, colour='Black', is_captured=is_captured), Knight(2, colour='Black', is_captured=is_captured), Rook(2, colour='Black', is_captured=is_captured), ] }
def set_pieces(self): for square in self.get_rank(2): square.piece = Pawn(Colors.WHITE, self) for square in self.get_rank(7): square.piece = Pawn(Colors.BLACK, self)
def init_pieces(self): # Init the pieces # black self.board[0][0].piece = Rook(0, 0, 'black', self) self.board[0][7].piece = Rook(0, 7, 'black', self) self.board[0][1].piece = Knight(0, 1, 'black', self) self.board[0][6].piece = Knight(0, 6, 'black', self) self.board[0][2].piece = Bishop(0, 2, 'black', self) self.board[0][5].piece = Bishop(0, 5, 'black', self) self.board[0][3].piece = Queen(0, 3, 'black', self) self.board[0][4].piece = King(0, 4, 'black', self) # white self.board[7][0].piece = Rook(7, 0, 'white', self) self.board[7][7].piece = Rook(7, 7, 'white', self) self.board[7][1].piece = Knight(7, 1, 'white', self) self.board[7][6].piece = Knight(7, 6, 'white', self) self.board[7][2].piece = Bishop(7, 2, 'white', self) self.board[7][5].piece = Bishop(7, 5, 'white', self) # self.board[4][2].piece = Bishop(4, 2, 'white', self) self.board[7][3].piece = Queen(7, 3, 'white', self) # self.board[3][7].piece = Queen(3, 7, 'white', self) self.board[7][4].piece = King(7, 4, 'white', self) for j in range(8): self.board[1][j].piece = Pawn(1, j, 'black', self) self.board[6][j].piece = Pawn(6, j, 'white', self)
def test_pawn_no_valid_moves(): board = Board() board.board[1][0] = Pawn(1, 0, 'b') white_pawn = Pawn(2, 0, 'w') white_pawn.valid_moves(board) actual = white_pawn.move_list expected = [] assert actual == expected
def test_en_passant(self): # add enemy piece that just double moved enemy_piece = Pawn(3, 4, "black") enemy_piece.setDoubleMoved(True) addPiece(enemy_piece, self.board) self.OUT = Pawn(2, 4, "white") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(3, 5))
def test_knight_valid_attack(): board = Board() knight = Knight(4, 4, 'w') board.board[6][5] = Pawn(6, 5, 'b') board.board[6][3] = Pawn(6, 3, 'b') board.board[5][6] = Pawn(5, 6, 'b') knight.valid_moves(board) actual = knight.attack_list expected = [[6, 3], [6, 5], [5, 6]] assert actual == expected
def test_queen_attacking(): board = Board() queen = Queen(4, 3, 'w') board.board[4][3] = queen board.board[5][4] = Pawn(5, 4, 'b') board.board[2][3] = Pawn(2, 3, 'b') queen.valid_moves(board) actual = queen.attack_list expected = [[2, 3], [5, 4]] assert actual == expected
def test_valid_move_reversal(self): """ This tests that a pieces valid moves successfully reverse based on their colour. """ bp = Pawn("black") wp = Pawn("white") self.assertEqual(wp.moves()[6][7], 1) self.assertEqual(bp.moves()[8][7], 1)
def setUp(self) -> None: self.player_turn = 1 self.chess_game = ChessGame() self.chess_board = self.chess_game.board self.chess_game.player_turn = self.player_turn self.start_space = Vec2(5, 5) self.king = King(team=self.player_turn) self.knight = Knight(team=self.player_turn) self.pawn = Pawn(team=self.player_turn) self.enemy_pawn = Pawn(team=2) self.p1_pawn = Pawn(team=1)
def test_target_area(self): other_friendly_piece = Tower(1, 5, "black") addPiece(other_friendly_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 5)) other_pawn = Pawn(2, 6, "black") addPiece(other_pawn, self.board) other_enemy_piece = Tower(2, 5, "white") addPiece(other_enemy_piece, self.board) self.assertFalse(other_pawn.checkValidTurn(2, 5)) other_enemy_piece2 = Tower(3, 5, "white") addPiece(other_enemy_piece2, self.board) self.assertTrue(other_pawn.checkValidTurn(3, 5))
def test_rook_attack_list(): board = Board() rook = Rook(4, 4, 'w') board.board[4][1] = Pawn(4, 1, 'b') board.board[4][2] = Pawn(4, 2, 'b') board.board[7][4] = Pawn(7, 4, 'b') board.board[0][4] = Pawn(0, 4, 'b') board.board[6][6] = Pawn(6, 6, 'b') rook.valid_moves(board) actual = rook.attack_list expected = [[0, 4], [7, 4], [4, 2]] assert actual == expected
class TestWhitePawn(PieceTestCase): def getPiece(self): return Pawn(1, 1, "white") def test_allowed_moves(self): self.assertTrue(self.OUT.checkValidTurn(1, 2)) self.assertTrue(self.OUT.checkValidTurn(1, 3)) self.OUT = Pawn(1, 3, "white") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(1, 4)) def test_disallowed_moves(self): self.assertFalse(self.OUT.checkValidTurn(2, 1)) self.assertFalse(self.OUT.checkValidTurn(1, 0)) self.assertFalse(self.OUT.checkValidTurn(1, 4)) self.assertFalse(self.OUT.checkValidTurn(1, 5)) self.assertFalse(self.OUT.checkValidTurn(2, 2)) self.OUT = Pawn(1, 3, "white") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 5)) def test_target_area(self): # check for collision with friendly piece other_friendly_piece = Tower(1, 2, "white") addPiece(other_friendly_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 2)) # add other pawn other_pawn = Pawn(2, 1, "white") addPiece(other_pawn, self.board) # check for collision with enemy piece other_enemy_piece = Tower(2, 2, "black") addPiece(other_enemy_piece, self.board) self.assertFalse(other_pawn.checkValidTurn(2, 2)) # check for valid move on enemy piece other_enemy_piece2 = Tower(3, 2, "black") addPiece(other_enemy_piece2, self.board) self.assertTrue(other_pawn.checkValidTurn(3, 2)) def test_out_of_board(self): self.OUT = Pawn(1, 7, "white") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 8)) def test_blockage(self): other_piece = Knight(1, 2, "white") addPiece(other_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 3)) def test_en_passant(self): # add enemy piece that just double moved enemy_piece = Pawn(3, 4, "black") enemy_piece.setDoubleMoved(True) addPiece(enemy_piece, self.board) self.OUT = Pawn(2, 4, "white") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(3, 5))
def setPawns(board): i = 1 j = 0 while j < len(board): board[i].append(Pawn(i,j,'black')) j += 1 i = 6 j = 0 while j < len(board): board[i].append(Pawn(i,j,'white')) j += 1
def populate_board(self): """ Initialize board with positions of pieces. """ self.board = [ [ Rook(owner='white', position=(0, 0)), Knight(owner='white', position=(1, 0)), Bishop(owner='white', position=(2, 0)), Queen(owner='white', position=(3, 0)), King(owner='white', position=(4, 0)), Bishop(owner='white', position=(5, 0)), Knight(owner='white', position=(6, 0)), Rook(owner='white', position=(7, 0)), ], [Pawn(owner='white', position=(i, 1)) for i in range(8)], *[[None] * 8 for _ in range(4)], [Pawn(owner='black', position=(i, 6)) for i in range(8)], [ Rook(owner='black', position=(0, 7)), Knight(owner='black', position=(1, 7)), Bishop(owner='black', position=(2, 7)), Queen(owner='black', position=(3, 7)), King(owner='black', position=(4, 7)), Bishop(owner='black', position=(5, 7)), Knight(owner='black', position=(6, 7)), Rook(owner='black', position=(7, 7)), ], ] self.char_board = [] for row in self.board: disp_row = [] for piece in row: if piece: disp_row.append(piece.cli_characterset) else: disp_row.append(None) self.char_board.append(disp_row) for i, row in enumerate(self.board): self.pieces_in_play['white'].extend( [piece for piece in row if i < 2]) self.pieces_in_play['black'].extend( [piece for piece in row if i > 5]) # Add reference to the kings for both players self.w_king = self.board[0][4] self.b_king = self.board[7][4]
def piecesInit(self): board = [[ None for j in range(8)] for i in range(8)] for i in range(8): board[1][i] = Pawn(1,i,"w") for i in range(8): board[6][i] = Pawn(6,i,"b") for color in [["w",0],["b",7]]: for i in [0,7]: board[color[1]][abs(i- 0)] = Rook(color[1], abs(i- 0), color[0]) board[color[1]][abs(i- 1)] = Knight(color[1], abs(i - 1), color[0]) board[color[1]][abs(i- 2)] = Bishop(color[1], abs(i - 2), color[0]) board[color[1]][3] = Queen(color[1],3,color[0]) board[color[1]][4] = King(color[1],4,color[0]) return board
def testGetPossibleMoves(self): pawn = self._board.GetPiece((4, 1)) self.assertListEqual(pawn.GetPossibleMoves(self._board, None), [(4, 2), (4, 3)]) self._board.Pieces.append(Pawn((4, 3), "black")) self.assertListEqual(pawn.GetPossibleMoves(self._board, None), [(4, 2)]) self._board.Pieces.append(Pawn((4, 2), "black")) self.assertListEqual(pawn.GetPossibleMoves(self._board, None), []) self._board.Pieces.append(Pawn((5, 2), "black")) self._board.Pieces.append(Pawn((3, 2), "white")) self.assertListEqual(pawn.GetPossibleMoves(self._board, None), [(5, 2)])
def setBoard(self): backRank, nextRank = 0, 1 if(self.color == "black"): backRank = 7 nextRank = 6 for piece in self.piecesNameList: if(piece == "r"): self.board[backRank][0] = Rook(self.color, (0, backRank)) self.board[backRank][7] = Rook(self.color, (7, backRank)) elif(piece == "n"): self.board[backRank][1] = Knight(self.color, (1, backRank)) self.board[backRank][6] = Knight(self.color, (6, backRank)) elif(piece == "b"): self.board[backRank][2] = Bishop(self.color, (2, backRank)) self.board[backRank][5] = Bishop(self.color, (5, backRank)) elif(piece == "q"): self.board[backRank][3] = Queen(self.color, (3, backRank)) elif(piece == "k"): self.board[backRank][4] = King(self.color, (4, backRank)) else: for file in range(0, 8): self.board[nextRank][file] = Pawn(self.color, (file, nextRank))
def makePiece(pieceString, x, y, color): """This method returns a piece in a given x, y, and color Args: x - x coordinate - integer y - y coordinate - integer color - White, Black Returns: Piece object """ if (pieceString == "King"): piece = King() elif (pieceString == "Queen"): piece = Queen() elif (pieceString == "Rook"): piece = Rook() elif (pieceString == "Bishop"): piece = Bishop() elif (pieceString == "Pawn"): piece = Pawn() elif (pieceString == "Knight"): piece = Knight() piece.setX(x) piece.setY(y) if (color == "White"): piece.setColor(0) if (color == "Black"): piece.setColor(1) return piece
def init(self): """Initialize board pieces.""" self._pieces = { BLACK: PList([]), WHITE: PList([]), } self._playing_color = WHITE for color in [BLACK, WHITE]: for pawn_n in range(8): x = 1 if color is TOP_COLOR else 6 y = pawn_n pawn = Pawn(x, y, color) self._add_piece(pawn) lign = 0 if color is TOP_COLOR else 7 self._add_piece(Bishop(lign, 2, color)) self._add_piece(Bishop(lign, 5, color)) self._add_piece(Knight(lign, 1, color)) self._add_piece(Knight(lign, 6, color)) self._add_piece(Rook(lign, 0, color)) self._add_piece(Rook(lign, 7, color)) if TOP_COLOR is BLACK: self._add_piece(Queen(lign, 3, color)) self._add_piece(King(lign, 4, color)) else: self._add_piece(King(lign, 3, color)) self._add_piece(Queen(lign, 4, color))
def unpack(packed_board): board = Board() board.clear() board.moves = eval(packed_board["moves"]) board.can_castle = eval(packed_board["can_castle"]) b = packed_board["board"] board.player_to_move = packed_board['player_to_move'] m = board.matrix for i in range(8): for j in range(8): square = b[i][j] if square == None: m[i][j] = 0 else: color = (square["color"] == "white") * 2 - 1 row = square["pos_row"] column = square["pos_col"] if square["type"] == "rook": Rook(color, row, column, board) elif square["type"] == "knight": Knight(color, row, column, board) elif square["type"] == "bishop": Bishop(color, row, column, board) elif square["type"] == "queen": Queen(color, row, column, board) elif square["type"] == "pawn": Pawn(color, row, column, board) elif square["type"] == "king": kk = King(color, row, column, board) if color == 1: board.white_king = kk else: board.black_king = kk return board
def undo_move(self): self.player_to_move *= -1 move = self.moves.pop() if move[6] == "0-0" or move[ 6] == "0-0-0": ## Undoing castling requires a good deal of special logic row = move[1] color = move[2] if move[6] == "0-0": #kingside squares = (King(color, row, 4, self), 0, 0, Rook(color, row, 7, self)) def col_func( j ): ## a quick helper function to grab the appropriate columns on the matrix return 4 + j rangee = 4 else: squares = (King(color, row, 4, self), 0, 0, 0, Rook(color, row, 0, self)) #queenside def col_func(j): return 4 - j rangee = 5 for i in range(rangee): self.matrix[row][col_func(i)] = squares[i] else: # If the last move wasn't castling, undo the piece move, and if it captured something, put the captured piece back on the board. self.matrix[move[0]][move[1]] = self.matrix[move[2]][move[3]] self.matrix[move[2]][move[3]] = move[4] if move[5] == True: #If there was an EnPassant capture, put a pawn on the appropriate square color = self.matrix[move[0]][move[1]].color self.matrix[move[0]][move[3]] = Pawn(-1 * color, move[0], move[3])
def create_pieces(self, config): self.pieces = [] self.king = None for pdict in config: if pdict['name'] == 'pawn': pawn = Pawn(pdict['coord'], pdict['c']) self.pieces.append(pawn) elif pdict['name'] == 'bishop': bishop = Bishop(pdict['coord'], pdict['c']) self.pieces.append(bishop) elif pdict['name'] == 'queen': queen = Queen(pdict['coord'], pdict['c']) self.pieces.append(queen) elif pdict['name'] == 'rock': rock = Rock(pdict['coord'], pdict['c']) self.pieces.append(rock) elif pdict['name'] == 'knight': knight = Knight(pdict['coord'], pdict['c']) self.pieces.append(knight) elif pdict['name'] == 'king': king = King(pdict['coord'], pdict['c']) self.pieces.append(king) self.king = king # get player's color self.color = self.king.color
def __init__(self): self.player_to_move = 1 # as per custom for app, 1 is white, and -1 is black. self.moves = [] self.matrix = [[0 for j in range(8)] for i in range(8)] pieces = (Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook) for i in range(8): for j in range(2): if j == 0: color = 1 row1 = 6 row2 = 7 else: color = -1 row1 = 1 row2 = 0 self.matrix[row1][i] = Pawn(color, row1, i, self) self.matrix[row2][i] = pieces[i](color, row2, i, self) self.EP = False self.white_king = self.matrix[7][4] self.black_king = self.matrix[0][4] self.can_castle = { "w00": True, "b00": True, "w000": True, "b000": True } ## 00 and 000 are chess shorthand for castling kingside and queenside, respectively
def test_piece_constructor(self): """Initialize any piece and check the all inner data has been stored correctly""" pawn: Pawn = Pawn(board.WHITE) self.assertEqual(pawn.color, board.WHITE) self.assertTrue(pawn.position.x is None) self.assertTrue(pawn.position.y is None) self.assertTrue(pawn.active) self.assertFalse(pawn.has_moved)
def test_disallowed_moves(self): self.assertFalse(self.OUT.checkValidTurn(2, 6)) self.assertFalse(self.OUT.checkValidTurn(1, 3)) self.assertFalse(self.OUT.checkValidTurn(1, 7)) self.assertFalse(self.OUT.checkValidTurn(1, 6)) self.OUT = Pawn(1, 4, "black") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 2))
class TestBlackPawn(PieceTestCase): """ on passant noch nicht im test promotion nicht im test """ def getPiece(self): return Pawn(1, 6, "black") def test_allowed_moves(self): self.assertTrue(self.OUT.checkValidTurn(1, 5)) self.assertTrue(self.OUT.checkValidTurn(1, 4)) self.OUT = Pawn(1, 4, "black") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(1, 3)) def test_disallowed_moves(self): self.assertFalse(self.OUT.checkValidTurn(2, 6)) self.assertFalse(self.OUT.checkValidTurn(1, 3)) self.assertFalse(self.OUT.checkValidTurn(1, 7)) self.assertFalse(self.OUT.checkValidTurn(1, 6)) self.OUT = Pawn(1, 4, "black") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 2)) def test_target_area(self): other_friendly_piece = Tower(1, 5, "black") addPiece(other_friendly_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 5)) other_pawn = Pawn(2, 6, "black") addPiece(other_pawn, self.board) other_enemy_piece = Tower(2, 5, "white") addPiece(other_enemy_piece, self.board) self.assertFalse(other_pawn.checkValidTurn(2, 5)) other_enemy_piece2 = Tower(3, 5, "white") addPiece(other_enemy_piece2, self.board) self.assertTrue(other_pawn.checkValidTurn(3, 5)) def test_out_of_board(self): self.OUT = Pawn(1, 0, "black") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, -1)) def test_blockage(self): other_piece = Knight(1, 5, "white") addPiece(other_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 4)) def test_en_passant(self): # add enemy piece that just double moved enemy_piece = Pawn(3, 3, "white") enemy_piece.setDoubleMoved(True) addPiece(enemy_piece, self.board) self.OUT = Pawn(2, 3, "black") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(3, 2))
def test_target_area(self): # check for collision with friendly piece other_friendly_piece = Tower(1, 2, "white") addPiece(other_friendly_piece, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 2)) # add other pawn other_pawn = Pawn(2, 1, "white") addPiece(other_pawn, self.board) # check for collision with enemy piece other_enemy_piece = Tower(2, 2, "black") addPiece(other_enemy_piece, self.board) self.assertFalse(other_pawn.checkValidTurn(2, 2)) # check for valid move on enemy piece other_enemy_piece2 = Tower(3, 2, "black") addPiece(other_enemy_piece2, self.board) self.assertTrue(other_pawn.checkValidTurn(3, 2))
def test_disallowed_moves(self): self.assertFalse(self.OUT.checkValidTurn(2, 1)) self.assertFalse(self.OUT.checkValidTurn(1, 0)) self.assertFalse(self.OUT.checkValidTurn(1, 4)) self.assertFalse(self.OUT.checkValidTurn(1, 5)) self.assertFalse(self.OUT.checkValidTurn(2, 2)) self.OUT = Pawn(1, 3, "white") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 5))
def test_king_attack(): board = Board() king = King(4, 4, 'w') board.board[4][4] = king board.board[3][4] = Pawn(3, 4, 'b') king.valid_moves(board) actual = king.attack_list expected = [[3, 4]] assert actual == expected
def test_out_of_board(self): self.OUT = Pawn(1, 7, "white") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, 8))
def test_allowed_moves(self): self.assertTrue(self.OUT.checkValidTurn(1, 2)) self.assertTrue(self.OUT.checkValidTurn(1, 3)) self.OUT = Pawn(1, 3, "white") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(1, 4))
def test_out_of_board(self): self.OUT = Pawn(1, 0, "black") addPiece(self.OUT, self.board) self.assertFalse(self.OUT.checkValidTurn(1, -1))
def test_allowed_moves(self): self.assertTrue(self.OUT.checkValidTurn(1, 5)) self.assertTrue(self.OUT.checkValidTurn(1, 4)) self.OUT = Pawn(1, 4, "black") addPiece(self.OUT, self.board) self.assertTrue(self.OUT.checkValidTurn(1, 3))