Refactor backend into domain-first slices

apps/backend/Shared/AI/GoapCore.cs

@@ -0,0 +1,92 @@
+
+namespace SpaceGame.Api.Shared.AI;
+
+public abstract class GoapAction<TState>
+{
+  public abstract string Name { get; }
+  public abstract float Cost { get; }
+  public abstract bool CheckPreconditions(TState state);
+  public abstract TState ApplyEffects(TState state);
+  public abstract void Execute(SimulationEngine engine, SimulationWorld world, CommanderRuntime commander);
+}
+
+public abstract class GoapGoal<TState>
+{
+  public abstract string Name { get; }
+  public abstract bool IsSatisfied(TState state);
+  public abstract float ComputePriority(TState state, SimulationWorld world, CommanderRuntime commander);
+}
+
+public sealed class GoapPlan<TState>
+{
+  public static readonly GoapPlan<TState> Empty = new() { Actions = [], TotalCost = 0f };
+
+  public required IReadOnlyList<GoapAction<TState>> Actions { get; init; }
+  public required float TotalCost { get; init; }
+  public int CurrentStep { get; set; }
+
+  public GoapAction<TState>? CurrentAction => CurrentStep < Actions.Count ? Actions[CurrentStep] : null;
+  public bool IsComplete => CurrentStep >= Actions.Count;
+  public void Advance() => CurrentStep++;
+}
+
+public sealed class GoapPlanner<TState>
+{
+  private readonly Func<TState, TState> cloneState;
+
+  public GoapPlanner(Func<TState, TState> cloneState)
+  {
+    this.cloneState = cloneState;
+  }
+
+  public GoapPlan<TState>? Plan(
+      TState initialState,
+      GoapGoal<TState> goal,
+      IReadOnlyList<GoapAction<TState>> availableActions)
+  {
+    if (goal.IsSatisfied(initialState))
+    {
+      return GoapPlan<TState>.Empty;
+    }
+
+    var openSet = new PriorityQueue<PlanNode, float>();
+    openSet.Enqueue(new PlanNode(cloneState(initialState), [], 0f), 0f);
+
+    const int MaxIterations = 256;
+    var iterations = 0;
+
+    while (openSet.Count > 0 && iterations++ < MaxIterations)
+    {
+      var current = openSet.Dequeue();
+
+      if (goal.IsSatisfied(current.State))
+      {
+        return new GoapPlan<TState>
+        {
+          Actions = current.Actions,
+          TotalCost = current.Cost,
+        };
+      }
+
+      foreach (var action in availableActions)
+      {
+        if (!action.CheckPreconditions(current.State))
+        {
+          continue;
+        }
+
+        var newState = action.ApplyEffects(cloneState(current.State));
+        var newCost = current.Cost + action.Cost;
+        var newActions = new List<GoapAction<TState>>(current.Actions) { action };
+        openSet.Enqueue(new PlanNode(newState, newActions, newCost), newCost);
+      }
+    }
+
+    return null;
+  }
+
+  private sealed record PlanNode(
+      TState State,
+      IReadOnlyList<GoapAction<TState>> Actions,
+      float Cost);
+}

apps/backend/Shared/Contracts/Common.cs

@@ -0,0 +1,4 @@
+namespace SpaceGame.Api.Shared.Contracts;
+
+public sealed record Vector3Dto(float X, float Y, float Z);
+

apps/backend/Shared/Runtime/SimulationKinds.cs

