def create():
b = [[
Rook("black"),
Knight("black"),
Bishop("black"),
Queen("black"),
King("black"),
Bishop("black"),
Knight("black"),
Rook("black")
],
[
Pawn("black"),
Pawn("black"),
Pawn("black"),
Pawn("black"),
Pawn("black"),
Pawn("black"),
Pawn("black"),
Pawn("black")
]]
for i in range(2, 6):
b.append([
BlankPiece(),
BlankPiece(),
BlankPiece(),
BlankPiece(),
BlankPiece(),
BlankPiece(),
BlankPiece(),
BlankPiece()
])
b.append([
Pawn("white"),
Pawn("white"),
Pawn("white"),
Pawn("white"),
Pawn("white"),
Pawn("white"),
Pawn("white"),
Pawn("white")
])
b.append([
Rook("white"),
Knight("white"),
Bishop("white"),
Queen("white"),
King("white"),
Bishop("white"),
Knight("white"),
Rook("white")
])
return b
def test_cozio_s_mate():
""""""
game = Game([
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(6)] + [Pawn('black'), Empty()],
[Empty() for _ in range(5)] +
[Queen('black'), King('black'), Empty()],
[Empty() for _ in range(7)] + [Queen('white')],
[Empty() for _ in range(6)] + [King('white'), Empty()],
])
assert game.is_check('black'), print(game)
assert game.is_checkmate('black'), print(game)
def test_white_pawn_promotion():
__ = BlankPiece()
p1 = Pawn("white")
p2 = Pawn("white")
# Enemy rook
rr = Rook("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, rr, __, __], # 0
[__, __, p1, __, __, p2, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, __, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
# Left-most pawn
assert_length(board[1][2].get_attack_set(board, [1, 2], []), 0)
assert_contains(board[1][2].get_move_set(board, [1, 2], []), [
Move.pawn_promotion([1, 2], [0, 2], Queen("white")),
Move.pawn_promotion([1, 2], [0, 2], Bishop("white")),
Move.pawn_promotion([1, 2], [0, 2], Knight("white")),
Move.pawn_promotion([1, 2], [0, 2], Rook("white"))
])
assert_length(board[1][5].get_attack_set(board, [1, 5], []), 0)
assert_length(board[1][5].get_move_set(board, [1, 5], []), 0)
def promotioned(self, piece, l):
position = None
if piece.getcolor() == "White":
info = self.table.getwhitepieces()
else:
info = self.table.getblackpieces()
for i in range(0, len(info)):
if info[i].getid() == piece.getid():
position = i
break
if l == "Bishop":
k = info[position] = Bishop.Bishop(piece.getid(), piece.getcolor(),
piece.getx(), piece.gety())
self.table.updatepiece(info[position], info[position].getx(),
info[position].gety())
elif l == "Rook":
k = info[position] = Rook.Rook(piece.getid(), piece.getcolor(),
piece.getx(), piece.gety())
self.table.updatepiece(info[position], info[position].getx(),
info[position].gety())
elif l == "Queen":
k = info[position] = Queen.Queen(piece.getid(), piece.getcolor(),
piece.getx(), piece.gety())
self.table.updatepiece(info[position], info[position].getx(),
info[position].gety())
elif l == "Knight":
k = info[position] = Knight.Knight(piece.getid(), piece.getcolor(),
piece.getx(), piece.gety())
self.table.updatepiece(info[position], info[position].getx(),
info[position].gety())
else:
return None
return k
def test_stalemate():
# Opposite col test omitted as player color doesn't effect this test.
__ = BlankPiece()
wk = King("white")
r = Rook("black")
q = Queen("black")
bk = King("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, r, __, __, __, __, __, __], # 3
[__, __, __, __, __, __, __, bk], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, __, q, __, __, __], # 6
[wk, __, __, __, __, __, __, __] # 7
]
assert_false("White should NOT be a check state",
is_being_checked(board, "white"))
assert_true("White should be in stalemate",
is_stalemate(board, "white", []))
assert_false("Black should NOT be in stalemate state",
is_stalemate(board, "black", []))
def test_fail_castling_when_some_piece_is_between_king_rook(self):
board = Board(initial_pieces={
'e1': King('white'),
'f1': Queen('white'),
'h1': Rook('white')
})
self.assertRaises(ImpossibleMove, board.move, 'e1', 'g1')
def __init__(self, initial_pieces=None):
self.check = None
self.__turn = 'white'
self.__squares = {}
self.__initial_pieces = initial_pieces or {
'a1': Rook('white'),
'b1': Knight('white'),
'c1': Bishop('white'),
'd1': Queen('white'),
'e1': King('white'),
'f1': Bishop('white'),
'g1': Knight('white'),
'h1': Rook('white'),
'a2': Pawn('white'),
'b2': Pawn('white'),
'c2': Pawn('white'),
'd2': Pawn('white'),
'e2': Pawn('white'),
'f2': Pawn('white'),
'g2': Pawn('white'),
'h2': Pawn('white'),
'a8': Rook('black'),
'b8': Knight('black'),
'c8': Bishop('black'),
'd8': Queen('black'),
'e8': King('black'),
'f8': Bishop('black'),
'g8': Knight('black'),
'h8': Rook('black'),
'a7': Pawn('black'),
'b7': Pawn('black'),
'c7': Pawn('black'),
'd7': Pawn('black'),
'e7': Pawn('black'),
'f7': Pawn('black'),
'g7': Pawn('black'),
'h7': Pawn('black'),
}
for _x in x:
for _y in y:
self.__squares[_x + _y] = None
if _x + _y in self.__initial_pieces:
self.__squares[_x + _y] = self.__initial_pieces[_x + _y]
def __init__(self):
self.classic = ([
Rook.Rook(0, "White", 0, 0),
Knight.Knight(1, "White", 1, 0),
Bishop.Bishop(2, "White", 2, 0),
Queen.Queen(3, "White", 3, 0),
King.King(4, "White", 4, 0),
Bishop.Bishop(5, "White", 5, 0),
Knight.Knight(6, "White", 6, 0),
Rook.Rook(7, "White", 7, 0),
Pawn.Pawn(8, "White", 0, 1),
Pawn.Pawn(9, "White", 1, 1),
Pawn.Pawn(10, "White", 2, 1),
Pawn.Pawn(11, "White", 3, 1),
Pawn.Pawn(12, "White", 4, 1),
Pawn.Pawn(13, "White", 5, 1),
Pawn.Pawn(14, "White", 6, 1),
Pawn.Pawn(15, "White", 7, 1)
], [
Pawn.Pawn(16, "Black", 0, 6),
Pawn.Pawn(17, "Black", 1, 6),
Pawn.Pawn(18, "Black", 2, 6),
Pawn.Pawn(19, "Black", 3, 6),
Pawn.Pawn(20, "Black", 4, 6),
Pawn.Pawn(21, "Black", 5, 6),
Pawn.Pawn(22, "Black", 6, 6),
Pawn.Pawn(23, "Black", 7, 6),
Rook.Rook(24, "Black", 0, 7),
Knight.Knight(25, "Black", 1, 7),
Bishop.Bishop(26, "Black", 2, 7),
King.King(27, "Black", 4, 7),
Queen.Queen(28, "Black", 3, 7),
Bishop.Bishop(29, "Black", 5, 7),
Knight.Knight(30, "Black", 6, 7),
Rook.Rook(31, "Black", 7, 7)
])
self.table = Table.Table(self.classic[0], self.classic[1])
self.shift = "White"
self.player1 = ("Player 1", "White")
self.player2 = ("Player 2", "Black")
self.winner = None
self.finish = False
def move(self, from_, to):
piece = self.board[from_]
# If a Pawn reaches eigth rank then replace by a queen.
if isinstance(piece, Pawn) and to[0] in [0, 7]:
piece = Queen(self.current_color)
self.board[to] = piece
self.board[from_] = Empty(None, self)
self.current_color = self.opponent_color()
return self
def back_row(self, color):
return [
Tower(color, self),
Horse(color, self),
Bishop(color, self),
King(color, self),
Queen(color, self),
Bishop(color, self),
Horse(color, self),
Tower(color, self),
]
def test_queen():
piece = Queen(Color.BLACK, Position(x=3, y=3))
assert piece.can_move_to(Position(x=7, y=3))
assert piece.can_move_to(Position(x=3, y=7))
assert piece.can_move_to(Position(x=2, y=2))
assert piece.can_move_to(Position(x=4, y=4))
assert piece.can_move_to(Position(x=1, y=5))
# Knight
assert not piece.can_move_to(Position(x=4, y=5))
assert not piece.can_move_to(Position(x=2, y=5))
assert not piece.can_move_to(Position(x=4, y=1))
assert not piece.can_move_to(Position(x=2, y=1))
assert not piece.can_move_to(Position(x=1, y=2))
assert not piece.can_move_to(Position(x=1, y=4))
assert not piece.can_move_to(Position(x=5, y=2))
assert not piece.can_move_to(Position(x=5, y=4))
def test_serialization():
__ = BlankPiece()
wp = Pawn("white")
bp = Pawn("black")
br = Rook("black")
bh = Knight("black")
bb = Bishop("black")
bq = Queen("black")
bk = King("black")
# 0 1 2 3 4 5 6 7
board = [
[br, bh, bb, bq, bk, __, __, __], # 0
[bp, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, __, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, __], # 5
[wp, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
serializable_gameboard = convert_to_string_gameboard(board)
expected_gameboard = [
['br', 'bh', 'bb', 'bq', 'bk', '_', '_', '_'],
['bp', '_', '_', '_', '_', '_', '_', '_'],
['_', '_', '_', '_', '_', '_', '_', '_'],
['_', '_', '_', '_', '_', '_', '_', '_'],
['_', '_', '_', '_', '_', '_', '_', '_'],
['_', '_', '_', '_', '_', '_', '_', '_'],
['wp', '_', '_', '_', '_', '_', '_', '_'],
['_', '_', '_', '_', '_', '_', '_', '_']
]
assert_length(serializable_gameboard, 8)
assert_length(serializable_gameboard[3], 8)
if expected_gameboard != serializable_gameboard:
raise AssertionError("Expected gameboard" + str(expected_gameboard) + " but was " + str(serializable_gameboard))
new_board = convert_from_string_gameboard(expected_gameboard)
for i in range(0, len(board)):
for j in range(0, len(board[0])):
expected_piece = board[i][j]
actual_piece = new_board[i][j]
if expected_piece.type != actual_piece.type:
raise AssertionError("Expected piece type at " + str(i) + ", " + str(j) + " was " + expected_piece.type
+ ", but got " + actual_piece.type)
if expected_piece.col != actual_piece.col:
raise AssertionError("Expected piece col at " + str(i) + ", " + str(
j) + " was " + expected_piece.col + " but got " + actual_piece.col)
def test_damiano_s_bishop_mate():
""""""
game = Game([
[Empty() for _ in range(5)] +
[King('black'), Empty(), Empty()],
[Empty() for _ in range(5)] +
[Queen('white'), Empty(), Empty()],
[Empty()
for _ in range(6)] + [Bishop('white'), Empty()],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(7)] + [King('white')],
])
assert game.is_check('black'), print(game)
assert game.is_checkmate('black'), print(game)
def test_check():
# Opposite col test omitted as it requires an alternate implementation *and* player color doesn't effect this test.
_ = BlankPiece()
k = King("white")
k.has_never_moved = False
p = Pawn("black")
p.has_never_moved = False
# 0 1 2 3 4 5 6 7
board = [
[_, _, _, _, _, _, _, _], # 0
[_, _, _, _, _, _, _, _], # 1
[_, _, _, _, _, p, _, _], # 2
[_, _, _, _, k, _, _, _], # 3
[_, _, _, _, _, _, _, _], # 4
[_, _, _, _, _, _, _, _], # 5
[_, _, _, _, _, _, _, _], # 6
[_, _, _, _, _, _, _, _] # 7
]
assert_true("King should be checked", is_being_checked(board, "white"))
# Enemy rook
r = Rook("black")
q = Queen("black")
# 0 1 2 3 4 5 6 7
board = [
[_, _, _, _, _, _, _, _], # 0
[_, _, _, _, _, _, _, _], # 1
[_, _, _, _, _, _, _, _], # 2
[_, _, _, _, _, _, _, _], # 3
[_, _, _, _, _, _, _, _], # 4
[_, _, _, _, _, _, _, _], # 5
[_, _, _, _, _, _, r, _], # 6
[_, _, k, _, _, _, _, q] # 7
]
assert_false("Should be checkmate",
can_player_leave_check_state(board, "white", []))
def convert_from_string_gameboard(serializable_gameboard):
"""
Get gameboard from the serializable entity.
Note: This information is only useful for display purposes. (information such as whether castling is still a
valid move does not exist here).
:param game_board: list of lists containing "wp" or "bk" to represent white pawn or black knight.
:return: list of list containing instances of the Piece class
"""
gameboard = []
for row in serializable_gameboard:
gameboard_row = []
for piece in row:
piece_col = ""
if piece == "_":
gameboard_row.append(BlankPiece())
else:
if piece[0] == "w":
piece_col = "white"
elif piece[0] == "b":
piece_col = "black"
if piece[1] == "r":
gameboard_row.append(Rook(piece_col))
elif piece[1] == "h":
gameboard_row.append(Knight(piece_col))
elif piece[1] == "b":
gameboard_row.append(Bishop(piece_col))
elif piece[1] == "q":
gameboard_row.append(Queen(piece_col))
elif piece[1] == "k":
gameboard_row.append(King(piece_col))
elif piece[1] == "p":
gameboard_row.append(Pawn(piece_col))
gameboard.append(gameboard_row)
return gameboard
class TestPawn(unittest.TestCase):
def setUp(self):
self.coords = Coordinates('d', 4)
self.queen = Queen(self.coords, 'white')
def test_queen_initialization(self):
self.assertEqual(self.queen.coordinates, self.coords)
def test_queen_position(self):
self.assertTupleEqual((3, 3), self.queen.position)
def test_queen_resource_name(self):
self.assertEqual('white_queen.png', self.queen.resource_name)
def test_queen_can_move_ahead(self):
new_coord = Coordinates('d', 5)
self.assertTrue(self.queen.can_move_to(new_coord))
def test_queen_can_move_behind(self):
new_coord = Coordinates('d', 3)
self.assertTrue(self.queen.can_move_to(new_coord))
def test_queen_can_move_to_left(self):
new_coord = Coordinates('c', 4)
self.assertTrue(self.queen.can_move_to(new_coord))
def test_queen_can_move_to_right(self):
new_coord = Coordinates('e', 4)
self.assertTrue(self.queen.can_move_to(new_coord))
def test_queen_can_move_more_than_one_tile(self):
new_coord = Coordinates('d', 8)
self.assertTrue(self.queen.can_move_to(new_coord))
def test_queen_can_move_diagonally(self):
new_coord = Coordinates('e', 5)
self.assertTrue(self.queen.can_move_to(new_coord))
import unittest
from chess.pieces import Queen
queen = Queen()
class TestQueen(unittest.TestCase):
def test_get_moves(self):
self.assertEqual(
queen.get_moves("E4"),
sorted([
"F3", "F4", "F5", "E5", "E3", "D3", "D4", "D5", "C2", "B1",
"G6", "H7", "G2", "H1", "C6", "B7", "A8", "C4", "B4", "A4",
"G4", "H4", "E1", "E2", "E6", "E7", "E8"
]))
if __name__ == "__main__":
unittest.main()
def test_queen_move_as_rook(self):
queen = Queen('white')
self.assertTrue(queen.can_move('d5', 'd8'))
self.assertTrue(queen.can_move('e2', 'h2'))
def test_queen_move_as_bishop(self):
queen = Queen('white')
self.assertTrue(queen.can_move('f1', 'g2'))
self.assertTrue(queen.can_move('f1', 'a6'))
def test_fail_queen_move(self):
queen = Queen('white')
self.assertFalse(queen.can_move('a1', 'h7'))
self.assertFalse(queen.can_move('d4', 'f5'))
def test_queen_name(self):
queen = Queen('white')
self.assertEqual('Queen', queen.name)
from chess.pieces import Tower
from chess.pieces import Horse
from chess.pieces import Bishop
from chess.pieces import King
from chess.pieces import Queen
from chess.pieces import Pawn
from chess.pieces import Empty
import pytest
from itertools import product
pieces = [
King('white'),
Queen('white'),
Horse('white'),
Bishop('white'),
Tower('white'),
Pawn('white'),
]
@pytest.mark.parametrize("piece", pieces)
def test_no_moves_outside_board(piece):
"""Test that a piece cannot move outside the board."""
for i in range(8):
for j in range(8):
new_board = Board([[Empty() for i in range(8)] for j in range(8)])
new_board[i, j] = piece
for move in piece.moves():
def test_queen_is_black(self):
queen = Queen('black')
self.assertEqual('black', queen.color)
def test_queen_is_white(self):
queen = Queen('white')
self.assertEqual('white', queen.color)
def setUp(self):
self.coords = Coordinates('d', 4)
self.queen = Queen(self.coords, 'white')
def test_queen_can_moves_as_bishop():
queen = Queen('white')
board = Board(initial_pieces={'f1': queen})
board.move('f1', 'g2')
assert board.get_piece('g2') is queen
assert board.get_piece('f1') is None
def test_create_pieces(self):
self.assertEqual(create_piece('k'), King())
self.assertEqual(create_piece('q'), Queen())
self.assertEqual(create_piece('b'), Bishop())
self.assertEqual(create_piece('r'), Rook())
self.assertEqual(create_piece('n'), Knight())
def test_cant_moves():
board = Board(initial_pieces={'a1': Queen('white')})
with pytest.raises(ImpossibleMove):
board.move('a1', 'h7')
def test_sliding_pieces(player_col, opponent_col):
_ = BlankPiece()
r = Rook(player_col)
b = Bishop(player_col)
q = Queen(player_col)
# Enemy rook
e = Rook(opponent_col)
# Friendly Pawn
f = Pawn(player_col)
f.has_never_moved = False
# 0 1 2 3 4 5 6 7
board = [
[r, _, _, e, _, _, _, _], # 0
[_, _, _, _, _, _, r, _], # 1
[_, _, q, _, _, _, f, _], # 2
[_, _, _, _, _, _, _, _], # 3
[_, _, _, _, _, _, _, _], # 4
[_, _, _, b, _, _, _, _], # 5
[_, _, _, _, _, _, _, _], # 6
[_, _, e, _, _, _, _, f] # 7
]
# Top-left rook
assert_length(board[0][0].get_move_set(board, [0, 0], []), 0)
assert_contains(
board[0][0].get_attack_set(board, [0, 0], []),
create_list_of_moves(
MoveType.NORMAL,
[0, 0],
[ # Down
[1, 0],
[2, 0],
[3, 0],
[4, 0],
[5, 0],
[6, 0],
[7, 0],
# Right
[0, 1],
[0, 2],
[0, 3]
]))
# Second rook
assert_length(board[1][6].get_move_set(board, [1, 6], []), 0)
assert_contains(
board[1][6].get_attack_set(board, [1, 6], []),
create_list_of_moves(
MoveType.NORMAL,
[1, 6],
[ # Up
[0, 6],
# Left
[1, 5],
[1, 4],
[1, 3],
[1, 2],
[1, 1],
[1, 0],
# Right
[1, 7]
]))
# Bishop
assert_length(board[5][3].get_move_set(board, [5, 3], []), 0)
assert_contains(
board[5][3].get_attack_set(board, [5, 3], []),
create_list_of_moves(
MoveType.NORMAL,
[5, 3],
[ # North-west
[4, 2],
[3, 1],
[2, 0],
# North-east
[4, 4],
[3, 5],
# South-west
[6, 2],
[7, 1],
# South-east
[6, 4],
[7, 5]
]))
# Queen
assert_length(board[2][2].get_move_set(board, [2, 2], []), 0)
assert_contains(
board[2][2].get_attack_set(board, [2, 2], []),
create_list_of_moves(
MoveType.NORMAL,
[2, 2],
[ # Down
[3, 2],
[4, 2],
[5, 2],
[6, 2],
[7, 2],
# Up
[1, 2],
[0, 2],
# Left
[2, 0],
[2, 1],
# Right
[2, 3],
[2, 4],
[2, 5],
# North-west
[1, 1],
# North-east
[1, 3],
[0, 4],
# South-west
[3, 1],
[4, 0],
# South-east
[3, 3],
[4, 4],
[5, 5],
[6, 6]
]))
def test_queen_can_moves_as_rook():
queen = Queen('white')
board = Board(initial_pieces={'d5': queen})
board.move('d5', 'd8')
assert board.get_piece('d8') is queen
assert board.get_piece('d5') is None
