feat: production chain

2026-03-15 22:46:47 -04:00
parent 651556c916
commit 5ba1287f85
65 changed files with 3718 additions and 687 deletions
--- a/apps/backend/Simulation/SimulationEngine.PowerAndInventorySystems.cs
+++ b/apps/backend/Simulation/SimulationEngine.PowerAndInventorySystems.cs
@@ -5,6 +5,8 @@ namespace SpaceGame.Simulation.Api.Simulation;

 public sealed partial class SimulationEngine
 {
+    private const float StationEnergyCellToEnergyRatio = 1f;
+
    private static bool HasShipModules(ShipDefinition definition, params string[] modules) =>
        modules.All(moduleId => definition.Modules.Contains(moduleId, StringComparer.Ordinal));

@@ -19,7 +21,7 @@ public sealed partial class SimulationEngine
        foreach (var station in world.Stations)
        {
            var previousEnergy = station.EnergyStored;
-            GenerateStationEnergy(station, deltaSeconds);
+            GenerateStationEnergy(station, world, deltaSeconds);

            if (previousEnergy > 0.01f && station.EnergyStored <= 0.01f && GetInventoryAmount(station.Inventory, "fuel") <= 0.01f)
            {
@@ -39,7 +41,7 @@ public sealed partial class SimulationEngine
        }
    }

-    private static void GenerateStationEnergy(StationRuntime station, float deltaSeconds)
+    private static void GenerateStationEnergy(StationRuntime station, SimulationWorld world, float deltaSeconds)
    {
        var powerCores = CountModules(station.InstalledModules, "power-core");
        var tanks = CountModules(station.InstalledModules, "liquid-tank");
@@ -53,6 +55,32 @@ public sealed partial class SimulationEngine
        var energyCapacity = powerCores * StationEnergyPerPowerCore;
        var fuelStored = GetInventoryAmount(station.Inventory, "fuel");
        var desiredEnergy = MathF.Max(0f, energyCapacity - station.EnergyStored);
+        if (desiredEnergy <= 0.01f)
+        {
+            station.EnergyStored = MathF.Min(station.EnergyStored, energyCapacity);
+            station.Inventory["fuel"] = MathF.Min(fuelStored, tanks * StationFuelPerTank);
+            return;
+        }
+
+        var solarGenerated = MathF.Min(desiredEnergy, GetStationSolarGeneration(station, world) * deltaSeconds);
+        if (solarGenerated > 0.01f)
+        {
+            station.EnergyStored = MathF.Min(energyCapacity, station.EnergyStored + solarGenerated);
+            desiredEnergy = MathF.Max(0f, energyCapacity - station.EnergyStored);
+        }
+
+        if (desiredEnergy > 0.01f && fuelStored <= 0.01f)
+        {
+            var energyCells = GetInventoryAmount(station.Inventory, "energy-cell");
+            if (energyCells > 0.01f)
+            {
+                var consumedCells = MathF.Min(energyCells, desiredEnergy / StationEnergyCellToEnergyRatio);
+                RemoveInventory(station.Inventory, "energy-cell", consumedCells);
+                station.EnergyStored = MathF.Min(energyCapacity, station.EnergyStored + (consumedCells * StationEnergyCellToEnergyRatio));
+                desiredEnergy = MathF.Max(0f, energyCapacity - station.EnergyStored);
+            }
+        }
+
        if (desiredEnergy <= 0.01f || fuelStored <= 0.01f)
        {
            station.EnergyStored = MathF.Min(station.EnergyStored, energyCapacity);
@@ -69,6 +97,37 @@ public sealed partial class SimulationEngine
        station.EnergyStored = MathF.Min(energyCapacity, station.EnergyStored + actualGenerated);
    }

+    private static float GetStationFuelCapacity(StationRuntime station) =>
+        CountModules(station.InstalledModules, "liquid-tank") * StationFuelPerTank;
+
+    private static float GetStationEnergyCapacity(StationRuntime station) =>
+        CountModules(station.InstalledModules, "power-core") * StationEnergyPerPowerCore;
+
+    private static float GetStationSolarGeneration(StationRuntime station, SimulationWorld world) =>
+        world.Balance.Energy.StationSolarCharge * (1f + CountModules(station.InstalledModules, "solar-array"));
+
+    private static float GetStationStorageCapacity(StationRuntime station, string storageClass)
+    {
+        var baseCapacity = station.Definition.Storage.TryGetValue(storageClass, out var capacity)
+            ? capacity
+            : 0f;
+
+        var extraBulkBays = Math.Max(0, CountModules(station.InstalledModules, "bulk-bay") - CountModules(station.Definition.Modules, "bulk-bay"));
+        var extraLiquidTanks = Math.Max(0, CountModules(station.InstalledModules, "liquid-tank") - CountModules(station.Definition.Modules, "liquid-tank"));
+        var extraGasTanks = Math.Max(0, CountModules(station.InstalledModules, "gas-tank") - CountModules(station.Definition.Modules, "gas-tank"));
+        var extraContainerBays = Math.Max(0, CountModules(station.InstalledModules, "container-bay") - CountModules(station.Definition.Modules, "container-bay"));
+        var moduleBonus = storageClass switch
+        {
+            "bulk-solid" => extraBulkBays * 1000f,
+            "bulk-liquid" => extraLiquidTanks * 500f,
+            "bulk-gas" => extraGasTanks * 500f,
+            "container" => extraContainerBays * 800f,
+            _ => 0f,
+        };
+
+        return baseCapacity + moduleBonus;
+    }
+
    private static void GenerateShipEnergy(ShipRuntime ship, SimulationWorld world, float deltaSeconds)
    {
        var reactors = CountModules(ship.Definition.Modules, "reactor-core");
@@ -166,11 +225,265 @@ public sealed partial class SimulationEngine
            _ => false,
        };

+    private static bool CanBuildClaimBeacon(ShipRuntime ship) =>
+        string.Equals(ship.Definition.Role, "military", StringComparison.Ordinal);
+
    private static float GetShipFuelCapacity(ShipRuntime ship) =>
        CountModules(ship.Definition.Modules, "reactor-core") * ShipFuelPerReactor;

-    internal static bool NeedsRefuel(ShipRuntime ship) =>
-        GetInventoryAmount(ship.Inventory, "fuel") < (GetShipFuelCapacity(ship) * 0.7f);
+    private static float GetShipAvailableEnergyBudget(ShipRuntime ship) =>
+        ship.EnergyStored + (GetInventoryAmount(ship.Inventory, "fuel") * ShipFuelToEnergyRatio);
+
+    private static float GetShipFuelReserve(ShipRuntime ship, float plannedFuel)
+    {
+        var capacity = GetShipFuelCapacity(ship);
+        var reserveRatio = ship.Definition.CargoItemId == "gas" ? 0.4f : 0.3f;
+        var reserve = MathF.Max(16f, MathF.Max(capacity * 0.18f, plannedFuel * reserveRatio));
+        return MathF.Min(capacity, reserve);
+    }
+
+    private static float EstimateFuelForEnergyDemand(ShipRuntime ship, float energyDemand) =>
+        MathF.Max(0f, energyDemand - ship.EnergyStored) / ShipFuelToEnergyRatio;
+
+    private static float EstimateTimedEnergyUse(SimulationWorld world, float durationSeconds, float drainPerSecond) =>
+        MathF.Max(0f, durationSeconds) * drainPerSecond;
+
+    private static float EstimateTravelEnergy(
+        ShipRuntime ship,
+        SimulationWorld world,
+        Vector3 fromPosition,
+        string fromSystemId,
+        Vector3 toPosition,
+        string toSystemId)
+    {
+        if (!string.Equals(fromSystemId, toSystemId, StringComparison.Ordinal))
+        {
+            var destinationEntryNode = ResolveSystemEntryNode(world, toSystemId);
+            var destinationEntryPosition = destinationEntryNode?.Position ?? toPosition;
+            var ftlDistance = fromPosition.DistanceTo(destinationEntryPosition);
+            var ftlDuration = ftlDistance / MathF.Max(ship.Definition.FtlSpeed, 0.01f);
+            return EstimateTimedEnergyUse(world, ship.Definition.SpoolTime, world.Balance.Energy.IdleDrain)
+                + EstimateTimedEnergyUse(world, ftlDuration, world.Balance.Energy.WarpDrain)
+                + EstimateInSystemTravelEnergy(ship, world, destinationEntryPosition, toPosition);
+        }
+
+        return EstimateInSystemTravelEnergy(ship, world, fromPosition, toPosition);
+    }
+
+    private static float EstimateInSystemTravelEnergy(ShipRuntime ship, SimulationWorld world, Vector3 fromPosition, Vector3 toPosition)
+    {
+        var distance = fromPosition.DistanceTo(toPosition);
+        if (distance <= world.Balance.ArrivalThreshold)
+        {
+            return 0f;
+        }
+
+        if (distance <= 120f)
+        {
+            var localDuration = distance / MathF.Max(ship.Definition.Speed, 0.01f);
+            return EstimateTimedEnergyUse(world, localDuration, world.Balance.Energy.MoveDrain);
+        }
+
+        var warpSpoolDuration = MathF.Max(0.4f, ship.Definition.SpoolTime * 0.5f);
+        var warpDuration = distance / MathF.Max(ship.Definition.Speed, 0.01f);
+        return EstimateTimedEnergyUse(world, warpSpoolDuration, world.Balance.Energy.IdleDrain)
+            + EstimateTimedEnergyUse(world, warpDuration, world.Balance.Energy.WarpDrain);
+    }
+
+    private static float EstimateDockingEnergy(SimulationWorld world) =>
+        EstimateTimedEnergyUse(world, world.Balance.DockingDuration, world.Balance.Energy.MoveDrain)
+        + EstimateTimedEnergyUse(world, 6f, world.Balance.Energy.IdleDrain);
+
+    private static float EstimateUndockingEnergy(SimulationWorld world) =>
+        EstimateTimedEnergyUse(world, world.Balance.UndockingDuration, world.Balance.Energy.MoveDrain)
+        + EstimateTimedEnergyUse(world, 4f, world.Balance.Energy.IdleDrain);
+
+    private static float EstimateExtractionEnergy(ShipRuntime ship, SimulationWorld world)
+    {
+        var remainingCargo = MathF.Max(0f, ship.Definition.CargoCapacity - GetShipCargoAmount(ship));
+        if (remainingCargo <= 0.01f)
+        {
+            return 0f;
+        }
+
+        var cycles = MathF.Ceiling(remainingCargo / MathF.Max(world.Balance.MiningRate, 0.01f));
+        return EstimateTimedEnergyUse(world, cycles * world.Balance.MiningCycleSeconds, world.Balance.Energy.MoveDrain)
+            + EstimateTimedEnergyUse(world, cycles * 1.5f, world.Balance.Energy.IdleDrain);
+    }
+
+    private static float EstimateConstructionEnergy(ShipRuntime ship, SimulationWorld world, StationRuntime station)
+    {
+        var holdPosition = GetConstructionHoldPosition(station, ship.Id);
+        var travelEnergy = EstimateTravelEnergy(ship, world, ship.Position, ship.SystemId, holdPosition, station.SystemId);
+        var site = GetConstructionSiteForStation(world, station.Id);
+        if (site is not null && site.State == ConstructionSiteStateKinds.Active && IsConstructionSiteReady(world, site))
+        {
+            if (world.ModuleRecipes.TryGetValue(site.BlueprintId ?? string.Empty, out var siteRecipe))
+            {
+                return travelEnergy + EstimateTimedEnergyUse(world, siteRecipe.Duration, world.Balance.Energy.IdleDrain);
+            }
+
+            return travelEnergy;
+        }
+
+        var moduleId = site?.BlueprintId ?? GetNextStationModuleToBuild(station, world);
+        if (moduleId is not null
+            && world.ModuleRecipes.TryGetValue(moduleId, out var recipe)
+            && CanStartModuleConstruction(station, recipe))
+        {
+            return travelEnergy + EstimateTimedEnergyUse(world, recipe.Duration, world.Balance.Energy.IdleDrain);
+        }
+
+        return travelEnergy;
+    }
+
+    private static float EstimateResourceHarvestEnergy(ShipRuntime ship, SimulationWorld world)
+    {
+        var cargoItemId = ship.Definition.CargoItemId;
+        if (cargoItemId is null)
+        {
+            return 0f;
+        }
+
+        var requiredModule = cargoItemId == "gas" ? "gas-extractor" : "mining-turret";
+        var behavior = ship.DefaultBehavior;
+        var refinery = SelectBestBuyStation(world, ship, cargoItemId, behavior.StationId);
+        var node = behavior.NodeId is null
+            ? world.Nodes
+                .Where(candidate =>
+                    (behavior.AreaSystemId is null || candidate.SystemId == behavior.AreaSystemId) &&
+                    candidate.ItemId == cargoItemId &&
+                    candidate.OreRemaining > 0.01f)
+                .OrderByDescending(candidate => candidate.OreRemaining)
+                .FirstOrDefault()
+            : world.Nodes.FirstOrDefault(candidate => candidate.Id == behavior.NodeId && candidate.OreRemaining > 0.01f);
+        if (refinery is null || node is null || !HasShipModules(ship.Definition, "reactor-core", "capacitor-bank", requiredModule))
+        {
+            return 0f;
+        }
+
+        var currentPosition = ship.Position;
+        var currentSystemId = ship.SystemId;
+        var energy = 0f;
+        var cargoAmount = GetShipCargoAmount(ship);
+        if (ship.DockedStationId == refinery.Id)
+        {
+            currentPosition = GetUndockTargetPosition(refinery, ship.AssignedDockingPadIndex, world.Balance.UndockDistance);
+            currentSystemId = refinery.SystemId;
+            energy += EstimateUndockingEnergy(world);
+        }
+
+        if (cargoAmount > 0.01f)
+        {
+            energy += EstimateTravelEnergy(ship, world, currentPosition, currentSystemId, refinery.Position, refinery.SystemId);
+            return energy + EstimateDockingEnergy(world);
+        }
+
+        var holdPosition = GetResourceHoldPosition(node.Position, ship.Id, 20f);
+        energy += EstimateTravelEnergy(ship, world, currentPosition, currentSystemId, holdPosition, node.SystemId);
+        energy += EstimateExtractionEnergy(ship, world);
+        energy += EstimateTravelEnergy(ship, world, holdPosition, node.SystemId, refinery.Position, refinery.SystemId);
+        energy += EstimateDockingEnergy(world);
+        return energy;
+    }
+
+    private static float EstimateResourceReturnEnergy(ShipRuntime ship, SimulationWorld world)
+    {
+        var cargoItemId = ship.Definition.CargoItemId;
+        if (cargoItemId is null)
+        {
+            return 0f;
+        }
+
+        var refinery = SelectBestBuyStation(world, ship, cargoItemId, ship.DefaultBehavior.StationId);
+        if (refinery is null)
+        {
+            return 0f;
+        }
+
+        var currentPosition = ship.Position;
+        var currentSystemId = ship.SystemId;
+        return EstimateTravelEnergy(ship, world, currentPosition, currentSystemId, refinery.Position, refinery.SystemId)
+            + EstimateDockingEnergy(world);
+    }
+
+    private static float EstimateTransportEnergy(ShipRuntime ship, SimulationWorld world)
+    {
+        var cargoItemId = ship.Definition.CargoItemId;
+        if (cargoItemId is null)
+        {
+            return 0f;
+        }
+
+        var behavior = ship.DefaultBehavior;
+        var source = SelectBestSellStation(world, ship, cargoItemId, behavior.StationId);
+        var destination = SelectBestBuyStation(world, ship, cargoItemId, behavior.StationId);
+        if (source is null && destination is null)
+        {
+            return 0f;
+        }
+
+        var cargoAmount = GetShipCargoAmount(ship);
+        var currentPosition = ship.Position;
+        var currentSystemId = ship.SystemId;
+        if (ship.DockedStationId is not null)
+        {
+            var dockedStation = world.Stations.FirstOrDefault(candidate => candidate.Id == ship.DockedStationId);
+            if (dockedStation is not null)
+            {
+                currentPosition = GetUndockTargetPosition(dockedStation, ship.AssignedDockingPadIndex, world.Balance.UndockDistance);
+                currentSystemId = dockedStation.SystemId;
+            }
+        }
+
+        var targetStation = cargoAmount > 0.01f ? destination : source;
+        if (targetStation is null)
+        {
+            return ship.DockedStationId is not null ? EstimateUndockingEnergy(world) : 0f;
+        }
+
+        var energy = ship.DockedStationId is not null ? EstimateUndockingEnergy(world) : 0f;
+        energy += EstimateTravelEnergy(ship, world, currentPosition, currentSystemId, targetStation.Position, targetStation.SystemId);
+        return energy + EstimateDockingEnergy(world);
+    }
+
+    private static float EstimateShipMissionEnergyDemand(ShipRuntime ship, SimulationWorld world) =>
+        ship.DefaultBehavior.Kind switch
+        {
+            "auto-mine" or "auto-harvest-gas" => EstimateResourceHarvestEnergy(ship, world),
+            "auto-supply-energy" => EstimateTransportEnergy(ship, world),
+            "construct-station" when ship.DefaultBehavior.StationId is not null
+                => world.Stations.FirstOrDefault(candidate => candidate.Id == ship.DefaultBehavior.StationId) is { } station
+                    ? EstimateConstructionEnergy(ship, world, station)
+                    : 0f,
+            _ when ship.ControllerTask.TargetPosition is { } targetPosition && ship.ControllerTask.TargetSystemId is { } targetSystemId
+                => EstimateTravelEnergy(ship, world, ship.Position, ship.SystemId, targetPosition, targetSystemId),
+            _ => 0f,
+        };
+
+    private static float GetShipRefuelTarget(ShipRuntime ship, SimulationWorld world)
+    {
+        var capacity = GetShipFuelCapacity(ship);
+        var missionFuel = EstimateFuelForEnergyDemand(ship, EstimateShipMissionEnergyDemand(ship, world));
+        var reserveFuel = GetShipFuelReserve(ship, missionFuel);
+        return MathF.Min(capacity, missionFuel + reserveFuel);
+    }
+
+    internal static bool NeedsRefuel(ShipRuntime ship, SimulationWorld world) =>
+        GetInventoryAmount(ship.Inventory, "fuel") + 0.01f < GetShipRefuelTarget(ship, world);
+
+    internal static bool NeedsEmergencyReturn(ShipRuntime ship, SimulationWorld world)
+    {
+        if (ship.DefaultBehavior.Kind is not "auto-mine" and not "auto-harvest-gas")
+        {
+            return false;
+        }
+
+        var returnEnergy = EstimateResourceReturnEnergy(ship, world);
+        var reserveFuel = GetShipFuelReserve(ship, EstimateFuelForEnergyDemand(ship, returnEnergy));
+        var requiredBudget = returnEnergy + (reserveFuel * ShipFuelToEnergyRatio);
+        return GetShipAvailableEnergyBudget(ship) + 0.01f < requiredBudget;
+    }

    private static float ComputeWorkforceRatio(float population, float workforceRequired)
    {
@@ -206,7 +519,8 @@ public sealed partial class SimulationEngine
            return 0f;
        }

-        if (!station.Definition.Storage.TryGetValue(storageClass, out var capacity))
+        var capacity = GetStationStorageCapacity(station, storageClass);
+        if (capacity <= 0.01f)
        {
            return 0f;
        }
@@ -232,6 +546,17 @@ public sealed partial class SimulationEngine
            string.Equals(site.StationId, stationId, StringComparison.Ordinal)
            && site.State is not ConstructionSiteStateKinds.Completed and not ConstructionSiteStateKinds.Destroyed);

-    private static bool IsConstructionSiteReady(ConstructionSiteRuntime site) =>
-        site.RequiredItems.All(entry => GetInventoryAmount(site.DeliveredItems, entry.Key) + 0.001f >= entry.Value);
+    private 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);
+    }
+
+    private static bool IsConstructionSiteReady(SimulationWorld world, ConstructionSiteRuntime site) =>
+        site.RequiredItems.All(entry => GetConstructionDeliveredAmount(world, site, entry.Key) + 0.001f >= entry.Value);
 }