Пример #1
0
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
Пример #2
0
    def __init__(self, board_size=(8, 8)):
        self.board = Board(board_size)
        self.state = PRE
        self.judge = False
        self.score = 0

        self.pre_solve_figures_queue = queue.Queue()
Пример #3
0
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')
Пример #4
0
def run():
    board = Board()
    board.start_game()

    gui = Gui(board)
    gui.load_images()
    gui.run()
Пример #5
0
 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)
Пример #6
0
def parse_board(message, width, height):
    b = Board(width, height)
    fig_info = re.findall(r'\([a-zA-Z]*\d* \d* \d*\)', message)
    for info in fig_info:
        info = info.replace('(', '').replace(')', '').split()
        b.add_figure(info[0], int(info[1]), int(info[2]))
    return b
Пример #7
0
        def test_it_raise_an_exception_if_a_piece_already_settled(self):

            board = Board()
            board.squares = {'a': {'1': Rook()}}

            with pytest.raises(ImpossibleSettleException):

                board.settle(Rook(), x='a', y='1')
Пример #8
0
 def _init(self):
     self.selected = None
     self.board = Board()
     self.turn = WHITE
     self.valid_moves = []
     self.check_mate = False
     self.move_x, self.move_y = 805, 40
     self.__draw_static_text()
Пример #9
0
    def test_en_passant(self):
        board = Board.from_fen(
            'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq A1 0 1')
        self.assertEqual(board.en_passant_pos, P('a1'))

        board = Board.from_fen(
            'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq h8 0 1')
        self.assertEqual(board.en_passant_pos, P('h8'))
Пример #10
0
        def test_it_should_settle_the_rook_in_a_square(self):

            board = Board()
            rook = Rook()

            board.settle(rook, x='a', y='1')

            assert board.squares['a']['1'] == rook
Пример #11
0
 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'])
Пример #12
0
def test_copy():
  board = Board()
  king = King(BLACK, 0, 0)
  rook = Rook(WHITE, 2, 2)
  board._pieces = {king, rook}
  clone = board.copy()
  assert len(clone._pieces) == len(board._pieces)
  for piece in clone._pieces:
    assert piece not in board._pieces
Пример #13
0
    def test_active_side(self):
        with self.subTest('should be white'):
            board = Board.from_fen('8/8/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1')
            self.assertEqual(board.player, Color.WHITE)
            self.assertEqual(board.enemy, Color.BLACK)

        with self.subTest('should be black'):
            board = Board.from_fen('8/8/8/8/8/8/PPPPPPPP/RNBQKBNR b - - 0 1')
            self.assertEqual(board.player, Color.BLACK)
            self.assertEqual(board.enemy, Color.WHITE)
Пример #14
0
    def test_full_move_clock(self):
        board = Board.from_fen('8/8/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1')
        self.assertEqual(getattr(board, 'full_move'), 1)

        board = Board.from_fen('8/8/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 42')
        self.assertEqual(getattr(board, 'full_move'), 42)

        self.assertTrue(
            False,
            'Refactor this test')  # the getattr with direct attribute access
Пример #15
0
 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')
Пример #16
0
 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'])
Пример #17
0
 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')
Пример #18
0
def test_king_can_moves():
    king = King('white')
    #
    # I have to pass a second king because the board look for a second
    # king when you set the first one. Maybe a have to add an attribute
    # to the board class to say wether the match is tutorial or not.
    #
    board = Board(initial_pieces={'f5': king, 'h1': King('black')})
    board.move('f5', 'e5')
    assert board.get_piece('e5') is king
    assert board.get_piece('f5') is None
Пример #19
0
    def test_knight_capture(self):
        board = Board(initial_pieces={'a8': King('black'), 'e5': Pawn('black'), 'f3': Knight('white')})
        pieces = [piece for piece in board.squares.values() if piece is not None]
        self.assertEqual(3, len(pieces))

        knight = board.squares['f3']
        board.move('f3', 'e5')
        self.assertIs(knight, board.squares['e5'])

        pieces = [piece for piece in board.squares.values() if piece is not None]
        self.assertEqual(2, len(pieces))
Пример #20
0
 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'])
Пример #21
0
    def test_it_returns_a_piece_by_coordinates(self):
        board = Board()
        piece = board.tiles[0][0].piece
        retrieved_piece = board.get_piece_on_coordinates('a8')

        self.assertEqual(piece, retrieved_piece)

        piece = board.tiles[0][1].piece
        retrieved_piece = board.get_piece_on_coordinates('b8')
        self.assertEqual(piece, retrieved_piece)

        self.assertIsNone(board.get_piece_on_coordinates('c5'))
