moved everything related to python in the python

folder

python/src/ai/ai.py

@@ -0,0 +1,169 @@
+from collections import defaultdict
+import time
+
+from tqdm import tqdm
+from logic.board import INITIAL_BOARD, Board
+from logic.move import Move
+from logic.pieces.piece import Colour
+
+pos2expected = {
+    # -- Position 1
+    "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1": {
+        1: 20,
+        2: 400,
+        3: 8_902,
+        4: 197_281,
+    },
+
+    # -- Position 2
+    "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1": {
+        1: 48,
+        2: 2_039,
+        3: 97_862,
+        4: 4_085_603,
+    },
+
+    # -- Position 3
+    "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1": {
+        1: 14,
+        2: 191,
+        3: 2_812,
+        4: 43_238,
+        5: 674_624,
+    },
+
+    # -- Position 4
+    "r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1": {
+        1: 6,
+        2: 264,
+        3: 9467,
+        4: 422_333,
+    },
+
+    # -- Position 5
+    "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8": {
+        1: 44,
+        2: 1486,
+        3: 62379,
+        4: 2103487,
+    },
+
+    # -- Position 6
+    "r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10": {
+        1: 46,
+        2: 2079,
+        3: 89890,
+        4: 3894594,
+    },
+}
+
+tick = "\033[92m✔️\033[0m"  # Green Tick
+cross = "\033[91m❌\033[0m"  # Red Cross
+
+res = defaultdict(lambda : 0)
+
+def peft(pos: str):
+    global res
+    expected = pos2expected[pos]
+    board = Board.setup_FEN_position(pos)
+    for depth in expected:
+        with tqdm(total=expected[depth], desc=f"Depth: {depth}") as bar:
+            start = time.process_time()
+            moves = move_generation_test(bar, board, depth, depth)
+            bar.close()
+            elapsed = time.process_time() - start
+            elapsed *= 1_000
+
+            print("Depth:", depth, end=" ")
+            print("Result:", moves, end=" ")
+            if moves == expected[depth]:
+                print(f"{tick}", end=" ")
+            else:
+                print(f"{cross} (expected {expected[depth]})", end=" ")
+            print("positions Time:", int(elapsed), "milliseconds")
+
+            if moves != expected[depth]:
+                print()
+                for key, value in res.items():
+                    print(f"{key}: {value}")
+
+
+
+def move_generation_test(bar, board: Board, depth: int, max_depth, first = None):
+    global res
+    if first is None:
+        res = defaultdict(lambda : 0)
+
+    if board.is_terminal():
+        # bar.update(1)
+        # res[first] += 1
+        return 0
+
+    if depth == 0:
+        res[first] += 1
+        bar.update(1)
+        return 1
+
+    moves = board.legal_moves()
+    if depth == 1:
+        res[first] += len(moves)
+        bar.update(len(moves))
+        return len(moves)
+
+    num_pos = 0
+    for move in moves:
+        tmp_board = board.make_move(move)
+        if first is None:
+            first = move.piece.pos.to_algebraic() + move.pos.to_algebraic()
+
+        if first == "f7h8":
+            print(tmp_board.legal_moves())
+        num_pos += move_generation_test(bar, tmp_board, depth - 1, max_depth, first = first)
+
+        if depth == max_depth:
+            first = None
+
+    return num_pos
+
+
+
+def play_game(board: Board, strategies: dict, verbose: bool = False) -> Board:
+    """Play a turn-taking game. `strategies` is a {player_name: function} dict,
+    where function(state) is used to get the player's move."""
+    state = board
+    move_counter = 1
+    while not (board.is_checkmate_for(board._turn) or board.is_stalemate_for(board._turn)):
+        player = board._turn
+        move = strategies[player](state)
+        state = board.make_move(move)
+        if verbose:
+            if player == Colour.WHITE:
+                print(str(move_counter) + ".", move, end=" ")
+            else:
+                print(move)
+
+    return state
+
+def minmax_search(state: Board) -> tuple[float, Move]:
+    """Search game tree to determine best move; return (value, move) pair."""
+    return _max_value(state) if state._turn == Colour.WHITE else _min_value(state)
+
+def _max_value(state: Board) -> tuple[float, Move]:
+    if state.is_terminal():
+        return state.utility(), None
+    v, move = -float("inf"), None
+    for a in state.legal_moves():
+        v2, _ = _min_value(state.make_move(a))
+        if v2 > v:
+            v, move = v2, a
+    return v, move
+
+def _min_value(state: Board) -> tuple[float, Move]:
+    if state.is_terminal():
+        return state.utility(), None
+    v, move = float("inf"), None
+    for a in state.legal_moves():
+        v2, _ = _min_value(state.make_move(a))
+        if v2 < v:
+            v, move = v2, a
+    return v, move

python/src/controller/controller.py

@@ -40,11 +40,11 @@ class Controller:
 
     def on_tile_selected(self, x: int, y: int) -> None:
         pos = Position(x, y)
-        print(f"Clicked on {pos.to_algebraic()}")
 
         piece = self._board.piece_at(x, y)
 
-        if self._selected_piece is None or (piece is not None and piece != self._selected_piece):
+        if self._selected_piece is None \
+            or (piece is not None and piece != self._selected_piece and piece.colour == self._selected_piece.colour):
             self._show_legal_moves(pos)
         else:
             legal_moves_positions = [move for move in self._legal_moves if move.pos == pos]
@@ -55,3 +55,9 @@ class Controller:
             else:
                 move = legal_moves_positions[0]
                 self._make_move(move)
