312 lines
9.1 KiB
C#
312 lines
9.1 KiB
C#
using Shogi.Domain.Pieces;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Shogi.Domain
|
|
{
|
|
// TODO: Avoid extending dictionary. Use composition instead.
|
|
// Then validation can occur when assigning a piece to a position.
|
|
public class ShogiBoardState
|
|
{
|
|
private static readonly string BoardNotationRegex = @"(?<file>[A-I])(?<rank>[1-9])";
|
|
private static readonly char A = 'A';
|
|
public delegate void ForEachDelegate(Piece element, Vector2 position);
|
|
/// <summary>
|
|
/// Key is position notation, such as "E4".
|
|
/// </summary>
|
|
private readonly Dictionary<string, Piece?> board;
|
|
|
|
public List<Piece> ActivePlayerHand => WhoseTurn == WhichPlayer.Player1 ? Player1Hand : Player2Hand;
|
|
/// <summary>
|
|
/// "Active Player" means the player whose turn it is.
|
|
/// </summary>
|
|
public Vector2 ActivePlayerKingPosition => WhoseTurn == WhichPlayer.Player1 ? Player1KingPosition : Player2KingPosition;
|
|
/// <summary>
|
|
/// "Opposing Player" means the player whose turn it isn't.
|
|
/// </summary>
|
|
public Vector2 OpposingPlayerKingPosition => WhoseTurn == WhichPlayer.Player1 ? Player2KingPosition : Player1KingPosition;
|
|
public Vector2 Player1KingPosition { get; set; }
|
|
public Vector2 Player2KingPosition { get; set; }
|
|
public List<Piece> Player1Hand { get; }
|
|
public List<Piece> Player2Hand { get; }
|
|
public Vector2 PreviousMoveFrom { get; private set; }
|
|
public Vector2 PreviousMoveTo { get; private set; }
|
|
public WhichPlayer WhoseTurn { get; set; }
|
|
public WhichPlayer? InCheck { get; set; }
|
|
public bool IsCheckmate { get; set; }
|
|
|
|
public ShogiBoardState()
|
|
{
|
|
board = new Dictionary<string, Piece?>(81, StringComparer.OrdinalIgnoreCase);
|
|
InitializeBoardState();
|
|
Player1Hand = new List<Piece>();
|
|
Player2Hand = new List<Piece>();
|
|
PreviousMoveTo = Vector2.Zero;
|
|
CacheKingPositions();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Copy constructor.
|
|
/// </summary>
|
|
public ShogiBoardState(ShogiBoardState other) : this()
|
|
{
|
|
foreach (var kvp in other.board)
|
|
{
|
|
// Replace copy constructor with static factory method in Piece.cs
|
|
board[kvp.Key] = kvp.Value == null ? null : Piece.Create(kvp.Value);
|
|
}
|
|
WhoseTurn = other.WhoseTurn;
|
|
InCheck = other.InCheck;
|
|
IsCheckmate = other.IsCheckmate;
|
|
PreviousMoveTo = other.PreviousMoveTo;
|
|
Player1Hand.AddRange(other.Player1Hand);
|
|
Player2Hand.AddRange(other.Player2Hand);
|
|
Player1KingPosition = other.Player1KingPosition;
|
|
Player2KingPosition = other.Player2KingPosition;
|
|
}
|
|
|
|
public Piece? this[string notation]
|
|
{
|
|
// TODO: Validate "notation" here and throw an exception if invalid.
|
|
get => board[notation];
|
|
set
|
|
{
|
|
if (value?.WhichPiece == WhichPiece.King)
|
|
{
|
|
if (value.Owner == WhichPlayer.Player1)
|
|
{
|
|
// TODO: This FromBoardNotation() is a waste if the Vector2 indexer was called. :(
|
|
Player1KingPosition = FromBoardNotation(notation);
|
|
}
|
|
else if (value.Owner == WhichPlayer.Player2)
|
|
{
|
|
Player2KingPosition = FromBoardNotation(notation);
|
|
}
|
|
}
|
|
board[notation] = value;
|
|
}
|
|
}
|
|
|
|
public Piece? this[Vector2 vector]
|
|
{
|
|
get => this[ToBoardNotation(vector)];
|
|
set => this[ToBoardNotation(vector)] = value;
|
|
}
|
|
|
|
public Piece? this[int x, int y]
|
|
{
|
|
get => this[ToBoardNotation(x, y)];
|
|
set => this[ToBoardNotation(x, y)] = value;
|
|
}
|
|
|
|
internal void RememberAsMostRecentMove(Vector2 from, Vector2 to)
|
|
{
|
|
PreviousMoveFrom = from;
|
|
PreviousMoveTo = to;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the given path can be traversed without colliding into a piece.
|
|
/// </summary>
|
|
public bool IsPathBlocked(IEnumerable<Vector2> path)
|
|
{
|
|
return !path.Any()
|
|
|| path.SkipLast(1).Any(position => this[position] != null)
|
|
|| this[path.Last()]?.Owner == WhoseTurn;
|
|
}
|
|
|
|
public void ForEachNotNull(ForEachDelegate callback)
|
|
{
|
|
for (var x = 0; x < 9; x++)
|
|
{
|
|
for (var y = 0; y < 9; y++)
|
|
{
|
|
var position = new Vector2(x, y);
|
|
var elem = this[position];
|
|
if (elem != null)
|
|
callback(elem, position);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool IsWithinPromotionZone(Vector2 position)
|
|
{
|
|
return (WhoseTurn == WhichPlayer.Player1 && position.Y > 5)
|
|
|| (WhoseTurn == WhichPlayer.Player2 && position.Y < 3);
|
|
}
|
|
|
|
internal static bool IsWithinBoardBoundary(Vector2 position)
|
|
{
|
|
return position.X <= 8 && position.X >= 0
|
|
&& position.Y <= 8 && position.Y >= 0;
|
|
}
|
|
|
|
internal IEnumerable<BoardTile> GetTilesOccupiedBy(WhichPlayer whichPlayer) => board
|
|
.Where(kvp => kvp.Value?.Owner == whichPlayer)
|
|
.Select(kvp => new BoardTile(kvp.Value!, FromBoardNotation(kvp.Key)));
|
|
|
|
internal void Capture(Vector2 to)
|
|
{
|
|
var piece = this[to];
|
|
if (piece == null) throw new InvalidOperationException("Cannot capture. Piece at position does not exist.");
|
|
|
|
piece.Capture(WhoseTurn);
|
|
ActivePlayerHand.Add(piece);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does not include the start position.
|
|
/// </summary>
|
|
internal static IEnumerable<Vector2> GetPathAlongDirectionFromStartToEdgeOfBoard(Vector2 start, Vector2 direction)
|
|
{
|
|
var next = start;
|
|
while (IsWithinBoardBoundary(next + direction))
|
|
{
|
|
next += direction;
|
|
yield return next;
|
|
}
|
|
}
|
|
|
|
internal Piece? GetFirstPieceAlongPath(IEnumerable<Vector2> path)
|
|
{
|
|
foreach (var step in path)
|
|
{
|
|
if (this[step] != null) return this[step];
|
|
}
|
|
return null;
|
|
}
|
|
public static string ToBoardNotation(Vector2 vector)
|
|
{
|
|
return ToBoardNotation((int)vector.X, (int)vector.Y);
|
|
}
|
|
private static string ToBoardNotation(int x, int y)
|
|
{
|
|
var file = (char)(x + A);
|
|
var rank = y + 1;
|
|
return $"{file}{rank}";
|
|
}
|
|
public static Vector2 FromBoardNotation(string notation)
|
|
{
|
|
if (Regex.IsMatch(notation, BoardNotationRegex))
|
|
{
|
|
var match = Regex.Match(notation, BoardNotationRegex, RegexOptions.IgnoreCase);
|
|
char file = match.Groups["file"].Value[0];
|
|
int rank = int.Parse(match.Groups["rank"].Value);
|
|
return new Vector2(file - A, rank - 1);
|
|
}
|
|
throw new ArgumentException($"Board notation not recognized. Notation given: {notation}");
|
|
}
|
|
|
|
private void CacheKingPositions()
|
|
{
|
|
ForEachNotNull((tile, position) =>
|
|
{
|
|
if (tile.WhichPiece == WhichPiece.King)
|
|
{
|
|
if (tile.Owner == WhichPlayer.Player1)
|
|
{
|
|
Player1KingPosition = position;
|
|
}
|
|
else if (tile.Owner == WhichPlayer.Player2)
|
|
{
|
|
Player2KingPosition = position;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void InitializeBoardState()
|
|
{
|
|
this["A1"] = new Lance(WhichPlayer.Player1);
|
|
this["B1"] = new Knight(WhichPlayer.Player1);
|
|
this["C1"] = new SilverGeneral(WhichPlayer.Player1);
|
|
this["D1"] = new GoldGeneral(WhichPlayer.Player1);
|
|
this["E1"] = new King(WhichPlayer.Player1);
|
|
this["F1"] = new GoldGeneral(WhichPlayer.Player1);
|
|
this["G1"] = new SilverGeneral(WhichPlayer.Player1);
|
|
this["H1"] = new Knight(WhichPlayer.Player1);
|
|
this["I1"] = new Lance(WhichPlayer.Player1);
|
|
|
|
this["A2"] = null;
|
|
this["B2"] = new Bishop(WhichPlayer.Player1);
|
|
this["C2"] = null;
|
|
this["D2"] = null;
|
|
this["E2"] = null;
|
|
this["F2"] = null;
|
|
this["G2"] = null;
|
|
this["H2"] = new Rook(WhichPlayer.Player1);
|
|
this["I2"] = null;
|
|
|
|
this["A3"] = new Pawn(WhichPlayer.Player1);
|
|
this["B3"] = new Pawn(WhichPlayer.Player1);
|
|
this["C3"] = new Pawn(WhichPlayer.Player1);
|
|
this["D3"] = new Pawn(WhichPlayer.Player1);
|
|
this["E3"] = new Pawn(WhichPlayer.Player1);
|
|
this["F3"] = new Pawn(WhichPlayer.Player1);
|
|
this["G3"] = new Pawn(WhichPlayer.Player1);
|
|
this["H3"] = new Pawn(WhichPlayer.Player1);
|
|
this["I3"] = new Pawn(WhichPlayer.Player1);
|
|
|
|
this["A4"] = null;
|
|
this["B4"] = null;
|
|
this["C4"] = null;
|
|
this["D4"] = null;
|
|
this["E4"] = null;
|
|
this["F4"] = null;
|
|
this["G4"] = null;
|
|
this["H4"] = null;
|
|
this["I4"] = null;
|
|
|
|
this["A5"] = null;
|
|
this["B5"] = null;
|
|
this["C5"] = null;
|
|
this["D5"] = null;
|
|
this["E5"] = null;
|
|
this["F5"] = null;
|
|
this["G5"] = null;
|
|
this["H5"] = null;
|
|
this["I5"] = null;
|
|
|
|
this["A6"] = null;
|
|
this["B6"] = null;
|
|
this["C6"] = null;
|
|
this["D6"] = null;
|
|
this["E6"] = null;
|
|
this["F6"] = null;
|
|
this["G6"] = null;
|
|
this["H6"] = null;
|
|
this["I6"] = null;
|
|
|
|
this["A7"] = new Pawn(WhichPlayer.Player2);
|
|
this["B7"] = new Pawn(WhichPlayer.Player2);
|
|
this["C7"] = new Pawn(WhichPlayer.Player2);
|
|
this["D7"] = new Pawn(WhichPlayer.Player2);
|
|
this["E7"] = new Pawn(WhichPlayer.Player2);
|
|
this["F7"] = new Pawn(WhichPlayer.Player2);
|
|
this["G7"] = new Pawn(WhichPlayer.Player2);
|
|
this["H7"] = new Pawn(WhichPlayer.Player2);
|
|
this["I7"] = new Pawn(WhichPlayer.Player2);
|
|
|
|
this["A8"] = null;
|
|
this["B8"] = new Rook(WhichPlayer.Player2);
|
|
this["C8"] = null;
|
|
this["D8"] = null;
|
|
this["E8"] = null;
|
|
this["F8"] = null;
|
|
this["G8"] = null;
|
|
this["H8"] = new Bishop(WhichPlayer.Player2);
|
|
this["I8"] = null;
|
|
|
|
this["A9"] = new Lance(WhichPlayer.Player2);
|
|
this["B9"] = new Knight(WhichPlayer.Player2);
|
|
this["C9"] = new SilverGeneral(WhichPlayer.Player2);
|
|
this["D9"] = new GoldGeneral(WhichPlayer.Player2);
|
|
this["E9"] = new King(WhichPlayer.Player2);
|
|
this["F9"] = new GoldGeneral(WhichPlayer.Player2);
|
|
this["G9"] = new SilverGeneral(WhichPlayer.Player2);
|
|
this["H9"] = new Knight(WhichPlayer.Player2);
|
|
this["I9"] = new Lance(WhichPlayer.Player2);
|
|
}
|
|
}
|
|
}
|