Пример #22
0
    def test_moving_the_king_should_disallow_any_further_castling(self):
        with self.subTest('white'):
            board = Board.from_strings([
                # bcdefgh
                '........',  # 8
                '........',  # 7
                '........',  # 6
                '........',  # 5
                '........',  # 4
                '........',  # 3
                '........',  # 2
                'R...K..R'  # 1
                # bcdefgh
            ])
            white_king = board[Rank.ONE][File.E]
            moves = white_king.generate_moves(board, P('e1'))
            self.assertIn(P('c1'), moves)
            self.assertIn(P('g1'), moves)

            # move the king and then return it in it's original position
            board.move(from_pos=P('e1'), to_pos=P('f1'))
            board.move(from_pos=P('f1'), to_pos=P('e1'))

            moves = white_king.generate_moves(board, P('e1'))
            self.assertNotIn(P('c1'), moves)
            self.assertNotIn(P('g1'), moves)

        with self.subTest('black'):
            board = Board.from_strings([
                # bcdefgh
                'r...k..r',  # 8
                '........',  # 7
                '........',  # 6
                '........',  # 5
                '........',  # 4
                '........',  # 3
                '........',  # 2
                '........'  # 1
                # bcdefgh
            ])
            black_king = board[Rank.EIGHT][File.E]
            moves = black_king.generate_moves(board, P('e8'))
            self.assertIn(P('c8'), moves)
            self.assertIn(P('g8'), moves)

            board.move(from_pos=P('e8'), to_pos=P('f8'))
            board.move(from_pos=P('f8'), to_pos=P('e8'))

            moves = black_king.generate_moves(board, P('e8'))
            self.assertNotIn(P('c8'), moves)
            self.assertNotIn(P('g8'), moves)
Пример #23
0
def main():
    run = True
    clock = pygame.time.Clock()
    board = Board(WIN)
    while run:
        clock.tick(FPS)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
                break
            if event.type == pygame.MOUSEBUTTONDOWN:
                pass
        board.update()
    pygame.quit()
Пример #24
0
 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'])