+
+        if self._board.is_checkmate_for(self._board._turn):
+            self._view.notify_checkmate(self._board._turn)
+            
+        if self._board.is_stalemate_for(self._board._turn):
+            self._view.notify_stalemate(self._board._turn)

python/src/logic/board.py

@@ -0,0 +1,360 @@
+from logic.move import CastleSide, Move
+from logic.pieces.bishop import Bishop
+from logic.pieces.king import King
+from logic.pieces.knight import Knight
+from logic.pieces.queen import Queen
+from logic.pieces.rook import Rook
+from logic.pieces.pawn import Pawn
+from logic.pieces.piece import Colour, Piece
+from logic.position import Position
+
+from typing import Type
+
+class Board:
+    def __init__(self) -> None:
+        self._white: dict[Position, Piece] = {}
+        self._black: dict[Position, Piece] = {}
+        self._turn = None
+        self._white_castling_rights = set()
+        self._black_castling_rights = set()
+        self._en_passant_target = None
+        self._n_moves = 0
+        self._n_half_moves = 0
+
+    @staticmethod
+    def _piece_class_from_char(c: str) -> Type[Piece]:
+        assert len(c) == 1, f"The piece {c} isn't denoted by 1 character"
+        c = c.lower()
+        if c == "p":
+            return Pawn
+        if c == "r":
+            return Rook
+        if c == "n":
+            return Knight
+        if c == "b":
+            return Bishop
+        if c == "q":
+            return Queen
+        if c == "k":
+            return King
+        raise ValueError(f"Unknown piece '{c}'")
+
+    @staticmethod
+    def setup_FEN_position(position: str) -> "Board":
+        ret = Board()
+        index = 0
+
+        # -- Pieces
+        pieces = "prnbqk" # possible pieces
+        numbers = "12345678" # possible number of empty squares
+
+        x = 0
+        y = 7 # FEN starts from the top left, so 8th rank
+        for c in position:
+            index += 1
+            if c == " ":
+                break
+            if c in pieces or c in pieces.upper():
+                pos = Position(x, y)
+                piece = Board._piece_class_from_char(c)
+                if c.isupper():
+                    ret._white[pos] = piece(pos, Colour.WHITE)
+                else:
+                    ret._black[pos] = piece(pos, Colour.BLACK)
+
+                x += 1
+                continue
+            if c in numbers:
+                x += int(c)
+            if c == '/':
+                x = 0
+                y -= 1
+
+
+        # -- Active colour
+        if position[index] == "w":
+            ret._turn = Colour.WHITE
+        elif position[index] == "b":
+            ret._turn = Colour.BLACK
+        else:
+            raise ValueError(f"The FEN position is malformed, the active colour should be either 'w' or 'b', but is '{position[index]}'")
+        index += 2
+
+
+        # -- Castling Rights
+        for c in position[index:]:
+            index += 1
+            if c == "-" or c == " ":
+                if c == "-":
+                    index += 1
+                break
+
+            sides = "kq"
+            assert c in sides or c in sides.upper(), f"The FEN position is malformed, the castling rights should be either k or q (both either lower- or upper-case), instead is '{c}'"
+            if c == "K":
+                ret._white_castling_rights.add(CastleSide.King)
+            if c == "Q":
+                ret._white_castling_rights.add(CastleSide.Queen)
+            if c == "k":
+                ret._black_castling_rights.add(CastleSide.King)
+            if c == "q":
+                ret._black_castling_rights.add(CastleSide.Queen)
+
+        # -- En passant target
+        if position[index] != "-":
+            pos = Position.from_algebraic(position[index:index+2]) 
+            index += 2
+            if pos.y == 2:
+                pos.y += 1
+                assert pos in ret._white, "En passant target is not in the position"
+                ret._en_passant_target = ret._white[pos]
+            elif pos.y == 5:
+                pos.y -= 1
+                assert pos in ret._black, "En passant target is not in the position"
+                ret._en_passant_target = ret._black[pos]
+            else:
+                raise ValueError("You can't have a en passant target that is not on the third or sixth rank")
+        else:
+            index += 1
+        index += 1
+
+        ret._n_half_moves = int(position[index:position.find(" ", index + 1)])
+        ret._n_moves = int(position[position.find(" ", index)+1:])
+
+        return ret
+
+    def piece_at(self, x: int, y: int) -> Piece | None:
+        pos = Position(x, y)
+        white_piece = self._white.get(pos, None)
+        black_piece = self._black.get(pos, None)
+
+        assert white_piece == None or black_piece == None, f"There are two pieces at the same position {pos}, this shouldn't happen!"
+
+        if white_piece != None:
+            return white_piece
+        return black_piece
+
+    def is_check_for(self, colour: Colour) -> bool:
+        """ Is it check for the defending colour passed as parameter """
+        defending_pieces, attacking_pieces = (self._white, self._black) if colour == Colour.WHITE else (self._black, self._white)
+
+        kings = [piece for piece in defending_pieces.values() if type(piece) == King]
+        assert len(kings) == 1, f"We have more than one king for {colour}, that is no buono..."
+        king = kings[0]
+
+        for piece in attacking_pieces.values():
+            possible_pos = []
+            if type(piece) == King: 
+                # special case for the king, because it creates infinite recursion (since he looks if he's walking into a check)
+                for dx in [-1, 0, 1]:
+                    for dy in [-1, 0, 1]:
+                        x, y = piece.pos.x + dx, piece.pos.y + dy
+                        if Position.is_within_bounds(x, y):
+                            possible_pos.append(Position(x, y))
+            else:
+                possible_pos += [move.pos for move in piece.legal_moves(self, looking_for_check=True)]
+            if king.pos in possible_pos:
+                return True
+        return False
+
+    def is_checkmate_for(self, colour: Colour) -> bool:
+        """ Is it checkmate for the defending colour passed as parameter """
+        return self.is_check_for(colour) and self._no_legal_moves_for(colour)
+
+    def is_stalemate_for(self, colour: Colour) -> bool:
+        """ Is it stalemate for the defending colour passed as parameter """
+        return not self.is_check_for(colour) and self._no_legal_moves_for(colour)
+
+    def _no_legal_moves_for(self, colour: Colour) -> bool:
+        """ Return true if there are indeed no legal moves for the given colour (for checkmate or stalemate)"""
+        pieces = self._white if colour == Colour.WHITE else self._black
+        for piece in pieces.values():
+            if len(piece.legal_moves(self)) > 0:
+                return False
+        return True
+
+    def castling_rights_for(self, colour: Colour) -> set[CastleSide]:
+        return self._white_castling_rights if colour == Colour.WHITE else self._black_castling_rights
+
+    def make_move(self, move: Move) -> "Board":
+        dest_piece = self.piece_at(move.pos.x, move.pos.y) 
+
+        if dest_piece:
+            assert dest_piece.colour != move.piece.colour, "A piece cannot cannot eat another piece of the same colour"
+
+        # -- Copy current state
+        ret = Board()
+        ret._white = self._white.copy()
+        ret._black = self._black.copy()
+        ret._turn = Colour.WHITE if self._turn == Colour.BLACK else Colour.BLACK
+        ret._white_castling_rights = self._white_castling_rights.copy()
+        ret._black_castling_rights = self._black_castling_rights.copy()
+
+
+        piece = move.piece
+
+        # -- Actually make the move
+        pieces_moving, other_pieces = (ret._white, ret._black) if piece.colour == Colour.WHITE else (ret._black, ret._white)
+
+        del pieces_moving[piece.pos]
+        pieces_moving[move.pos] = piece.move_to(move.pos)
+        if move.pos in other_pieces:
+            del other_pieces[move.pos]
+
+        if piece.colour == Colour.BLACK:
+            ret._n_moves = self._n_moves + 1
+
+        if move.is_capturing or type(piece) == Pawn:
+            ret._n_half_moves = 0
+        else:
+            ret._n_half_moves = self._n_half_moves + 1
+
+        if move.en_passant:
+            pos_to_remove = Position(move.pos.x, move.pos.y + (1 if self._turn == Colour.BLACK else -1))
+            del other_pieces[pos_to_remove]
+
+        if move.promotes_to is not None:
+            assert type(piece) == Pawn, "Trying to promote something that is not a pawn: not good!"
+            pieces_moving[move.pos] = move.promotes_to(move.pos, piece.colour)
+
+        # -- Set en passant target if needed
+        if move.becomes_en_passant_target:
+            ret._en_passant_target = pieces_moving[move.pos]
+        else:
+            ret._en_passant_target = None
+
+        # -- Handle castling (just move the rook over)
+        if move.castle_side == CastleSide.King:
+            rook_pos = Position(7, piece.pos.y)
+            assert rook_pos in pieces_moving and type(pieces_moving[rook_pos]) == Rook, "Either rook is absent from the king side or you are trying to castle with something else than a rook..."
+            del pieces_moving[rook_pos]
+            new_rook_pos = Position(5, piece.pos.y)
+            pieces_moving[new_rook_pos] = Rook(new_rook_pos, piece.colour)
+
+        elif move.castle_side == CastleSide.Queen:
+            rook_pos = Position(0, piece.pos.y)
+            assert rook_pos in pieces_moving and type(pieces_moving[rook_pos]) == Rook, "Either rook is absent from the queen side or you are trying to castle with something else than a rook..."
+            del pieces_moving[rook_pos]
+            new_rook_pos = Position(3, piece.pos.y)
+            pieces_moving[new_rook_pos] = Rook(new_rook_pos, piece.colour)
+
+        # -- Check for castling rights
+        if piece.colour == Colour.WHITE:
+            if type(piece) == King:
+                ret._white_castling_rights = set()
+
+            if type(piece) == Rook:
+                if piece.pos.x == 0 and CastleSide.Queen in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.Queen)
+                elif piece.pos.x == 7 and CastleSide.King in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.King)
+
+            if move.is_capturing and move.pos.y == 7 and move.pos in self._black and type(self._black[move.pos]) == Rook:
+                if move.pos.x == 0 and CastleSide.Queen in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.Queen)
+                elif move.pos.x == 7 and CastleSide.King in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.King)
+        else:
+            if type(piece) == King:
+                ret._black_castling_rights = set()
+
+            if type(piece) == Rook:
+                if piece.pos.x == 0 and CastleSide.Queen in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.Queen)
+                elif piece.pos.x == 7 and CastleSide.King in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.King)
+
+            if move.is_capturing and move.pos.y == 0 and move.pos in self._white and type(self._white[move.pos]) == Rook:
+                if move.pos.x == 0 and CastleSide.Queen in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.Queen)
+                elif move.pos.x == 7 and CastleSide.King in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.King)
+
+        return ret
+
+    def to_fen_string(self):
+        ret = ""
+        for y in range(7, -1, -1):
+            empty_cell_counter = 0
+            for x in range(8):
+                pos = Position(x, y)
+
+                piece = None
+                if pos in self._white:
+                    piece = self._white[pos]
+                elif pos in self._black:
+                    piece = self._black[pos]
+
+                if piece is None:
+                    empty_cell_counter += 1
+                    continue
+
+                if empty_cell_counter > 0:
+                    ret += str(empty_cell_counter)
+                    empty_cell_counter = 0
+                letter = piece.letter()
+                ret += letter.lower() if piece.colour == Colour.BLACK else letter.upper()
+
+            if empty_cell_counter > 0:
+                ret += str(empty_cell_counter)
+
+            if y > 0:
+                ret += "/"
+        ret += " "
+
+        ret += "w" if self._turn == Colour.WHITE else "b"
+        ret += " "
+
+        if len(self._white_castling_rights) == 0 and len(self._black_castling_rights) == 0:
+            ret += "-"
+        else: 
+            if CastleSide.King in self._white_castling_rights:
+                ret += "K"
+            if CastleSide.Queen in self._white_castling_rights:
+                ret += "Q"
+
+            if CastleSide.King in self._black_castling_rights:
+                ret += "k"
+            if CastleSide.Queen in self._black_castling_rights:
+                ret += "q"
+        ret += " "
+
+        if self._en_passant_target is not None:
+            pos = Position(self._en_passant_target.pos.x, self._en_passant_target.pos.y)
+            pos.y += -1 if self._en_passant_target.colour == Colour.WHITE else 1
+            ret += pos.to_algebraic()
+        else:
+            ret += "-"
+        ret += " "
+
+        ret += str(self._n_half_moves)
+        ret += " "
+        ret += str(self._n_moves)
+
+        return ret
+
+
+    def legal_moves(self) -> list[Move]:
+        ret = []
+        pieces = self._white if self._turn == Colour.WHITE else self._black
+        for piece in pieces.values():
+            ret += piece.legal_moves(self)
+        return ret
+
+    def is_terminal(self) -> bool:
+        return self.is_stalemate_for(Colour.WHITE) or self.is_stalemate_for(Colour.BLACK) or self.is_checkmate_for(Colour.WHITE) or self.is_checkmate_for(Colour.BLACK)
+
+    def utility(self) -> int:
+        if self.is_stalemate_for(Colour.WHITE) or self.is_stalemate_for(Colour.BLACK):
+            return 0
+
+        if self.is_checkmate_for(Colour.WHITE):
+            return 1
+
+        if self.is_checkmate_for(Colour.BLACK):
+            return -1
+        
+        raise ValueError("Cannot determine the utility of board become it neither checkmate nor stalemate for either players")
+
+_fen_pos = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+INITIAL_BOARD = Board.setup_FEN_position(_fen_pos)

