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_conducting_col_h_castle_move():
board = get_castling_board()
col_h_castle = Move(MoveType.CASTLING, [7, 4], [7, 6])
board, move_history_element = conduct_move(board, col_h_castle, "white")
_ = BlankPiece()
expected_row = [Rook("white"), _, _, _, _, Rook("white"), King("white"), _]
actual_row = board[7]
assert_row_contain_same_type_elements(expected_row, actual_row)
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 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 test_king_can_do_castling_to_left():
board = Board(initial_pieces={'e1': King('white'), 'a1': Rook('white')})
king = board.get_piece('e1')
rook = board.get_piece('a1')
board.move('e1', 'c1')
assert board.get_piece('c1') == king
assert board.get_piece('d1') == rook
assert board.get_piece('e1') is None
assert board.get_piece('a1') is None
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_raise_exception_when_player_doesnt_get_out_of_check(self):
board = Board({
'e1': King('black'),
'f8': Rook('white'),
'a1': King('white')
})
self.assertIsNone(board.check)
board.move('f8', 'e8')
self.assertEqual('black', board.check)
self.assertRaises(ImpossibleMove, board.move, 'e1', 'e2')
def test_check_if_player_is_not_in_check_anymore(self):
board = Board({
'e1': King('black'),
'f8': Rook('white'),
'a1': King('white')
})
self.assertIsNone(board.check)
board.move('f8', 'e8')
self.assertEqual('black', board.check)
board.move('e1', 'f1')
self.assertIsNone(board.check)
def test_player_should_to_get_out_of_check():
board = Board({
'e1': King('black'),
'f8': Rook('white'),
'a1': King('white')
})
assert board.check is None
board.move('f8', 'e8')
assert board.check == 'black'
with pytest.raises(ImpossibleMove):
board.move('e1', 'e2')
def test_players_can_get_out_of_check():
board = Board({
'e1': King('black'),
'f8': Rook('white'),
'a1': King('white')
})
assert board.check is None
board.move('f8', 'e8')
assert board.check == 'black'
board.move('e1', 'f1')
assert board.check is None
def test_fail_castling_when_king_already_moved():
board = Board(initial_pieces={
'a8': King('black'),
'a7': Pawn('black'),
'e1': King('white'),
'h1': Rook('white')})
board.move('e1', 'f1') # king moves
board.move('a7', 'a6') # pawn moves
board.move('f1', 'e1') # king moves back
board.move('a6', 'a5') # pawn moves again
with pytest.raises(ImpossibleMove):
board.move('e1', 'g1')
def test_castling_left_white(self):
board = Board(initial_pieces={
'e1': King('white'),
'a1': Rook('white')
})
king = board.squares['e1']
rook = board.squares['a1']
board.move('e1', 'c1')
self.assertIs(king, board.squares['c1'])
self.assertIs(rook, board.squares['d1'])
self.assertIsNone(board.squares['e1'])
self.assertIsNone(board.squares['a1'])
def test_rook():
piece = Rook(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))
# Bishop
assert not piece.can_move_to(Position(x=1, y=1))
# 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))
assert not piece.was_move
piece.move_to(Position(x=5, y=3))
assert piece.was_move
def get_castling_board():
# Home rank is just a constant in the castling implementation
# so it's asserted unit testing only white piece's castling is sufficient
__ = BlankPiece()
p = Pawn("white")
k = King("white")
r1 = Rook("white")
r2 = Rook("white")
# 0 1 2 3 4 5 6 7
return [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, __, __, __, __, __, __, __], # 3
[__, __, __, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, p, p, p, __, __], # 6
[r1, __, __, __, k, __, __, r2] # 7
]
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_fail_castling_when_king_already_moved(self):
board = Board(
initial_pieces={
'a8': King('black'),
'a7': Pawn('black'),
'e1': King('white'),
'h1': Rook('white')
})
board.move('e1', 'f1')
board.move('a7', 'a6') # pawn moves
board.move('f1', 'e1')
board.move('a6', 'a5') # pawn moves
self.assertRaises(ImpossibleMove, board.move, 'e1', 'g1')
def test_castling_left_black(self):
board = Board(initial_pieces={
'a2': Pawn('white'),
'e8': King('black'),
'a8': Rook('black')
})
king = board.squares['e8']
rook = board.squares['a8']
board.move('a2', 'a3') # just because white have to move first
board.move('e8', 'c8')
self.assertIs(king, board.squares['c8'])
self.assertIs(rook, board.squares['d8'])
self.assertIsNone(board.squares['e8'])
self.assertIsNone(board.squares['a8'])
def get_fifty_move_rule_board():
"""
Helper function to run through the first 3 moves in a "four move rule" (use a smaller deque for sanity here -- 50
is a lot),
"""
#
conducted_move_history = deque([], 4)
__ = BlankPiece()
wk = King("white")
wp = Pawn("white")
br = Rook("black")
bk = King("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, bk, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, br, __, __, __, __, __, __], # 3
[__, __, __, __, __, __, __, __], # 4
[__, __, __, __, __, __, __, __], # 5
[__, wp, __, __, __, __, __, __], # 6
[__, __, __, __, wk, __, __, __] # 7
]
msg = "Should NOT be 50-move rule draw"
board, move_history_element = conduct_move(
board, Move(MoveType.NORMAL, [7, 4], [7, 1]), "white")
conducted_move_history.append(move_history_element)
assert_false(msg, is_fifty_move_rule_draw(conducted_move_history))
board, move_history_element = conduct_move(
board, Move(MoveType.NORMAL, [7, 1], [7, 2]), "white")
conducted_move_history.append(move_history_element)
assert_false(msg, is_fifty_move_rule_draw(conducted_move_history))
board, move_history_element = conduct_move(
board, Move(MoveType.NORMAL, [7, 2], [7, 3]), "white")
conducted_move_history.append(move_history_element)
assert_false(msg, is_fifty_move_rule_draw(conducted_move_history))
return board, conducted_move_history
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 test_white_pawn_movements():
__ = BlankPiece()
p1 = Pawn("white")
p2 = Pawn("white")
p3 = Pawn("white")
p3.has_never_moved = False
# Enemy rook
rr = Rook("black")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[__, __, __, __, __, __, __, __], # 1
[__, __, __, __, __, __, __, __], # 2
[__, __, __, __, __, __, rr, rr], # 3
[__, __, __, __, __, __, __, p3], # 4
[__, __, __, __, rr, __, __, __], # 5
[p1, __, __, __, __, p2, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
# Left-most pawn
assert_length(board[6][0].get_attack_set(board, [6, 0], []), 0)
assert_contains(
board[6][0].get_move_set(board, [6, 0], []),
create_list_of_moves(MoveType.NORMAL, [6, 0], [[5, 0], [4, 0]]))
assert_contains(board[6][5].get_attack_set(board, [6, 5], []),
create_list_of_moves(MoveType.NORMAL, [6, 5], [[5, 4]]))
assert_contains(
board[6][5].get_move_set(board, [6, 5], []),
create_list_of_moves(MoveType.NORMAL, [6, 5], [[5, 5], [4, 5]]))
assert_contains(board[4][7].get_attack_set(board, [4, 7], []),
create_list_of_moves(MoveType.NORMAL, [4, 7], [[3, 6]]))
assert_length(board[4][7].get_move_set(board, [4, 7], []), 0)
def test_black_pawn_movements():
__ = BlankPiece()
p1 = Pawn("black")
p2 = Pawn("black")
p3 = Pawn("black")
# Enemy rook
rr = Rook("white")
# 0 1 2 3 4 5 6 7
board = [
[__, __, __, __, __, __, __, __], # 0
[p1, __, __, __, __, p2, __, __], # 1
[__, __, __, __, rr, __, __, __], # 2
[__, __, __, __, __, __, __, p3], # 3
[__, __, __, __, __, __, rr, rr], # 4
[__, __, __, __, __, __, __, __], # 5
[__, __, __, __, __, __, __, __], # 6
[__, __, __, __, __, __, __, __] # 7
]
# Left-most pawn
assert_length(board[1][0].get_attack_set(board, [1, 0], []), 0)
assert_contains(
board[1][0].get_move_set(board, [1, 0], []),
create_list_of_moves(MoveType.NORMAL, [1, 0], [[2, 0], [3, 0]]))
assert_contains(board[1][5].get_attack_set(board, [1, 5], []),
create_list_of_moves(MoveType.NORMAL, [1, 5], [[2, 4]]))
assert_contains(
board[1][5].get_move_set(board, [1, 5], []),
create_list_of_moves(MoveType.NORMAL, [1, 5], [[2, 5], [3, 5]]))
assert_contains(board[3][7].get_attack_set(board, [3, 7], []),
create_list_of_moves(MoveType.NORMAL, [3, 7], [[4, 6]]))
assert_length(board[3][7].get_move_set(board, [3, 7], []), 0)
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.rook = Rook(self.coords, 'white')
def test_rook_initialization(self):
self.assertEqual(self.rook.coordinates, self.coords)
def test_rook_position(self):
self.assertTupleEqual((3, 3), self.rook.position)
def test_rook_resource_name(self):
self.assertEqual('white_rook.png', self.rook.resource_name)
def test_rook_can_move_ahead(self):
new_coord = Coordinates('d', 5)
self.assertTrue(self.rook.can_move_to(new_coord))
def test_rook_can_move_behind(self):
new_coord = Coordinates('d', 3)
self.assertTrue(self.rook.can_move_to(new_coord))
def test_rook_can_move_to_left(self):
new_coord = Coordinates('c', 4)
self.assertTrue(self.rook.can_move_to(new_coord))
def test_rook_can_move_to_right(self):
new_coord = Coordinates('e', 4)
self.assertTrue(self.rook.can_move_to(new_coord))
def test_rook_can_move_more_than_one_tile(self):
new_coord = Coordinates('d', 8)
self.assertTrue(self.rook.can_move_to(new_coord))
def test_rook_cant_move_diagonally(self):
new_coord = Coordinates('e', 5)
self.assertFalse(self.rook.can_move_to(new_coord))
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_teleporting_pieces(player_col, opponent_col):
_ = BlankPiece()
k = King(player_col)
k.has_never_moved = False
h = Knight(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 = [
[h, _, _, _, _, _, _, _], # 0
[_, _, _, _, _, _, _, _], # 1
[_, _, _, f, _, e, _, _], # 2
[_, _, _, _, _, _, _, _], # 3
[_, _, _, _, h, _, _, _], # 4
[_, _, _, _, _, _, _, _], # 5
[_, h, _, _, _, _, _, _], # 6
[_, _, _, _, _, _, _, k] # 7
]
# Top-left knight
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], [
[1, 2],
[2, 1],
]))
# Knight near bottom
assert_length(board[6][1].get_move_set(board, [6, 1], []), 0)
assert_contains(
board[6][1].get_attack_set(board, [6, 1], []),
create_list_of_moves(MoveType.NORMAL, [6, 1],
[[4, 0], [4, 2], [5, 3], [7, 3]]))
# Middle knight
assert_length(board[4][4].get_move_set(board, [4, 4], []), 0)
assert_contains(
board[4][4].get_attack_set(board, [4, 4], []),
create_list_of_moves(
MoveType.NORMAL, [4, 4],
[[2, 5], [6, 5], [6, 3], [3, 2], [5, 2], [3, 6], [5, 6]]))
# Bottom-right king
assert_length(board[7][7].get_move_set(board, [7, 7], []), 0)
assert_contains(
board[7][7].get_attack_set(board, [7, 7], []),
create_list_of_moves(
MoveType.NORMAL,
[7, 7],
[ # Up
[6, 7],
# Left
[7, 6],
# north-east
[6, 6]
]))
def test_rook_can_moves():
rook = Rook('white')
board = Board(initial_pieces={'d5': rook})
board.move('d5', 'd8')
assert board.get_piece('d8') is rook
assert board.get_piece('d5') is None
def test_rook_cant_moves():
board = Board(initial_pieces={'e5': Rook('white')})
with pytest.raises(ImpossibleMove):
board.move('e5', 'd8')
def test_rook_move(self):
rook = Rook('white')
self.assertTrue(rook.can_move('d5', 'd8'))
self.assertTrue(rook.can_move('e2', 'h2'))
def test_fail_rook_move(self):
rook = Rook('white')
self.assertFalse(rook.can_move('e5', 'd8'))
self.assertFalse(rook.can_move('a1', 'h8'))