def test_get_board_moves(self):
l1 = []
for mock_id in xrange(MOCKS_COUNT):
board = get_mock(mock_id)
l1.append(sorted(board.get_board_moves()))
l2 = []
for mock_id in xrange(MOCKS_COUNT):
board = get_mock(mock_id)
l2.append(sorted(board.get_board_moves()))
assert_equal(l1, l2)
def test_en_passant(self):
board = get_mock(7)
print_board(board)
assert_equal(board.en_passant, (6, 2))
assert_equal(board.evaluation_params()['material'], [12, 8])
assert_equal(board.evaluation_params()['activeness'], [24, 21])
assert_true(board.pieces[(6, 3)] == ('pawn', WHITE))
cnt = 0
for move in board.get_board_moves(
capture_sort_key=Board.sort_take_by_value):
revert_info = board.make_move(move)
if revert_info is None:
continue
if cnt == 0:
assert_equal(move['piece'], 'pawn')
assert_equal(move['new_position'], (6, 2))
assert_equal(move['captured_piece'], 'pawn')
assert_equal(board.evaluation_params()['material'], [11, 8])
assert_equal(board.evaluation_params()['activeness'], [22, 21])
assert_true((6, 3) not in board.pieces)
cnt += 1
board.revert_move(revert_info)
assert_true(board.pieces[(6, 3)] == ('pawn', WHITE))
def test_king_castle_deep_4(self):
lines = 10
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=4,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(15)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(2):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['position'],
result[ind]['moves'][-1]['new_position'],
result[ind]['moves'][-3]['piece'],
result[ind]['moves'][-3]['position'],
result[ind]['moves'][-3]['new_position']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (997, 'knight', (6, 0), (7, 2), 'king',
(4, 0), (6, 0)))
assert_true(to_check[1][0] != 997)
def test_mock_0_deep_3(self):
lines = 17
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=3,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(0)
print_board(board)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(9):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position']))
to_check.sort()
assert_equal(to_check[0], (-2, 'king', (3, 0)))
assert_equal(to_check[1], (-2, 'king', (3, 1)))
assert_equal(to_check[2], (-2, 'pawn', (0, 1)))
assert_equal(to_check[3], (-2, 'rook', (0, 3)))
assert_equal(to_check[4], (-2, 'rook', (0, 4)))
assert_equal(to_check[5], (-2, 'rook', (0, 5)))
assert_equal(to_check[6], (-2, 'rook', (0, 6)))
assert_equal(to_check[7], (-1, 'rook', (1, 7)))
assert_equal(to_check[8][0], 0)
assert_equal(len(result), 16)
def test_hash(self):
hashes = set()
for mock_id in xrange(MOCKS_COUNT):
hashes.add(get_mock(mock_id).hash)
assert_equal(len(hashes), MOCKS_COUNT)
pieces = {(0, 0): ('king', WHITE), (7, 6): ('king', BLACK)}
hashes = set()
hashes.add(Board(pieces, move_color=WHITE).hash)
hashes.add(Board(pieces, move_color=BLACK).hash)
hashes.add(Board(pieces, move_color=BLACK, en_passant=(2, 2)).hash)
hashes.add(
Board(pieces,
move_color=BLACK,
castles=get_castles(white_qc=True, black_kc=True)).hash)
hashes.add(
Board(pieces, move_color=BLACK,
castles=get_castles(white_kc=True)).hash)
hashes.add(
Board(pieces, move_color=BLACK,
castles=get_castles(black_qc=True)).hash)
assert_equal(len(hashes), 6)
def test_sort_take_by_value(self):
board = get_mock(22)
moves = board.get_board_captures(Board.sort_take_by_value)
assert_equal(moves[0]['new_position'], (2, 7))
assert_equal(moves[0]['new_piece'], 'queen')
assert_equal(moves[1]['new_position'], (4, 7))
assert_equal(moves[1]['new_piece'], 'queen')
def test_get_board_simple_moves_shuffle(self):
for mock_id in xrange(MOCKS_COUNT):
board = get_mock(mock_id)
moves = board.get_board_simple_moves()
assert_true(
any(moves != board.get_board_simple_moves()
for _ in xrange(5)))
def test_fen(self):
for ind in xrange(MOCKS_COUNT):
board = get_mock(ind)
fen = get_fen_from_board(board)
board_2 = get_board_from_fen(fen)
fen_2 = get_fen_from_board(board_2)
assert_equal(board.hash, board_2.hash)
assert_equal(fen, fen_2)
def test_one_pawn(self):
board = get_mock(4)
result = get_syzygy_best_move(board)
assert_equal(
{
'position': (3, 4),
'new_position': (2, 5),
'piece': 'king',
'new_piece': 'king',
'captured_piece': None
}, result['moves'][0])
def test_promotion_rook(self):
board = get_mock(5)
result = get_syzygy_best_move(board)
assert_equal(
{
'position': (5, 6),
'new_position': (5, 7),
'piece': 'pawn',
'new_piece': 'rook',
'captured_piece': None
}, result['moves'][0])
def test_castle_obstacle_not_valid(self):
for mock_id in [1, 9, 14]:
board = get_mock(mock_id)
print_board(board)
for move in board.get_board_moves():
revert_info = board.make_move(move)
if revert_info is None:
continue
board.revert_move(revert_info)
if (move['piece'] == 'king'
and move['new_position'] == (6, 0)):
assert_true(False)
def test_castle_beaten_cell_check(self):
for mock_id in [11, 12, 13]:
board = get_mock(mock_id)
print_board(board)
for move in board.get_board_moves():
revert_info = board.make_move(move)
if revert_info is None:
continue
board.revert_move(revert_info)
if (move['piece'] == 'king'
and abs(move['new_position'][0] - move['position'][0])
== 2):
assert_true(False)
def test_get_board_moves_2(self):
for mock_id in xrange(MOCKS_COUNT):
board = get_mock(mock_id)
print_board(board)
assert_equal(sorted(board.get_board_moves()),
sorted(board.get_board_moves_old()))
for move in board.get_board_moves():
revert_info = board.make_move(move)
if not revert_info:
continue
assert_equal(sorted(board.get_board_moves()),
sorted(board.get_board_moves_old()))
board.revert_move(revert_info)
def test_castle_become_invalid(self):
for mock_id in [16]:
board = get_mock(mock_id)
print_board(board)
assert_equal(board.castles[BLACK_QC], True)
is_any_move = False
for move in board.get_board_moves():
revert_info = board.make_move(move)
if revert_info is None:
continue
assert_equal(board.castles[BLACK_QC], False)
board.revert_move(revert_info)
is_any_move = True
assert_equal(is_any_move, True)
assert_equal(board.castles[BLACK_QC], True)
def test_max_deep_captures_promotion(self):
lines = 10
analyzer = AlphaBetaAnalyzer(max_deep=1,
max_deep_captures=1,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(23)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(1):
to_check.append(
(result[ind]['evaluation'], result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-2]['new_piece']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (9, 'king', 'queen'))
def test_promotion_not_capture(self):
lines = 10
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=2,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(21)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(4):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position'],
result[ind]['moves'][-1]['new_piece']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (999, 'pawn', (5, 7), 'knight'))
assert_equal(to_check[1], (0, 'pawn', (5, 7), 'queen'))
def test_on_passan(self):
lines = 10
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=3,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(6)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(3):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (4, 'pawn', (7, 3)))
assert_equal(to_check[1], (-998, 'pawn', (6, 3)))
assert_equal(to_check[2], (-998, 'pawn', (6, 2)))
assert_equal(len(result), 3)
def test_max_deep_one_capture(self):
lines = 10
analyzer = AlphaBetaAnalyzer(max_deep=1,
max_deep_one_capture=1,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(6)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(3):
to_check.append(
(result[ind]['evaluation'], result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (3, 'pawn', (7, 3)))
assert_equal(to_check[1], (3, 'pawn', (6, 3)))
assert_equal(to_check[2], (3, 'pawn', (6, 2)))
assert_equal(len(result), 3)
def test_castle_valid(self):
for mock_id in [10]:
board = get_mock(mock_id)
print_board(board)
assert_equal(board.castles[WHITE_KC], True)
assert_equal(board.castles[WHITE_QC], True)
for move in board.get_board_moves():
revert_info = board.make_move(move)
if revert_info is None:
continue
if (move['piece'] == 'king' and move['new_position'] == (6, 0)
and (4, 0) not in board.pieces
and board.pieces[(5, 0)] == ('rook', WHITE)
and board.pieces[(6, 0)] == ('king', WHITE)
and (7, 0) not in board.pieces):
break
board.revert_move(revert_info)
else:
assert_true(False)
def test_mock_2_deep_4(self):
lines = 17
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=4,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(2)
print_board(board)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(9):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position']))
to_check.sort(reverse=True)
assert_equal(to_check[0], (997, 'queen', (6, 7)))
assert_equal(to_check[1][0], 5)
assert_equal(len(result), 17)
def test_mock_0_deep_1(self):
lines = 5
for analyzer_class in analyzer_classes:
analyzer = analyzer_class(max_deep=1,
evaluation_func=material_evaluation,
lines=lines)
board = get_mock(0)
print_board(board)
analysis = analyzer.analyze(board)
result = analysis['result']
to_check = []
for ind in xrange(3):
to_check.append((result[ind]['evaluation'],
result[ind]['moves'][-1]['piece'],
result[ind]['moves'][-1]['new_position']))
to_check.sort()
assert_equal(to_check[0], (-2, 'pawn', (0, 1)))
assert_equal(to_check[1], (-2, 'rook', (0, 1)))
assert_equal(to_check[2][0], -1)
assert_equal(len(result), lines)
def test_complex(self):
board = get_mock(3)
print_board(board)
d = [{
'move': {
'position': (3, 4),
'new_position': (2, 4),
'piece': 'queen',
'new_piece': 'queen',
'captured_piece': 'rook',
'captured_position': (2, 4)
},
'evaluation': [21, 3],
'activeness': [50, 6]
}, {
'move': {
'position': (6, 5),
'new_position': (5, 6),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': 'knight',
'captured_position': (5, 6)
},
'evaluation': [21, 5],
'activeness': [52, 14]
}, {
'move': {
'position': (7, 7),
'new_position': (5, 6),
'piece': 'knight',
'new_piece': 'knight',
'captured_piece': 'knight',
'captured_position': (5, 6)
},
'evaluation': [21, 5],
'activeness': [56, 14]
}, {
'move': {
'position': (6, 6),
'new_position': (5, 6),
'piece': 'rook',
'new_piece': 'rook',
'captured_piece': 'knight',
'captured_position': (5, 6)
},
'evaluation': [21, 5],
'activeness': [52, 14]
}]
cnt = 0
assert_equal(board.evaluation_params()['material'], [21, 8])
for move in board.get_board_moves(
capture_sort_key=Board.sort_take_by_value):
revert_info = board.make_move(move)
if revert_info is None:
continue
if cnt < len(d):
assert_equal(move, d[cnt]['move'])
assert_equal(board.evaluation_params()['material'],
d[cnt]['evaluation'])
assert_equal(board.evaluation_params()['activeness'],
d[cnt]['activeness'])
else:
assert_equal(board.evaluation_params()['material'], [21, 8])
cnt += 1
board.revert_move(revert_info)
cells = [(0, 1), (0, 6)]
for c in xrange(5):
cells.append((c, 0))
cells.append((c, 7))
stats = defaultdict(dict)
for cell in cells:
x = cell[0] * cell_size * 2
y = (7 - cell[1]) * cell_size * 2
for dx in xrange(cell_size * 2):
for dy in xrange(cell_size * 2):
pixel = get_pixel(bitmap, x + dx, y + dy)
stats[cell][(dx, dy)] = pixel
pixels = {}
init_board = get_mock(1)
pixels = {}
for cell in cells:
print
piece, color = init_board.pieces[cell]
print piece, color
while True:
p1 = random.choice(stats[cell].keys())
p2 = random.choice(stats[cell].keys())
p1_color = None
p2_color = None
for piece_color in ['white_piece', 'black_piece']:
if similiar_pixel(stats[cell][p1],
[settings['colors'][piece_color]]):
p1_color = piece_color
'color': BLACK,
'from_to': [('d7', 'd6'), ('e7', 'e5')]
# }, {
# 'name': 'd5e6',
# 'color': BLACK,
# 'from_to': [
# ('d7', 'd5'),
# ('e7', 'e6')
# ]
}
]
# TODO: think if this is enough?
OPENINGS = []
for opening in OPENINGS:
board = get_mock(1)
color_pieces = get_color_pieces(board.pieces, opening['color'])
hashes = []
for name_from, name_to in opening['from_to']:
hashes.append(Board.pieces_hash(color_pieces))
position = name_to_cell(name_from)
new_position = name_to_cell(name_to)
color_pieces[new_position] = color_pieces[position]
del color_pieces[position]
opening['hashes'] = hashes
def test_moves_stringify(self):
input_1 = ([{
'position': (4, 1),
'new_position': (4, 3),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': None,
'captured_position': (4, 3)
}, {
'position': (3, 4),
'new_position': (4, 3),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': 'pawn',
'captured_position': (4, 3)
}, {
'position': (2, 1),
'new_position': (0, 1),
'piece': 'rook',
'new_piece': 'rook',
'captured_piece': None,
'captured_position': (0, 1)
}, {
'position': (1, 3),
'new_position': (0, 1),
'piece': 'knight',
'new_piece': 'knight',
'captured_piece': 'rook',
'captured_position': (0, 1)
}], get_mock(20), '1.e4 dxe4 2.Ra2 Nxa2')
input_2 = ([{
'position': (3, 4),
'new_position': (4, 5),
'piece': 'queen',
'new_piece': 'queen',
'captured_piece': None,
'captured_position': (4, 5)
}, {
'position': (6, 6),
'new_position': (7, 5),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': 'knight',
'captured_position': (7, 5)
}, {
'position': (4, 5),
'new_position': (6, 7),
'piece': 'queen',
'new_piece': 'queen',
'captured_piece': None,
'captured_position': (6, 7)
}], get_mock(2), '1.Qe6 gxh6 2.Qg8+')
input_3 = ([{
'position': (3, 4),
'new_position': (6, 7),
'piece': 'queen',
'new_piece': 'queen',
'captured_piece': None,
'captured_position': (6, 7)
}, {
'position': (5, 7),
'new_position': (6, 7),
'piece': 'rook',
'new_piece': 'rook',
'captured_piece': 'queen',
'captured_position': (6, 7)
}, {
'position': (7, 5),
'new_position': (5, 6),
'piece': 'knight',
'new_piece': 'knight',
'captured_piece': None,
'captured_position': (5, 6)
}], get_mock(2), '1.Qg8+ Rxg8 2.Nf7#')
inputs = [input_1, input_2, input_3]
for moves, board, text in inputs:
assert_equal(moves_stringify(board, list(reversed(moves))), text)
def get_board(mode, prev_board):
board_data = get_board_data(mode, prev_board)
if not board_data:
return None
settings = get_settings(mode)
bitmap = board_data['bitmap']
move_up_color = board_data['move_up_color']
cell_size = board_data['cell_size']
pieces = {}
move_color = None
yellow_cells = []
for c in xrange(8):
for r in xrange(8):
x = c * cell_size * 2
y = (7 - r) * cell_size * 2
cell = normalize_cell((c, r), move_up_color)
for piece, piece_info in settings['pixels'].items():
for color, piece_color_info in piece_info.items():
for pixel_info in piece_color_info:
px = pixel_info[0][0]
py = pixel_info[0][1]
pixel = get_pixel(bitmap, x + px, y + py)
if pixel != settings['colors'][pixel_info[1]]:
break
else:
if cell in pieces:
print 'Two pieces for cell {}: {}, {}'.format(
cell, pieces[cell], (piece, color))
return None
pieces[cell] = (piece, color)
# Determine whose move
pixel = get_pixel(bitmap, x + 5, y + 5)
if similiar_pixel(pixel, [
settings['colors']['moved_white_board_cell'],
settings['colors']['moved_black_board_cell']
]):
yellow_cells.append(cell)
if cell in pieces:
move_color = get_opp_color(pieces[cell][1])
if move_color is None:
if (not yellow_cells and all(
(c, r) in pieces for c in xrange(8) for r in [0, 1, 6, 7])):
# Initial position, consider also 960
# Maybe no 960???
move_color = WHITE
elif (len(yellow_cells) == 2 and yellow_cells[0][1] == 0
and yellow_cells[1][1] == 0):
move_color = BLACK
elif (len(yellow_cells) == 2 and yellow_cells[0][1] == 7
and yellow_cells[1][1] == 7):
move_color = WHITE
else:
print 'Can not determine move color'
return None
en_passant = None
if (len(yellow_cells) == 2
and abs(yellow_cells[0][1] - yellow_cells[1][1]) == 2):
if (pieces.get(yellow_cells[0], (None, None))[0] == 'pawn'
or pieces.get(yellow_cells[1], (None, None))[0] == 'pawn'):
en_passant = (yellow_cells[0][0],
(yellow_cells[0][1] + yellow_cells[1][1]) / 2)
# Castles
castles = get_castles()
if prev_board is not None:
castles = list(prev_board.castles)
else:
# Init position
init_board = get_mock(1)
for color in [WHITE, BLACK]:
color_pieces = get_color_pieces(pieces, color)
init_pieces = get_color_pieces(init_board.pieces, color)
if color_pieces == init_pieces:
castles[get_castle_id(color, 'k')] = True
castles[get_castle_id(color, 'q')] = True
# Refresh castles regarding to move
castles = update_castles(castles, yellow_cells)
return Board(pieces=pieces,
move_color=move_color,
en_passant=en_passant,
castles=castles,
move_up_color=move_up_color,
lt_screen=board_data['lt_screen'],
cell_size=cell_size)
def test_mock_fens(self):
for ind in xrange(MOCKS_COUNT):
board = get_mock(ind)
assert_equal(get_fen_from_board(board), FENS[ind])
def test_format_move(self):
board = get_mock(19)
inputs = [
({
'position': (7, 5),
'new_position': (6, 3),
'piece': 'knight',
'new_piece': 'knight',
'captured_piece': None,
'captured_position': (6, 3)
}, 'N6g4'),
({
'position': (5, 3),
'new_position': (6, 3),
'piece': 'queen',
'new_piece': 'queen',
'captured_piece': 'knight',
'captured_position': (6, 3)
}, 'Qfxg4'),
({
'position': (0, 5),
'new_position': (2, 4),
'piece': 'knight',
'new_piece': 'knight',
'captured_piece': None,
'captured_position': (2, 4)
}, 'Na6c5'),
({
'position': (4, 1),
'new_position': (4, 3),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': None,
'captured_position': (4, 3)
}, 'e4'),
({
'position': (3, 3),
'new_position': (4, 2),
'piece': 'pawn',
'new_piece': 'pawn',
'captured_piece': 'pawn',
'captured_position': (4, 3)
}, 'dxe3'),
({
'position': (1, 6),
'new_position': (1, 7),
'piece': 'pawn',
'new_piece': 'queen',
'captured_piece': None,
'captured_position': (1, 7)
}, 'b8=Q+'),
({
'position': (2, 6),
'new_position': (1, 7),
'piece': 'bishop',
'new_piece': 'bishop',
'captured_piece': 'queen',
'captured_position': (1, 7)
}, 'Bxb8'),
({
'position': (4, 0),
'new_position': (2, 0),
'piece': 'king',
'new_piece': 'king',
'captured_piece': None,
'captured_position': (2, 0)
}, 'O-O-O'),
({
'position': (4, 7),
'new_position': (6, 7),
'piece': 'king',
'new_piece': 'king',
'captured_piece': None,
'captured_position': (6, 7)
}, 'O-O'),
]
for move, text in inputs:
assert_equal(format_move(board, move), text)
board.make_move(move)
def test_copy(self):
for mock_id in xrange(MOCKS_COUNT):
board = get_mock(mock_id)
board2 = board.copy()
assert_equal(board.hash, board2.hash)