python/src/logic/move.py

@@ -0,0 +1,51 @@
+# from logic.pieces.piece import Piece
+from typing import Type
+from logic.position import Position
+from enum import Enum
+
+class CastleSide(Enum):
+    Neither = ""
+    King = "O-O"
+    Queen = "O-O-O"
+
+class Move:
+    def __init__(self, piece: "Piece", pos: Position,/, is_capturing: bool = False, castle_side: CastleSide = CastleSide.Neither, en_passant: bool = False, becomes_en_passant_target: bool = False, promotes_to: Type["Piece"] = None) -> None:
+        self.piece = piece
+        self.pos = pos
+        self.is_capturing = is_capturing
+        self.castle_side = castle_side
+        self.becomes_en_passant_target = becomes_en_passant_target
+        self.en_passant = en_passant
+        self.promotes_to = promotes_to
+
+    def to_algebraic(self) -> str:
+        raise NotImplementedError("The move can't be translated to algbraic notation, as it was not implemented")
+
+    @staticmethod
+    def from_algebraic(move: str) -> "Move":
+        raise NotImplementedError("The move can't be translated from algbraic notation, as it was not implemented")
+
+    def __str__(self) -> str:
+        if self.castle_side == CastleSide.King:
+            return "O-O"
+        if self.castle_side == CastleSide.Queen:
+            return "O-O-O"
+
+        ret = ""
+        if type(self.piece).__name__ == "Pawn":
+            if self.is_capturing:
+                ret += self.piece.pos.to_algebraic()[0]
+                ret += "x"
+                ret += self.pos.to_algebraic()
+            else:
+                ret += self.pos.to_algebraic()
+        else:
+            ret += self.piece.letter().upper()
+            if self.is_capturing:
+                ret += "x"
+            ret += str(self.pos)
+        
+        return ret
+    
+    def __repr__(self) -> str:
+        return str(self)

