Allow claiming fifty-moves before final move (fixes niklasf#632)

niklasf · niklasf · commit 1064bf59bafb · 2020-09-23T12:52:54.000+02:00
diff --git a/chess/__init__.py b/chess/__init__.py
@@ -1832,18 +1832,17 @@ def has_insufficient_material(self, color: Color) -> bool:
 
         return True
 
+    def _is_halfmoves(self, n: int) -> bool:
+        return self.halfmove_clock >= n and any(self.generate_legal_moves())
+
     def is_seventyfive_moves(self) -> bool:
         """
         Since the 1st of July 2014, a game is automatically drawn (without
         a claim by one of the players) if the half-move clock since a capture
         or pawn move is equal to or greater than 150. Other means to end a game
         take precedence.
         """
-        if self.halfmove_clock >= 150:
-            if any(self.generate_legal_moves()):
-                return True
-
-        return False
+        return self._is_halfmoves(150)
 
     def is_fivefold_repetition(self) -> bool:
         """
@@ -1856,28 +1855,44 @@ def is_fivefold_repetition(self) -> bool:
 
     def can_claim_draw(self) -> bool:
         """
-        Checks if the side to move can claim a draw by the fifty-move rule or
+        Checks if the player to move can claim a draw by the fifty-move rule or
         by threefold repetition.
 
         Note that checking the latter can be slow.
         """
         return self.can_claim_fifty_moves() or self.can_claim_threefold_repetition()
 
+    def is_fifty_moves(self) -> bool:
+        return self._is_halfmoves(100)
+
     def can_claim_fifty_moves(self) -> bool:
         """
+        Checks if the player to move can claim a draw by the fifty-move rule.
+
         Draw by the fifty-move rule can be claimed once the clock of halfmoves
-        since the last capture or pawn move becomes equal or greater to 100
-        and the side to move still has a legal move they can make.
+        since the last capture or pawn move becomes equal or greater to 100,
+        or if there is a legal move that achieves this. Other means of ending
+        the game take precedence.
         """
-        # Fifty-move rule.
-        if self.halfmove_clock >= 100:
-            if any(self.generate_legal_moves()):
-                return True
+        if self.is_fifty_moves():
+            return True
+
+        if self.halfmove_clock >= 99:
+            for move in self.generate_legal_moves():
+                if not self.is_zeroing(move):
+                    self.push(move)
+                    try:
+                        if self.is_fifty_moves():
+                            return True
+                    finally:
+                        self.pop()
 
         return False
 
     def can_claim_threefold_repetition(self) -> bool:
         """
+        Checks if the player to move can claim a draw by threefold repetition.
+
         Draw by threefold repetition can be claimed if the position on the
         board occured for the third time or if such a repetition is reached
         with one of the possible legal moves.
diff --git a/chess/variant.py b/chess/variant.py
@@ -700,10 +700,8 @@ def _push_capture(self, move: chess.Move, capture_square: chess.Square, piece_ty
         else:
             self.pockets[self.turn].add(piece_type)
 
-    def can_claim_fifty_moves(self) -> bool:
-        return False
-
-    def is_seventyfive_moves(self) -> bool:
+    def _is_halfmoves(self, n: int) -> bool:
+        # No draw by 50-move rule or 75-move rule.
         return False
 
     def is_irreversible(self, move: chess.Move) -> bool:
diff --git a/test.py b/test.py
@@ -1268,27 +1268,35 @@ def test_trivial_is_repetition(self):
     def test_fifty_moves(self):
         # Test positions from Jan Timman vs. Christopher Lutz (1995).
         board = chess.Board()
+        self.assertFalse(board.is_fifty_moves())
         self.assertFalse(board.can_claim_fifty_moves())
         board = chess.Board("8/5R2/8/r2KB3/6k1/8/8/8 w - - 19 79")
+        self.assertFalse(board.is_fifty_moves())
         self.assertFalse(board.can_claim_fifty_moves())
         board = chess.Board("8/8/6r1/4B3/8/4K2k/5R2/8 b - - 68 103")
+        self.assertFalse(board.is_fifty_moves())
         self.assertFalse(board.can_claim_fifty_moves())
         board = chess.Board("6R1/7k/8/8/1r3B2/5K2/8/8 w - - 99 119")
-        self.assertFalse(board.can_claim_fifty_moves())
+        self.assertFalse(board.is_fifty_moves())
+        self.assertTrue(board.can_claim_fifty_moves())
         board = chess.Board("8/7k/8/6R1/1r3B2/5K2/8/8 b - - 100 119")
+        self.assertTrue(board.is_fifty_moves())
         self.assertTrue(board.can_claim_fifty_moves())
         board = chess.Board("8/7k/8/1r3KR1/5B2/8/8/8 w - - 105 122")
+        self.assertTrue(board.is_fifty_moves())
         self.assertTrue(board.can_claim_fifty_moves())
 
         # Once checkmated, it is too late to claim.
         board = chess.Board("k7/8/NKB5/8/8/8/8/8 b - - 105 176")
+        self.assertFalse(board.is_fifty_moves())
         self.assertFalse(board.can_claim_fifty_moves())
 
         # A stalemate is a draw, but you can not and do not need to claim it by
         # the fifty-move rule.
         board = chess.Board("k7/3N4/1K6/1B6/8/8/8/8 b - - 99 1")
         self.assertTrue(board.is_stalemate())
         self.assertTrue(board.is_game_over())
+        self.assertFalse(board.is_fifty_moves())
         self.assertFalse(board.can_claim_fifty_moves())
         self.assertFalse(board.can_claim_draw())
 
