Did a little code review and cleaned up and fixed a few things here and there. Nothing major.

lithander · lithander · commit 55a907c71d08 · 2021-08-28T22:51:31.000+02:00
diff --git a/MinimalChess/Board.cs b/MinimalChess/Board.cs
@@ -104,15 +104,12 @@ private set
 
         //Rank - the eight horizontal rows of the chess board are called ranks.
         //File - the eight vertical columns of the chess board are called files.
-        public Piece this[int rank, int file]
-        {
-            get => _state[rank * 8 + file];
-        }
+        public Piece this[int rank, int file] => _state[rank * 8 + file];
 
         public void SetupPosition(string fen)
         {
             //Startpos in FEN looks like this: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-            https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation
+            //https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation
             string[] fields = fen.Split();
             if (fields.Length < 4)
                 throw new ArgumentException($"FEN needs at least 4 fields. Has only {fields.Length} fields.");
@@ -645,36 +642,6 @@ private void SetCastlingRights(CastlingRights flag, bool state)
             _zobristHash ^= Zobrist.Castling(_castlingRights);
         }
 
-        public override bool Equals(object obj)
-        {
-            if (obj is Board board)
-                return Equals(board);
-
-            return false;
-        }
-
-        public bool Equals(Board other)
-        {
-            //Used for detecting repetition
-            //From: https://en.wikipedia.org/wiki/Threefold_repetition
-            //Two positions are by definition "the same" if... 
-            //1.) the same player has the move 
-            if (other._sideToMove != _sideToMove)
-                return false;
-            //2.) the remaining castling rights are the same and 
-            if (other._castlingRights != _castlingRights)
-                return false;
-            //3.) the possibility to capture en passant is the same. 
-            if (other._enPassantSquare != _enPassantSquare)
-                return false;
-            //4.) the same types of pieces occupy the same squares
-            for (int square = 0; square < 64; square++)
-                if (other._state[square] != _state[square])
-                    return false;
-
-            return true;
-        }
-
         private void InitZobristHash()
         {
             //Side to move
diff --git a/MinimalChess/Evaluation.cs b/MinimalChess/Evaluation.cs
@@ -220,8 +220,6 @@ public static double Linstep(double edge0, double edge1, double value)
             0,   30,    3,   12,    5,  -99,    0,      6,    4,    7,   -8,    6,    0,  // K
         };
 
-        public static int DynamicScore;
-
         public static int ComputeMobility(Board board)
         {
             int mobility = 0;
diff --git a/MinimalChess/History.cs b/MinimalChess/History.cs
@@ -1,10 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace MinimalChess
+﻿namespace MinimalChess
 {
     public class History
     {
@@ -45,7 +39,7 @@ public float Value(Board context, Move move)
             int iPiece = PieceIndex(context[move.FromSquare]);
             float a = Positive[move.ToSquare, iPiece];
             float b = Negative[move.ToSquare, iPiece];
-            return a / (a + b + 1);//Interval [0..1]
+            return a / (a + b + 1);//ratio of good increments in the range of [0..1]
         }
     }
 }
diff --git a/MinimalChess/IterativeSearch.cs b/MinimalChess/IterativeSearch.cs
@@ -20,6 +20,7 @@ public class IterativeSearch
         private History _history;
         private KillSwitch _killSwitch;
         private long _maxNodes;
