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)