@@ -0,0 +1,231 @@
+namespace SpaceGame.Api.Shared.Runtime;
+
+public enum SpatialNodeKind
+{
+  Star,
+  Planet,
+  Moon,
+  LagrangePoint,
+}
+
+public enum WorkStatus
+{
+  Pending,
+  Active,
+  Completed,
+}
+
+public enum OrderStatus
+{
+  Queued,
+  Accepted,
+  Completed,
+}
+
+public enum ShipState
+{
+  Idle,
+  Arriving,
+  LocalFlight,
+  SpoolingWarp,
+  Warping,
+  SpoolingFtl,
+  Ftl,
+  CargoFull,
+  MiningApproach,
+  Mining,
+  NodeDepleted,
+  AwaitingDock,
+  DockingApproach,
+  Docking,
+  Docked,
+  Transferring,
+  Loading,
+  Unloading,
+  WaitingMaterials,
+  ConstructionBlocked,
+  Constructing,
+  DeliveringConstruction,
+  Blocked,
+  Undocking,
+}
+
+public enum ControllerTaskKind
+{
+  Idle,
+  Travel,
+  Extract,
+  Dock,
+  Load,
+  Unload,
+  DeliverConstruction,
+  BuildConstructionSite,
+
+  ConstructModule,
+  Undock,
+}
+
+public static class SpaceLayerKinds
+{
+  public const string UniverseSpace = "universe-space";
+  public const string GalaxySpace = "galaxy-space";
+  public const string SystemSpace = "system-space";
+  public const string LocalSpace = "local-space";
+}
+
+public static class MovementRegimeKinds
+{
+  public const string LocalFlight = "local-flight";
+  public const string Warp = "warp";
+  public const string StargateTransit = "stargate-transit";
+  public const string FtlTransit = "ftl-transit";
+}
+
+public static class CommanderKind
+{
+  public const string Faction = "faction";
+  public const string Station = "station";
+  public const string Ship = "ship";
+  public const string Fleet = "fleet";
+  public const string Sector = "sector";
+  public const string TaskGroup = "task-group";
+}
+
+public static class ShipTaskKinds
+{
+  public const string Idle = "idle";
+  public const string LocalMove = "local-move";
+  public const string WarpToNode = "warp-to-node";
+  public const string UseStargate = "use-stargate";
+  public const string UseFtl = "use-ftl";
+  public const string Dock = "dock";
+  public const string Undock = "undock";
+  public const string LoadCargo = "load-cargo";
+  public const string UnloadCargo = "unload-cargo";
+
+  public const string MineNode = "mine-node";
+  public const string HarvestGas = "harvest-gas";
+  public const string DeliverToStation = "deliver-to-station";
+  public const string ClaimLagrangePoint = "claim-lagrange-point";
+  public const string BuildConstructionSite = "build-construction-site";
+  public const string EscortTarget = "escort-target";
+  public const string AttackTarget = "attack-target";
+  public const string DefendCelestial = "defend-celestial";
+  public const string Retreat = "retreat";
+  public const string HoldPosition = "hold-position";
+}
+
+public static class ShipOrderKinds
+{
+  public const string DirectMove = "direct-move";
+  public const string TravelToNode = "travel-to-node";
+  public const string DockAtStation = "dock-at-station";
+  public const string DeliverCargo = "deliver-cargo";
+  public const string BuildAtSite = "build-at-site";
+  public const string AttackTarget = "attack-target";
+  public const string HoldPosition = "hold-position";
+}
+
+public static class ClaimStateKinds
+{
+  public const string Placed = "placed";
+  public const string Activating = "activating";
+  public const string Active = "active";
+  public const string Destroyed = "destroyed";
+}
+
+public static class ConstructionSiteStateKinds
+{
+  public const string Planned = "planned";
+  public const string Active = "active";
+  public const string Paused = "paused";
+  public const string Completed = "completed";
+  public const string Destroyed = "destroyed";
+}
+
+public static class MarketOrderKinds
+{
+  public const string Buy = "buy";
+  public const string Sell = "sell";
+}
+
+public static class MarketOrderStateKinds
+{
+  public const string Open = "open";
+  public const string PartiallyFilled = "partially-filled";
+  public const string Filled = "filled";
+  public const string Cancelled = "cancelled";
+}
+
+public static class SimulationEnumMappings
+{
+  public static string ToContractValue(this SpatialNodeKind kind) => kind switch
+  {
+    SpatialNodeKind.Star => "star",
+    SpatialNodeKind.Planet => "planet",
+    SpatialNodeKind.Moon => "moon",
+    SpatialNodeKind.LagrangePoint => "lagrange-point",
+    _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+  };
+
+  public static string ToContractValue(this WorkStatus status) => status switch
+  {
+    WorkStatus.Pending => "pending",
+    WorkStatus.Active => "active",
+    WorkStatus.Completed => "completed",
+    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
+  };
+
+  public static string ToContractValue(this OrderStatus status) => status switch
+  {
+    OrderStatus.Queued => "queued",
+    OrderStatus.Accepted => "accepted",
+    OrderStatus.Completed => "completed",
+    _ => throw new ArgumentOutOfRangeException(nameof(status), status, null),
+  };
+
+  public static string ToContractValue(this ShipState state) => state switch
+  {
+    ShipState.Idle => "idle",
+    ShipState.Arriving => "arriving",
+    ShipState.LocalFlight => "local-flight",
+    ShipState.SpoolingWarp => "spooling-warp",
+    ShipState.Warping => "warping",
+    ShipState.SpoolingFtl => "spooling-ftl",
+    ShipState.Ftl => "ftl",
+    ShipState.CargoFull => "cargo-full",
+    ShipState.MiningApproach => "mining-approach",
+    ShipState.Mining => "mining",
+    ShipState.NodeDepleted => "node-depleted",
+    ShipState.AwaitingDock => "awaiting-dock",
+    ShipState.DockingApproach => "docking-approach",
+    ShipState.Docking => "docking",
+    ShipState.Docked => "docked",
+    ShipState.Transferring => "transferring",
+    ShipState.Loading => "loading",
+    ShipState.Unloading => "unloading",
+    ShipState.WaitingMaterials => "waiting-materials",
+    ShipState.ConstructionBlocked => "construction-blocked",
+    ShipState.Constructing => "constructing",
+    ShipState.DeliveringConstruction => "delivering-construction",
+    ShipState.Blocked => "blocked",
+    ShipState.Undocking => "undocking",
+    _ => throw new ArgumentOutOfRangeException(nameof(state), state, null),
+  };
+
+  public static string ToContractValue(this ControllerTaskKind kind) => kind switch
+  {
+    ControllerTaskKind.Idle => "idle",
+    ControllerTaskKind.Travel => "travel",
+    ControllerTaskKind.Extract => "extract",
+    ControllerTaskKind.Dock => "dock",
+    ControllerTaskKind.Load => "load",
+    ControllerTaskKind.Unload => "unload",
+    ControllerTaskKind.DeliverConstruction => "deliver-construction",
+    ControllerTaskKind.BuildConstructionSite => "build-construction-site",
+
+    ControllerTaskKind.ConstructModule => "construct-module",
+    ControllerTaskKind.Undock => "undock",
+    _ => throw new ArgumentOutOfRangeException(nameof(kind), kind, null),
+  };
+}

