refactor: move search config (maxDepth, timeBudget, MaxSearchDepth) into SearchManager

Author: boraaros

Alligator.Solver/Algorithms/AlphaBetaPruning.cs

@@ -8,7 +8,6 @@ internal class AlphaBetaPruning<TPosition, TStep> : IAlphaBetaPruning<TPosition>
         private readonly IHeuristicTables<TStep> heuristicTables;
         private readonly ISearchManager searchManager;
 
-        private const int MaxSearchDepth = 48;
         private readonly List<TStep>[] orderedStepBuffers;
 
         public AlphaBetaPruning(
@@ -22,8 +21,8 @@ public AlphaBetaPruning(
             this.heuristicTables = heuristicTables ?? throw new ArgumentNullException(nameof(heuristicTables));
             this.searchManager = searchManager ?? throw new ArgumentNullException(nameof(searchManager));
 
-            orderedStepBuffers = new List<TStep>[MaxSearchDepth];
-            for (int i = 0; i < MaxSearchDepth; i++)
+            orderedStepBuffers = new List<TStep>[searchManager.MaxDepth];
+            for (int i = 0; i < searchManager.MaxDepth; i++)
             {
                 orderedStepBuffers[i] = new List<TStep>();
             }
@@ -189,16 +188,11 @@ private bool IsOpponentsTurn(int depth)
             return distanceFromRoot % 2 != 0;
         }
 
-        /// <summary>
-        /// Computes the terminal (win/loss) value at the given remaining depth.
-        /// Uses distance-from-root so the same game-theoretic outcome
-        /// produces the same value regardless of the current DepthLimit.
-        /// Closer wins score higher.
-        /// </summary>
+        // Distance-from-root makes this value independent of DepthLimit (important for TT consistency)
         private int WinValue(int depth)
         {
             int distanceFromRoot = searchManager.DepthLimit - depth;
-            return sbyte.MaxValue + MaxSearchDepth - distanceFromRoot;
+            return sbyte.MaxValue + searchManager.MaxDepth - distanceFromRoot;
         }
     }
 }

Alligator.Solver/Algorithms/AlphaBetaSolver.cs

@@ -9,23 +9,17 @@ internal class AlphaBetaSolver<TPosition, TStep> : ISolver<TStep>
         private readonly IRules<TPosition, TStep> rules;
         private readonly ISearchManager searchManager;
         private readonly Action<string> logger;
-        private readonly int maxDepth;
-        private readonly long timeBudgetMs;
 
         public AlphaBetaSolver(
             AlphaBetaPruning<TPosition, TStep> alphaBetaPruning,
             IRules<TPosition, TStep> rules,
             ISearchManager searchManager,
-            Action<string> logger,
-            int maxDepth,
-            long timeBudgetMs = 0)
+            Action<string> logger)
         {
             this.alphaBetaPruning = alphaBetaPruning ?? throw new ArgumentNullException(nameof(alphaBetaPruning));
             this.rules = rules ?? throw new ArgumentNullException(nameof(rules));
             this.searchManager = searchManager ?? throw new ArgumentNullException(nameof(searchManager));
             this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            this.maxDepth = maxDepth;
-            this.timeBudgetMs = timeBudgetMs;
         }
 
         public TStep OptimizeNextStep(IList<TStep> history)
@@ -34,12 +28,11 @@ public TStep OptimizeNextStep(IList<TStep> history)
             sw.Restart();
             var position = CreatePosition(history);
 
-TStep? bestStep = default;
-
-searchManager.StartTimedSearch(timeBudgetMs);
+            TStep? bestStep = default;
+            searchManager.StartSearch();
             var guess = 0;
 