Пример #25
0
 def __init__(self, win, skill_level):
     self.win = win
     self.board = Board()
     self._initialize()
     self.engine = Engine(skill_level)
     self.buttons = [
         Button(SQUARE_SIZE * 9, SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE // 2,
                RED, "queen"),
         Button(SQUARE_SIZE * 9, SQUARE_SIZE * 2, SQUARE_SIZE,
                SQUARE_SIZE // 2, BLUE, "bishop"),
         Button(SQUARE_SIZE * 9, SQUARE_SIZE * 3, SQUARE_SIZE,
                SQUARE_SIZE // 2, GREEN, "knight"),
         Button(SQUARE_SIZE * 9, SQUARE_SIZE * 4, SQUARE_SIZE,
                SQUARE_SIZE // 2, ORANGE, "rook")
     ]
Пример #26
0
    def __init__(
        self,
        board=None,
        white_player=RandomAgent,
        black_player=RandomAgent,
        current_color='white',
    ):
        self.white_player = white_player(color='white')
        self.black_player = black_player(color='black')
        self.current_color = current_color
        if board is None:
            self.board = Board()
        else:
            self.board = Board(board)

        self._game_history = []
Пример #27
0
    def test_en_passant_square_is_set_on_the_board_object(self):
        board = Board.from_strings([
            # bcdefgh
            '........',  # 8
            '.p......',  # 7
            '........',  # 6
            '........',  # 5
            '........',  # 4
            '........',  # 3
            '.P......',  # 2
            '........'  # 1
        ])

        with self.subTest('white'):
            en_passant_want = Position(Rank.THREE, File.B)
            f, t = Position(Rank.TWO, File.B), Position(Rank.FOUR, File.B)
            board.move(from_pos=f, to_pos=t)

            self.assertEqual(board.en_passant_pos, en_passant_want)

        with self.subTest('black'):
            en_passant_want = Position(Rank.SIX, File.B)
            f, t = Position(Rank.SEVEN, File.B), Position(Rank.FIVE, File.B)
            board.move(from_pos=f, to_pos=t)

            self.assertEqual(board.en_passant_pos, en_passant_want)
Пример #28
0
    def test_promotion_callback_should_be_called(self):
        board = Board.from_strings([
            # bcdefgh
            '........',  # 8
            '.P......',  # 7
            '........',  # 6
            '........',  # 5
            '........',  # 4
            '........',  # 3
            '.p......',  # 2
            '........'  # 1
        ])
        board.promotion_cb = unittest.mock.Mock()
        mock_piece = board.promotion_cb.return_value

        with self.subTest('white'):
            f, t = Position(Rank.SEVEN, File.B), Position(Rank.EIGHT, File.B)

            board.move(from_pos=f, to_pos=t)

            board.promotion_cb.assert_called_once()
            mock_piece.assert_called_once_with(Color.WHITE)

        board.promotion_cb.reset_mock()
        mock_piece = board.promotion_cb.return_value
        with self.subTest('black'):
            f, t = Position(Rank.TWO, File.B), Position(Rank.ONE, File.B)

            board.move(from_pos=f, to_pos=t)

            board.promotion_cb.assert_called_once()
            mock_piece.assert_called_once_with(Color.BLACK)
Пример #29
0
    def test_get_attackers_detects_king_attacks(self):
        """The placement of this test must seem off
            The bulk of the use cases are get_attackers are
            tested inderectly in the check awareness tests

            The only use case that cannot be tested with check awareness
            is when the king attacks something
        """
        board = Board.from_strings([
            # bcdefgh
            "p.......",  # 8 
            "K.......",  # 7 
            "........",  # 6 
            "........",  # 5 
            "........",  # 4 
            "........",  # 3 
            "k.......",  # 2 
            "P......."  # 1
        ])

        with self.subTest('white pawn attacked'):
            attackers = board.get_attackers(P('a1'), Color.WHITE)
            self.assertEqual([P('a2')], list(attackers))

        with self.subTest('black pawn attacked'):
            attackers = board.get_attackers(P('a8'), Color.BLACK)
            self.assertEqual([P('a7')], list(attackers))
Пример #30
0
 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')
Пример #31
0
 def test_double_check_no_other_pieces_other_than_king_should_move(self):
     for figure, figure_name in (
         ('q', 'queen'),
         ('n', 'knight'),
         ('b', 'bishop'),
         ('p', 'pawn'),
         ('r', 'rook'),
     ):
         test_case = {
             'name':
             f'{figure_name}_is_blocking_double_check_and_should_not_be_able_to_move',
             'board':
             Board.from_strings(
                 os.linesep.join([
                     # bcdefgh
                     '....q...',  # 8
                     '.q......',  # 7
                     '..X.....',  # 6
                     '.K......',  # 5
                     '.......Q',  # 4
                     '....Q...',  # 3
                     '.....x..',  # 2
                     '....k...'  # 1
                 ]).replace('x', figure).replace('X', figure.upper()).split(
                     os.linesep)),
             'want': {
                 'white': {
                     P('c6'): {}
                 },
                 'black': {
                     P('f2'): {}
                 }
             }
         }
         self.runMoveGenerationTest(test_case)
Пример #32
0
def test_alternating_between_players():
    board = Board()
    assert board.turn == 'white'
    board.move('g2', 'g3')  # white pawn moves
    assert board.turn == 'black'
    board.move('b7', 'b6')  # black pawn moves
    assert board.turn == 'white'
    board.move('f1', 'g2')  # white bishop moves
    assert board.turn == 'black'
Пример #33
0
 def moves_str(self, color):
     moves_strs = []
     for piece, move in self.moves(color, with_piece=True):
         move_str = Board.chess_move_notation(move)
         moves_strs.append(
             f"{str(piece)} : {move_str}"
         )
     return '\n'.join(moves_strs)
Пример #34
0
    def test_instantiate_board(self):
        board = Board()
        self.assertEqual(64, len(board.squares))

        pieces = [
            piece for piece in board.squares.values() if piece is not None
        ]
        self.assertEqual(32, len(pieces))
Пример #35
0
def test_icon():
    board = Board()

    rook = Rook(0, 0, Color.WHITE, board)
    assert rook.char() == '♖'

    rook = Rook(0, 0, Color.BLACK, board)
    assert rook.char() == '♜'
Пример #36
0
    def test_it_has_tiles(self):
        board = Board()
        self.assertEqual(len(board.tiles), board.height)
        for row in board.tiles:
            self.assertEqual(len(row), board.width)

        tile = board.tiles[0][0]
        self.assertIsInstance(tile, Tile)
Пример #37
0
def main():
    run = True
    clock = pygame.time.Clock()
    board = Board()
    active_click = 0

    while run:
        clock.tick(FPS)

        for event in pygame.event.get():
            #For exiting the game
            if event.type == pygame.QUIT:
                run = False

            #For clicking on screen
            if event.type == pygame.MOUSEBUTTONDOWN:
                if active_click == 1:
                    pos = pygame.mouse.get_pos()
                    row, col = return_row_col_of_mouse(pos)
                    board.move_piece(piece, row, col)
                    active_click = 0
                else:
                    pos = pygame.mouse.get_pos()
                    row, col = return_row_col_of_mouse(pos)
                    piece = board.return_piece(row, col)
                    if piece != 0:
                        active_click = 1

        board.draw(WIN)
        pygame.display.update()

    pygame.quit()
Пример #38
0
def assignment():
    """ Assignment """
    board = Board(5, 5)
    pieces = {}
    pieces['king'] = 2
    pieces['queen'] = 2
    pieces['bishop'] = 2
    pieces['rook'] = 0
    pieces['knight'] = 1
    start = datetime.datetime.now()
    print 'Start', start
    board.set_pieces(pieces)
    board.put_pieces()
    end = datetime.datetime.now()
    print 'End', end
    print 'Duration', end-start
    print 'Found '+str(len(board.solutions))+ ' solutions'
    exit()
Пример #39
0
 def to_python(self, value):
     u"""Creates a new board from the board described by board_string."""
     if isinstance(value, Board):
         return value
     else:
         if value is not None:
             if len(value) == 0:  # Web requrests can provide an empty string
                 value = None
         return Board(value)
Пример #40
0
def test_pieces_can_capture_opponent_pieces():
    board = Board(initial_pieces={'a8': King('black'), 'e5': Pawn('black'), 'f3': Knight('white')})
    assert board.pieces_quantity() == 3

    knight = board.get_piece('f3')
    board.move('f3', 'e5')
    assert board.get_piece('e5') is knight
    assert board.pieces_quantity() == 2
Пример #41
0
class TestPawnInit(unittest.TestCase):
    def setUp(self):
        self.board = Board()

    def test_init_pawn(self):
        pawn = Pawn(self.board, 'c', '5', 'white')
        posx, posy = self.board.convert_pos_to_array('c', 5)
        self.assertIsNotNone(self.board.__board__[posx][posy])
        self.assertTrue(pawn in self.board.white_set)
        self.assertFalse(pawn in self.board.black_set)
Пример #42
0
def test_alternating_between_players():
    board = Board()
    assert board.turn == 'white'
    board.move('g2', 'g3')  # white pawn moves
    assert board.turn == 'black'
    board.move('b7', 'b6')  # black pawn moves
    assert board.turn == 'white'
    board.move('f1', 'g2')  # white bishop moves
    assert board.turn == 'black'
Пример #43
0
def test_check_small():
  board = Board()
  king = King(BLACK, 0, 0)
  rook = Rook(WHITE, 2, 2)
  board._pieces = {king, rook}
  assert not board.checked(BLACK)
  board.move(rook, 2, 0)
  assert board.checked(BLACK)
Пример #44
0
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')
Пример #45
0
def test_check_medium():
  board = Board()
  king = King(BLACK, 0, 0)
  rook = Rook(WHITE, 2, 2)
  pawn = Pawn(WHITE, 7, 3)
  bishop = Bishop(WHITE, 1, 3)
  enemy_king = King(WHITE, 6, 6)
  board._pieces = {king, rook, pawn, bishop, enemy_king}
  assert not board.checked(BLACK)
  board.move(rook, 2, 0)
  assert board.checked(BLACK)
  assert not board.checked(WHITE)
Пример #46
0
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
Пример #47
0
    def test_bishop_capture_rook(self):
        board = Board()
        pieces = [piece for piece in board.squares.values() if piece is not None]
        self.assertEqual(32, len(pieces))

        bishop = board.squares['f1']
        board.move('g2', 'g3')  # white pawn moves
        board.move('b7', 'b6')  # black pawn moves
        board.move('f1', 'g2')  # white bishop moves
        board.move('g8', 'f6')  # black knight moves
        board.move('g2', 'a8')  # white bishop capture white rook
        self.assertIs(bishop, board.squares['a8'])

        pieces = [piece for piece in board.squares.values() if piece is not None]
        self.assertEqual(31, len(pieces))
Пример #48
0
    def test_board_regular_move(self):
        board = Board()
        knight = board.squares['g1']
        board.move('g1', 'f3')
        self.assertIs(knight, board.squares['f3'])
        self.assertIsNone(board.squares['g1'])

        board = Board()
        pawn = board.squares['e2']
        board.move('e2', 'e3')
        self.assertIs(pawn, board.squares['e3'])
        self.assertIsNone(board.squares['e2'])
Пример #49
0
def main():
    """ Main function """
    parser = ArgumentParser()
    parser.add_argument("-x", "--horizontal", dest="width", default=3, type=int,
    help="Horizontal dimension (default=3)")
    parser.add_argument("-y", "--vertical", dest="height", default=3, type=int,
    help="Vertical dimension (default=3)")
    parser.add_argument("-k", "--kings", dest="king", default=0, type=int,
    help="Number of kings")
    parser.add_argument("-q", "--queens", dest="queen", default=0, type=int,
    help="Number of queens")
    parser.add_argument("-b", "--bishops", dest="bishop", default=0, type=int,
    help="Number of bishops")
    parser.add_argument("-r", "--rooks", dest="rook", default=0, type=int,
    help="Number of rooks")
    parser.add_argument("-n", "--knights", dest="knight", default=0, type=int,
    help="Number of knights")
    parser.add_argument("-p", "--print", dest="printsolutions", default=False,
    help="Print the solutions", action='store_true')
    args = parser.parse_args()

    if sum([args.king, args.queen, args.bishop, args.rook, args.knight]) == 0:
        print 'No chess pieces given. Nothing to do. Running the assignment!'
        assignment()
    else:
        print 'Chess pieces:'
        print '- Kings ' + str(args.king)
        print '- Queens ' + str(args.queen)
        print '- Bishops ' + str(args.bishop)
        print '- Rooks ' + str(args.rook)
        print '- Knights ' + str(args.knight)

    board = Board(args.width, args.height)
    pieces = {}
    pieces['king'] = args.king
    pieces['queen'] = args.queen
    pieces['bishop'] = args.bishop
    pieces['rook'] = args.rook
    pieces['knight'] = args.knight
    board.set_pieces(pieces)
    print 'Start', datetime.datetime.now()
    board.put_pieces()
    print 'End', datetime.datetime.now()
    print 'Found '+str(len(board.solutions))+ ' solutions'
    if args.printsolutions is True:
        board.print_solutions()
Пример #50
0
 def test_fail_pawn_moves_two_squares(self):
     board = Board()
     board.move('a2', 'a3')
     self.assertRaises(ImpossibleMove, board.move, 'a3', 'a5')
Пример #51
0
def test_pawn_cant_move_diagonally():
    board = Board()
    with pytest.raises(ImpossibleMove):
        board.move('e2', 'f3')
Пример #52
0
def test_pawn_can_moves():
    board = Board()
    pawn = board.get_piece('e2')
    board.move('e2', 'e3')
    assert board.get_piece('e3') is pawn
    assert board.get_piece('e2') is None
Пример #53
0
def test_pawn_cant_moves_two_squares_after_moved():
    board = Board()
    board.move('e2', 'e3')
    with pytest.raises(ImpossibleMove):
        board.move('e3', 'f5')
Пример #54
0
def test_pawn_cant_move_back():
    board = Board(initial_pieces={'b4': Pawn('white')})
    with pytest.raises(ImpossibleMove):
        assert board.move('b4', 'b3')
Пример #55
0
 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')
Пример #56
0
from py_uci import UCIEngine
from chess.board import Board

b = Board()
b.move_algebraic("e4")
b.move_algebraic("c5")
b.move_algebraic("Nf3")
b.move_algebraic("d6")
b.move_algebraic("d4")
b.move_algebraic("cxd4")
b.move_algebraic("Nxd4")
b.move_algebraic("Nf6")
b.move_algebraic("Nc3")
b.move_algebraic("a6")
b.move_algebraic("g4")

e = UCIEngine(multi_pv=10)
e.new_game()
e.set_position(moves=b.get_moves())
e.find_best_move(10000)
print b
Пример #57
0
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
Пример #58
0
def test_rook_cant_moves():
    board = Board(initial_pieces={'e5': Rook('white')})
    with pytest.raises(ImpossibleMove):
        board.move('e5', 'd8')
Пример #59
0
 def test_pawn_moves_two_square(self):
     board = Board()
     pawn = board.squares['a2']
     board.move('a2', 'a4')
     self.assertIs(pawn, board.squares['a4'])
     self.assertIsNone(board.squares['a2'])