apps/backend/Shared/Runtime/SimulationRuntimeSupport.cs

@@ -0,0 +1,181 @@
+
+namespace SpaceGame.Api.Shared.Runtime;
+
+internal static class SimulationRuntimeSupport
+{
+  internal static bool HasShipCapabilities(ShipDefinition definition, params string[] capabilities) =>
+      capabilities.All(cap => definition.Capabilities.Contains(cap, StringComparer.Ordinal));
+
+  internal static int CountStationModules(StationRuntime station, string moduleId) =>
+      station.Modules.Count(module => string.Equals(module.ModuleId, moduleId, StringComparison.Ordinal));
+
+  internal static void AddStationModule(SimulationWorld world, StationRuntime station, string moduleId)
+  {
+    if (!world.ModuleDefinitions.TryGetValue(moduleId, out var definition))
+    {
+      return;
+    }
+
+    station.Modules.Add(new StationModuleRuntime
+    {
+      Id = $"{station.Id}-module-{station.Modules.Count + 1}",
+      ModuleId = moduleId,
+      Health = definition.Hull,
+      MaxHealth = definition.Hull,
+    });
+    station.Radius = GetStationRadius(world, station);
+  }
+
+  internal static float GetStationRadius(SimulationWorld world, StationRuntime station)
+  {
+    var totalArea = station.Modules
+      .Select(module => world.ModuleDefinitions.TryGetValue(module.ModuleId, out var definition) ? definition.Radius * definition.Radius : 0f)
+      .Sum();
+    return MathF.Max(24f, MathF.Sqrt(MathF.Max(totalArea, 1f)));
+  }
+
+  internal static float GetStationStorageCapacity(StationRuntime station, string storageClass)
+  {
+    var baseCapacity = storageClass switch
+    {
+      "manufactured" => 400f,
+      _ => 0f,
+    };
+
+    var bulkBays = CountStationModules(station, "module_arg_stor_solid_m_01");
+    var liquidTanks = CountStationModules(station, "module_arg_stor_liquid_m_01");
+    var containerBays = CountStationModules(station, "module_arg_stor_container_m_01");
+
+    var moduleCapacity = storageClass switch
+    {
+      "solid" => bulkBays * 1000f,
+      "liquid" => liquidTanks * 500f,
+      "container" => containerBays * 800f,
+      "manufactured" => containerBays * 200f,
+      _ => 0f,
+    };
+
+    return baseCapacity + moduleCapacity;
+  }
+
+  internal static int CountModules(IEnumerable<string> modules, string moduleId) =>
+      modules.Count(candidate => string.Equals(candidate, moduleId, StringComparison.Ordinal));
+
+  internal static float GetInventoryAmount(IReadOnlyDictionary<string, float> inventory, string itemId) =>
+      inventory.TryGetValue(itemId, out var amount) ? amount : 0f;
+
+  internal static void AddInventory(IDictionary<string, float> inventory, string itemId, float amount)
+  {
+    if (amount <= 0f)
+    {
+      return;
+    }
+
+    inventory[itemId] = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId) + amount;
+  }
+
+  internal static float RemoveInventory(IDictionary<string, float> inventory, string itemId, float amount)
+  {
+    var current = GetInventoryAmount((IReadOnlyDictionary<string, float>)inventory, itemId);
+    var removed = MathF.Min(current, amount);
+    var remaining = current - removed;
+    if (remaining <= 0.001f)
+    {
+      inventory.Remove(itemId);
+    }
+    else
+    {
+      inventory[itemId] = remaining;
+    }
+
+    return removed;
+  }
+
+  internal static bool HasStationModules(StationRuntime station, params string[] modules) =>
+      modules.All(moduleId => station.Modules.Any(candidate => string.Equals(candidate.ModuleId, moduleId, StringComparison.Ordinal)));
+
+  internal static bool CanExtractNode(ShipRuntime ship, ResourceNodeRuntime node, SimulationWorld world) =>
+      HasShipCapabilities(ship.Definition, "mining")
+      && world.ItemDefinitions.TryGetValue(node.ItemId, out var item)
+      && string.Equals(item.CargoKind, ship.Definition.CargoKind, StringComparison.Ordinal);
+
+  internal static bool CanBuildClaimBeacon(ShipRuntime ship) =>
+      string.Equals(ship.Definition.Kind, "military", StringComparison.Ordinal);
+
+  internal static float ComputeWorkforceRatio(float population, float workforceRequired)
+  {
+    if (workforceRequired <= 0.01f)
+    {
+      return 1f;
+    }
+
+    var staffedRatio = MathF.Min(1f, population / workforceRequired);
+    return 0.1f + (0.9f * staffedRatio);
+  }
+
+  internal static string? GetStorageRequirement(string storageClass) =>
+      storageClass switch
+      {
+        "solid" => "module_arg_stor_solid_m_01",
+        "liquid" => "module_arg_stor_liquid_m_01",
+        _ => null,
+      };
+
+  internal static float TryAddStationInventory(SimulationWorld world, StationRuntime station, string itemId, float amount)
+  {
+    if (amount <= 0f || !world.ItemDefinitions.TryGetValue(itemId, out var itemDefinition))
+    {
+      return 0f;
+    }
+
+    var storageClass = itemDefinition.CargoKind;
+    var requiredModule = GetStorageRequirement(storageClass);
+    if (requiredModule is not null && !station.InstalledModules.Contains(requiredModule, StringComparer.Ordinal))
+    {
+      return 0f;
+    }
+
+    var capacity = GetStationStorageCapacity(station, storageClass);
+    if (capacity <= 0.01f)
+    {
+      return 0f;
+    }
+
+    var used = station.Inventory
+        .Where(entry => world.ItemDefinitions.TryGetValue(entry.Key, out var definition) && definition.CargoKind == storageClass)
+        .Sum(entry => entry.Value);
+    var accepted = MathF.Min(amount, MathF.Max(0f, capacity - used));
+    if (accepted <= 0.01f)
+    {
+      return 0f;
+    }
+
+    AddInventory(station.Inventory, itemId, accepted);
+    return accepted;
+  }
+
+  internal static bool CanStartModuleConstruction(StationRuntime station, ModuleRecipeDefinition recipe) =>
+      recipe.Inputs.All(input => GetInventoryAmount(station.Inventory, input.ItemId) + 0.001f >= input.Amount);
+
+  internal static ConstructionSiteRuntime? GetConstructionSiteForStation(SimulationWorld world, string stationId) =>
+      world.ConstructionSites.FirstOrDefault(site =>
+          string.Equals(site.StationId, stationId, StringComparison.Ordinal)
+          && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed);
+
+  internal static float GetConstructionDeliveredAmount(SimulationWorld world, ConstructionSiteRuntime site, string itemId)
+  {
+    if (site.StationId is not null
+        && world.Stations.FirstOrDefault(candidate => candidate.Id == site.StationId) is { } station)
+    {
+      return GetInventoryAmount(station.Inventory, itemId);
+    }
+
+    return GetInventoryAmount(site.DeliveredItems, itemId);
+  }
+
+  internal static bool IsConstructionSiteReady(SimulationWorld world, ConstructionSiteRuntime site) =>
+      site.RequiredItems.All(entry => GetConstructionDeliveredAmount(world, site, entry.Key) + 0.001f >= entry.Value);
+
+  internal static float GetShipCargoAmount(ShipRuntime ship) =>
+    ship.Inventory.Values.Sum();
+}

