checkpoint

Shogi.Domain/ValueObjects/Rules/StandardRules.cs

@@ -0,0 +1,166 @@
+using Shogi.Domain.YetToBeAssimilatedIntoDDD;
+using BoardTile = System.Collections.Generic.KeyValuePair<System.Numerics.Vector2, Shogi.Domain.ValueObjects.Piece>;
+
+namespace Shogi.Domain.ValueObjects
+{
+    internal class StandardRules
+    {
+        private readonly BoardState boardState;
+
+        internal StandardRules(BoardState board)
+        {
+            boardState = board;
+        }
+
+        /// <summary>
+        /// Determines if the last move put the player who moved in check.
+        /// </summary>
+        /// <remarks>
+        /// This strategy recognizes that a "discover check" could only occur from a subset of pieces: Rook, Bishop, Lance.
+        /// In this way, only those pieces need to be considered when evaluating if a move placed the moving player in check.
+        /// </remarks>
+        internal bool DidPlayerPutThemselfInCheck()
+        {
+            if (boardState.PreviousMove.From == null)
+            {
+                // You can't place yourself in check by placing a piece from your hand.
+                return false;
+            }
+
+            var previousMovedPiece = boardState[boardState.PreviousMove.To];
+            if (previousMovedPiece == null) throw new ArgumentNullException(nameof(previousMovedPiece), $"No piece exists at position {boardState.PreviousMove.To}.");
+            var kingPosition = previousMovedPiece.Owner == WhichPlayer.Player1 ? boardState.Player1KingPosition : boardState.Player2KingPosition;
+
+
+            var isDiscoverCheck = false;
+            // Get line equation from king through the now-unoccupied location.
+            var direction = Vector2.Subtract(kingPosition, boardState.PreviousMove.From.Value);
+            var slope = Math.Abs(direction.Y / direction.X);
+            var path = BoardState.GetPathAlongDirectionFromStartToEdgeOfBoard(boardState.PreviousMove.From.Value, Vector2.Normalize(direction));
+            var threat = boardState.QueryFirstPieceInPath(path);
+            if (threat == null || threat.Owner == previousMovedPiece.Owner) return false;
+            // If absolute slope is 45°, look for a bishop along the line.
+            // If absolute slope is 0° or 90°, look for a rook along the line.
+            // if absolute slope is 0°, look for lance along the line.
+            if (float.IsInfinity(slope))
+            {
+                isDiscoverCheck = threat.WhichPiece switch
+                {
+                    WhichPiece.Lance => !threat.IsPromoted,
+                    WhichPiece.Rook => true,
+                    _ => false
+                };
+            }
+            else if (slope == 1)
+            {
+                isDiscoverCheck = threat.WhichPiece switch
+                {
+                    WhichPiece.Bishop => true,
+                    _ => false
+                };
+            }
+            else if (slope == 0)
+            {
+                isDiscoverCheck = threat.WhichPiece switch
+                {
+                    WhichPiece.Rook => true,
+                    _ => false
+                };
+            }
+            return isDiscoverCheck;
+        }
+
+        internal bool IsOpponentInCheckAfterMove() => IsOpposingKingThreatenedByPosition(boardState.PreviousMove.To);
+
+        internal bool IsOpposingKingThreatenedByPosition(Vector2 position)
+        {
+            var previousMovedPiece = boardState[position];
+            if (previousMovedPiece == null) return false;
+
+            var kingPosition = previousMovedPiece.Owner == WhichPlayer.Player1 ? boardState.Player2KingPosition : boardState.Player1KingPosition;
+            var path = previousMovedPiece.GetPathFromStartToEnd(position, kingPosition);
+            var threatenedPiece = boardState.QueryFirstPieceInPath(path);
+            if (!path.Any() || threatenedPiece == null) return false;
+
+            return threatenedPiece.WhichPiece == WhichPiece.King;
+        }
+
+        internal bool IsOpponentInCheckMate()
+        {
+            // Assume checkmate, then try to disprove.
+            if (!boardState.InCheck.HasValue) return false;
+            // Get all pieces from opponent who threaten the king in question.
+            var opponent = boardState.WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
+            var tilesOccupiedByOpponent = boardState.GetTilesOccupiedBy(opponent);
+            var kingPosition = boardState.WhoseTurn == WhichPlayer.Player1
+                    ? boardState.Player1KingPosition
+                    : boardState.Player2KingPosition;
+            var threats = tilesOccupiedByOpponent.Where(tile => PieceHasLineOfSight(tile, kingPosition)).ToList();
+            if (threats.Count == 1)
+            {
+                /* If there is exactly one threat it is possible to block the check.
+                 * Foreach piece owned by whichPlayer
+                 *	if piece can intercept check, return false;
+                 */
+                var threat = threats.Single();
+                var pathFromThreatToKing = threat.Value.GetPathFromStartToEnd(threat.Key, kingPosition);
+                var tilesThatCouldBlockTheThreat = boardState.GetTilesOccupiedBy(boardState.WhoseTurn);
+                foreach (var threatBlockingPosition in pathFromThreatToKing)
+                {
+                    var tilesThatDoBlockThreat = tilesThatCouldBlockTheThreat
+                        .Where(tile => PieceHasLineOfSight(tile, threatBlockingPosition))
+                        .ToList();
+
+                    if (tilesThatDoBlockThreat.Any())
+                    {
+                        return false; // Cannot be check-mate if a piece can intercept the threat.
+                    }
+                }
+            }
+            else
+            {
+                /*
+                 * If no ability to block the check, maybe the king can evade check by moving.
+                */
+
+                foreach (var maybeSafePosition in GetPossiblePositionsForKing(boardState.WhoseTurn))
+                {
+                    threats = tilesOccupiedByOpponent
+                        .Where(tile => PieceHasLineOfSight(tile, maybeSafePosition))
+                        .ToList();
+                    if (!threats.Any())
+                    {
+                        return false;
+                    }
+                }
+
+            }
+
+            return true;
+        }
+
+        private List<Vector2> GetPossiblePositionsForKing(WhichPlayer whichPlayer)
+        {
+            var kingPosition = whichPlayer == WhichPlayer.Player1
+                ? boardState.Player1KingPosition
+                : boardState.Player2KingPosition;
+
+						var paths = boardState[kingPosition]!.MoveSet;
+            return paths
+                .Select(path => path.Step + kingPosition)
+								// Because the king could be on the edge of the board, where some of its paths do not make sense.
+                .Where(newPosition => newPosition.IsInsideBoardBoundary())
+                // Where tile at position is empty, meaning the king could move there.
+                .Where(newPosition => boardState[newPosition] == null)
+                .ToList();
+        }
+
+        private bool PieceHasLineOfSight(BoardTile tile, Vector2 lineOfSightTarget)
+        {
+            var path = tile.Value.GetPathFromStartToEnd(tile.Key, lineOfSightTarget);
+            return path
+                .SkipLast(1)
+                .All(position => boardState[Notation.ToBoardNotation(position)] == null);
+        }
+    }
+}