Implement Killer move heuristic

In closed positions with very few good captures, this heuristic cuts down the search tree much faster. Easiest example is FEN "r2q1rk1/p1p1ppbp/2pp1np1/8/3PP3/2N2Q1P/PPP2PP1/R1B1K2R w KQ - 0 10". At depth 6, this brings down node traversal count from 758872 to 158769 - a huge improvement.

Rudim/Board/MoveOrdering.cs

@@ -5,6 +5,7 @@ namespace Rudim.Board
     static class MoveOrdering
     {
         private static readonly int[,] MVVLVA;
+        private static Move[,] KillerMoves;
 
         static MoveOrdering()
         {
@@ -18,11 +19,20 @@ static MoveOrdering()
                { 0, 0, 0, 0, 0, 0, 0 },       // K
                { 0, 0, 0, 0, 0, 0, 0 }        // None
             };
+            KillerMoves = new Move[2, Constants.MaxPly];
         }
-        public static void PopulateMoveScore(Move move, BoardState boardState)
+        public static void PopulateMoveScore(Move move, BoardState boardState, int ply = Constants.MaxPly - 1)
         {
             if (!move.IsCapture())
-                move.Score = 0;
+            {
+                if (move == KillerMoves[0, ply])
+                    move.Score = 9; // TODO : Revisit, assign better values and extract to constants
+                else if (move == KillerMoves[1, ply])
+                    move.Score = 8;
+                else
+                    move.Score = 0;
+                return;
+            }
             var targetPiece = (int)Piece.None;
             var sourcePiece = boardState.GetPieceOn(move.Source, boardState.SideToMove);
             if (move.Type == MoveTypes.EnPassant)
@@ -32,6 +42,14 @@ public static void PopulateMoveScore(Move move, BoardState boardState)
             move.Score = MVVLVA[targetPiece, sourcePiece];
         }
 
+        public static void AddKillerMove(Move move, int ply)
+        {
+            if (KillerMoves[0, ply] != move)
+            {
+                KillerMoves[1, ply] = KillerMoves[0, ply];
+                KillerMoves[0, ply] = move;
+            }
+        }
         public static void SortMoves(BoardState boardState)
         {
             // TODO : Partially sort within the loop only to avoid sorting elements that are not going to be queried after beta cutoff?

Rudim/Common/Constants.cs

@@ -11,5 +11,6 @@ public static class Constants
         public const int MaxRookMask = 1 << 12;
         public const int MaxMaskIndex = MaxRookMask;
         public const int MaxCentipawnEval = 49000;
+        public const int MaxPly = 64;
     }
 }

Rudim/Common/Move.cs

@@ -1,9 +1,10 @@
 using Rudim.Board;
 using System;
+using System.Collections.Generic;
 
 namespace Rudim.Common
 {
-    public class Move
+    public class Move : IEquatable<Move>
     {
         public Square Source { get; set; }
         public Square Target { get; set; }
@@ -66,5 +67,33 @@ private static Square ParseFromString(string squareString)
             _ = Enum.TryParse(squareString, out square);
             return square;
         }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as Move);
+        }
+
+        public bool Equals(Move other)
+        {
+            return other != null &&
+                   Source == other.Source &&
+                   Target == other.Target &&
+                   EqualityComparer<MoveType>.Default.Equals(Type, other.Type);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Source, Target, Type);
+        }
+
+        public static bool operator ==(Move left, Move right)
+        {
+            return EqualityComparer<Move>.Default.Equals(left, right);
+        }
+
+        public static bool operator !=(Move left, Move right)
+        {
+            return !(left == right);
+        }
     }
 }

Rudim/Search/Negamax.cs

@@ -19,10 +19,11 @@ public static int Search(BoardState boardState, int depth, int alpha, int beta)
             Move bestEvaluation = null;
 
             boardState.GenerateMoves();
+            var ply = SearchDepth - depth;
             // TODO : Flag in GenerateMoves to avoid extra iteration?
             foreach (var move in boardState.Moves)
             {
-                MoveOrdering.PopulateMoveScore(move, boardState);
+                MoveOrdering.PopulateMoveScore(move, boardState, ply);
             }
 
             MoveOrdering.SortMoves(boardState);
@@ -42,7 +43,11 @@ public static int Search(BoardState boardState, int depth, int alpha, int beta)
                 boardState.UnmakeMove(move);
                 numberOfLegalMoves++;
                 if (score >= beta)
+                {
+                    if (!move.IsCapture())
+                        MoveOrdering.AddKillerMove(move, ply);
                     return beta;
+                }
                 if (score > alpha)
                 {
                     alpha = score;