apps/backend/Shared/Runtime/SimulationUnits.cs

@@ -0,0 +1,15 @@
+namespace SpaceGame.Api.Shared.Runtime;
+
+public static class SimulationUnits
+{
+    public const float KilometersPerAu = 149_597_870.7f;
+    public const float MetersPerKilometer = 1000f;
+
+    public static float AuToKilometers(float au) => au * KilometersPerAu;
+
+    public static float AuPerSecondToKilometersPerSecond(float auPerSecond) =>
+        auPerSecond * KilometersPerAu;
+
+    public static float MetersPerSecondToKilometersPerSecond(float metersPerSecond) =>
+        metersPerSecond / MetersPerKilometer;
+}

apps/backend/Shared/Runtime/Vector3.cs

@@ -0,0 +1,36 @@
+namespace SpaceGame.Api.Shared.Runtime;
+
+public readonly record struct Vector3(float X, float Y, float Z)
+{
+    public static Vector3 Zero => new(0f, 0f, 0f);
+
+    public float DistanceTo(Vector3 other)
+    {
+        var dx = X - other.X;
+        var dy = Y - other.Y;
+        var dz = Z - other.Z;
+        return MathF.Sqrt((dx * dx) + (dy * dy) + (dz * dz));
+    }
+
+    public float LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
+
+    public Vector3 MoveToward(Vector3 target, float maxDistance)
+    {
+        var delta = target.Subtract(this);
+        var distance = MathF.Sqrt(delta.LengthSquared());
+        if (distance <= 0.0001f || distance <= maxDistance)
+        {
+            return target;
+        }
+
+        var scale = maxDistance / distance;
+        return new Vector3(
+            X + (delta.X * scale),
+            Y + (delta.Y * scale),
+            Z + (delta.Z * scale));
+    }
+
+    public Vector3 Subtract(Vector3 other) => new(X - other.X, Y - other.Y, Z - other.Z);
+
+    public Vector3 Divide(float scalar) => MathF.Abs(scalar) <= 0.0001f ? Zero : new Vector3(X / scalar, Y / scalar, Z / scalar);
+}