optimizations (fixed bugs, improved speed and general code cleanup)

* implemented parallel perft() * code cleanup * implemented stuck piece detection (except for pawns) * trapped pieces score less * fixed broken "go perft n" * renamed to greek letters * fixed alpha/beta pruning * hashtable is now concurrent collection * mended some tests + updated opening book
sictransit · Dec 31, 2022 · 2ce9c6c · 2ce9c6c
1 parent 85018ce
commit 2ce9c6c
Show file tree

Hide file tree

Showing 28 changed files with 1,795 additions and 413 deletions.
diff --git a/Common/Board.cs b/Common/Board.cs
@@ -49,16 +49,14 @@ public int Score
                 {
                     var evaluation = internals.Scoring.EvaluatePiece(piece, phase);
 
-                    switch (piece.GetPieceType())
+                    if (piece.GetPieceType() == Piece.Pawn && IsPassedPawn(piece))
                     {
-                        case Piece.Pawn:
-                            if (IsPassedPawn(piece))
-                            {
-                                evaluation *= 2;
-                            }
-                            break;
-                        default:
-                            break;
+                        evaluation *= 2;
+                    }
+
+                    if (IsBlocked(piece))
+                    {
+                        evaluation = evaluation * phase / 24;
                     }
 
                     score += piece.Is(Piece.White) ? evaluation : -evaluation;
@@ -316,9 +314,16 @@ public IEnumerable<Piece> GetAttackers(Piece piece)
             }
         }
 
+        private bool IsBlocked(Piece piece)
+        {
+            var blockedMask = internals.Moves.GetBlockedMask(piece);
+
+            return (blockedMask & GetBitboard(ActiveColor).All) == blockedMask;
+        }
+
         public IEnumerable<Move> GetLegalMoves()
         {
-            foreach (var piece in GetPieces(ActiveColor))
+            foreach (var piece in GetPieces(ActiveColor).Where(p => !IsBlocked(p)))
             {
                 foreach (var move in GetLegalMoves(piece))
                 {
@@ -349,7 +354,10 @@ public IEnumerable<Move> GetLegalMoves(Piece piece)
                         break;
                     }
 
-                    if (IsMovingIntoCheck(move))
+                    var testBoard = Play(move);
+
+                    // Moving into check?
+                    if (testBoard.IsAttacked(testBoard.FindKing(ActiveColor)))
                     {
                         if (hostileTarget != Piece.None)
                         {
@@ -421,13 +429,6 @@ private bool ValidateMove(Move move, Piece hostileTarget)
             return true;
         }
 
-        private bool IsMovingIntoCheck(Move move)
-        {
-            var testBoard = Play(move);
-
-            return testBoard.IsAttacked(testBoard.FindKing(ActiveColor));
-        }
-
         public bool IsChecked => IsAttacked(FindKing(ActiveColor));
 
         public bool IsAttacked(Piece piece) => GetAttackers(piece).Any();

diff --git a/Common/Common.csproj b/Common/Common.csproj
@@ -21,7 +21,7 @@
 
   <ItemGroup>
     <None Update="Resources\eco.json">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
 

diff --git a/Common/Extensions/BoardExtensions.cs b/Common/Extensions/BoardExtensions.cs
@@ -48,6 +48,18 @@ public static string PrettyPrint(this IBoard b)
         }
 
         public static ulong Perft(this IBoard board, int depth)
+        {
+            ulong count = 0;
+
+            Parallel.ForEach(board.GetLegalMoves(), move =>
+            {
+                Interlocked.Add(ref count, board.Play(move).ParallelPerft(depth - 1));
+            });
+
+            return count;
+        }
+
+        private static ulong ParallelPerft(this IBoard board, int depth)
         {
             if (depth <= 1)
             {
@@ -58,7 +70,7 @@ public static ulong Perft(this IBoard board, int depth)
 
             foreach (var move in board.GetLegalMoves())
             {
-                count += Perft(board.Play(move), depth - 1);
+                count += board.Play(move).ParallelPerft(depth - 1);
             }
 
             return count;

diff --git a/Common/Lookup/Moves.cs b/Common/Lookup/Moves.cs
@@ -8,18 +8,39 @@ namespace SicTransit.Woodpusher.Common.Lookup
     public class Moves
     {
         private readonly Dictionary<Piece, Move[][]> vectors = new();
+        private readonly Dictionary<Piece, ulong> blockedMasks = new();
         private readonly Dictionary<ulong, ulong> travelMasks = new();
         private readonly Dictionary<Piece, ulong> passedPawnMasks = new();
 
         public Moves()
         {
             InitializeVectors();
 
+            InitializeBlockedMasks();
+
             InitializeTravelMasks();
 
             InitializePassedPawnMasks();
         }
 
+        private void InitializeBlockedMasks()
+        {
+            foreach (var vector in vectors)
+            {
+                if (vector.Key.Is(Piece.Pawn))
+                {
+                    // TODO: implement for pawns
+                    blockedMasks.Add(vector.Key, ulong.MaxValue);
+
+                    continue;
+                }
+
+                var mask = vector.Value.Select(series => series.First()).Aggregate(0ul, (current, move) => current | move.Target);
+
+                blockedMasks.Add(vector.Key, mask);
+            }
+        }
+
         private void InitializeTravelMasks()
         {
             var squares = Enumerable.Range(0, 64).Select(shift => 1ul << shift);
@@ -65,6 +86,8 @@ private void InitializePassedPawnMasks()
             }
         }
 
+        public ulong GetBlockedMask(Piece piece) => blockedMasks[piece];
+
         public ulong GetTravelMask(ulong current, ulong target) => travelMasks[current | target];
 
         public ulong GetPassedPawnMask(Piece piece) => passedPawnMasks[piece];
@@ -82,10 +105,7 @@ private void InitializeVectors()
             });
         }
 
-        public Move[][] GetVectors(Piece piece)
-        {
-            return vectors[piece];
-        }
+        public Move[][] GetVectors(Piece piece) => vectors[piece];
 
         private static IEnumerable<IEnumerable<Move>> CreateVectors(Piece piece)
         {

diff --git a/Common/Movement/RookMovement.cs b/Common/Movement/RookMovement.cs
@@ -29,10 +29,6 @@ public static IEnumerable<IEnumerable<Move>> GetTargetVectors(Piece piece)
             {
                 yield return Enumerable.Range(0, square.File).Reverse().Select(f => new Move(piece, square.NewFile(f)));
             }
-
         }
     }
-
-
-
 }