python/src/logic/pieces/bishop.py

@@ -2,7 +2,7 @@ from logic.move import Move
 from .piece import Piece
 
 class Bishop(Piece):
-    def legal_moves(self, board: "Board") -> list[Move]:
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
         ret = []
 
         # looking north east
@@ -17,5 +17,8 @@ class Bishop(Piece):
         # looking north west
         ret.extend(self._look_direction(board, -1, 1))
 
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
         return ret
 

python/src/logic/pieces/king.py

@@ -0,0 +1,69 @@
+from logic.move import CastleSide, Move
+from logic.position import Position
+from .piece import Piece
+
+class King(Piece):
+    def legal_moves(self, board: "Board") -> list[Move]:
+        ret = []
+
+        # -- Regular moves
+        for dx in [-1, 0, 1]:
+            for dy in [-1, 0, 1]:
+                if dx == 0 and dy == 0: # skip current position
+                    continue
+                x = self.pos.x + dx
+                y = self.pos.y + dy
+                move = self._move_for_position(board, x, y)
+                if move:
+                    board_after_move = board.make_move(move)
+                    if not board_after_move.is_check_for(self.colour):
+                        ret.append(move)
+
+        if board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
+        # -- Castles
+        castling_rights = board.castling_rights_for(self.colour)
+        if len(castling_rights) == 0:
+            return ret
+
+        if CastleSide.King in castling_rights:
+            clear = True
+            for dx in range(1, 3):
+                x = self.pos.x + dx
+                y = self.pos.y
+                if board.piece_at(x, y) is not None:
+                    clear = False
+                    break
+
+                move = self._move_for_position(board, x, y)
+                board_after_move = board.make_move(move)
+                if board_after_move.is_check_for(self.colour):
+                    clear = False
+                    break
+
+            if clear:
+                ret.append(Move(self, Position(6, self.pos.y), castle_side=CastleSide.King))
+
+        if CastleSide.Queen in castling_rights:
+            clear = True
+            for dx in range(1, 4):
+                x = self.pos.x - dx
+                y = self.pos.y
+
+                if board.piece_at(x, y) is not None:
+                    clear = False
+                    break
+
+                move = self._move_for_position(board, x, y)
+                board_after_move = board.make_move(move)
+                if dx < 3 and board_after_move.is_check_for(self.colour):
+                    clear = False
+                    break
+
+            if clear:
+                ret.append(Move(self, Position(2, self.pos.y), castle_side=CastleSide.Queen))
+
+        return ret
+
+

