Shogi/Shogi.Domain/ValueObjects/ShogiBoard.cs

using System.Text;

namespace Shogi.Domain.ValueObjects;

/// <summary>
/// Facilitates Shogi board state transitions, cognisant of Shogi rules.
/// The board is always from Player1's perspective.
/// [0,0] is the lower-left position, [8,8] is the higher-right position
/// </summary>
public sealed class ShogiBoard
{
    private readonly StandardRules rules;

    public ShogiBoard(BoardState initialState)
    {
        BoardState = initialState;
        rules = new StandardRules(BoardState);
    }

    public BoardState BoardState { get; }

    /// <summary>
    /// Move a piece from a board position to another board position, potentially capturing an opponents piece. Respects all rules of the game.
    /// </summary>
    /// <remarks>
    /// The strategy involves simulating a move on a throw-away board state that can be used to 
    /// validate legal vs illegal moves without having to worry about reverting board state.
    /// </remarks>
    /// <exception cref="InvalidOperationException"></exception>
    public void Move(string from, string to, bool isPromotion)
    {
        var simulationState = new BoardState(BoardState);
        var simulation = new StandardRules(simulationState);
        var moveResult = simulation.Move(from, to, isPromotion);
        if (!moveResult.Success)
        {
            throw new InvalidOperationException(moveResult.Reason);
        }

        // If already in check, assert the move that resulted in check no longer results in check.
        if (BoardState.InCheck == BoardState.WhoseTurn
          && simulation.IsOpposingKingThreatenedByPosition(BoardState.PreviousMove.To))
        {
            throw new InvalidOperationException("Unable to move because you are still in check.");
        }

        var otherPlayer = BoardState.WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
        if (simulation.IsPlayerInCheckAfterMove())
        {
            throw new InvalidOperationException("Illegal move. This move places you in check.");
        }

        _ = rules.Move(from, to, isPromotion);
        if (rules.IsOpponentInCheckAfterMove())
        {
            BoardState.InCheck = otherPlayer;
            if (rules.IsOpponentInCheckMate())
            {
                BoardState.IsCheckmate = true;
            }
        }
        else
        {
            BoardState.InCheck = null;
        }
        BoardState.WhoseTurn = otherPlayer;
    }

    public void Move(WhichPiece pieceInHand, string to)
    {
        var index = BoardState.ActivePlayerHand.FindIndex(p => p.WhichPiece == pieceInHand);
        if (index == -1)
        {
            throw new InvalidOperationException($"{pieceInHand} does not exist in the hand.");
        }

        if (BoardState[to] != null)
        {
            throw new InvalidOperationException("Illegal placement of piece from the hand. Destination is not empty.");
        }

        var toVector = Notation.FromBoardNotation(to);
        switch (pieceInHand)
        {
            case WhichPiece.Knight:
                {
                    // Knight cannot be placed onto the farthest two ranks from the hand.
                    if (BoardState.WhoseTurn == WhichPlayer.Player1 && toVector.Y > 6
                      || BoardState.WhoseTurn == WhichPlayer.Player2 && toVector.Y < 2)
                    {
                        throw new InvalidOperationException("Illegal move. Knight has no valid moves after placement.");
                    }
                    break;
                }
            case WhichPiece.Lance:
            case WhichPiece.Pawn:
                {
                    // Lance and Pawn cannot be placed onto the farthest rank from the hand.
                    if (BoardState.WhoseTurn == WhichPlayer.Player1 && toVector.Y == 8
                      || BoardState.WhoseTurn == WhichPlayer.Player2 && toVector.Y == 0)
                    {
                        throw new InvalidOperationException($"Illegal move. {pieceInHand} has no valid moves after placement.");
                    }
                    break;
                }
        }

        var tempBoard = new BoardState(BoardState);
        var simulation = new StandardRules(tempBoard);
        var moveResult = simulation.Move(pieceInHand, to);
        if (!moveResult.Success)
        {
            throw new InvalidOperationException(moveResult.Reason);
        }

        var otherPlayer = tempBoard.WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
        if (BoardState.InCheck == BoardState.WhoseTurn)
        {
            //if (simulation.IsPlayerInCheckAfterMove(boardState.PreviousMoveTo, toVector, boardState.WhoseTurn))
            //{
            //	throw new InvalidOperationException("Illegal move. You're still in check!");
            //}
        }

        var kingPosition = otherPlayer == WhichPlayer.Player1 ? tempBoard.Player1KingPosition : tempBoard.Player2KingPosition;
        //if (simulation.IsPlayerInCheckAfterMove(toVector, kingPosition, otherPlayer))
        //{

        //}

        //rules.Move(from, to, isPromotion);
        //if (rules.IsPlayerInCheckAfterMove(fromVector, toVector, otherPlayer))
        //{
        //	board.InCheck = otherPlayer;
        //	board.IsCheckmate = rules.EvaluateCheckmate();
        //}
        //else
        //{
        //	board.InCheck = null;
        //}
        BoardState.WhoseTurn = otherPlayer;
    }

    /// <summary>
    /// Prints a ASCII representation of the board for debugging board state.
    /// </summary>
    /// <returns></returns>
    public string ToStringStateAsAscii()
    {
        var builder = new StringBuilder();
        builder.Append("                    ");
        builder.Append("Player 2(.)");
        builder.AppendLine();
        for (var rank = 8; rank >= 0; rank--)
        {
            // Horizontal line
            builder.Append("     - ");
            for (var file = 0; file < 8; file++) builder.Append("- - ");
            builder.Append("- -");

            // Print Rank ruler.
            builder.AppendLine();
            builder.Append($"{rank + 1}  ");

            // Print pieces.
            builder.Append("  |");
            for (var x = 0; x < 9; x++)
            {
                var piece = BoardState[x, rank];
                if (piece == null)
                {
                    builder.Append("   ");
                }
                else
                {
                    builder.AppendFormat("{0}", ToAscii(piece));
                }
                builder.Append('|');
            }
            builder.AppendLine();
        }

        // Horizontal line
        builder.Append("     - ");
        for (var x = 0; x < 8; x++) builder.Append("- - ");
        builder.Append("- -");
        builder.AppendLine();
        builder.Append("                    ");
        builder.Append("Player 1");

        builder.AppendLine();
        builder.AppendLine();
        // Print File ruler.
        builder.Append("     ");
        builder.Append("  A   B   C   D   E   F   G   H   I  ");

        return builder.ToString();
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="piece"></param>
    /// <returns>
    /// A string with three characters. 
    /// The first character indicates promotion status. 
    /// The second character indicates piece. 
    /// The third character indicates ownership.
    /// </returns>
    private static string ToAscii(Piece piece)
    {
        var builder = new StringBuilder();
        if (piece.IsPromoted) builder.Append('^');
        else builder.Append(' ');

        var name = piece.WhichPiece switch
        {
            WhichPiece.King => "K",
            WhichPiece.GoldGeneral => "G",
            WhichPiece.SilverGeneral => "S",
            WhichPiece.Bishop => "B",
            WhichPiece.Rook => "R",
            WhichPiece.Knight => "k",
            WhichPiece.Lance => "L",
            WhichPiece.Pawn => "P",
            _ => throw new ArgumentException($"Unknown value for {nameof(WhichPiece)}."),
        };
        builder.Append(name);

        if (piece.Owner == WhichPlayer.Player2) builder.Append('.');
        else builder.Append(' ');

        return builder.ToString();
    }
}