Made PrincipalVariation simpler to use. It can now grow indefinitely and doesn't have a fixed capacity anymore!

lithander · lithander · commit 3be9f3eba764 · 2021-03-19T15:24:12.000+01:00
The "position fen" UCI command now doesn't always expect 7 tokens
Increased version to 0.3.1 PeSTO
diff --git a/MinimalChess/IterativeSearch.cs b/MinimalChess/IterativeSearch.cs
@@ -12,9 +12,9 @@ public class IterativeSearch
         public int Depth { get; private set; }
         public int Score { get; private set; }
         public Board Position => new Board(_root); //return copy, _root must not be modified during search!
-        public Move[] PrincipalVariation => Depth > 0 ? _pv.GetLine(Depth) : null;
+        public Move[] PrincipalVariation => _pv.GetLine(Depth);
         public bool Aborted => _killSwitch.Triggered;
-        public bool GameOver => _pv.IsGameOver(Depth);
+        public bool GameOver => PrincipalVariation?.Length < Depth;
 
         Board _root = null;
         List<Move> _rootMoves = null;
@@ -25,14 +25,14 @@ public IterativeSearch(Board board)
         {
             _root = new Board(board);
             _rootMoves = new LegalMoves(board);
-            _pv = new PrincipalVariation(20);
+            _pv = new PrincipalVariation();
         }
 
         public IterativeSearch(Board board, List<Move> rootMoves)
         {
             _root = new Board(board);
             _rootMoves = rootMoves;
-            _pv = new PrincipalVariation(20);
+            _pv = new PrincipalVariation();
         }
 
         public void Search(int maxDepth)
@@ -105,7 +105,7 @@ private int EvalPosition(Board position, int depth, SearchWindow window)
             if (expandedNodes == 0) //no expansion happened from this node!
             {
                 //having no legal moves can mean two things: (1) lost or (2) draw?
-                _pv.Clear(depth);
+                _pv[depth] = default;
                 return position.IsChecked(position.ActiveColor) ? (int)color * PeSTO.LostValue : 0;
             }
 
