class TestPawn(unittest.TestCase):
def setUp(self):
self.coords = Coordinates('d', 4)
self.bishop = Bishop(self.coords, 'white')
def test_bishop_initialization(self):
self.assertEqual(self.bishop.coordinates, self.coords)
def test_bishop_position(self):
self.assertTupleEqual((3, 3), self.bishop.position)
def test_bishop_resource_name(self):
self.assertEqual('white_bishop.png', self.bishop.resource_name)
def test_bishop_cant_move_ahead(self):
new_coord = Coordinates('d', 5)
self.assertFalse(self.bishop.can_move_to(new_coord))
def test_bishop_cant_move_behind(self):
new_coord = Coordinates('d', 3)
self.assertFalse(self.bishop.can_move_to(new_coord))
def test_bishop_cant_move_to_the_left(self):
new_coord = Coordinates('c', 4)
self.assertFalse(self.bishop.can_move_to(new_coord))
def test_bishop_cant_move_to_the_right(self):
new_coord = Coordinates('e', 4)
self.assertFalse(self.bishop.can_move_to(new_coord))
def test_bishop_can_move_diagonally(self):
new_coord = Coordinates('e', 5)
self.assertTrue(self.bishop.can_move_to(new_coord))
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 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_blackburne_s_mate():
""""""
game = Game([
[Empty() for _ in range(5)] +
[Tower('black'), King('black'), Empty()],
[Empty() for _ in range(7)] + [Bishop('white')],
[Empty() for _ in range(8)],
[Empty() for _ in range(6)] + [Horse('white'), Empty()],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty(), Bishop('white')] + [Empty() for _ in range(6)],
[Empty() for _ in range(8)],
])
assert game.is_check('black'), print(game)
assert game.is_checkmate('black'), print(game)
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_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 test_bodens_mate():
""""""
game = Game([
[Empty(), Empty()] + [King('black'), Tower('black')] +
[Empty() for _ in range(4)],
[Empty()
for _ in range(3)] + [Pawn('black')] + [Empty() for _ in range(4)],
[Bishop('white')] + [Empty() for _ in range(7)],
[Empty() for _ in range(8)],
[Empty() for _ in range(5)] +
[Bishop('white'), Empty(), Empty()],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
])
assert game.is_check('black'), print(game)
assert game.is_checkmate('black'), print(game)
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 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_bishop():
piece = Bishop(Color.BLACK, Position(x=3, y=3))
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=2, y=4))
# Rook
assert not piece.can_move_to(Position(x=4, y=3))
assert not piece.can_move_to(Position(x=3, y=2))
# 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_bishop_and_knight_mate():
""""""
game = Game([
[Empty() for _ in range(7)] + [King('black')],
[Empty() for _ in range(8)],
[Empty() for _ in range(5)] +
[Bishop('white'), King('white'),
Horse('white')],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
[Empty() for _ in range(8)],
])
assert game.is_check('black'), print(game)
assert game.is_checkmate('black'), print(game)
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 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
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_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_bishop_can_moves():
bishop = Bishop('White')
board = Board(initial_pieces={'f1': bishop})
board.move('f1', 'h3')
assert board.get_piece('h3') is bishop
assert board.get_piece('f1') is None
def test_insufficient_material_states():
__ = BlankPiece()
wk = King("white")
bk = King("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, wk, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
assert_true("Just kings should impossible to checkmate",
is_impossible_to_reach_checkmate(board))
bB = Bishop("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, wk, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, __, bB, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
assert_true("King vs King and bishop should be impossible to checkmate",
is_impossible_to_reach_checkmate(board))
bH = Knight("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, wk, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, __, bH, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
assert_true("King vs King and Knight should be impossible checkmate",
is_impossible_to_reach_checkmate(board))
wb = Bishop("white")
bb = Bishop("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, wk, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, wb], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, bb], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
assert_true(
"King and Bishop vs King and Bishop should be impossible if they are on the same color square",
is_impossible_to_reach_checkmate(board))
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, wk, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, wb], # 3
[__, __, bk, __, __, __, __, bb], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
assert_false(
"King and Bishop vs King and Bishop should be POSSIBLE to reach checkmate if they're on different "
"colours", is_impossible_to_reach_checkmate(board))
# Does not matter the amount of Bishops as long as they are on the same color square
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, wb, __, __], # 1
[__, __, wk, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, wb], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, wb, __, bb], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, wb] # 7
]
assert_true(
"King and Bishop(s) vs King and Bishop(s) should be impossible if they are on the same color square",
is_impossible_to_reach_checkmate(board))
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, wb, __, __], # 1
[__, __, wk, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, wb], # 3
[__, __, bk, __, __, __, __, __], # 4
[__, __, __, __, __, wb, __, bb], # 5
[__, __, __, __, __, __, __, wb], # 6
[__, __, __, __, __, __, __, wb] # 7
]
assert_false(
"King and Bishop(s) vs King and Bishop(s) should be POSSIBLE as not all on same color square",
is_impossible_to_reach_checkmate(board))
def test_instantiate_with_different_cases(self):
self.assertIsInstance(Bishop('WhItE'), Bishop)
self.assertIsInstance(Bishop('wHiTe'), Bishop)
self.assertIsInstance(Bishop('White'), Bishop)
def test_pieces_should_have_correct_name():
assert Bishop('white').name == 'White Bishop'
def test_can_instantiate_with_different_cases():
assert isinstance(Bishop('WhItE'), Bishop)
assert isinstance(Bishop('wHiTe'), Bishop)
def test_pieces_cant_be_instatiated_with_invalid_color():
with pytest.raises(InvalidChessColor):
Bishop('blue')
def test_pieces_should_have_correct_color():
assert Bishop('black').color == 'black'
assert Bishop('white').color == 'white'
def test_bishop_is_black(self):
bishop = Bishop('black')
self.assertEqual('black', bishop.color)
def test_bishop_name(self):
bishop = Bishop('white')
self.assertEqual('Bishop', bishop.name)
def test_bishop_is_white(self):
bishop = Bishop('white')
self.assertEqual('white', bishop.color)
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():
assert move in product(
range(8),
def test_bishop_move(self):
bishop = Bishop('white')
self.assertTrue(bishop.can_move('f1', 'g2'))
self.assertTrue(bishop.can_move('f1', 'a6'))
def test_bishop_cant_moves():
board = Board(initial_pieces={'f1': Bishop('White')})
with pytest.raises(ImpossibleMove):
board.move('f1', 'f3')
def test_fail_bishop_move(self):
bishop = Bishop('white')
self.assertFalse(bishop.can_move('f1', 'f2'))
self.assertFalse(bishop.can_move('a1', 'a3'))
