Example #1
0
 def test_in_bounds(self):
     self.assertTrue(
         all(position.in_bounds for position in self.flat_positions))
     self.assertFalse(
         any(Position(-1, col).in_bounds for col in range(-1, 9)))
     self.assertFalse(
         any(Position(8, col).in_bounds for col in range(-1, 9)))
     self.assertFalse(
         any(Position(row, -1).in_bounds for row in range(-1, 9)))
     self.assertFalse(
         any(Position(row, 8).in_bounds for row in range(-1, 9)))
Example #2
0
    def newGame(self, fen=None):

        #if we have a boardstring
        if fen:
            turn = self.position.fen.turn 
            self.position = Position(fen)
            self._start_name = "Custom"
        # else let it set to the default position
        else:
            self.position = Position()
            self._start_name = "Start"
Example #3
0
 def test_from_notation(self):
     for row, notation_row in enumerate(self.notation):
         for col, square in enumerate(notation_row):
             board_piece = self.board[row][col]
             if square == "":
                 self.assertEqual(board_piece, None)
             else:
                 self.assertEqual(Position(row, col), board_piece.position)
                 self.assertEqual(Color.from_notation(square[0]), board_piece.color)
                 self.assertEqual(Piece.from_notation(square[1]), type(board_piece))
Example #4
0
 def test_eq_hash(self):
     for row, position_row in enumerate(self.positions):
         for col, position in enumerate(position_row):
             others = self.flat_positions - {position}
             # test equality
             self.assertEqual(position, Position(row, col))
             self.assertFalse(any(position == other for other in others))
             # test hash
             self.assertIn(position, self.flat_positions)
             self.assertNotIn(position, others)
Example #5
0
 def test_add(self):
     board = Board()
     self.assertTrue(all(square == None for square in board.squares()))
     board.add(Color.white, Pawn, Position(3, 4))
     board.add(Color.black, Pawn, Position(6, 6))
     self.assertEqual(Color.white, board.at(Position(3, 4)).color)
     self.assertEqual(Pawn, type(board.at(Position(3, 4))))
     self.assertEqual(Color.black, board.at(Position(6, 6)).color)
     self.assertEqual(Pawn, type(board.at(Position(6, 6))))
     self.assertEqual(2, len(list(board.pieces())))
     for position in board.positions():
         if position not in (Position(3, 4), Position(6, 6)):
             self.assertIsNone(board.at(position))
Example #6
0
 def setUp(self):
     self.positions = [[Position(row, col) for col in range(8)]
                       for row in range(8)]
     self.flat_positions = set(itertools.chain(*self.positions))
     self.notations = [["A1", "B1", "C1", "D1", "E1", "F1", "G1", "H1"],
                       ["A2", "B2", "C2", "D2", "E2", "F2", "G2", "H2"],
                       ["A3", "B3", "C3", "D3", "E3", "F3", "G3", "H3"],
                       ["A4", "B4", "C4", "D4", "E4", "F4", "G4", "H4"],
                       ["A5", "B5", "C5", "D5", "E5", "F5", "G5", "H5"],
                       ["A6", "B6", "C6", "D6", "E6", "F6", "G6", "H6"],
                       ["A7", "B7", "C7", "D7", "E7", "F7", "G7", "H7"],
                       ["A8", "B8", "C8", "D8", "E8", "F8", "G8", "H8"]]
Example #7
0
    def test_possible_moves(self):
        upper_moves = self.upper_rook.possible_moves
        self.assertEqual(10, len(upper_moves))
        self.assertIn(Position(0, 1), upper_moves)  # move up
        self.assertIn(Position(1, 0), upper_moves)  # move left
        self.assertContainsAll(upper_moves,
                               [Position(2, 1), Position(3, 1)])  # moves down
        self.assertContainsAll(upper_moves,
                               [Position(1, col)
                                for col in range(2, 8)])  # moves right

        left_moves = self.left_rook.possible_moves
        self.assertEqual(7, len(left_moves))
        self.assertContainsAll(left_moves,
                               [Position(3, 1), Position(2, 1)])  # moves up
        self.assertIn(Position(4, 0), left_moves)  # moves left
        self.assertContainsAll(left_moves,
                               [Position(row, 1)
                                for row in range(5, 8)])  # moves down
        self.assertIn(Position(4, 2), left_moves)  # moves right

        right_moves = self.right_rook.possible_moves
        self.assertEqual(10, len(right_moves))
        self.assertContainsAll(right_moves,
                               [Position(row, 5)
                                for row in range(4)])  # moves up
        self.assertIn(Position(4, 4), right_moves)  # moves left
        self.assertContainsAll(right_moves,
                               [Position(row, 5)
                                for row in range(5, 8)])  # moves down
        self.assertContainsAll(right_moves,
                               [Position(4, col)
                                for col in range(6, 8)])  # moves right

        middle_moves = self.middle_rook.possible_moves
        self.assertEqual(9, len(middle_moves))
        self.assertContainsAll(middle_moves,
                               [Position(row, 3)
                                for row in range(4)])  # moves up
        self.assertIn(Position(4, 2), middle_moves)  # moves left
        self.assertIn(Position(4, 4), middle_moves)  # moves right
        self.assertContainsAll(middle_moves,
                               [Position(row, 3)
                                for row in range(5, 8)])  # moves down

        lower_moves = self.lower_rook.possible_moves
        self.assertEqual(14, len(lower_moves))
        self.assertContainsAll(lower_moves,
                               [Position(row, 7)
                                for row in range(6)])  # moves up
        self.assertContainsAll(lower_moves,
                               [Position(6, col)
                                for col in range(7)])  # moves left
        self.assertIn(Position(7, 7), lower_moves)  # moves down
