[5/9] Add MVV-LVA capture ordering and killer moves heuristic

Improves move ordering for better pruning:

**MVV-LVA (Most Valuable Victim - Least Valuable Attacker):**
- Sort captures by MVV-LVA score in `organize_moves()`
- Best captures (e.g., pawn takes queen) searched first
- Increases beta cutoff rate for better pruning

**Killer Moves Heuristic:**
- Track quiet moves that cause beta cutoffs (2 per ply)
- Add `killers` parameter to `organize_moves()` and `negamax()`
- Killer moves searched after captures, before other quiet moves
- Killers stored in a table indexed by ply depth

**Move Ordering Priority:**
1. Captures (sorted by MVV-LVA)
2. Killer moves (quiet moves that caused cutoffs at this ply)
3. Other quiet moves (shuffled for variety)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: luccabb

moonfish/engines/alpha_beta.py

@@ -184,6 +184,8 @@ def negamax(
         cache: DictProxy | CACHE_TYPE,
         alpha: float = float("-inf"),
         beta: float = float("inf"),
+        ply: int = 0,
+        killers: Optional[list] = None,
     ) -> Tuple[float | int, Optional[Move]]:
         """
         This functions receives a board, depth and a player; and it returns
@@ -275,6 +277,8 @@ def negamax(
                     cache=cache,
                     alpha=-beta,
                     beta=-beta + 1,
+                    ply=ply + 1,
+                    killers=killers,
                 )[0]
                 board.pop()
                 if board_score >= beta:
@@ -284,9 +288,12 @@ def negamax(
 
         best_move = None
         best_score = float("-inf")
-        moves = organize_moves(board)
+        ply_killers = killers[ply] if killers and ply < len(killers) else None
+        moves = organize_moves(board, ply_killers)
 
         for move in moves:
+            is_capture = board.is_capture(move)
+
             # make the move
             board.push(move)
 
@@ -297,6 +304,8 @@ def negamax(
                 cache=cache,
                 alpha=-beta,
                 beta=-alpha,
+                ply=ply + 1,
+                killers=killers,
             )[0]
             if board_score > self.config.checkmate_threshold:
                 board_score -= 1
@@ -313,6 +322,18 @@ def negamax(
 
             # beta-cutoff: opponent won't allow this position
             if best_score >= beta:
+                # Update killer moves for quiet moves that cause beta cutoff
+                # Add to killers if not already there (keep 2 killers per ply)
+                if (
+                    killers
+                    and not is_capture
+                    and ply < len(killers)
+                    and move not in killers[ply]
+                ):
+                    killers[ply].insert(0, move)
+                    if len(killers[ply]) > 2:
+                        killers[ply].pop()
+
                 # LOWER_BOUND: true score is at least best_score
                 cache[cache_key] = (best_score, best_move, Bound.LOWER_BOUND, depth)
                 return best_score, best_move
@@ -339,8 +360,18 @@ def search_move(self, board: Board) -> Move:
         # create shared cache
         cache: CACHE_TYPE = {}
 
+        # Killer moves table: 2 killers per ply
+        # Max ply is roughly target_depth + quiescence_depth + some buffer
+        max_ply = self.config.negamax_depth + self.config.quiescence_search_depth + 10
+        killers: list = [[] for _ in range(max_ply)]
+
         best_move = self.negamax(
-            board, copy(self.config.negamax_depth), self.config.null_move, cache
+            board,
+            copy(self.config.negamax_depth),
+            self.config.null_move,
+            cache,
+            ply=0,
+            killers=killers,
         )[1]
         assert best_move is not None, "Best move from root should not be None"
         return best_move

moonfish/move_ordering.py

@@ -1,34 +1,54 @@
 import random
+from typing import List, Optional
 
 from chess import BLACK, Board, Move
 
 from moonfish.psqt import evaluate_capture, evaluate_piece, get_phase
 
 
-def organize_moves(board: Board):
+def organize_moves(board: Board, killers: Optional[List[Move]] = None):
     """
     This function receives a board and it returns a list of all the
     possible moves for the current player, sorted by importance.
-    It sends capturing moves at the starting positions in
-    the array (to try to increase pruning and do so earlier).
+
+    Order: captures (sorted by MVV-LVA) -> killer moves -> other quiet moves
 
     Arguments:
             - board: chess board state
+            - killers: optional list of killer moves for this ply
 
     Returns:
             - legal_moves: list of all the possible moves for the current player.
     """
     non_captures = []
     captures = []
+    phase = get_phase(board)
 
     for move in board.legal_moves:
         if board.is_capture(move):
             captures.append(move)
         else:
             non_captures.append(move)
 
-    random.shuffle(captures)
+    # Sort captures by MVV-LVA (best captures first)
+    captures.sort(
+        key=lambda move: mvv_lva(board, move, phase), reverse=(board.turn != BLACK)
+    )
+
+    # Shuffle non-captures for variety, then we'll extract killers
     random.shuffle(non_captures)
+
+    # Extract killer moves from non-captures and put them first
+    if killers:
+        killer_moves = []
+        remaining_quiet = []
+        for move in non_captures:
+            if move in killers:
+                killer_moves.append(move)
+            else:
+                remaining_quiet.append(move)
+        non_captures = killer_moves + remaining_quiet
+
     return captures + non_captures