516 lines
17 KiB
C#
516 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using System.Text;
|
|
|
|
namespace Gameboard.ShogiUI.BoardState
|
|
{
|
|
/// <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 class ShogiBoard
|
|
{
|
|
private delegate void MoveSetCallback(Piece piece, Vector2 position);
|
|
private ShogiBoard validationBoard;
|
|
private Vector2 player1King;
|
|
private Vector2 player2King;
|
|
public IReadOnlyDictionary<WhichPlayer, List<Piece>> Hands { get; }
|
|
public Array2D<Piece> Board { get; }
|
|
public List<Move> MoveHistory { get; }
|
|
public WhichPlayer WhoseTurn => MoveHistory.Count % 2 == 0 ? WhichPlayer.Player1 : WhichPlayer.Player2;
|
|
public WhichPlayer? InCheck { get; private set; }
|
|
public bool IsCheckmate { get; private set; }
|
|
|
|
public ShogiBoard()
|
|
{
|
|
Board = new Array2D<Piece>(9, 9);
|
|
MoveHistory = new List<Move>(20);
|
|
Hands = new Dictionary<WhichPlayer, List<Piece>> {
|
|
{ WhichPlayer.Player1, new List<Piece>()},
|
|
{ WhichPlayer.Player2, new List<Piece>()},
|
|
};
|
|
InitializeBoardState();
|
|
player1King = new Vector2(4, 0);
|
|
player2King = new Vector2(4, 8);
|
|
}
|
|
|
|
public bool Move(Move move)
|
|
{
|
|
var otherPlayer = WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
|
|
var moveSuccess = TryMove(move);
|
|
|
|
if (!moveSuccess) return false;
|
|
|
|
// Evaluate check
|
|
InCheck = EvaluateCheck(otherPlayer) ? otherPlayer : null;
|
|
if (InCheck.HasValue)
|
|
{
|
|
//IsCheckmate = EvaluateCheckmate();
|
|
}
|
|
return true;
|
|
}
|
|
/// <summary>
|
|
/// Attempts a given move. Returns false if the move is illegal.
|
|
/// </summary>
|
|
private bool TryMove(Move move)
|
|
{
|
|
// Try making the move in a "throw away" board.
|
|
if (validationBoard == null)
|
|
{
|
|
validationBoard = ConstructWithMoves(MoveHistory);
|
|
}
|
|
var isValid = move.PieceFromCaptured.HasValue
|
|
? validationBoard.PlaceFromHand(move)
|
|
: validationBoard.PlaceFromBoard(move);
|
|
if (!isValid)
|
|
{
|
|
// Invalidate the "throw away" board.
|
|
validationBoard = null;
|
|
return false;
|
|
}
|
|
// Assert that this move does not put the moving player in check.
|
|
if (validationBoard.EvaluateCheck(WhoseTurn)) return false;
|
|
|
|
// The move is valid and legal; update board state.
|
|
if (move.PieceFromCaptured.HasValue) PlaceFromHand(move);
|
|
else PlaceFromBoard(move);
|
|
return true;
|
|
}
|
|
private bool EvaluateCheckmate()
|
|
{
|
|
if (!InCheck.HasValue) return false;
|
|
|
|
// Assume true and try to disprove.
|
|
var isCheckmate = true;
|
|
Board.ForEachNotNull((piece, x, y) => // For each piece...
|
|
{
|
|
if (!isCheckmate) return; // Short circuit
|
|
|
|
var from = new Vector2(x, y);
|
|
if (piece.Owner == InCheck) // Owned by the player in check...
|
|
{
|
|
var positionsToCheck = new List<Vector2>(10);
|
|
IterateMoveSet(from, (innerPiece, position) =>
|
|
{
|
|
if (innerPiece?.Owner != InCheck) positionsToCheck.Add(position); // Find possible moves...
|
|
});
|
|
|
|
// And evaluate if any move gets the player out of check.
|
|
foreach (var position in positionsToCheck)
|
|
{
|
|
if (validationBoard == null) validationBoard = ConstructWithMoves(MoveHistory);
|
|
var moveSuccess = validationBoard.TryMove(new Move { From = from, To = position });
|
|
if (moveSuccess)
|
|
{
|
|
isCheckmate &= validationBoard.EvaluateCheck(InCheck.Value);
|
|
validationBoard = null;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return isCheckmate;
|
|
}
|
|
/// <returns>True if the move was successful.</returns>
|
|
private bool PlaceFromHand(Move move)
|
|
{
|
|
if (move.PieceFromCaptured.HasValue == false) return false; //Invalid move
|
|
var index = Hands[WhoseTurn].FindIndex(p => p.WhichPiece == move.PieceFromCaptured);
|
|
if (index < 0) return false; // Invalid move
|
|
if (Board[move.To.X, move.To.Y] != null) return false; // Invalid move; cannot capture while playing from the hand.
|
|
|
|
var minimumY = 0;
|
|
switch (move.PieceFromCaptured.Value)
|
|
{
|
|
case WhichPiece.Knight:
|
|
// Knight cannot be placed onto the farthest two ranks from the hand.
|
|
minimumY = WhoseTurn == WhichPlayer.Player1 ? 2 : 6;
|
|
break;
|
|
case WhichPiece.Lance:
|
|
case WhichPiece.Pawn:
|
|
// Lance and Pawn cannot be placed onto the farthest rank from the hand.
|
|
minimumY = WhoseTurn == WhichPlayer.Player1 ? 1 : 7;
|
|
break;
|
|
}
|
|
if (WhoseTurn == WhichPlayer.Player1 && move.To.Y < minimumY) return false;
|
|
if (WhoseTurn == WhichPlayer.Player2 && move.To.Y > minimumY) return false;
|
|
|
|
// Mutate the board.
|
|
Board[move.To.X, move.To.Y] = Hands[WhoseTurn][index];
|
|
Hands[WhoseTurn].RemoveAt(index);
|
|
|
|
return true;
|
|
}
|
|
/// <returns>True if the move was successful.</returns>
|
|
private bool PlaceFromBoard(Move move)
|
|
{
|
|
var fromPiece = Board[move.From.X, move.From.Y];
|
|
if (fromPiece == null) return false; // Invalid move
|
|
if (fromPiece.Owner != WhoseTurn) return false; // Invalid move; cannot move other players pieces.
|
|
if (ValidateMoveAgainstMoveSet(move.From, move.To) == false) return false; // Invalid move; move not part of move-set.
|
|
|
|
var captured = Board[move.To.X, move.To.Y];
|
|
if (captured != null)
|
|
{
|
|
if (captured.Owner == WhoseTurn) return false; // Invalid move; cannot capture your own piece.
|
|
captured.Capture();
|
|
Hands[captured.Owner].Add(captured);
|
|
}
|
|
|
|
//Mutate the board.
|
|
if (move.IsPromotion)
|
|
{
|
|
if (WhoseTurn == WhichPlayer.Player1 && (move.To.Y > 5 || move.From.Y > 5))
|
|
{
|
|
fromPiece.Promote();
|
|
}
|
|
else if (WhoseTurn == WhichPlayer.Player2 && (move.To.Y < 3 || move.From.Y < 3))
|
|
{
|
|
fromPiece.Promote();
|
|
}
|
|
}
|
|
Board[move.To.X, move.To.Y] = fromPiece;
|
|
Board[move.From.X, move.From.Y] = null;
|
|
if (fromPiece.WhichPiece == WhichPiece.King)
|
|
{
|
|
if (fromPiece.Owner == WhichPlayer.Player1)
|
|
{
|
|
player1King.X = move.To.X;
|
|
player1King.Y = move.To.Y;
|
|
}
|
|
else if (fromPiece.Owner == WhichPlayer.Player2)
|
|
{
|
|
player2King.X = move.To.X;
|
|
player2King.Y = move.To.Y;
|
|
}
|
|
}
|
|
MoveHistory.Add(move);
|
|
return true;
|
|
}
|
|
public void PrintStateAsAscii()
|
|
{
|
|
var builder = new StringBuilder();
|
|
builder.Append(" Player 2");
|
|
builder.AppendLine();
|
|
for (var y = 8; y > -1; y--)
|
|
{
|
|
builder.Append("- ");
|
|
for (var x = 0; x < 8; x++) builder.Append("- - ");
|
|
builder.Append("- -");
|
|
builder.AppendLine();
|
|
builder.Append('|');
|
|
for (var x = 0; x < 9; x++)
|
|
{
|
|
var piece = Board[x, y];
|
|
if (piece == null)
|
|
{
|
|
builder.Append(" ");
|
|
}
|
|
else
|
|
{
|
|
builder.AppendFormat("{0}", piece.ShortName);
|
|
}
|
|
builder.Append('|');
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
builder.Append("- ");
|
|
for (var x = 0; x < 8; x++) builder.Append("- - ");
|
|
builder.Append("- -");
|
|
builder.AppendLine();
|
|
builder.Append(" Player 1");
|
|
Console.WriteLine(builder.ToString());
|
|
}
|
|
#region Rules Validation
|
|
/// <summary>
|
|
/// Evaluate if a player is in check given the current board state.
|
|
/// </summary>
|
|
private bool EvaluateCheck(WhichPlayer whichPlayer)
|
|
{
|
|
var kingPosition = whichPlayer == WhichPlayer.Player1 ? player1King : player2King;
|
|
var inCheck = false;
|
|
// Iterate every board piece...
|
|
Board.ForEachNotNull((piece, x, y) =>
|
|
{
|
|
var v = new Vector2(x, y);
|
|
// ...that belongs to the opponent within range...
|
|
if (piece.Owner != whichPlayer && (piece.IsRanged || Vector2.Distance(kingPosition, v) < 3))
|
|
{
|
|
IterateMoveSet(new Vector2(x, y), (threatenedPiece, position) =>
|
|
{
|
|
// ...and threatens the player's king.
|
|
inCheck |=
|
|
threatenedPiece?.WhichPiece == WhichPiece.King
|
|
&& threatenedPiece?.Owner == whichPlayer;
|
|
});
|
|
}
|
|
});
|
|
return inCheck;
|
|
}
|
|
private bool ValidateMoveAgainstMoveSet(Vector2 from, Vector2 to)
|
|
{
|
|
var isValid = false;
|
|
IterateMoveSet(from, (piece, position) =>
|
|
{
|
|
if (piece?.Owner != WhoseTurn && position == to)
|
|
{
|
|
isValid = true;
|
|
}
|
|
});
|
|
|
|
return isValid;
|
|
}
|
|
/// <summary>
|
|
/// Iterate through the possible moves of a piece at a given position.
|
|
/// </summary>
|
|
private void IterateMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
// TODO: Make these are of the move To, so only possible moves towards the move To are iterated.
|
|
// Maybe separate functions? Sometimes I need to iterate the whole move-set, sometimes I need to iterate only the move-set towards the move To.
|
|
var piece = Board[from.X, from.Y];
|
|
switch (piece?.WhichPiece)
|
|
{
|
|
case WhichPiece.King:
|
|
IterateKingMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.GoldenGeneral:
|
|
IterateGoldenGeneralMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.SilverGeneral:
|
|
IterateSilverGeneralMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.Bishop:
|
|
IterateBishopMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.Rook:
|
|
IterateRookMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.Knight:
|
|
IterateKnightMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.Lance:
|
|
IterateLanceMoveSet(from, callback);
|
|
break;
|
|
case WhichPiece.Pawn:
|
|
IteratePawnMoveSet(from, callback);
|
|
break;
|
|
}
|
|
}
|
|
private void IterateKingMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
var direction = new Direction(piece.Owner);
|
|
BoardStep(from, direction.Up, callback);
|
|
BoardStep(from, direction.UpLeft, callback);
|
|
BoardStep(from, direction.UpRight, callback);
|
|
BoardStep(from, direction.Down, callback);
|
|
BoardStep(from, direction.DownLeft, callback);
|
|
BoardStep(from, direction.DownRight, callback);
|
|
BoardStep(from, direction.Left, callback);
|
|
BoardStep(from, direction.Right, callback);
|
|
}
|
|
private void IterateGoldenGeneralMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
var direction = new Direction(piece.Owner);
|
|
BoardStep(from, direction.Up, callback);
|
|
BoardStep(from, direction.UpLeft, callback);
|
|
BoardStep(from, direction.UpRight, callback);
|
|
BoardStep(from, direction.Down, callback);
|
|
BoardStep(from, direction.Left, callback);
|
|
BoardStep(from, direction.Right, callback);
|
|
}
|
|
private void IterateSilverGeneralMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
var direction = new Direction(piece.Owner);
|
|
if (piece.IsPromoted)
|
|
{
|
|
IterateGoldenGeneralMoveSet(from, callback);
|
|
}
|
|
else
|
|
{
|
|
BoardStep(from, direction.Up, callback);
|
|
BoardStep(from, direction.UpLeft, callback);
|
|
BoardStep(from, direction.UpRight, callback);
|
|
BoardStep(from, direction.DownLeft, callback);
|
|
BoardStep(from, direction.DownRight, callback);
|
|
}
|
|
}
|
|
private void IterateBishopMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
var direction = new Direction(piece.Owner);
|
|
BoardWalk(from, direction.UpLeft, callback);
|
|
BoardWalk(from, direction.UpRight, callback);
|
|
BoardWalk(from, direction.DownLeft, callback);
|
|
BoardWalk(from, direction.DownRight, callback);
|
|
if (piece.IsPromoted)
|
|
{
|
|
BoardStep(from, direction.Up, callback);
|
|
BoardStep(from, direction.Left, callback);
|
|
BoardStep(from, direction.Right, callback);
|
|
BoardStep(from, direction.Down, callback);
|
|
}
|
|
}
|
|
private void IterateRookMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
var direction = new Direction(piece.Owner);
|
|
BoardWalk(from, direction.Up, callback);
|
|
BoardWalk(from, direction.Left, callback);
|
|
BoardWalk(from, direction.Right, callback);
|
|
BoardWalk(from, direction.Down, callback);
|
|
if (piece.IsPromoted)
|
|
{
|
|
BoardStep(from, direction.UpLeft, callback);
|
|
BoardStep(from, direction.UpRight, callback);
|
|
BoardStep(from, direction.DownLeft, callback);
|
|
BoardStep(from, direction.DownRight, callback);
|
|
}
|
|
}
|
|
private void IterateKnightMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
if (piece.IsPromoted)
|
|
{
|
|
IterateGoldenGeneralMoveSet(from, callback);
|
|
}
|
|
else
|
|
{
|
|
var direction = new Direction(piece.Owner);
|
|
BoardStep(from, direction.KnightLeft, callback);
|
|
BoardStep(from, direction.KnightRight, callback);
|
|
}
|
|
}
|
|
private void IterateLanceMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
if (piece.IsPromoted)
|
|
{
|
|
IterateGoldenGeneralMoveSet(from, callback);
|
|
}
|
|
else
|
|
{
|
|
var direction = new Direction(piece.Owner);
|
|
BoardWalk(from, direction.Up, callback);
|
|
}
|
|
}
|
|
private void IteratePawnMoveSet(Vector2 from, MoveSetCallback callback)
|
|
{
|
|
var piece = Board[from.X, from.Y];
|
|
if (piece?.WhichPiece == WhichPiece.Pawn)
|
|
{
|
|
if (piece.IsPromoted)
|
|
{
|
|
IterateGoldenGeneralMoveSet(from, callback);
|
|
}
|
|
else
|
|
{
|
|
var direction = new Direction(piece.Owner);
|
|
BoardStep(from, direction.Up, callback);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Useful for iterating the board for pieces that move many spaces.
|
|
/// </summary>
|
|
/// <param name="callback">A function that returns true if walking should continue.</param>
|
|
private void BoardWalk(Vector2 from, Vector2 direction, MoveSetCallback callback)
|
|
{
|
|
var foundAnotherPiece = false;
|
|
var to = Vector2.Add(from, direction);
|
|
while (to.X >= 0 && to.X < 9 && to.Y >= 0 && to.Y < 9 && !foundAnotherPiece)
|
|
{
|
|
var piece = Board[to.X, to.Y];
|
|
callback(piece, to);
|
|
to = Vector2.Add(to, direction);
|
|
foundAnotherPiece = piece != null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Useful for iterating the board for pieces that move only one space.
|
|
/// </summary>
|
|
private void BoardStep(Vector2 from, Vector2 direction, MoveSetCallback callback)
|
|
{
|
|
var to = Vector2.Add(from, direction);
|
|
if (to.X >= 0 && to.X < 9 && to.Y >= 0 && to.Y < 9)
|
|
{
|
|
callback(Board[to.X, to.Y], to);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Initialize
|
|
private void ResetEmptyRows()
|
|
{
|
|
for (int y = 3; y < 6; y++)
|
|
for (int x = 0; x < 9; x++)
|
|
Board[x, y] = null;
|
|
}
|
|
private void ResetFrontRow(WhichPlayer player)
|
|
{
|
|
int y = player == WhichPlayer.Player1 ? 2 : 6;
|
|
for (int x = 0; x < 9; x++) Board[x, y] = new Piece(WhichPiece.Pawn, player);
|
|
}
|
|
private void ResetMiddleRow(WhichPlayer player)
|
|
{
|
|
int y = player == WhichPlayer.Player1 ? 1 : 7;
|
|
|
|
Board[0, y] = null;
|
|
for (int x = 2; x < 7; x++) Board[x, y] = null;
|
|
Board[8, y] = null;
|
|
if (player == WhichPlayer.Player1)
|
|
{
|
|
Board[1, y] = new Piece(WhichPiece.Bishop, player);
|
|
Board[7, y] = new Piece(WhichPiece.Rook, player);
|
|
}
|
|
else
|
|
{
|
|
Board[1, y] = new Piece(WhichPiece.Rook, player);
|
|
Board[7, y] = new Piece(WhichPiece.Bishop, player);
|
|
}
|
|
}
|
|
private void ResetRearRow(WhichPlayer player)
|
|
{
|
|
int y = player == WhichPlayer.Player1 ? 0 : 8;
|
|
|
|
Board[0, y] = new Piece(WhichPiece.Lance, player);
|
|
Board[1, y] = new Piece(WhichPiece.Knight, player);
|
|
Board[2, y] = new Piece(WhichPiece.SilverGeneral, player);
|
|
Board[3, y] = new Piece(WhichPiece.GoldenGeneral, player);
|
|
Board[4, y] = new Piece(WhichPiece.King, player);
|
|
Board[5, y] = new Piece(WhichPiece.GoldenGeneral, player);
|
|
Board[6, y] = new Piece(WhichPiece.SilverGeneral, player);
|
|
Board[7, y] = new Piece(WhichPiece.Knight, player);
|
|
Board[8, y] = new Piece(WhichPiece.Lance, player);
|
|
}
|
|
private void InitializeBoardState()
|
|
{
|
|
ResetRearRow(WhichPlayer.Player1);
|
|
ResetMiddleRow(WhichPlayer.Player1);
|
|
ResetFrontRow(WhichPlayer.Player1);
|
|
ResetEmptyRows();
|
|
ResetFrontRow(WhichPlayer.Player2);
|
|
ResetMiddleRow(WhichPlayer.Player2);
|
|
ResetRearRow(WhichPlayer.Player2);
|
|
}
|
|
#endregion
|
|
|
|
public static ShogiBoard ConstructWithMoves(IList<Move> moves)
|
|
{
|
|
var s = new ShogiBoard();
|
|
for (var i = 0; i < moves.Count; i++)
|
|
{
|
|
if (!s.Move(moves[i]))
|
|
{
|
|
throw new InvalidOperationException($"Unable to construct ShogiBoard with the given move at index {i}.");
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
}
|
|
}
|