python/src/logic/pieces/knight.py

@@ -1,7 +1,10 @@
 from .piece import Piece
 
 class Knight(Piece):
-    def legal_moves(self, board: "Board") -> list["Move"]:
+    def letter(self):
+        return "n"
+
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list["Move"]:
         ret = []
         for dx, dy in [
             (+2, +1), (+1, +2), # north east
@@ -12,5 +15,9 @@ class Knight(Piece):
             move = self._move_for_position(board, self.pos.x + dx, self.pos.y + dy)
             if move is not None:
                 ret.append(move)
+
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
         return ret
 

python/src/logic/pieces/pawn.py

@@ -0,0 +1,80 @@
+from logic.move import Move
+from logic.pieces.bishop import Bishop
+from logic.pieces.knight import Knight
+from logic.pieces.piece import Colour, Piece
+from logic.pieces.queen import Queen
+from logic.pieces.rook import Rook
+from logic.position import Position
+
+class Pawn(Piece):
+    def legal_moves(self, board, / , looking_for_check = False) -> list[Move]:
+        ret = []
+
+        # can we capture to the left?
+        if self.pos.x > 0 and (
+            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y + 1)))
+            or
+            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y - 1)))
+        ):
+            if capturable_piece.colour != self.colour:
+                if (self.colour == Colour.WHITE and capturable_piece.pos.y == 7) or (self.colour == Colour.BLACK and capturable_piece.pos.y == 0):
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, capturable_piece.pos, is_capturing=True, promotes_to=piece))
+                else:
+                    ret.append(Move(self, capturable_piece.pos, is_capturing = True))
+
+        # can we capture to the right?
+        if self.pos.x < 7 and (
+            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y + 1)))
+            or
+            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y - 1)))
+        ):
+            if capturable_piece.colour != self.colour:
+                if (self.colour == Colour.WHITE and capturable_piece.pos.y == 7) or (self.colour == Colour.BLACK and capturable_piece.pos.y == 0):
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, capturable_piece.pos, is_capturing=True, promotes_to=piece))
+                else:
+                    ret.append(Move(self, capturable_piece.pos, is_capturing = True))
+
+        # -- Can we capture en passant?
+        if board._en_passant_target is not None and \
+            board._en_passant_target.pos.y == self.pos.y and (
+                board._en_passant_target.pos.x == self.pos.x - 1
+                or board._en_passant_target.pos.x == self.pos.x + 1
+        ):
+            if board._en_passant_target.colour != self.colour:
+                old_pos = board._en_passant_target.pos
+                new_pos = Position(old_pos.x, old_pos.y + (1 if self.colour == Colour.WHITE else -1))
+                ret.append(Move(self, new_pos, is_capturing = True, en_passant = True))
+
+        # -- Normal moves
+        if self.colour == Colour.WHITE:
+            for dy in range(1, 3 if self.pos.y == 1 else 2):
+                y = self.pos.y + dy
+                if y > 7 or board.piece_at(self.pos.x, y):
+                    break
+                pos = Position(self.pos.x, y)
+                if y == 7:
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, pos, promotes_to=piece))
+                else:
+                    ret.append(Move(self, pos, becomes_en_passant_target=dy==2))
+        else:
+            for dy in range(1, 3 if self.pos.y == 6 else 2):
+                y = self.pos.y - dy
+                if y < 0 or board.piece_at(self.pos.x, y):
+                    break
+                pos = Position(self.pos.x, y)
+                if y == 0:
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, pos, promotes_to=piece))
+                else:
+                    ret.append(Move(self, pos, becomes_en_passant_target=dy==2))
+
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
+        return ret
+
+    def letter(self):
+        return "p"

python/src/logic/pieces/piece.py

@@ -1,4 +1,4 @@
-from logic.move import Move, PieceMove
+from logic.move import Move
 from logic.position import Position
 from enum import Enum
 
@@ -7,12 +7,26 @@ class Colour(Enum):
     WHITE = "white"
     BLACK = "black"
 
+    def __str__(self) -> str:
+        return self.value
+
 class Piece:
     def __init__(self, pos: Position, colour: Colour) -> None:
         self.pos = pos
         assert colour == Colour.WHITE or colour == Colour.BLACK, "The colour of the piece must be either Piece.WHITE or Piece.BLACK"
         self.colour = colour
 
+    def letter(self):
+        return type(self).__name__[0].lower()
+
+    def keep_only_blocking(self, candidates: list[Move], board: "Board") -> list[Move]:
+        ret = []
+        for move in candidates:
+            board_after_move = board.make_move(move)
+            if not board_after_move.is_check_for(self.colour):
+                ret.append(move)
+        return ret
+
     def _look_direction(self, board: "Board", mult_dx: int, mult_dy: int):
         ret = []
         for d in range(1, 8):
