def confirm_moves(fen, depth): moves = BitBoardState.from_fen(fen).all_moves() random.shuffle(moves) expected_moves = all_moves_from_chess_package(fen) try: assert_equal(set(moves), set(expected_moves)) except AssertionError: print(fen) print(BitBoardState.from_fen(fen).to_grid()) raise if depth <= 1: return len(moves) total = 0 for move in moves: board = BitBoardState.from_fen(fen) record = board.make_move(move) total += confirm_moves(board.to_fen(), depth - 1) board.unmake_move(record) try: assert_equal(board, BitBoardState.from_fen(fen)) except AssertionError: print(board.to_fen()) print(board.to_grid()) print(BitBoardState.from_fen(fen).to_grid()) raise return total
def test_positions(): positions = [ 'rnbq1bnr/pppkpppp/2P5/3p4/8/8/PP1PPPPP/RNBQKBNR b KQ - 0 3', 'rnbq1bnr/pppkpppp/2P5/3p4/8/8/PP1PPPPP/RNBQKBNR b KQ - 0 3', 'r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2NQ4/PPPBBPpP/R4RK1 b kq - 1 2', '8/8/3p4/1Pp4r/1K3p2/6k1/4P1P1/1R6 w - c6 0 3', 'r3k2r/1ppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R1Q2R1K b k - 3 3' ] for fen in positions: board = BitBoardState.from_fen(fen) moves = board.all_moves() expected_moves = all_moves_from_chess_package(fen) try: assert_equal(set(moves), set(expected_moves)) except AssertionError: print(board.to_grid()) raise # The following two positions should have 218 moves each. # See https://chessprogramming.wikispaces.com/Encoding+Moves positions_218 = [ 'R6R/3Q4/1Q4Q1/4Q3/2Q4Q/Q4Q2/pp1Q4/kBNN1KB1 w - - 0 1', '3Q4/1Q4Q1/4Q3/2Q4R/Q4Q2/3Q4/1Q4Rp/1K1BBNNk w - - 0 1', ] for fen in positions_218: moves = BitBoardState.from_fen(fen).all_moves() expected_moves = all_moves_from_chess_package(fen) assert_equal(set(moves), set(expected_moves)) assert_equal(len(moves), 218)
def test_from_fen(): fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' bb = BitBoardState.from_fen(fen) assert_equal( bb.get_k().to_str(), '0001000000000000000000000000000000000000000000000000000000010000') assert_equal( bb.get_q().to_str(), '0000100000000000000000000000000000000000000000000000000000001000') assert_equal( bb.get_b().to_str(), '0010010000000000000000000000000000000000000000000000000000100100') assert_equal( bb.get_n().to_str(), '0100001000000000000000000000000000000000000000000000000001000010') assert_equal( bb.get_r().to_str(), '1000000100000000000000000000000000000000000000000000000010000001') assert_equal( bb.get_p().to_str(), '0000000011111111000000000000000000000000000000001111111100000000') assert_equal( bb.get_white().to_str(), '0000000000000000000000000000000000000000000000001111111111111111') assert_equal( bb.get_black().to_str(), '1111111111111111000000000000000000000000000000000000000000000000')
def test_queen_captures(): fen = 'rnbqkbnr/pppppppp/8/8/8/3P4/PPP1PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).queen_captures()) assert_equal(moves, set()) fen = 'rnbqkbnr/pppppppp/8/8/8/3p4/PPP1PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).queen_captures()) assert_equal(moves, {Move(3, 19)}) fen = 'rnbqkbnr/pppppppp/8/8/8/1pPP4/PP2PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).queen_captures()) assert_equal(moves, {Move(3, 17)}) # Make sure a pinned queen doesn't move out of the pin ray fen = 'rnb1kbnr/4q3/8/8/8/8/PPPPRPPP/RNBQKBNR b KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).queen_captures()) assert_equal(moves, {Move(52, 52 - 40)})
def test_promotion(): fen = '4k3/P7/8/8/8/8/8/8 w - - 0 100' board = BitBoardState.from_fen(fen) move = Move(48, 56, 'Q') record = board.make_move(move) assert_equal(record.promoted_from, 'P') assert_equal(board.to_fen(), 'Q3k3/8/8/8/8/8/8/8 b - - 0 100') board.unmake_move(record) assert_equal(board.to_fen(), fen)
def test_long_form_move_formats(): starting_fen = 'rnbqkbnr/pppppppr/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' board = BitBoardState.from_fen(starting_fen) mv = Move.from_long_form(True, 'e2-e4') assert_equal(mv.to_long_form(), 'e2-e4') board.make_move(mv) assert_equal( board.to_fen(), 'rnbqkbnr/pppppppr/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1')
def test_all_captures(): fens = [ 'rnbqkbnr/pppppppr/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1', '1k6/1b6/8/8/7R/8/8/4K2R b K - 0 1', '5k2/8/8/8/8/8/8/4K2R w K - 0 1', 'rnbqkb1r/ppp1pppp/5n2/3p4/4P3/2N2P2/PPPP2PP/R1BQKBNR b KQkq - 0 3' ] for fen in fens: board = BitBoardState.from_fen(fen) moves = board.all_moves() captures = board.all_captures() assert_equal(set(captures), set(filter(move_is_capture(board), moves)))
def test_boardstate_to_grid(): starting_fen = 'rnbqkbnr/pppppppr/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' board = BitBoardState.from_fen(starting_fen) expected_grid = ''' rnbqkbnr pppppppr -------- -------- -------- -------- PPPPPPPP RNBQKBNR '''.replace(' ', '').strip() assert_equal(board.to_grid(), expected_grid)
def test_to_fen(): fens = [ '8/5N2/4p2p/5p1k/1p4rP/1P2Q1P1/P4P1K/5q2 w - - 15 44', 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1', 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1', 'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2', 'rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R b KQkq - 1 2', 'R6R/3Q4/1Q4Q1/4Q3/2Q4Q/Q4Q2/pp1Q4/kBNN1KB1 w - - 0 1', '3Q4/1Q4Q1/4Q3/2Q4R/Q4Q2/3Q4/1Q4Rp/1K1BBNNk w - - 0 1', ] for fen in fens: bb = BitBoardState.from_fen(fen) new_fen = bb.to_fen() assert_equal(new_fen, fen)
def verify_zobrist_update_on_position(fen): board = BitBoardState.from_fen(fen) initial = board.zobrist_hash() moves = board.all_moves() for i, move in enumerate(moves): rec = board.make_move(move) new_hash = board.zobrist_hash() assert_equal(board.get_zobrist_hash(), new_hash) updated_hash = initial.update(board, rec) assert_equal(new_hash, updated_hash) downdated_hash = updated_hash.update(board, rec) assert_equal(downdated_hash, initial) board.unmake_move(rec) assert_equal(initial, board.zobrist_hash()) assert_equal(board.get_zobrist_hash(), initial) return True
def test_quiescence_efficiency(): starting_fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' board = BitBoardState.from_fen(starting_fen) quiescent = ThresholdPlayer(0, .0000001, True) mundane = ThresholdPlayer(0, .0000001, False) t0 = time.time() n = 1 for _ in range(n): mundane.movesearch(board) t1 = time.time() print('Mundane player took %fs for %d search%s.' % (t1 - t0, n, 'es' if n > 1 else '')) for _ in range(n): quiescent.movesearch(board) t1 = time.time() print('Quiescent player took %fs for %d search%s.' % (t1 - t0, n, 'es' if n > 1 else ''))
def test_movesearch(): starting_fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' # starting_fen = 'rn1q1bnr/pp1bk1pp/2p1pp2/8/3p4/BPP1PN2/P4PPP/RN2KB1R b KQ - 2 9' # starting_fen = 'rnbqkb1r/ppp1pppp/5n2/3p4/4P3/2N5/PPPP1PPP/R1BQKBNR w KQkq d6 0 3' board = BitBoardState.from_fen(starting_fen) # white = ThresholdPlayer(5000000, 1e-6) # black = ThresholdPlayer(5000000, 1e-9) white = TimePlayer(5000000, 6, False) black = TimePlayer(5000000, 6, True) print('\n') print(board.to_grid()) while (True): t0 = time.time() move = white.movesearch(board) t1 = time.time() print('%s: Search took %fs.' % (board.to_fen(), t1 - t0)) if move: board.make_move(move) print('#' * 10) print(board.to_grid()) # break if board.checkmate(): print 'White wins!' break if not move: print 'Stalemate!' break t0 = time.time() move = black.movesearch(board) t1 = time.time() print('%s: Search took %fs.' % (board.to_fen(), t1 - t0)) if move: board.make_move(move) print('#' * 10) print(board.to_grid()) if board.checkmate(): print 'Black wins!' break if not move: print 'Stalemate!' break
def compare_to_python(fen, depth): board = BitBoardState.from_fen(fen) pyboard = chess.Board(fen) def _compare_to_python(board, pyboard, depth): fen = board.to_fen() moves = board.all_moves() captures = board.all_captures() assert_equal(set(captures), set(filter(move_is_capture(board), moves))) pymoves_ = list(pyboard.legal_moves) if pyboard.turn: pymoves = list(map(chess_move_to_white_move, pymoves_)) else: pymoves = list(map(chess_move_to_black_move, pymoves_)) assert_equal(set(moves), set(pymoves)) order = list(map(pymoves.index, moves)) if depth <= 1: return for i, move in enumerate(moves): record = board.make_move(move) pyboard.push(pymoves_[order[i]]) try: _compare_to_python(board, pyboard, depth - 1) except AssertionError: print('depth = %d' % depth) print(board.to_fen()) print(board.to_grid()) print(pyboard.fen()) print(pyboard) print(move) print(pymoves_[order[i]]) print(i) record = board.unmake_move(record) pyboard.pop() raise board.unmake_move(record) pyboard.pop() assert_equal(board.to_fen(), fen) _compare_to_python(board, pyboard, depth)
def test_quiet_queen_moves(): fen = 'rnbqkbnr/pppppppp/8/8/8/3P4/PPP1PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal(moves, {Move(3, 11)}) fen = 'rnbqkbnr/pppppppp/8/8/8/2PP4/PP2PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal(moves, {Move(3, 11), Move(3, 10), Move(3, 17), Move(3, 24)}) fen = 'rnbqkbnr/pppppppp/8/8/8/1pPP4/PP2PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal(moves, {Move(3, 11), Move(3, 10)}) fen = 'rnbqkbnQ/ppppppp1/8/8/8/1pPP4/PP2PPPP/RNBQKBNR w KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal( moves, { Move(3, 11), Move(3, 10), Move(63, 63 - 8), Move(63, 63 - 16), Move(63, 63 - 24), Move(63, 63 - 32), Move(63, 63 - 40) }) fen = 'rnbqkbnr/ppp1pppp/8/8/8/3P4/PPP1PPPP/RNBQKBNR b KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal(moves, { Move(59, 59 - 8), Move(59, 59 - 16), Move(59, 59 - 24), Move(59, 59 - 32) }) # Make sure a pinned queen doesn't move out of the pin ray fen = 'rnb1kbnr/4q3/8/8/8/8/PPPPRPPP/RNBQKBNR b KQkq - 0 1' moves = set(BitBoardState.from_fen(fen).quiet_queen_moves()) assert_equal(moves, { Move(52, 52 - 8), Move(52, 52 - 16), Move(52, 52 - 24), Move(52, 52 - 32) })
def test_make_move(): starting_fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' # Try moving king's pawn one space board = BitBoardState.from_fen(starting_fen) record = board.make_move(Move(12, 20)) assert_equal(board.to_fen(), 'rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR b KQkq - 0 1') board.unmake_move(record) assert_equal(board.to_fen(), starting_fen) # Try moving king's pawn two spaces, thus invoking en passant board = BitBoardState.from_fen(starting_fen) record = board.make_move(Move(12, 28)) assert_equal(board.get_enpassant(), 20) assert_equal( board.to_fen(), 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1') board.unmake_move(record) assert_equal(board.to_fen(), starting_fen) # Attempt an en passant capture record_stack = [] fen_stack = [starting_fen] board = BitBoardState.from_fen(starting_fen) move = Move(12, 28) record = board.make_move(move) record_stack.append(record) assert_equal(record.from_square, move.from_square) assert_equal(record.to_square, move.to_square) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr pppppppp -------- -------- ----P--- ----*--- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) move = Move(48, 40) record = board.make_move(move) record_stack.append(record) assert_equal(record.from_square, move.from_square) assert_equal(record.to_square, move.to_square) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr -ppppppp p------- -------- ----P--- -------- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) move = Move(28, 36) record = board.make_move(move) record_stack.append(record) assert_equal(record.from_square, move.from_square) assert_equal(record.to_square, move.to_square) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr -ppppppp p------- ----P--- -------- -------- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) move = Move(51, 35) record = board.make_move(move) record_stack.append(record) assert_equal(record.from_square, move.from_square) assert_equal(record.to_square, move.to_square) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr -pp-pppp p--*---- ---pP--- -------- -------- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) assert_equal(board.get_enpassant(), 43) move = Move(36, 43) record = board.make_move(move) record_stack.append(record) assert_equal(record.from_square, move.from_square) assert_equal(record.to_square, move.to_square) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr -pp-pppp p--P---- -------- -------- -------- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) record_stack.append(board.make_move(Move(52, 36))) fen_stack.append(board.to_fen()) assert_equal( ''' rnbqkbnr -pp--ppp p--P*--- ----p--- -------- -------- PPPP-PPP RNBQKBNR '''.replace(' ', '').strip(), board.to_grid()) fen = fen_stack.pop(-1) assert_equal(fen, board.to_fen()) while record_stack: record = record_stack.pop(-1) board.unmake_move(record) fen = fen_stack.pop(-1) assert_equal(fen, board.to_fen()) assert_equal(board.to_fen(), starting_fen) # Try white castle king side board = BitBoardState.from_fen( 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK2R w KQkq - 0 1') record = board.make_move(Move(4, 6)) assert_equal(board.to_fen(), 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1RK1 b kq - 1 1') board.unmake_move(record) assert_equal(board.to_fen(), 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK2R w KQkq - 0 1') # Try white castle queen side board = BitBoardState.from_fen( 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3KBNR w KQkq - 0 1') record = board.make_move(Move(4, 2)) assert_equal(board.to_fen(), 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/2KR1BNR b kq - 1 1') board.unmake_move(record) assert_equal(board.to_fen(), 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3KBNR w KQkq - 0 1') # Try black castle king side board = BitBoardState.from_fen( 'rnbqk2r/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1') record = board.make_move(Move(60, 62)) assert_equal(board.to_fen(), 'rnbq1rk1/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQ - 1 2') board.unmake_move(record) assert_equal(board.to_fen(), 'rnbqk2r/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1') # Try black castle queen side board = BitBoardState.from_fen( 'r3kbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1') record = board.make_move(Move(60, 58)) assert_equal(board.to_fen(), '2kr1bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQ - 1 2') board.unmake_move(record) assert_equal(board.to_fen(), 'r3kbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1')
def choose_move(self, board): fen = board.fen() bitboard = BitBoardState.from_fen(fen) mv = self.player.movesearch(bitboard) return chess.Move.from_uci(mv.to_uci())
def test_black_castling(): fen = 'r3k2r/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1' moves = BitBoardState.from_fen(fen).all_moves() expected_moves = all_moves_from_chess_package(fen) assert_equal(set(moves), set(expected_moves))
def test_white_castling(): fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1' moves = BitBoardState.from_fen(fen).all_moves() expected_moves = all_moves_from_chess_package(fen) assert_equal(set(moves), set(expected_moves))
def start(self, fen): self.board = BitBoardState.from_fen(fen) self.player = TimePlayer(self.tt_size, self.time_limit, self.use_quiescence)
def test_perft(): # https://www.chessprogramming.net/perfect-perft/ print('') print('Running perft tests...') fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' depth = 3 state = BitBoardState.from_fen(fen) t0 = time.time() assert_equal(state.perft(depth), 8902) t1 = time.time() print('%s perft(%d) passed in %f seconds' % (fen, depth, t1 - t0)) fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' depth = 5 state = BitBoardState.from_fen(fen) t0 = time.time() assert_equal(state.perft(depth), 4865609) t1 = time.time() print('%s perft(%d) passed in %f seconds' % (fen, depth, t1 - t0)) fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' depth = 6 state = BitBoardState.from_fen(fen) t0 = time.time() assert_equal(state.perft(depth), 119060324) t1 = time.time() print('%s perft(%d) passed in %f seconds' % (fen, depth, t1 - t0)) fen = 'r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(5), 193690690) print('%s perft passed' % fen) fen = '8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(7), 178633661) print('%s perft passed' % fen) fen = 'r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 706045033) print('%s perft passed' % fen) fen = '1k6/1b6/8/8/7R/8/8/4K2R b K - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(5), 1063513) print('%s perft passed' % fen) fen = '3k4/3p4/8/K1P4r/8/8/8/8 b - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 1134888) print('%s perft passed' % fen) fen = '8/8/4k3/8/2p5/8/B2P2K1/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 1015133) print('%s perft passed' % fen) fen = '8/8/1k6/2b5/2pP4/8/5K2/8 b - d3 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 1440467) print('%s perft passed' % fen) fen = '5k2/8/8/8/8/8/8/4K2R w K - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 661072) print('%s perft passed' % fen) fen = '3k4/8/8/8/8/8/8/R3K3 w Q - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 803711) print('%s perft passed' % fen) fen = 'r3k2r/1b4bq/8/8/8/8/7B/R3K2R w KQkq - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(4), 1274206) print('%s perft passed' % fen) fen = 'r3k2r/8/3Q4/8/8/5q2/8/R3K2R b KQkq - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(4), 1720476) print('%s perft passed' % fen) fen = '2K2r2/4P3/8/8/8/8/8/3k4 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 3821001) print('%s perft passed' % fen) fen = '8/8/1P2K3/8/2n5/1q6/8/5k2 b - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(5), 1004658) print('%s perft passed' % fen) fen = '4k3/1P6/8/8/8/8/K7/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 217342) print('%s perft passed' % fen) fen = '8/P1k5/K7/8/8/8/8/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 92683) print('%s perft passed' % fen) fen = 'K1k5/8/P7/8/8/8/8/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(6), 2217) print('%s perft passed' % fen) fen = '8/k1P5/8/1K6/8/8/8/8 w - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(7), 567584) print('%s perft passed' % fen) fen = '8/8/2k5/5q2/5n2/8/5K2/8 b - - 0 1' assert_equal(BitBoardState.from_fen(fen).perft(4), 23527) print('%s perft passed' % fen) print('All perft tests complete.')
def test_to_grid(): fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' grid = ''' rnbqkbnr pppppppp -------- -------- -------- -------- PPPPPPPP RNBQKBNR '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = '8/5N2/4p2p/5p1k/1p4rP/1P2Q1P1/P4P1K/5q2 w - - 15 44' grid = ''' -------- -----N-- ----p--p -----p-k -p----rP -P--Q-P- P----P-K -----q-- '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1' grid = ''' rnbqkbnr pppppppp -------- -------- ----P--- ----*--- PPPP-PPP RNBQKBNR '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = 'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2' grid = ''' rnbqkbnr pp-ppppp --*----- --p----- ----P--- -------- PPPP-PPP RNBQKBNR '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = 'rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R b KQkq - 1 2' grid = ''' rnbqkbnr pp-ppppp -------- --p----- ----P--- -----N-- PPPP-PPP RNBQKB-R '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = 'R6R/3Q4/1Q4Q1/4Q3/2Q4Q/Q4Q2/pp1Q4/kBNN1KB1 w - - 0 1' grid = ''' R------R ---Q---- -Q----Q- ----Q--- --Q----Q Q----Q-- pp-Q---- kBNN-KB- '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid) fen = '3Q4/1Q4Q1/4Q3/2Q4R/Q4Q2/3Q4/1Q4Rp/1K1BBNNk w - - 0 1' grid = ''' ---Q---- -Q----Q- ----Q--- --Q----R Q----Q-- ---Q---- -Q----Rp -K-BBNNk '''.strip().replace(' ', '') bb = BitBoardState.from_fen(fen) assert_equal(bb.to_grid(), grid)
def test_all_moves(): fen = 'rnbqkbnr/pppppppr/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' moves = BitBoardState.from_fen(fen).all_moves() expected_moves = all_moves_from_chess_package(fen) assert_equal(set(moves), set(expected_moves))
def test_place_piece(): fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' bb = BitBoardState.from_fen(fen) bb.place_piece(0, 'p') new_fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/pNBQKBNR w KQkq - 0 1' assert_equal(bb.to_fen(), new_fen)