diff --git a/MinimalChess/PrincipalVariation.cs b/MinimalChess/PrincipalVariation.cs
@@ -4,13 +4,8 @@ namespace MinimalChess
 {
     class PrincipalVariation
     {
-        readonly Move[] _moves;
-
-        public PrincipalVariation(int maxDepth)
-        {
-            int length = Index(maxDepth + 1);
-            _moves = new Move[length];
-        }
+        Move[] _moves = new Move[0];
+        int _depth = 0;
 
         private int Index(int depth)
         {
@@ -19,36 +14,28 @@ private int Index(int depth)
             return (d * d + d) / 2;
         }
 
-        public void Clear(int depth)
+        public void Grow(int depth)
         {
-            int iDepth = Index(depth);
-            for (int i = 0; i < depth; i++)
-                _moves[iDepth + i] = default;
+            while (_depth < depth)
+                Grow();
         }
 
-        public void Grow(int depth)
+        private void Grow()
         {
-            //TODO: if depth > maxdepth return or else we get a crash. but that's fine for now as it will probably a bug has caused an "endless" search and we want to find those!
-
-            Clear(depth);
-            if (depth <= 1)
-                return;
-
-            //copy previous line
-            int start = Index(depth - 1);
-            int nullMove = Array.IndexOf(_moves, default, start, depth);
-            int count = nullMove - start;
-
-            Clear(depth);
-            int target = Index(depth);
-            for (int i = 0; i < count; i++)
-                _moves[target + i] = _moves[start + i];
-
-            //copy to sub-pv's
-            for (int i = 1; i < depth; i++)
+            _depth++;
+            int size = Index(_depth + 1);
+            Move[] moves = new Move[size];
+            //copy pv lines to new array
+            int to = 0;
+            for (int depth = 0; depth < _depth; depth++)
             {
-                this[i] = _moves[target + depth - i];
+                //copy the last d elements of the mainline 
+                for (int i = 0; i < depth; i++)
+                    moves[to++] = _moves[^(depth - i)];
+                //leave one free
+                to++;
             }
+            _moves = moves;
         }
 
         public Move[] GetLine(int depth)
@@ -58,17 +45,10 @@ public Move[] GetLine(int depth)
             int count = (nullMove == -1) ? depth : nullMove - start;
 
             Move[] line = new Move[count];
-            Array.Copy(_moves, Index(depth), line, 0, count);
+            Array.Copy(_moves, start, line, 0, count);
             return line;
         }
 
-        public bool IsGameOver(int depth)
-        {
-            int start = Index(depth);
-            int nullMove = Array.IndexOf(_moves, default, start, depth);
-            return nullMove != -1;
-        }
-
         public Move this[int depth]
         {
             get
@@ -79,7 +59,7 @@ public Move this[int depth]
             {
                 int a = Index(depth);
                 _moves[a] = value;
-
+                //remember the continuation
                 int b = Index(depth - 1);
                 for (int i = 0; i < depth - 1; i++)
                     _moves[a + i + 1] = _moves[b + i];
diff --git a/MinimalChessEngine/Program.cs b/MinimalChessEngine/Program.cs
@@ -7,7 +7,7 @@ namespace MinimalChessEngine
 {
     public static class Program
     {
-        const string NAME_VERSION = "MinimalChess 0.3 PeSTO";
+        const string NAME_VERSION = "MinimalChess 0.3.1 PeSTO";
 
         static Engine _engine = new Engine();
 
@@ -75,7 +75,10 @@ private static void UciPosition(string[] tokens)
             if (tokens[1] == "startpos")
                 _engine.SetupPosition(new Board(Board.STARTING_POS_FEN));
             else if (tokens[1] == "fen") //rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
-                _engine.SetupPosition(new Board($"{tokens[2]} {tokens[3]} {tokens[4]} {tokens[5]} {tokens[6]} {tokens[7]}"));
+            {
+                string fen = string.Join(' ', tokens[2..]);
+                _engine.SetupPosition(new Board(fen));
+            }
             else
             {
                 Uci.Log("'position' parameters missing or not understood. Assuming 'startpos'.");
diff --git a/MinimalChessEngine/Properties/PublishProfiles/Windows x64.pubxml b/MinimalChessEngine/Properties/PublishProfiles/Windows x64.pubxml
@@ -8,7 +8,7 @@ https://go.microsoft.com/fwlink/?LinkID=208121.
     <Configuration>Release</Configuration>
     <Platform>Any CPU</Platform>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-    <PublishDir>D:\Projekte\Chess\Builds\MinimalChess 0.3 Windows</PublishDir>
+    <PublishDir>D:\Projekte\Chess\Builds\MinimalChess 0.3.1 PeSTO Windows</PublishDir>
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>
     <SelfContained>true</SelfContained>
     <PublishSingleFile>True</PublishSingleFile>

Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ public class IterativeSearch`
`12`	`12`	`public int Depth { get; private set; }`
`13`	`13`	`public int Score { get; private set; }`
`14`	`14`	`public Board Position => new Board(_root); //return copy, _root must not be modified during search!`
`15`		`- public Move[] PrincipalVariation => Depth > 0 ? _pv.GetLine(Depth) : null;`
	`15`	`+ public Move[] PrincipalVariation => _pv.GetLine(Depth);`
`16`	`16`	`public bool Aborted => _killSwitch.Triggered;`
`17`		`- public bool GameOver => _pv.IsGameOver(Depth);`
	`17`	`+ public bool GameOver => PrincipalVariation?.Length < Depth;`
`18`	`18`
`19`	`19`	`Board _root = null;`
`20`	`20`	`List<Move> _rootMoves = null;`
`@@ -25,14 +25,14 @@ public IterativeSearch(Board board)`
`25`	`25`	`{`
`26`	`26`	`_root = new Board(board);`
`27`	`27`	`_rootMoves = new LegalMoves(board);`
`28`		`- _pv = new PrincipalVariation(20);`
	`28`	`+ _pv = new PrincipalVariation();`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public IterativeSearch(Board board, List<Move> rootMoves)`
`32`	`32`	`{`
`33`	`33`	`_root = new Board(board);`
`34`	`34`	`_rootMoves = rootMoves;`
`35`		`- _pv = new PrincipalVariation(20);`
	`35`	`+ _pv = new PrincipalVariation();`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public void Search(int maxDepth)`
`@@ -105,7 +105,7 @@ private int EvalPosition(Board position, int depth, SearchWindow window)`
`105`	`105`	`if (expandedNodes == 0) //no expansion happened from this node!`
`106`	`106`	`{`
`107`	`107`	`//having no legal moves can mean two things: (1) lost or (2) draw?`
`108`		`- _pv.Clear(depth);`
	`108`	`+ _pv[depth] = default;`
`109`	`109`	`return position.IsChecked(position.ActiveColor) ? (int)color * PeSTO.LostValue : 0;`
`110`	`110`	`}`
`111`	`111`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace MinimalChessEngine`
`7`	`7`	`{`
`8`	`8`	`public static class Program`
`9`	`9`	`{`
`10`		`- const string NAME_VERSION = "MinimalChess 0.3 PeSTO";`
	`10`	`+ const string NAME_VERSION = "MinimalChess 0.3.1 PeSTO";`
`11`	`11`
`12`	`12`	`static Engine _engine = new Engine();`
`13`	`13`
`@@ -75,7 +75,10 @@ private static void UciPosition(string[] tokens)`
`75`	`75`	`if (tokens[1] == "startpos")`
`76`	`76`	`_engine.SetupPosition(new Board(Board.STARTING_POS_FEN));`
`77`	`77`	`else if (tokens[1] == "fen") //rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1`
`78`		`- _engine.SetupPosition(new Board($"{tokens[2]} {tokens[3]} {tokens[4]} {tokens[5]} {tokens[6]} {tokens[7]}"));`
	`78`	`+ {`
	`79`	`+ string fen = string.Join(' ', tokens[2..]);`
	`80`	`+ _engine.SetupPosition(new Board(fen));`
	`81`	`+ }`
`79`	`82`	`else`
`80`	`83`	`{`
`81`	`84`	`Uci.Log("'position' parameters missing or not understood. Assuming 'startpos'.");`