moved everything related to python in the python

folder

python/src/logic/pieces/bishop.py

@@ -0,0 +1,24 @@
+from logic.move import Move
+from .piece import Piece
+
+class Bishop(Piece):
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
+        ret = []
+
+        # looking north east
+        ret.extend(self._look_direction(board, 1, 1))
+
+        # looking south east
+        ret.extend(self._look_direction(board, 1, -1))
+
+        # looking south west
+        ret.extend(self._look_direction(board, -1, -1))
+
+        # 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

@@ -0,0 +1,23 @@
+from .piece import Piece
+
+class Knight(Piece):
+    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
+            (+2, -1), (+1, -2), # south east
+            (-2, -1), (-1, -2), # south west
+            (-2, +1), (-1, +2), # north west
+        ]:
+            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

@@ -0,0 +1,65 @@
+from logic.move import Move
+from logic.position import Position
+from enum import Enum
+
+
+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):
+            dx = mult_dx * d
+            dy = mult_dy * d
+
+            move = self._move_for_position(board, self.pos.x + dx, self.pos.y + dy)
+            if move is None:
+                break
+            ret.append(move)
+            if move.is_capturing:
+                break
+
+        return ret
+
+    def _move_for_position(self, board: "Board", x: int, y: int) -> Move | None:
+        if not Position.is_within_bounds(x, y):
+            return None
+        piece = board.piece_at(x, y) 
+
+        if piece is None:
+            return Move(self, Position(x, y))
+
+        if piece.colour != self.colour:
+            return Move(self, Position(x, y), is_capturing=True)
+        return None
+
+    def position(self) -> Position:
+        return self.pos
+
+    def move_to(self, pos: Position) -> "Piece":
+        ret = type(self)(pos, self.colour)
+        return ret
+
+    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

@@ -0,0 +1,35 @@
+from logic.move import Move
+from .piece import Piece
+
+class Queen(Piece):
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
+        ret = []
+
+        # looking north east
+        ret.extend(self._look_direction(board, 1, 1))
+
+        # looking south east
+        ret.extend(self._look_direction(board, 1, -1))
+
+        # looking south west
+        ret.extend(self._look_direction(board, -1, -1))
+
+        # looking north west
+        ret.extend(self._look_direction(board, -1, 1))
+
+        # looking east
+        ret.extend(self._look_direction(board, 1, 0))
+
+        # looking south
+        ret.extend(self._look_direction(board, 0, -1))
+
+        # looking west
+        ret.extend(self._look_direction(board, -1, 0))
+
+        # 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

@@ -0,0 +1,23 @@
+from logic.move import Move
+from .piece import Piece
+
+class Rook(Piece):
+    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
+        ret = []
+
+        # looking east
+        ret.extend(self._look_direction(board, 1, 0))
+
+        # looking south
+        ret.extend(self._look_direction(board, 0, -1))
+
+        # looking west
+        ret.extend(self._look_direction(board, -1, 0))
+
+        # 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