@@ -34,10 +48,10 @@ class Piece:
         piece = board.piece_at(x, y) 
 
         if piece is None:
-            return PieceMove(self, Position(x, y))
+            return Move(self, Position(x, y))
 
         if piece.colour != self.colour:
-            return PieceMove(self, Position(x, y), is_capturing=True)
+            return Move(self, Position(x, y), is_capturing=True)
         return None
 
     def position(self) -> Position:
@@ -47,5 +61,5 @@ class Piece:
         ret = type(self)(pos, self.colour)
         return ret
 
-    def legal_moves(self, board: "Board") -> list["Move"]:
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list["Move"]:
         raise NotImplementedError(f"Can't say what the legal moves are for {type(self).__name__}, the method hasn't been implemented yet")

python/src/logic/pieces/queen.py

@@ -2,7 +2,7 @@ from logic.move import Move
 from .piece import Piece
 
 class Queen(Piece):
-    def legal_moves(self, board: "Board") -> list[Move]:
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
         ret = []
 
         # looking north east
@@ -29,4 +29,7 @@ class Queen(Piece):
         # looking north
         ret.extend(self._look_direction(board, 0, 1))
 
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
         return ret

python/src/logic/pieces/rook.py

@@ -2,7 +2,7 @@ from logic.move import Move
 from .piece import Piece
 
 class Rook(Piece):
-    def legal_moves(self, board: "Board") -> list[Move]:
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
         ret = []
 
         # looking east
@@ -17,4 +17,7 @@ class Rook(Piece):
         # looking north
         ret.extend(self._look_direction(board, 0, 1))
 
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
         return ret

python/src/logic/position.py

@@ -17,6 +17,14 @@ class Position:
         return x >= Position._MIN_POS and x <= Position._MAX_POS \
             and y >= Position._MIN_POS and y <= Position._MAX_POS
 
+    @staticmethod
+    def from_algebraic(square: str) -> "Position":
+        assert len(square) == 2, f"'{square}' is malformed"
+        x = Position._FILES.index(square[0])
+        y = Position._RANKS.index(int(square[1]))
+
+        return Position(x, y)
+
     def to_algebraic(self) -> str:
         return f"{Position._FILES[self.x]}{Position._RANKS[self.y]}"
 
@@ -29,8 +37,7 @@ class Position:
         return hash((self.x, self.y))
 
     def __str__(self) -> str:
-        return f"{self.x, self.y}"
+        return f"{Position._FILES[self.x]}{Position._RANKS[self.y]}"
 
     def __repr__(self) -> str:
         return str(self)
-

python/src/main.py

@@ -0,0 +1,27 @@
+import time
+from pprint import pprint
+from tqdm import tqdm
+
+from ai.ai import move_generation_test
+from controller.controller import Controller
+from logic.board import INITIAL_BOARD, Board
+from logic.position import Position
+from view.gui import GUI
+from view.tui import TUI
+
+from ai.ai import peft
+
+if __name__ == "__main__":
+    board = INITIAL_BOARD
+
+    pos = "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8"
+    board = Board.setup_FEN_position(pos)
+
+    view = GUI()
+
+    controller = Controller(board, view)
+
+    # view.show()
+    # exit()
+
+    peft(pos)

python/src/view/gui.py

@@ -1,4 +1,5 @@
 import tkinter as tk
+from tkinter import messagebox
 from typing import Type
 from PIL import ImageTk, Image
 import os
@@ -37,8 +38,6 @@ class GUI(View):
 
         path = os.path.join(root, f"{"white" if colour == Colour.WHITE else "black"}-{piece_name}.png")
         img = Image.open(path)
-        size = int(self.tile_size * .85)
-        # img = img.resize((size, size))
 
         if img.mode == "LA":
             img = img.convert(mode="RGBA")
@@ -62,6 +61,12 @@ class GUI(View):
 
         self._controller.on_tile_selected(x, y)
 
+    def notify_checkmate(self, colour: Colour) -> None:
+        messagebox.showinfo("Checkmate",  f"{colour} is currently checkmated") 
+        
+    def notify_stalemate(self, colour: Colour) -> None:
+        messagebox.showinfo("Stalemate",  f"{colour} is currently stalemated") 
+        
 
     def update_board(self, board: Board, selected_piece: Piece, legal_moves: list[Move]) -> None:
         self.canvas.delete("all")
@@ -92,17 +97,29 @@ class GUI(View):
                 if selected_piece is not None:
                     possible_positions = [move.pos for move in legal_moves] 
                     if pos in possible_positions:
-                        radius = .15 * self.tile_size
                         colour = circle_colours[(x + y) % 2]
-                        self.canvas.create_oval(
-                            (x + .5) * self.tile_size - radius,
-                            (y + .5) * self.tile_size - radius,
-                            (x + .5) * self.tile_size + radius,
-                            (y + .5) * self.tile_size + radius,
-                            fill=colour,
-                            outline=colour,
-                        )
-
+                        move = [move for move in legal_moves if move.pos == pos][0]
+                        if move.is_capturing:
+                            radius = .40 * self.tile_size
+                            self.canvas.create_oval(
+                                (x + .5) * self.tile_size - radius,
+                                (y + .5) * self.tile_size - radius,
+                                (x + .5) * self.tile_size + radius,
+                                (y + .5) * self.tile_size + radius,
+                                fill="",
+                                outline=colour,
+                                width=.075 * self.tile_size,
+                            )
+                        else:
+                            radius = .15 * self.tile_size
+                            self.canvas.create_oval(
+                                (x + .5) * self.tile_size - radius,
+                                (y + .5) * self.tile_size - radius,
+                                (x + .5) * self.tile_size + radius,
+                                (y + .5) * self.tile_size + radius,
+                                fill=colour,
+                                outline=colour,
+                            )
 
                 piece = board.piece_at(x, 7-y)
 

