Organize domain project.

Shogi.Domain/YetToBeAssimilatedIntoDDD/DomainExtensions.cs

@@ -0,0 +1,19 @@
+using Shogi.Domain.ValueObjects;
+
+namespace Shogi.Domain.YetToBeAssimilatedIntoDDD
+{
+    internal static class DomainExtensions
+    {
+        public static bool IsKing(this Piece self) => self.WhichPiece == WhichPiece.King;
+
+        public static bool IsBetween(this float self, float min, float max)
+        {
+            return self >= min && self <= max;
+        }
+
+        public static bool IsInsideBoardBoundary(this Vector2 self)
+        {
+            return self.X.IsBetween(0, 8) && self.Y.IsBetween(0, 8);
+        }
+    }
+}

Shogi.Domain/YetToBeAssimilatedIntoDDD/Notation.cs

@@ -0,0 +1,33 @@
+using System.Text.RegularExpressions;
+
+namespace Shogi.Domain.YetToBeAssimilatedIntoDDD
+{
+    public static class Notation
+    {
+        private static readonly string BoardNotationRegex = @"(?<file>[A-I])(?<rank>[1-9])";
+        private static readonly char A = 'A';
+
+        public static string ToBoardNotation(Vector2 vector)
+        {
+            return ToBoardNotation((int)vector.X, (int)vector.Y);
+        }
+
+        public 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}");
+        }
+    }
+}

Shogi.Domain/YetToBeAssimilatedIntoDDD/Pathing/Direction.cs

@@ -0,0 +1,22 @@
+using System.Numerics;
+
+namespace Shogi.Domain.YetToBeAssimilatedIntoDDD.Pathing
+{
+    /// <summary>
+    /// Directions are relative to the perspective of Player 1.
+    /// Up points towards player 1. Down points towards player 2.
+    /// </summary>
+    public static class Direction
+    {
+        public static readonly Vector2 Up = new(0, 1);
+        public static readonly Vector2 Down = new(0, -1);
+        public static readonly Vector2 Left = new(-1, 0);
+        public static readonly Vector2 Right = new(1, 0);
+        public static readonly Vector2 UpLeft = new(-1, 1);
+        public static readonly Vector2 UpRight = new(1, 1);
+        public static readonly Vector2 DownLeft = new(-1, -1);
+        public static readonly Vector2 DownRight = new(1, -1);
+        public static readonly Vector2 KnightLeft = new(-1, 2);
+        public static readonly Vector2 KnightRight = new(1, 2);
+    }
+}

Shogi.Domain/YetToBeAssimilatedIntoDDD/Pathing/Distance.cs

@@ -0,0 +1,8 @@
+namespace Shogi.Domain.YetToBeAssimilatedIntoDDD.Pathing
+{
+    public enum Distance
+    {
+        OneStep,
+        MultiStep
+    }
+}

Shogi.Domain/YetToBeAssimilatedIntoDDD/Pathing/Path.cs

@@ -0,0 +1,41 @@
+using System.Diagnostics;
+
+namespace Shogi.Domain.YetToBeAssimilatedIntoDDD.Pathing
+{
+    [DebuggerDisplay("{Direction} - {Distance}")]
+    public class Path
+    {
+        public Vector2 Direction { get; }
+        public Distance Distance { get; }
+        public Path(Vector2 direction, Distance distance = Distance.OneStep)
+        {
+            Direction = direction;
+            Distance = distance;
+        }
+
+        public Path Invert() => new(Vector2.Negate(Direction), Distance);
+    }
+
+    public static class PathExtensions
+    {
+        public static Path GetNearestPath(this IEnumerable<Path> paths, Vector2 start, Vector2 end)
+        {
+            if (!paths.DefaultIfEmpty().Any())
+            {
+                throw new ArgumentException("No paths to get nearest path from.");
+            }
+
+            var shortestPath = paths.First();
+            foreach (var path in paths.Skip(1))
+            {
+                var distance = Vector2.Distance(start + path.Direction, end);
+                var shortestDistance = Vector2.Distance(start + shortestPath.Direction, end);
+                if (distance < shortestDistance)
+                {
+                    shortestPath = path;
+                }
+            }
+            return shortestPath;
+        }
+    }
+}

Shogi.Domain/YetToBeAssimilatedIntoDDD/ReadMe.md

@@ -0,0 +1,4 @@
+# Shogi.Domain
+
+### TODO:
+* There are enough non-DDD classes around navigating the standard 9x9 Shogi board that probably a new value object or entity is merited. See classes within Pathing folder as well as Notation.cs.