[4/9] Improve quiescence search

Enhances quiescence search with better handling of special positions:

**Draw Detection:**
- Check fifty-move rule and insufficient material
- Detect repetitions when making moves (return 0 for draws)

**Check Handling:**
- When in check, search ALL legal moves (evasions), not just captures
- Can't use stand-pat for pruning when in check (position is unstable)
- Separate best_score tracking for in-check vs normal positions

**Tactical Move Detection:**
- Add `is_tactical_move()` helper function
- Tactical moves: captures, promotions, and checks
- Previously included quiet pawn pushes (is_zeroing), now more precise

**Move Ordering:**
- Update `organize_moves_quiescence()` to use is_tactical_move
- Sort tactical moves by MVV-LVA

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: luccabb

moonfish/engines/alpha_beta.py

@@ -104,47 +104,77 @@ def quiescence_search(
         Returns:
             - best_score: returns best move's score.
         """
-        if board.is_stalemate():
-            return 0
+        in_check = board.is_check()
 
         if board.is_checkmate():
             return -self.config.checkmate_score
 
+        if board.is_stalemate():
+            return 0
+
+        # Draw detection: fifty-move rule, insufficient material
+        # Note: Repetition is checked after making moves, not here
+        if board.is_fifty_moves() or board.is_insufficient_material():
+            return 0
+
         stand_pat = self.eval_board(board)
 
-        # recursion base case
-        if depth == 0:
-            return stand_pat
+        # When in check, we can't use stand-pat for pruning (position is unstable)
+        # We must search all evasions. However, still respect depth limit.
+        if in_check:
+            # In check: search all evasions, but don't use stand-pat for cutoffs
+            if depth <= 0:
+                # At depth limit while in check: return evaluation
+                # (not ideal but prevents infinite recursion)
+                return stand_pat
+
+            best_score = float("-inf")
+            moves = list(board.legal_moves)  # All evasions
+        else:
+            # Not in check: normal quiescence behavior
+            # recursion base case
+            if depth <= 0:
+                return stand_pat
 
-        # beta-cutoff
-        if stand_pat >= beta:
-            return beta
+            # beta-cutoff: position is already good enough
+            if stand_pat >= beta:
+                return beta
 
-        # alpha update
-        alpha = max(alpha, stand_pat)
+            # Use stand-pat as baseline (we can always choose not to capture)
+            best_score = stand_pat
+            alpha = max(alpha, stand_pat)
 
-        # get moves for quiescence search
-        moves = organize_moves_quiescence(board)
+            # Only tactical moves when not in check
+            moves = organize_moves_quiescence(board)
 
         for move in moves:
             # make move and get score
             board.push(move)
-            score = -self.quiescence_search(
-                board=board,
-                depth=depth - 1,
-                alpha=-beta,
-                beta=-alpha,
-            )
+
+            # Check if this move leads to a repetition (draw)
+            if board.is_repetition(2):
+                score: float = 0  # Draw score
+            else:
+                score = -self.quiescence_search(
+                    board=board,
+                    depth=depth - 1,
+                    alpha=-beta,
+                    beta=-alpha,
+                )
+
             board.pop()
 
+            if score > best_score:
+                best_score = score
+
             # beta-cutoff
             if score >= beta:
                 return beta
 
             # alpha-update
             alpha = max(alpha, score)
 
-        return alpha
+        return best_score
 
     def negamax(
         self,

moonfish/move_ordering.py

@@ -32,26 +32,45 @@ def organize_moves(board: Board):
     return captures + non_captures
 
 
+def is_tactical_move(board: Board, move: Move) -> bool:
+    """
+    Check if a move is tactical (should be searched in quiescence).
+
+    Tactical moves are:
+    - Captures (change material)
+    - Promotions (significant material gain)
+    - Moves that give check (forcing)
+    """
+    return (
+        board.is_capture(move) or move.promotion is not None or board.gives_check(move)
+    )
+
+
 def organize_moves_quiescence(board: Board):
     """
     This function receives a board and it returns a list of all the
     possible moves for the current player, sorted by importance.
 
+    Only returns tactical moves: captures, promotions, and checks.
+
     Arguments:
             - board: chess board state
 
     Returns:
-            - moves: list of all the possible moves for the current player sorted based on importance.
+            - moves: list of tactical moves sorted by importance (MVV-LVA).
     """
     phase = get_phase(board)
-    # filter only important moves for quiescence search
-    captures = filter(
-        lambda move: board.is_zeroing(move) or board.gives_check(move),
+
+    # Filter only tactical moves for quiescence search
+    # (captures, promotions, checks - NOT quiet pawn pushes)
+    tactical_moves = filter(
+        lambda move: is_tactical_move(board, move),
         board.legal_moves,
     )
-    # sort moves by importance
+
+    # Sort moves by importance using MVV-LVA
     moves = sorted(
-        captures,
+        tactical_moves,
         key=lambda move: mvv_lva(board, move, phase),
         reverse=(board.turn == BLACK),
     )