python/src/view/view.py

@@ -1,6 +1,6 @@
 from logic.board import Board
 from logic.move import Move
-from logic.pieces.piece import Piece
+from logic.pieces.piece import Colour, Piece
 
 
 class View:
@@ -13,6 +13,12 @@ class View:
     def update_board(self, board: Board, selected_piece: Piece, legal_moves: list[Move]) -> None:
         raise NotImplementedError(f"Can't update the board, the update_board() method of {type(self)} is not implemented")
 
+    def notify_checkmate(self, colour: Colour) -> None:
+        raise NotImplementedError(f"Can't notify of the checkmate, the notify_checkmate() method of {type(self)} is not implemented")
+
+    def notify_stalemate(self, colour: Colour) -> None:
+        raise NotImplementedError(f"Can't notify of the stalemate, the notify_stalemate() method of {type(self)} is not implemented")
+
     def set_controller(self, controller: "Controller") -> None:
         self._controller = controller
 

python/tests/fen.py

@@ -0,0 +1,30 @@
+import unittest
+
+import sys
+sys.path.append('src') # you must execute pytest from the stickfosh dir for this to work
+
+from logic.board import Board
+
+class FENTests(unittest.TestCase):
+    def testInitialPosition(self):
+        pos = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+    def testRandomPositions(self):
+        pos = "r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b Qk - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "4k2r/6r1/8/8/8/8/3R4/R3K3 w Qk - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "8/8/8/4p1K1/2k1P3/8/8/8 b - - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "8/5k2/3p4/1p1Pp2p/pP2Pp1P/P4P1K/8/8 b - - 99 50"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+
+

python/tests/position.py

@@ -0,0 +1,30 @@
+import unittest
+
+import sys
+sys.path.append('src') # you must execute pytest from the stickfosh dir for this to work
+
+from logic.position import Position
+
+class PositionTests(unittest.TestCase):
+    def testXY2Algebraic(self):
+        self.assertEqual(Position(0, 0).to_algebraic(), "a1")
+        self.assertEqual(Position(1, 0).to_algebraic(), "b1")
+
+        self.assertEqual(Position(2, 1).to_algebraic(), "c2")
+        self.assertEqual(Position(4, 2).to_algebraic(), "e3")
+
+        self.assertEqual(Position(7, 7).to_algebraic(), "h8")
+
+    def testAlgebraic2XY(self):
+        self.assertEqual(Position.from_algebraic("a1"), Position(0, 0))
+        self.assertEqual(Position.from_algebraic("b1"), Position(1, 0))
+
+        self.assertEqual(Position.from_algebraic("c2"), Position(2, 1))
+        self.assertEqual(Position.from_algebraic("e3"), Position(4, 2))
+
+        self.assertEqual(Position.from_algebraic("h8"), Position(7, 7))
+
+        self.assertRaises(AssertionError, lambda : Position.from_algebraic("a11"))
+
+        self.assertRaises(ValueError, lambda : Position.from_algebraic("j1"))
+        self.assertRaises(ValueError, lambda : Position.from_algebraic("a9"))

src/logic/board.py