-            for (int i = 2; i < maxDepth; i += 2) 
+            for (int i = 2; i < searchManager.MaxDepth; i += 2)
             {
                 searchManager.DepthLimit = i;
                 var (OptimalSteps, Value) = BestNodeSearch(position, guess);
@@ -60,7 +53,7 @@ public TStep OptimizeNextStep(IList<TStep> history)
 
         private (ICollection<TStep> OptimalSteps, int Value) BestNodeSearch(TPosition position, int guess)
         {
-            const int winScore = sbyte.MaxValue + 48; // must match AlphaBetaPruning.MaxSearchDepth
+            int winScore = sbyte.MaxValue + searchManager.MaxDepth;
             int alpha = -winScore;
             int beta = winScore;
 

Alligator.Solver/Algorithms/ISearchManager.cs

@@ -2,10 +2,11 @@
 {
     internal interface ISearchManager
     {
+        int MaxDepth { get; }
         int DepthLimit { get; set; }
         bool IsAborted { get; }
 
-        void StartTimedSearch(long timeBudgetMs);
+        void StartSearch();
         void CheckTimeBudget();
     }
 }

Alligator.Solver/Algorithms/SearchManager.cs

@@ -5,23 +5,24 @@ namespace Alligator.Solver.Algorithms
     internal class SearchManager : ISearchManager
     {
         private readonly Stopwatch stopwatch = new();
-        private long timeLimitMs;
+        private readonly long timeLimitMs;
         private int nodeCount;
 
+        public int MaxDepth { get; }
         public int DepthLimit { get; set; }
         public bool IsAborted { get; private set; }
 
-        public SearchManager(int depthLimit)
+        public SearchManager(int maxDepth, TimeSpan? timeBudget = null)
         {
-            DepthLimit = depthLimit;
+            MaxDepth = maxDepth;
+            timeLimitMs = (long)(timeBudget?.TotalMilliseconds ?? 0);
         }
 
-        public void StartTimedSearch(long timeBudgetMs)
+        public void StartSearch()
         {
-            timeLimitMs = timeBudgetMs;
             nodeCount = 0;
             IsAborted = false;
-            if (timeBudgetMs > 0)
+            if (timeLimitMs > 0)
             {
                 stopwatch.Restart();
             }

Alligator.Solver/SolverProvider.cs

@@ -41,15 +41,15 @@ public ISolver<TStep> Create()
 
         internal ISolver<TStep> Create(ICacheTables<TPosition, TStep> cacheTables, IHeuristicTables<TStep> heuristicTables)
         {
-            var searchManager = new SearchManager(6); // TODO: remove this ctor parameter
+            var searchManager = new SearchManager(
+                solverConfiguration.MaxDepth,
+                solverConfiguration.TimeBudget);
 
             return new AlphaBetaSolver<TPosition, TStep>(
-                new AlphaBetaPruning<TPosition, TStep>(rules, cacheTables, heuristicTables, searchManager), 
-                rules, 
-                searchManager, 
-                logger,
-                solverConfiguration.MaxDepth,
-                (long)(solverConfiguration.TimeBudget?.TotalMilliseconds ?? 0));
+                new AlphaBetaPruning<TPosition, TStep>(rules, cacheTables, heuristicTables, searchManager),
+                rules,
+                searchManager,
+                logger);
         }
     }
 }

Alligator.Test/SolverTests.cs

@@ -16,11 +16,11 @@ private static int Solve(TreeNode root, int maxDepth = 7)
             var rules = new TreeRules(root);
             var cacheTables = new CacheTables<TreePosition, int>();
             var heuristicTables = new HeuristicTables<int>();
-var searchManager = new SearchManager(maxDepth - 1);
+var searchManager = new SearchManager(maxDepth);
 var alphaBeta = new AlphaBetaPruning<TreePosition, int>(
     rules, cacheTables, heuristicTables, searchManager);
 var solver = new AlphaBetaSolver<TreePosition, int>(
-    alphaBeta, rules, searchManager, _ => { }, maxDepth);
+    alphaBeta, rules, searchManager, _ => { });
 
             return solver.OptimizeNextStep([]);
         }