MoveList now stores SortedMove instead of Move: a struct that stores a move together with a priority. This eliminates the cost of repeatedly computing MvvLva or history values for moves while sorting. It's not a big ELO win but it's a more obvious choice for handling the move sorting and thus a better fit for a engine that tries to keep things simple and stupid.

lithander · lithander · commit be7d68750600 · 2021-08-28T22:50:11.000+02:00
diff --git a/MinimalChess/MoveCollection.cs b/MinimalChess/MoveCollection.cs
@@ -37,61 +37,46 @@ public static bool HasMoves(Board position)
         }
     }
 
-    public class MoveList : List<Move>
+    public struct SortedMove : IComparable<SortedMove>
+    {
+        public float Priority;
+        public Move Move;
+        public int CompareTo(SortedMove other) => other.Priority.CompareTo(Priority);
+        public static implicit operator Move(SortedMove m) => m.Move;
+    }
+
+    public class MoveList : List<SortedMove>
     {
         internal static MoveList Quiets(Board position)
         {
             MoveList quietMoves = new MoveList();
-            position.CollectQuiets(quietMoves.Add);
+            position.CollectQuiets(m => quietMoves.Add(m, 0));
             return quietMoves;
         }
 
         internal static MoveList SortedCaptures(Board position)
         {
             MoveList captures = new MoveList();
-            position.CollectCaptures(captures.Add);
-            captures.SortMvvLva(position);
+            position.CollectCaptures(m => captures.Add(m, ScoreMvvLva(m, position)));
+            captures.Sort();
             return captures;
         }
 
-        internal static MoveList SortedQuiets(Board position, History history, float threshold)
-        {
-            MoveList quiets = new MoveList();
-            position.CollectQuiets(move =>
-            {
-                float score = history.Value(position, move);
-                //if score >= threshold insertion-sort else just add
-                int index = score >= threshold ? quiets.FindIndex(m => history.Value(position, m) <= score) : -1;
-                if (index >= 0)
-                    quiets.Insert(index, move);
-                else
-                    quiets.Add(move);
-            });
-            return quiets;
-        }
-
         public static MoveList SortedQuiets(Board position, History history)
         {
             MoveList quiets = new MoveList();
-            position.CollectQuiets(quiets.Add);
-            quiets.SortHistory(position, history);
+            position.CollectQuiets(m => quiets.Add(m, history.Value(position, m)));
+            quiets.Sort();
             return quiets;
         }
 
-        private void SortMvvLva(Board context)
+        private static int ScoreMvvLva(Move move, Board context)
         {
-            int Score(Move move)
-            {
-                Piece victim = context[move.ToSquare];
-                Piece attacker = context[move.FromSquare];
-                return Pieces.MaxOrder * Pieces.Order(victim) - Pieces.Order(attacker);
-            }
-            Sort((a, b) => Score(b).CompareTo(Score(a)));
+            Piece victim = context[move.ToSquare];
+            Piece attacker = context[move.FromSquare];
+            return Pieces.MaxOrder * Pieces.Order(victim) - Pieces.Order(attacker);
         }
 
-        private void SortHistory(Board context, History history)
-        {
-            Sort((a, b) => history.Value(context, b).CompareTo(history.Value(context, a)));
-        }
+        private void Add(Move move, float priority) => Add(new SortedMove { Move = move, Priority = priority });
     }
 }