@@ -1,143 +0,0 @@
-from logic.move import Move
-from logic.pieces.bishop import Bishop
-from logic.pieces.king import King
-from logic.pieces.knight import Knight
-from logic.pieces.queen import Queen
-from logic.pieces.rook import Rook
-from logic.pieces.pawn import Pawn
-from logic.pieces.piece import Colour, Piece
-from logic.position import Position
-
-from typing import Type
-
-class Board:
-    def __init__(self) -> None:
-        self._white: dict[Position, Piece] = {}
-        self._black: dict[Position, Piece] = {}
-        self._turn = None
-        self._white_castling_write = set()
-        self._black_castling_write = set()
-        self._en_passant_target = None
-
-    @staticmethod
-    def _piece_class_from_char(c: str) -> Type[Piece]:
-        assert len(c) == 1, f"The piece {c} isn't denoted by 1 character"
-        c = c.lower()
-        if c == "p":
-            return Pawn
-        if c == "r":
-            return Rook
-        if c == "n":
-            return Knight
-        if c == "b":
-            return Bishop
-        if c == "q":
-            return Queen
-        if c == "k":
-            return King
-        raise ValueError(f"Unknown piece '{c}'")
-
-    @staticmethod
-    def setup_FEN_position(position: str) -> "Board":
-        ret = Board()
-        index = 0
-
-        # -- Pieces
-        pieces = "prnbqk" # possible pieces
-        numbers = "12345678" # possible number of empty squares
-
-        x = 0
-        y = 7 # FEN starts from the top left, so 8th rank
-        for c in position:
-            index += 1
-            if c == " ":
-                break
-            if c in pieces or c in pieces.upper():
-                pos = Position(x, y)
-                piece = Board._piece_class_from_char(c)
-                if c.isupper():
-                    ret._white[pos] = piece(pos, Colour.WHITE)
-                else:
-                    ret._black[pos] = piece(pos, Colour.BLACK)
-
-                x += 1
-                continue
-            if c in numbers:
-                x += int(c)
-            if c == '/':
-                x = 0
-                y -= 1
-
-
-        # -- Active colour
-        if position[index] == "w":
-            ret._turn = Colour.WHITE
-        elif position[index] == "b":
-            ret._turn = Colour.BLACK
-        else:
-            raise ValueError(f"The FEN position is malformed, the active colour should be either 'w' or 'b', but is '{position[index]}'")
-        index += 1
-
-
-        # -- Castling Rights
-        for c in position[index:]:
-            index += 1
-            if c == "-" or c == " ":
-                break
-
-            sides = "kq"
-            assert c in sides or c in sides.upper(), f"The FEN position is malformed, the castling rights should be either k or q (both either lower- or upper-case), instead is '{c}'"
-            if c == "K":
-                ret._white_castling_write.add(Board.KING_SIDE_CASTLE)
-            if c == "Q":
-                ret._white_castling_write.add(Board.QUEEN_SIDE_CASTLE)
-            if c == "k":
-                ret._black_castling_write.add(Board.KING_SIDE_CASTLE)
-            if c == "q":
-                ret._black_castling_write.add(Board.QUEEN_SIDE_CASTLE)
-
-        # -- En passant target
-        if position[index] != "-":
-            ret._en_passant_target = position[index:index+2]
-
-        return ret
-
-    def piece_at(self, x: int, y: int) -> Piece | None:
-        pos = Position(x, y)
-        white_piece = self._white.get(pos, None)
-        black_piece = self._black.get(pos, None)
-
-        assert white_piece == None or black_piece == None, f"There are two pieces at the same position {pos}, this shouldn't happen!"
-
-        if white_piece != None:
-            return white_piece
-        return black_piece
-
-    def make_move(self, move: Move) -> "Board":
-        dest_piece = self.piece_at(move.pos.x, move.pos.y) 
-
-        if dest_piece:
-            assert dest_piece.colour != move.piece.colour, "A piece cannot cannot eat another piece of the same colour"
-
-        ret = Board()
-        ret._white = self._white.copy()
-        ret._black = self._black.copy()
-        ret._turn = Colour.WHITE if self._turn == Colour.BLACK else Colour.BLACK
-        ret._white_castling_write = self._white_castling_write.copy()
-        ret._black_castling_write = self._black_castling_write.copy()
-        ret._en_passant_target = self._en_passant_target
-
-        piece = move.piece
-
-        if piece.colour == Colour.WHITE:
-            del ret._white[piece.pos]
-            ret._white[move.pos] = piece.move_to(move.pos)
-            if move.pos in ret._black:
-                del ret._black[move.pos]
-        else:
-            del ret._black[piece.pos]
-            ret._black[move.pos] = piece.move_to(move.pos)
-            if move.pos in ret._white:
-                del ret._white[move.pos]
-
-        return ret

src/logic/move.py

@@ -1,25 +0,0 @@
-# from logic.pieces.piece import Piece
-from logic.position import Position
-from enum import Enum
-
-class Move:
-    def __init__(self, is_capturing: bool) -> None:
-        self.is_capturing = is_capturing
-
-    def to_algebraic(self) -> str:
-        raise NotImplementedError("The move can't be translated to algbraic notation, as it was not implemented")
-
-    @staticmethod
-    def from_algebraic(move: str) -> "Move":
-        raise NotImplementedError("The move can't be translated from algbraic notation, as it was not implemented")
-
-
-class PieceMove(Move):
-    def __init__(self, piece: "Piece", pos: Position,/, is_capturing: bool = False) -> None:
-        super().__init__(is_capturing)
-        self.piece = piece
-        self.pos = pos
-
-class Castle(Move, Enum):
-    KING_SIDE_CASTLE = False
-    QUEEN_SIDE_CASTLE = False

src/logic/pieces/king.py

@@ -1,5 +0,0 @@
-from .piece import Piece
-
-class King(Piece):
-    pass
-

src/logic/pieces/pawn.py

@@ -1,40 +0,0 @@
-from logic.move import Move, PieceMove
-from logic.pieces.piece import Colour, Piece
-from logic.position import Position
-
-class Pawn(Piece):
-    def legal_moves(self, board) -> list[Move]:
-        ret = []
-
-        # can we capture to the left?
-        if self.pos.x > 0 and (
-            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y + 1)))
-            or
-            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y - 1)))
-        ):
-            if capturable_piece.colour != self.colour:
-                ret.append(PieceMove(self, capturable_piece.pos, is_capturing = True))
-
-        # can we capture to the right?
-        if self.pos.x < 7 and (
-            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y + 1)))
-            or
-            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y - 1)))
-        ):
-            if capturable_piece.colour != self.colour:
-                ret.append(PieceMove(self, capturable_piece.pos, is_capturing = True))
-
-        if self.colour == Colour.WHITE:
-            for dy in range(1, 3 if self.pos.y == 1 else 2):
-                if self.pos.y + dy > 7 or board.piece_at(self.pos.x, self.pos.y + dy):
-                    break
-                pos = Position(self.pos.x, self.pos.y + dy)
-                ret.append(PieceMove(self, pos))
-        else:
-            for dy in range(1, 3 if self.pos.y == 6 else 2):
-                if self.pos.y - dy < 0 or board.piece_at(self.pos.x, self.pos.y - dy):
-                    break
-                pos = Position(self.pos.x, self.pos.y - dy)
-                ret.append(PieceMove(self, pos))
-
-        return ret

src/main.py

@@ -1,14 +0,0 @@
-from controller.controller import Controller
-from logic.board import Board
-from view.gui import GUI
-from view.tui import TUI
-
-if __name__ == "__main__":
-    initial_board_position = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    board = Board.setup_FEN_position(initial_board_position)
-
-    view = GUI()
-
-    controller = Controller(board, view)
-
-    view.show()