feat: Update king movement logic to prevent crossing captured squares and enhance test coverage

Author: miskibin

draughts/boards/standard.py

@@ -169,28 +169,51 @@ def _get_man_legal_moves_from(
         return moves
 
     def _get_king_legal_moves_from(
-        self, square: int, is_capture_mandatory: bool
+        self, square: int, is_capture_mandatory: bool, forbidden_squares: set[int] | None = None
     ) -> list[Move]:
+        """
+        Generate legal moves for a king from a given square.
+        
+        Args:
+            square: The current square of the king
+            is_capture_mandatory: Whether we're in a capture sequence
+            forbidden_squares: Squares of previously captured pieces that cannot be crossed
+        """
+        if forbidden_squares is None:
+            forbidden_squares = set()
+        
         moves = []
         pos = self._pos  # Local reference for faster access
         turn_val = self.turn.value
+        max_len = 0  # Track max length across ALL directions
+        
         for direction in self.DIAGONAL_SHORT_MOVES[square]:
             dir_len = len(direction)
             for idx, target in enumerate(direction):
+                # Check if path crosses a forbidden square (previously captured piece)
+                if target in forbidden_squares:
+                    break
+                    
                 target_val = pos[target]
                 if (
                     dir_len > idx + 1
                     and target_val * turn_val < 0
                     and pos[direction[idx + 1]] == EMPTY
                 ):
                     i = idx + 1
-                    max_len = 0  # Track max length locally
                     while i < dir_len and pos[direction[i]] == EMPTY:
+                        # Check landing square is not forbidden
+                        if direction[i] in forbidden_squares:
+                            i += 1
+                            continue
+                            
                         move = Move(
                             [square, direction[i]], [target], [target_val]
                         )
                         self.push(move, False)
-                        sub_moves = self._get_king_legal_moves_from(direction[i], True)
+                        # Add the captured square to forbidden set for subsequent captures
+                        new_forbidden = forbidden_squares | {target}
+                        sub_moves = self._get_king_legal_moves_from(direction[i], True, new_forbidden)
                         self.pop(False)
 
                         if sub_moves:

test/test_standard_board.py

@@ -48,6 +48,11 @@ def test_legal_moves(self):
             ('[FEN "W:B:WK2,28,31,44:B20,K50"]', ["50x36"], []),
             # King cannot jump adjacent pieces (28 and 33 have no empty square between)
             ('[FEN "W:B:W7,28,31,33:B20,30,K50"]', [], ["50x50"]),
+            # King cannot hop over same piece twice during capture sequence
+            # Black king on 49 should capture 38, 28, 24 (path: 49->32->19->30/35)
+            # It should NOT capture 41 because to reach it after capturing 38,
+            # and then continue to 28, would require crossing 41's square twice
+            ('[FEN "W:B:W6,24,28,38,41:B13,K49"]', ["49x30", "49x35"], []),
         ],
     )
     def test_king_capture_edge_cases(self, fen, valid_moves, invalid_moves):
@@ -62,6 +67,36 @@ def test_king_capture_edge_cases(self, fen, valid_moves, invalid_moves):
         for move in invalid_moves:
             assert move not in move_strs, f"Invalid move {move} found in: {move_strs}"
 
+    def test_king_cannot_cross_captured_square(self):
+        """
+        Test that king cannot cross a square where a piece was already captured.
+        
+        FEN "W:B:W6,24,28,38,41:B13,K49" - Black king on 49
+        Valid path: 49 -> capture 38 -> land on 32 -> capture 28 -> land on 19 -> capture 24 -> land on 30/35
+        Invalid: capturing 41 then trying to capture 28 would cross the 41 square again
+        """
+        import numpy as np
+        
+        board = Board.from_fen('[FEN "W:B:W6,24,28,38,41:B13,K49"]')
+        legal_moves = board.legal_moves
+        
+        # Should have exactly 2 moves (49x30 and 49x35)
+        assert len(legal_moves) == 2, f"Expected 2 moves, got {len(legal_moves)}: {[str(m) for m in legal_moves]}"
+        
+        # Both moves should capture exactly 3 pieces: 38, 28, 24
+        for move in legal_moves:
+            captured_1idx = sorted([c + 1 for c in move.captured_list])
+            assert captured_1idx == [24, 28, 38], f"Expected captures [24, 28, 38], got {captured_1idx}"
+        
+        # Piece on 41 should NOT be captured (it's on a different branch)
+        test_board = Board.from_fen('[FEN "W:B:W6,24,28,38,41:B13,K49"]')
+        test_board.push(legal_moves[0])
+        
+        # Square 41 (0-indexed: 40) should still have a white piece
+        assert test_board.position[40] == -1, "White piece on square 41 was incorrectly captured"
+        # Square 6 (0-indexed: 5) should still have a white piece
+        assert test_board.position[5] == -1, "White piece on square 6 was incorrectly captured"
+
     def test_games_from_pdns(self):
         import re
         with open(self.random_pdns, "r") as f:

tools/compare_versions.py

@@ -25,7 +25,7 @@
 # === Configuration ===
 WARMUP_ROUNDS = 5
 BENCHMARK_ROUNDS = 10
-BENCHMARK_ITERATIONS = 1  # Number of times to run the legal moves benchmark
+BENCHMARK_ITERATIONS = 10  # Number of times to run the legal moves benchmark
 ENGINE_DEPTH = 4
 
 # === Paths ===