Example #8
0
 def move(self, begin, end):
     begin_position = Position.from_notation(str(begin))
     end_position = Position.from_notation(str(end))
     self._board.at(begin_position).move_to(end_position)
     return self.turn()
Example #9
0
 def position(self):
     return Position(self.row, self.col)
Example #10
0
 def setUp(self):
     self.board = Board()
     self.wpawn = self.board.add(Color.white, Pawn, Position(1, 4))
     self.bpawn = self.board.add(Color.black, Pawn, Position(2, 3))
Example #11
0
 def test_possible_moves(self):
     self.assertListEqual(self.wpawn.possible_moves,
                          [Position(2, 4), Position(3, 4)])
     self.assertListEqual(self.bpawn.possible_moves, [Position(1, 3)])
Example #12
0
class ChessLibGameEngine(object):
    
    def __init__(self):

        self.castles = {
            ('K', 'e1', 'g1'): Move.from_uci('h1f1'),
            ('K', 'e1', 'c1'): Move.from_uci('a1d1'),
            ('k', 'e8', 'g8'): Move.from_uci('h8f8'),
            ('k', 'e8', 'c8'): Move.from_uci('a8d8'),
        }

        self.castles_reversed  = {
            ('K', 'g1', 'e1'): Move.from_uci('f1h1'),
            ('K', 'c1', 'e1'): Move.from_uci('d1a1'),
            ('k', 'g8', 'e8'): Move.from_uci('f8h8'),
            ('k', 'c8', 'e8'): Move.from_uci('d8a8'),
        }
        self.position = None
        self._start_name = None

    @property
    def fen(self):
        return self.position and str(self.position.fen)
        

    def newGame(self, fen=None):

        #if we have a boardstring
        if fen:
            turn = self.position.fen.turn 
            self.position = Position(fen)
            self._start_name = "Custom"
        # else let it set to the default position
        else:
            self.position = Position()
            self._start_name = "Start"

    def makeMove(self, move):
        san = SanNotation(self.position, move)
        piece = self.position[move.source]
        captured = self.position[move.target]
        movenum = self.position.fen.full_move
        iswhite = self.position.fen.turn == 'w'
        before = self.fen
        self.position.make_move(move)
        after = self.fen

        game_move = GameMove(
            str(san),
            movenum,
            iswhite, 
            before, 
            after,
            move.source,
            move.target,
            captured,
            piece
        )
        return game_move

    def makeMoveFromSan(self, san):
        move = SanNotation.to_move(self.position, san)
        return self.makeMove(move)

    def sanToMove(self, san):
        return SanNotation.to_move(self.position, san)

    def validateMove(self, move):
        for m in self.position.get_legal_moves():
            if m == move:
                return True
        return False

    def castleRookMove(self, move):
        '''Returns the corresponding rook move if a given move is a castling one.'''

        piece, start, end = [str(move.piece), str(move.source), str(move.target)]

        for castle in [self.castles, self.castles_reversed]:
            if castle.has_key((piece, start, end)):
                return castle[(piece, start, end)]
        return None

    def toBoardstring(self):
        return BoardString(str(self.position.fen))

    def initialMove(self):
        '''Special game move to hold starting position.'''

        # FIXME: use iswhite
        start = GameMove(
            self._start_name,
            self.position.fen.full_move,
            self.position.fen.turn == 'w',
            None,
            self.fen,
            None,
            None,
            None,
            None
        )
        return start
Example #13
0
 def test_from_notation(self):
     for notation_row, position_row in zip(self.notations, self.positions):
         for notation, position in zip(notation_row, position_row):
             self.assertEqual(position, Position.from_notation(notation))
Example #14
0
 def test_from_notation(self):
     for notation_row, position_row in zip(self.notations, self.positions):
         for notation, position in zip(notation_row, position_row):
             self.assertEqual(position, Position.from_notation(notation))