96 lines
3.0 KiB
C#
96 lines
3.0 KiB
C#
using Shogi.Domain.Pathing;
|
|
using System.Diagnostics;
|
|
|
|
namespace Shogi.Domain.Pieces
|
|
{
|
|
[DebuggerDisplay("{WhichPiece} {Owner}")]
|
|
public abstract class Piece
|
|
{
|
|
/// <summary>
|
|
/// Creates a clone of an existing piece.
|
|
/// </summary>
|
|
public static Piece Create(Piece piece) => Create(piece.WhichPiece, piece.Owner, piece.IsPromoted);
|
|
public static Piece Create(WhichPiece piece, WhichPlayer owner, bool isPromoted = false)
|
|
{
|
|
return piece switch
|
|
{
|
|
WhichPiece.King => new King(owner, isPromoted),
|
|
WhichPiece.GoldGeneral => new GoldGeneral(owner, isPromoted),
|
|
WhichPiece.SilverGeneral => new SilverGeneral(owner, isPromoted),
|
|
WhichPiece.Bishop => new Bishop(owner, isPromoted),
|
|
WhichPiece.Rook => new Rook(owner, isPromoted),
|
|
WhichPiece.Knight => new Knight(owner, isPromoted),
|
|
WhichPiece.Lance => new Lance(owner, isPromoted),
|
|
WhichPiece.Pawn => new Pawn(owner, isPromoted),
|
|
_ => throw new ArgumentException($"Unknown {nameof(WhichPiece)} when cloning a {nameof(Piece)}.")
|
|
};
|
|
}
|
|
|
|
// TODO: MoveSet doesn't account for Player2's pieces which are upside-down.
|
|
public abstract IEnumerable<Path> MoveSet { get; }
|
|
public WhichPiece WhichPiece { get; }
|
|
public WhichPlayer Owner { get; private set; }
|
|
public bool IsPromoted { get; private set; }
|
|
public bool IsUpsideDown => Owner == WhichPlayer.Player2;
|
|
|
|
protected Piece(WhichPiece piece, WhichPlayer owner, bool isPromoted = false)
|
|
{
|
|
WhichPiece = piece;
|
|
Owner = owner;
|
|
IsPromoted = isPromoted;
|
|
}
|
|
|
|
public bool CanPromote => !IsPromoted
|
|
&& WhichPiece != WhichPiece.King
|
|
&& WhichPiece != WhichPiece.GoldGeneral;
|
|
|
|
public void Promote() => IsPromoted = CanPromote;
|
|
|
|
/// <summary>
|
|
/// Prep the piece for capture by changing ownership and demoting.
|
|
/// </summary>
|
|
public void Capture(WhichPlayer newOwner)
|
|
{
|
|
Owner = newOwner;
|
|
IsPromoted = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Respecting the move-set of the Piece, collect all positions from start to end.
|
|
/// Useful if you need to iterate a move-set.
|
|
/// </summary>
|
|
/// <param name="start"></param>
|
|
/// <param name="end"></param>
|
|
/// <returns>An empty list if the piece cannot legally traverse from start to end. Otherwise, a list of positions.</returns>
|
|
public IEnumerable<Vector2> GetPathFromStartToEnd(Vector2 start, Vector2 end)
|
|
{
|
|
var steps = new List<Vector2>(10);
|
|
|
|
var path = this.MoveSet.GetNearestPath(start, end);
|
|
var position = start;
|
|
while (Vector2.Distance(start, position) < Vector2.Distance(start, end))
|
|
{
|
|
position += path.Direction;
|
|
steps.Add(position);
|
|
}
|
|
|
|
if (position == end)
|
|
{
|
|
return steps;
|
|
}
|
|
|
|
return Array.Empty<Vector2>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all positions this piece could move to from the currentPosition, respecting the move-set of this piece.
|
|
/// </summary>
|
|
/// <param name="currentPosition"></param>
|
|
/// <returns>A list of positions the piece could move to.</returns>
|
|
public IEnumerable<Vector2> GetPossiblePositions(Vector2 currentPosition)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|