squash a bunch of commits

Shogi.Domain/ValueObjects/Piece.cs

@@ -0,0 +1,95 @@
+using Shogi.Domain.Pathing;
+using System.Diagnostics;
+
+namespace Shogi.Domain.ValueObjects
+{
+    [DebuggerDisplay("{WhichPiece} {Owner}")]
+    public abstract record class Piece
+    {
+        /// <summary>
+        /// Creates a clone of an existing piece.
+        /// </summary>
+        public static Piece CreateCopy(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)}.")
+            };
+        }
+        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 = MoveSet.GetNearestPath(start, end);
+            var position = start;
+            while (Vector2.Distance(start, position) < Vector2.Distance(start, end))
+            {
+                position += path.Direction;
+                steps.Add(position);
+
+                if (path.Distance == Distance.OneStep) break;
+            }
+
+            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();
+        }
+    }
+}