+        private int _mobilityBonus;
 
         public IterativeSearch(Board board, long maxNodes = long.MaxValue)
         {
@@ -38,7 +39,7 @@ public IterativeSearch(int searchDepth, Board board) : this(board)
         public void SearchDeeper(Func<bool> killSwitch = null)
         {
             Depth++;
-            _killers.Resize(Depth);
+            _killers.Expand(Depth);
             _history.Scale();
             StorePVinTT(PrincipalVariation, Depth);
             _killSwitch = new KillSwitch(killSwitch);
@@ -69,7 +70,7 @@ private void StorePVinTT(Move[] pv, int depth)
         {
             if (depth <= 0)
             {
-                Evaluation.DynamicScore = Evaluation.ComputeMobility(position);
+                _mobilityBonus = Evaluation.ComputeMobility(position);
                 return (QEval(position, window), Array.Empty<Move>());
             }
 
@@ -103,7 +104,7 @@ private void StorePVinTT(Move[] pv, int depth)
                 //moves after the PV node are unlikely to raise alpha. try to avoid a full evaluation!
                 if(expandedNodes > 1)
                 {
-                    bool tactical = isChecked || (move.Promotion > Piece.Queen) || child.IsChecked(child.SideToMove);
+                    bool tactical = isChecked || child.IsChecked(child.SideToMove);
 
                     //some moves are hopeless and can be skipped without deeper evaluation
                     if (depth <= 4 && !tactical)
@@ -176,7 +177,7 @@ private int QEval(Board position, SearchWindow window)
             //if inCheck we can't use standPat, need to escape check!
             if (!inCheck)
             {
-                int standPatScore = Evaluation.DynamicScore + position.Score;
+                int standPatScore = position.Score + _mobilityBonus;
                 //Cut will raise alpha and perform beta cutoff when standPatScore is too good
                 if (window.Cut(standPatScore, color))
                     return window.GetScore(color);
diff --git a/MinimalChess/KillSwitch.cs b/MinimalChess/KillSwitch.cs
@@ -2,7 +2,7 @@
 
 namespace MinimalChess
 {
-    public struct KillSwitch
+    struct KillSwitch
     {
         Func<bool> _killSwitch;
         bool _aborted;
diff --git a/MinimalChess/KillerMoves.cs b/MinimalChess/KillerMoves.cs
@@ -10,12 +10,12 @@ class KillerMoves
 
         public KillerMoves(int width)
         {
-            _moves = new Move[0];
+            _moves = Array.Empty<Move>();
             _depth = 0;
             _width = width;
         }
 
-        public void Resize(int depth)
+        public void Expand(int depth)
         {
             _depth = Math.Max(_depth, depth);
             Array.Resize(ref _moves, _depth * _width);
diff --git a/MinimalChess/Move.cs b/MinimalChess/Move.cs
@@ -30,7 +30,7 @@ public Move(string uciMoveNotation)
                 throw new ArgumentException($"Long algebraic notation expected. '{uciMoveNotation}' is too long!");
 
             //expected format is the long algebraic notation without piece names
-            https://en.wikipedia.org/wiki/Algebraic_notation_(chess)
+            //https://en.wikipedia.org/wiki/Algebraic_notation_(chess)
             //Examples: e2e4, e7e5, e1g1(white short castling), e7e8q(for promotion)
             string fromSquare = uciMoveNotation.Substring(0, 2);
             string toSquare = uciMoveNotation.Substring(2, 2);
diff --git a/MinimalChess/Notation.cs b/MinimalChess/Notation.cs
@@ -58,7 +58,7 @@ public static string ToSquareName(byte squareIndex)
         public static byte ToSquare(string squareNotation)
         {
             //Each square has a unique identification of file letter followed by rank number.
-            https://en.wikipedia.org/wiki/Algebraic_notation_(chess)
+            //https://en.wikipedia.org/wiki/Algebraic_notation_(chess)
             //Examples: White's king starts the game on square e1; Black's knight on b8 can move to open squares a6 or c6.
 
             //Map letters [a..h] to [0..7] with ASCII('a') == 97
diff --git a/MinimalChess/Playmaker.cs b/MinimalChess/Playmaker.cs
@@ -1,6 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Diagnostics;
+﻿using System.Collections.Generic;
 
 namespace MinimalChess
 {
diff --git a/MinimalChessBoard/AlgebraicNotation.cs b/MinimalChessBoard/AlgebraicNotation.cs
@@ -77,7 +77,7 @@ public static Move ToMove(Board board, string notation)
             throw new ArgumentException($"Move notation {notation} could not be parsed!");
         }
 
-        private static Move SelectMove(Board board, Piece moving, int toSquare, Piece promotion, char? disambiguate = null)
+        private static Move SelectMove(Board board, Piece moving, int toSquare, Piece promotion, char? fileOrRank = null)
         {
             foreach (var move in new LegalMoves(board))
             {
@@ -87,7 +87,7 @@ private static Move SelectMove(Board board, Piece moving, int toSquare, Piece pr
                     continue;
                 if (Pieces.Type(board[move.FromSquare]) != Pieces.Type(moving))
                     continue;
-                if (disambiguate is char fileOrRank && !Notation.ToSquareName(move.FromSquare).Contains(fileOrRank))
+                if (fileOrRank != null && !Notation.ToSquareName(move.FromSquare).Contains(fileOrRank.Value))
                     continue;
 
                 return move; //this is the move!
diff --git a/MinimalChessBoard/PerftTable.cs b/MinimalChessBoard/PerftTable.cs
@@ -1,6 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace MinimalChessBoard
 {
diff --git a/MinimalChessBoard/Program.cs b/MinimalChessBoard/Program.cs
@@ -14,10 +14,9 @@ static void Main()
         {
             CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
 
-            bool running = true;
             Board board = new Board(Board.STARTING_POS_FEN);
             Move move = default;
-            while (running)
+            while (true)
             {
                 try
                 {
@@ -213,9 +212,8 @@ private static long Perft(Board board, int depth)
             if (PerftTable.Retrieve(board.ZobristHash, depth, out long childCount))
                 return childCount;
 
-            var moves = new LegalMoves(board);
             long sum = 0;
-            foreach (var move in moves)
+            foreach (var move in new LegalMoves(board))
                 sum += Perft(new Board(board, move), depth - 1);
 
             PerftTable.Store(board.ZobristHash, depth, sum);
@@ -236,10 +234,9 @@ private static void RunPerft(Board board, int depth)
 
         private static void RunDivide(Board board, int depth)
         {
-            var moves = new LegalMoves(board);
             long sum = 0;
             Board next = new Board(board);
-            foreach (var move in moves)
+            foreach (var move in new LegalMoves(board))
             {
                 next.Copy(board);
                 next.Play(move);
diff --git a/MinimalChessEngine/Engine.cs b/MinimalChessEngine/Engine.cs
@@ -1,6 +1,5 @@
 ﻿using MinimalChess;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 
 
diff --git a/MinimalChessEngine/Program.cs b/MinimalChessEngine/Program.cs
@@ -7,10 +7,12 @@ namespace MinimalChessEngine
 {
     public static class Program
     {
-        const string NAME_VERSION = "MinimalChess 0.5.13";
+        const string NAME_VERSION = "MinimalChess 0.6";
+        const string AUTHOR = "Thomas Jahn";
 
         static Engine _engine = new Engine();
-        static async Task Main()
+
+        private static async Task Main()
         {
             Console.WriteLine(NAME_VERSION);
             Start();
@@ -35,7 +37,7 @@ private static void ParseUciCommand(string input)
             {
                 case "uci":
                     Console.WriteLine($"id name {NAME_VERSION}");
-                    Console.WriteLine($"id author Thomas Jahn");
+                    Console.WriteLine($"id author {AUTHOR}");
                     Console.WriteLine($"option name Hash type spin default {Transpositions.DEFAULT_SIZE_MB} min 1 max 2047");//consider gcAllowVeryLargeObjects if larger TT is needed
                     Console.WriteLine("uciok");
                     break;
diff --git a/MinimalChessEngine/Uci.cs b/MinimalChessEngine/Uci.cs
@@ -1,19 +1,16 @@
 ﻿using MinimalChess;
 using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace MinimalChessEngine
 {
     public static class Uci
     {
-        static public void BestMove(Move move)
+        public static void BestMove(Move move)
         {
             Console.WriteLine($"bestmove {move}");
         }
 
-        static internal void Info(int depth, int score, long nodes, int timeMs, Move[] pv)
+        public static void Info(int depth, int score, long nodes, int timeMs, Move[] pv)
         {
             double tS = Math.Max(1, timeMs) / 1000.0;
             int nps = (int)(nodes / tS);
@@ -32,7 +29,7 @@ private static string ScoreToString(int score, int plies)
             return $"mate {Math.Sign(score) * moves}";
         }
 
-        static public void Log(string message)
+        public static void Log(string message)
         {
             Console.WriteLine($"info string {message}");
         }

Original file line number	Diff line number	Diff line change
`@@ -220,8 +220,6 @@ public static double Linstep(double edge0, double edge1, double value)`
`220`	`220`	`0, 30, 3, 12, 5, -99, 0, 6, 4, 7, -8, 6, 0, // K`
`221`	`221`	`};`
`222`	`222`
`223`		`- public static int DynamicScore;`
`224`		`-`
`225`	`223`	`public static int ComputeMobility(Board board)`
`226`	`224`	`{`
`227`	`225`	`int mobility = 0;`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,4 @@`
`1`		`-using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`		`-using System.Text;`
`5`		`-using System.Threading.Tasks;`
`6`		`-`
`7`		`-namespace MinimalChess`
	`1`	`+namespace MinimalChess`
`8`	`2`	`{`
`9`	`3`	`public class History`
`10`	`4`	`{`
`@@ -45,7 +39,7 @@ public float Value(Board context, Move move)`
`45`	`39`	`int iPiece = PieceIndex(context[move.FromSquare]);`
`46`	`40`	`float a = Positive[move.ToSquare, iPiece];`
`47`	`41`	`float b = Negative[move.ToSquare, iPiece];`
`48`		`- return a / (a + b + 1);//Interval [0..1]`
	`42`	`+ return a / (a + b + 1);//ratio of good increments in the range of [0..1]`
`49`	`43`	`}`
`50`	`44`	`}`
`51`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ public class IterativeSearch`
`20`	`20`	`private History _history;`
`21`	`21`	`private KillSwitch _killSwitch;`
`22`	`22`	`private long _maxNodes;`
	`23`	`+ private int _mobilityBonus;`
`23`	`24`
`24`	`25`	`public IterativeSearch(Board board, long maxNodes = long.MaxValue)`
`25`	`26`	`{`
`@@ -38,7 +39,7 @@ public IterativeSearch(int searchDepth, Board board) : this(board)`
`38`	`39`	`public void SearchDeeper(Func<bool> killSwitch = null)`
`39`	`40`	`{`
`40`	`41`	`Depth++;`
`41`		`- _killers.Resize(Depth);`
	`42`	`+ _killers.Expand(Depth);`
`42`	`43`	`_history.Scale();`
`43`	`44`	`StorePVinTT(PrincipalVariation, Depth);`
`44`	`45`	`_killSwitch = new KillSwitch(killSwitch);`
`@@ -69,7 +70,7 @@ private void StorePVinTT(Move[] pv, int depth)`
`69`	`70`	`{`
`70`	`71`	`if (depth <= 0)`
`71`	`72`	`{`
`72`		`- Evaluation.DynamicScore = Evaluation.ComputeMobility(position);`
	`73`	`+ _mobilityBonus = Evaluation.ComputeMobility(position);`
`73`	`74`	`return (QEval(position, window), Array.Empty<Move>());`
`74`	`75`	`}`
`75`	`76`
`@@ -103,7 +104,7 @@ private void StorePVinTT(Move[] pv, int depth)`
`103`	`104`	`//moves after the PV node are unlikely to raise alpha. try to avoid a full evaluation!`
`104`	`105`	`if(expandedNodes > 1)`
`105`	`106`	`{`
`106`		`- bool tactical = isChecked \|\| (move.Promotion > Piece.Queen) \|\| child.IsChecked(child.SideToMove);`
	`107`	`+ bool tactical = isChecked \|\| child.IsChecked(child.SideToMove);`
`107`	`108`
`108`	`109`	`//some moves are hopeless and can be skipped without deeper evaluation`
`109`	`110`	`if (depth <= 4 && !tactical)`
`@@ -176,7 +177,7 @@ private int QEval(Board position, SearchWindow window)`
`176`	`177`	`//if inCheck we can't use standPat, need to escape check!`
`177`	`178`	`if (!inCheck)`
`178`	`179`	`{`
`179`		`- int standPatScore = Evaluation.DynamicScore + position.Score;`
	`180`	`+ int standPatScore = position.Score + _mobilityBonus;`
`180`	`181`	`//Cut will raise alpha and perform beta cutoff when standPatScore is too good`
`181`	`182`	`if (window.Cut(standPatScore, color))`
`182`	`183`	`return window.GetScore(color);`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace MinimalChess`
`4`	`4`	`{`
`5`		`- public struct KillSwitch`
	`5`	`+ struct KillSwitch`
`6`	`6`	`{`
`7`	`7`	`Func<bool> _killSwitch;`
`8`	`8`	`bool _aborted;`
Original file line number	Diff line number	Diff line change
`@@ -10,12 +10,12 @@ class KillerMoves`
`10`	`10`
`11`	`11`	`public KillerMoves(int width)`
`12`	`12`	`{`
`13`		`- _moves = new Move[0];`
	`13`	`+ _moves = Array.Empty<Move>();`
`14`	`14`	`_depth = 0;`
`15`	`15`	`_width = width;`
`16`	`16`	`}`
`17`	`17`
`18`		`- public void Resize(int depth)`
	`18`	`+ public void Expand(int depth)`
`19`	`19`	`{`
`20`	`20`	`_depth = Math.Max(_depth, depth);`
`21`	`21`	`Array.Resize(ref _moves, _depth * _width);`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public static string ToSquareName(byte squareIndex)`
`58`	`58`	`public static byte ToSquare(string squareNotation)`
`59`	`59`	`{`
`60`	`60`	`//Each square has a unique identification of file letter followed by rank number.`
`61`		`- https://en.wikipedia.org/wiki/Algebraic_notation_(chess)`
	`61`	`+ //https://en.wikipedia.org/wiki/Algebraic_notation_(chess)`
`62`	`62`	`//Examples: White's king starts the game on square e1; Black's knight on b8 can move to open squares a6 or c6.`
`63`	`63`
`64`	`64`	`//Map letters [a..h] to [0..7] with ASCII('a') == 97`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,4 @@`
`1`		`-using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Diagnostics;`
	`1`	`+using System.Collections.Generic;`
`4`	`2`
`5`	`3`	`namespace MinimalChess`
`6`	`4`	`{`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public static Move ToMove(Board board, string notation)`
`77`	`77`	`throw new ArgumentException($"Move notation {notation} could not be parsed!");`
`78`	`78`	`}`
`79`	`79`
`80`		`- private static Move SelectMove(Board board, Piece moving, int toSquare, Piece promotion, char? disambiguate = null)`
	`80`	`+ private static Move SelectMove(Board board, Piece moving, int toSquare, Piece promotion, char? fileOrRank = null)`
`81`	`81`	`{`
`82`	`82`	`foreach (var move in new LegalMoves(board))`
`83`	`83`	`{`
`@@ -87,7 +87,7 @@ private static Move SelectMove(Board board, Piece moving, int toSquare, Piece pr`
`87`	`87`	`continue;`
`88`	`88`	`if (Pieces.Type(board[move.FromSquare]) != Pieces.Type(moving))`
`89`	`89`	`continue;`
`90`		`- if (disambiguate is char fileOrRank && !Notation.ToSquareName(move.FromSquare).Contains(fileOrRank))`
	`90`	`+ if (fileOrRank != null && !Notation.ToSquareName(move.FromSquare).Contains(fileOrRank.Value))`
`91`	`91`	`continue;`
`92`	`92`
`93`	`93`	`return move; //this is the move!`