Refactor backend into domain-first slices

apps/backend/Universe/Api/GetWorldHandler.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Universe.Api;
+
+public sealed class GetWorldHandler(WorldService worldService) : EndpointWithoutRequest
+{
+  public override void Configure()
+  {
+    Get("/api/world");
+    AllowAnonymous();
+  }
+
+  public override Task HandleAsync(CancellationToken cancellationToken) =>
+    SendOkAsync(worldService.GetSnapshot(), cancellationToken);
+}

apps/backend/Universe/Api/GetWorldHealthHandler.cs

@@ -0,0 +1,23 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Universe.Api;
+
+public sealed class GetWorldHealthHandler(WorldService worldService) : EndpointWithoutRequest
+{
+  public override void Configure()
+  {
+    Get("/api/world/health");
+    AllowAnonymous();
+  }
+
+  public override Task HandleAsync(CancellationToken cancellationToken)
+  {
+    var status = worldService.GetStatus();
+    return SendOkAsync(new
+    {
+      ok = true,
+      sequence = status.Sequence,
+      generatedAtUtc = status.GeneratedAtUtc,
+    }, cancellationToken);
+  }
+}

apps/backend/Universe/Api/ResetWorldHandler.cs

@@ -0,0 +1,15 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Universe.Api;
+
+public sealed class ResetWorldHandler(WorldService worldService) : EndpointWithoutRequest
+{
+  public override void Configure()
+  {
+    Post("/api/world/reset");
+    AllowAnonymous();
+  }
+
+  public override Task HandleAsync(CancellationToken cancellationToken) =>
+    SendOkAsync(worldService.Reset(), cancellationToken);
+}

apps/backend/Universe/Api/RootRedirectHandler.cs

@@ -0,0 +1,18 @@
+using FastEndpoints;
+
+namespace SpaceGame.Api.Universe.Api;
+
+public sealed class RootRedirectHandler : EndpointWithoutRequest
+{
+  public override void Configure()
+  {
+    Get("/");
+    AllowAnonymous();
+  }
+
+  public override Task HandleAsync(CancellationToken cancellationToken)
+  {
+    HttpContext.Response.Redirect("/api/world");
+    return Task.CompletedTask;
+  }
+}

apps/backend/Universe/Api/StreamWorldHandler.cs

@@ -0,0 +1,53 @@
+using System.Text.Json;
+using FastEndpoints;
+
+namespace SpaceGame.Api.Universe.Api;
+
+public sealed class StreamWorldHandler(WorldService worldService) : EndpointWithoutRequest
+{
+  private static readonly JsonSerializerOptions SseJsonOptions = new(JsonSerializerDefaults.Web);
+
+  public override void Configure()
+  {
+    Get("/api/world/stream");
+    AllowAnonymous();
+  }
+
+  public override async Task HandleAsync(CancellationToken cancellationToken)
+  {
+    HttpContext.Response.Headers.Append("Cache-Control", "no-cache");
+    HttpContext.Response.Headers.Append("Content-Type", "text/event-stream");
+
+    var afterSequenceRaw = HttpContext.Request.Query["afterSequence"].ToString();
+    _ = long.TryParse(afterSequenceRaw, out var afterSequence);
+
+    var scopeKind = HttpContext.Request.Query["scopeKind"].ToString();
+    if (string.IsNullOrWhiteSpace(scopeKind))
+    {
+      scopeKind = HttpContext.Request.Query["scope"].ToString();
+    }
+
+    if (string.IsNullOrWhiteSpace(scopeKind))
+    {
+      scopeKind = "universe";
+    }
+
+    var systemId = HttpContext.Request.Query["systemId"].ToString();
+    var bubbleId = HttpContext.Request.Query["bubbleId"].ToString();
+    var scope = new ObserverScope(
+      scopeKind,
+      string.IsNullOrWhiteSpace(systemId) ? null : systemId,
+      string.IsNullOrWhiteSpace(bubbleId) ? null : bubbleId);
+    var stream = worldService.Subscribe(scope, afterSequence, cancellationToken);
+
+    await HttpContext.Response.WriteAsync(": connected\n\n", cancellationToken);
+    await HttpContext.Response.Body.FlushAsync(cancellationToken);
+
+    await foreach (var delta in stream.ReadAllAsync(cancellationToken))
+    {
+      var payload = JsonSerializer.Serialize(delta, SseJsonOptions);
+      await HttpContext.Response.WriteAsync($"event: world-delta\ndata: {payload}\n\n", cancellationToken);
+      await HttpContext.Response.Body.FlushAsync(cancellationToken);
+    }
+  }
+}

apps/backend/Universe/Contracts/Celestial.cs

@@ -0,0 +1,83 @@
+namespace SpaceGame.Api.Universe.Contracts;
+
+public sealed record StarSnapshot(
+  string Kind,
+  string Color,
+  string Glow,
+  float Size,
+  float OrbitRadius,
+  float OrbitSpeed,
+  float OrbitPhaseAtEpoch);
+
+public sealed record MoonSnapshot(
+  string Label,
+  float Size,
+  string Color,
+  float OrbitRadius,
+  float OrbitSpeed,
+  float OrbitPhaseAtEpoch,
+  float OrbitInclination,
+  float OrbitLongitudeOfAscendingNode);
+
+public sealed record SystemSnapshot(
+  string Id,
+  string Label,
+  Vector3Dto GalaxyPosition,
+  IReadOnlyList<StarSnapshot> Stars,
+  IReadOnlyList<PlanetSnapshot> Planets);
+
+public sealed record PlanetSnapshot(
+  string Label,
+  string PlanetType,
+  string Shape,
+  IReadOnlyList<MoonSnapshot> Moons,
+  float OrbitRadius,
+  float OrbitSpeed,
+  float OrbitEccentricity,
+  float OrbitInclination,
+  float OrbitLongitudeOfAscendingNode,
+  float OrbitArgumentOfPeriapsis,
+  float OrbitPhaseAtEpoch,
+  float Size,
+  string Color,
+  bool HasRing);
+
+public sealed record ResourceNodeSnapshot(
+  string Id,
+  string SystemId,
+  Vector3Dto LocalPosition,
+  string? CelestialId,
+  string SourceKind,
+  float OreRemaining,
+  float MaxOre,
+  string ItemId);
+
+public sealed record ResourceNodeDelta(
+  string Id,
+  string SystemId,
+  Vector3Dto LocalPosition,
+  string? CelestialId,
+  string SourceKind,
+  float OreRemaining,
+  float MaxOre,
+  string ItemId);
+
+public sealed record CelestialSnapshot(
+  string Id,
+  string SystemId,
+  string Kind,
+  Vector3Dto OrbitalAnchor,
+  float LocalSpaceRadius,
+  string? ParentNodeId,
+  string? OccupyingStructureId,
+  string? OrbitReferenceId);
+
+public sealed record CelestialDelta(
+  string Id,
+  string SystemId,
+  string Kind,
+  Vector3Dto OrbitalAnchor,
+  float LocalSpaceRadius,
+  string? ParentNodeId,
+  string? OccupyingStructureId,
+  string? OrbitReferenceId);

apps/backend/Universe/Contracts/World.cs

@@ -0,0 +1,58 @@
+namespace SpaceGame.Api.Universe.Contracts;
+
+public sealed record WorldSnapshot(
+  string Label,
+  int Seed,
+  long Sequence,
+  int TickIntervalMs,
+  double OrbitalTimeSeconds,
+  OrbitalSimulationSnapshot OrbitalSimulation,
+  DateTimeOffset GeneratedAtUtc,
+  IReadOnlyList<SystemSnapshot> Systems,
+  IReadOnlyList<CelestialSnapshot> Celestials,
+  IReadOnlyList<ResourceNodeSnapshot> Nodes,
+  IReadOnlyList<StationSnapshot> Stations,
+  IReadOnlyList<ClaimSnapshot> Claims,
+  IReadOnlyList<ConstructionSiteSnapshot> ConstructionSites,
+  IReadOnlyList<MarketOrderSnapshot> MarketOrders,
+  IReadOnlyList<PolicySetSnapshot> Policies,
+  IReadOnlyList<ShipSnapshot> Ships,
+  IReadOnlyList<FactionSnapshot> Factions);
+
+public sealed record WorldDelta(
+  long Sequence,
+  int TickIntervalMs,
+  double OrbitalTimeSeconds,
+  OrbitalSimulationSnapshot OrbitalSimulation,
+  DateTimeOffset GeneratedAtUtc,
+  bool RequiresSnapshotRefresh,
+  IReadOnlyList<SimulationEventRecord> Events,
+  IReadOnlyList<CelestialDelta> Celestials,
+  IReadOnlyList<ResourceNodeDelta> Nodes,
+  IReadOnlyList<StationDelta> Stations,
+  IReadOnlyList<ClaimDelta> Claims,
+  IReadOnlyList<ConstructionSiteDelta> ConstructionSites,
+  IReadOnlyList<MarketOrderDelta> MarketOrders,
+  IReadOnlyList<PolicySetDelta> Policies,
+  IReadOnlyList<ShipDelta> Ships,
+  IReadOnlyList<FactionDelta> Factions,
+  ObserverScope? Scope = null);
+
+public sealed record SimulationEventRecord(
+  string EntityKind,
+  string EntityId,
+  string Kind,
+  string Message,
+  DateTimeOffset OccurredAtUtc,
+  string Family = "simulation",
+  string ScopeKind = "universe",
+  string? ScopeEntityId = null,
+  string Visibility = "public");
+
+public sealed record ObserverScope(
+  string ScopeKind,
+  string? SystemId = null,
+  string? CelestialId = null);
+
+public sealed record OrbitalSimulationSnapshot(
+  double SimulatedSecondsPerRealSecond);

apps/backend/Universe/Runtime/SimulationWorld.cs

@@ -0,0 +1,28 @@
+
+namespace SpaceGame.Api.Universe.Runtime;
+
+public sealed class SimulationWorld
+{
+    public required string Label { get; init; }
+    public required int Seed { get; init; }
+    public required BalanceDefinition Balance { get; init; }
+    public required List<SystemRuntime> Systems { get; init; }
+    public required List<ResourceNodeRuntime> Nodes { get; init; }
+    public required List<CelestialRuntime> Celestials { get; init; }
+    public required List<StationRuntime> Stations { get; init; }
+    public required List<ShipRuntime> Ships { get; init; }
+    public required List<FactionRuntime> Factions { get; init; }
+    public required List<CommanderRuntime> Commanders { get; init; }
+    public required List<ClaimRuntime> Claims { get; init; }
+    public required List<ConstructionSiteRuntime> ConstructionSites { get; init; }
+    public required List<MarketOrderRuntime> MarketOrders { get; init; }
+    public required List<PolicySetRuntime> Policies { get; init; }
+    public required Dictionary<string, ShipDefinition> ShipDefinitions { get; init; }
+    public required Dictionary<string, ItemDefinition> ItemDefinitions { get; init; }
+    public required Dictionary<string, ModuleDefinition> ModuleDefinitions { get; init; }
+    public required Dictionary<string, ModuleRecipeDefinition> ModuleRecipes { get; init; }
+    public required Dictionary<string, RecipeDefinition> Recipes { get; init; }
+    public int TickIntervalMs { get; init; } = 200;
+    public double OrbitalTimeSeconds { get; set; }
+    public DateTimeOffset GeneratedAtUtc { get; set; }
+}

apps/backend/Universe/Runtime/SpatialRuntimeModels.cs

@@ -0,0 +1,59 @@
+
+namespace SpaceGame.Api.Universe.Runtime;
+
+public sealed class SystemRuntime
+{
+    public required SolarSystemDefinition Definition { get; init; }
+    public required Vector3 Position { get; init; }
+}
+
+public sealed class ResourceNodeRuntime
+{
+    public required string Id { get; init; }
+    public required string SystemId { get; init; }
+    public required Vector3 Position { get; set; }
+    public required string SourceKind { get; init; }
+    public required string ItemId { get; init; }
+    public string? CelestialId { get; set; }
+    public float OrbitRadius { get; init; }
+    public float OrbitPhase { get; init; }
+    public float OrbitInclination { get; init; }
+    public float OreRemaining { get; set; }
+    public float MaxOre { get; init; }
+    public string LastDeltaSignature { get; set; } = string.Empty;
+}
+
+public sealed class CelestialRuntime
+{
+    public required string Id { get; init; }
+    public required string SystemId { get; init; }
+    public required SpatialNodeKind Kind { get; init; }
+    public required Vector3 Position { get; set; }
+    public float LocalSpaceRadius { get; init; }
+    public string? ParentNodeId { get; set; }
+    public string? OccupyingStructureId { get; set; }
+    public string? OrbitReferenceId { get; set; }
+    public string LastDeltaSignature { get; set; } = string.Empty;
+}
+
+public sealed class ShipSpatialStateRuntime
+{
+    public string SpaceLayer { get; set; } = SpaceLayerKinds.LocalSpace;
+    public required string CurrentSystemId { get; set; }
+    public string? CurrentCelestialId { get; set; }
+    public Vector3? LocalPosition { get; set; }
+    public Vector3? SystemPosition { get; set; }
+    public string MovementRegime { get; set; } = MovementRegimeKinds.LocalFlight;
+    public string? DestinationNodeId { get; set; }
+    public ShipTransitRuntime? Transit { get; set; }
+}
+
+public sealed class ShipTransitRuntime
+{
+    public required string Regime { get; init; }
+    public string? OriginNodeId { get; init; }
+    public string? DestinationNodeId { get; init; }
+    public DateTimeOffset? StartedAtUtc { get; set; }
+    public DateTimeOffset? ArrivalDueAtUtc { get; set; }
+    public float Progress { get; set; }
+}

apps/backend/Universe/Scenario/DataCatalogLoader.cs

@@ -0,0 +1,300 @@
+using System.Text.Json;
+using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal sealed class DataCatalogLoader(string dataRoot)
+{
+  private readonly JsonSerializerOptions _jsonOptions = new()
+  {
+    PropertyNameCaseInsensitive = true,
+  };
+
+  internal ScenarioCatalog LoadCatalog()
+  {
+    var authoredSystems = Read<List<SolarSystemDefinition>>("systems.json");
+    var scenario = Read<ScenarioDefinition>("scenario.json");
+    var modules = NormalizeModules(Read<List<ModuleDefinition>>("modules.json"));
+    var ships = Read<List<ShipDefinition>>("ships.json");
+    var items = NormalizeItems(Read<List<ItemDefinition>>("items.json"));
+    var balance = Read<BalanceDefinition>("balance.json");
+    var recipes = BuildRecipes(items, ships, modules);
+    var moduleRecipes = BuildModuleRecipes(modules);
+
+    return new ScenarioCatalog(
+      authoredSystems,
+      scenario,
+      balance,
+      modules.ToDictionary(definition => definition.Id, StringComparer.Ordinal),
+      ships.ToDictionary(definition => definition.Id, StringComparer.Ordinal),
+      items.ToDictionary(definition => definition.Id, StringComparer.Ordinal),
+      recipes.ToDictionary(definition => definition.Id, StringComparer.Ordinal),
+      moduleRecipes.ToDictionary(definition => definition.ModuleId, StringComparer.Ordinal));
+  }
+
+  internal ScenarioDefinition NormalizeScenarioToAvailableSystems(
+    ScenarioDefinition scenario,
+    IReadOnlyList<string> availableSystemIds)
+  {
+    if (availableSystemIds.Count == 0)
+    {
+      return scenario;
+    }
+
+    var fallbackSystemId = availableSystemIds.Contains("sol", StringComparer.Ordinal)
+      ? "sol"
+      : availableSystemIds[0];
+
+    string ResolveSystemId(string systemId) =>
+      availableSystemIds.Contains(systemId, StringComparer.Ordinal) ? systemId : fallbackSystemId;
+
+    return new ScenarioDefinition
+    {
+      InitialStations = scenario.InitialStations
+        .Select(station => new InitialStationDefinition
+        {
+          SystemId = ResolveSystemId(station.SystemId),
+          Label = station.Label,
+          Color = station.Color,
+          StartingModules = station.StartingModules.ToList(),
+          FactionId = station.FactionId,
+          PlanetIndex = station.PlanetIndex,
+          LagrangeSide = station.LagrangeSide,
+          Position = station.Position?.ToArray(),
+        })
+        .ToList(),
+      ShipFormations = scenario.ShipFormations
+        .Select(formation => new ShipFormationDefinition
+        {
+          ShipId = formation.ShipId,
+          Count = formation.Count,
+          Center = formation.Center.ToArray(),
+          SystemId = ResolveSystemId(formation.SystemId),
+          FactionId = formation.FactionId,
+        })
+        .ToList(),
+      PatrolRoutes = scenario.PatrolRoutes
+        .Select(route => new PatrolRouteDefinition
+        {
+          SystemId = ResolveSystemId(route.SystemId),
+          Points = route.Points.Select(point => point.ToArray()).ToList(),
+        })
+        .ToList(),
+      MiningDefaults = new MiningDefaultsDefinition
+      {
+        NodeSystemId = ResolveSystemId(scenario.MiningDefaults.NodeSystemId),
+        RefinerySystemId = ResolveSystemId(scenario.MiningDefaults.RefinerySystemId),
+      },
+    };
+  }
+
+  private T Read<T>(string fileName)
+  {
+    var path = Path.Combine(dataRoot, fileName);
+    var json = File.ReadAllText(path);
+    return JsonSerializer.Deserialize<T>(json, _jsonOptions)
+      ?? throw new InvalidOperationException($"Unable to read {fileName}.");
+  }
+
+  private static List<ModuleRecipeDefinition> BuildModuleRecipes(IEnumerable<ModuleDefinition> modules) =>
+    modules
+      .Where(module => module.Construction is not null || module.Production.Count > 0)
+      .Select(module => new ModuleRecipeDefinition
+      {
+        ModuleId = module.Id,
+        Duration = module.Construction?.ProductionTime ?? module.Production[0].Time,
+        Inputs = (module.Construction?.Requirements ?? module.Production[0].Wares)
+          .Select(input => new RecipeInputDefinition
+          {
+            ItemId = input.ItemId,
+            Amount = input.Amount,
+          })
+          .ToList(),
+      })
+      .ToList();
+
+  private static List<RecipeDefinition> BuildRecipes(IEnumerable<ItemDefinition> items, IEnumerable<ShipDefinition> ships, IReadOnlyCollection<ModuleDefinition> modules)
+  {
+    var recipes = new List<RecipeDefinition>();
+    var preferredProducerByItemId = modules
+      .Where(module => module.Products.Count > 0)
+      .GroupBy(module => module.Products[0], StringComparer.Ordinal)
+      .ToDictionary(
+        group => group.Key,
+        group => group.OrderBy(module => module.Id, StringComparer.Ordinal).First().Id,
+        StringComparer.Ordinal);
+
+    foreach (var item in items)
+    {
+      if (item.Production.Count > 0)
+      {
+        foreach (var production in item.Production)
+        {
+          recipes.Add(new RecipeDefinition
+          {
+            Id = $"{item.Id}-{production.Method}-production",
+            Label = production.Name == "Universal" ? item.Name : $"{item.Name} ({production.Name})",
+            FacilityCategory = InferFacilityCategory(item),
+            Duration = production.Time,
+            Priority = InferRecipePriority(item),
+            RequiredModules = InferRequiredModules(item, preferredProducerByItemId),
+            Inputs = production.Wares
+              .Select(input => new RecipeInputDefinition
+              {
+                ItemId = input.ItemId,
+                Amount = input.Amount,
+              })
+              .ToList(),
+            Outputs =
+            [
+              new RecipeOutputDefinition
+              {
+                ItemId = item.Id,
+                Amount = production.Amount,
+              },
+            ],
+          });
+        }
+
+        continue;
+      }
+
+      if (item.Construction is null)
+      {
+        continue;
+      }
+
+      recipes.Add(new RecipeDefinition
+      {
+        Id = item.Construction.RecipeId ?? $"{item.Id}-production",
+        Label = item.Name,
+        FacilityCategory = item.Construction.FacilityCategory,
+        Duration = item.Construction.CycleTime,
+        Priority = item.Construction.Priority,
+        RequiredModules = item.Construction.RequiredModules.ToList(),
+        Inputs = item.Construction.Requirements
+          .Select(input => new RecipeInputDefinition
+          {
+            ItemId = input.ItemId,
+            Amount = input.Amount,
+          })
+          .ToList(),
+        Outputs =
+        [
+          new RecipeOutputDefinition
+          {
+            ItemId = item.Id,
+            Amount = item.Construction.BatchSize,
+          },
+        ],
+      });
+    }
+
+    foreach (var ship in ships)
+    {
+      if (ship.Construction is null)
+      {
+        continue;
+      }
+
+      recipes.Add(new RecipeDefinition
+      {
+        Id = ship.Construction.RecipeId ?? $"{ship.Id}-construction",
+        Label = $"{ship.Label} Construction",
+        FacilityCategory = ship.Construction.FacilityCategory,
+        Duration = ship.Construction.CycleTime,
+        Priority = ship.Construction.Priority,
+        RequiredModules = ship.Construction.RequiredModules.ToList(),
+        Inputs = ship.Construction.Requirements
+          .Select(input => new RecipeInputDefinition
+          {
+            ItemId = input.ItemId,
+            Amount = input.Amount,
+          })
+          .ToList(),
+        ShipOutputId = ship.Id,
+      });
+    }
+
+    return recipes;
+  }
+
+  private static string InferFacilityCategory(ItemDefinition item) =>
+    item.Group switch
+    {
+      "agricultural" or "food" or "pharmaceutical" or "water" => "farm",
+      _ => "station",
+    };
+
+  private static List<string> InferRequiredModules(ItemDefinition item, IReadOnlyDictionary<string, string> preferredProducerByItemId)
+  {
+    if (preferredProducerByItemId.TryGetValue(item.Id, out var moduleId))
+    {
+      return [moduleId];
+    }
+
+    return [];
+  }
+
+  private static int InferRecipePriority(ItemDefinition item) =>
+    item.Group switch
+    {
+      "energy" => 140,
+      "water" => 130,
+      "food" => 120,
+      "agricultural" => 110,
+      "refined" => 100,
+      "hightech" => 90,
+      "shiptech" => 80,
+      "pharmaceutical" => 70,
+      _ => 60,
+    };
+
+  private static List<ItemDefinition> NormalizeItems(List<ItemDefinition> items)
+  {
+    foreach (var item in items)
+    {
+      if (string.IsNullOrWhiteSpace(item.Type))
+      {
+        item.Type = string.IsNullOrWhiteSpace(item.Group) ? "material" : item.Group;
+      }
+    }
+
+    return items;
+  }
+
+  private static List<ModuleDefinition> NormalizeModules(List<ModuleDefinition> modules)
+  {
+    foreach (var module in modules)
+    {
+      if (module.Products.Count == 0 && !string.IsNullOrWhiteSpace(module.Product))
+      {
+        module.Products = [module.Product];
+      }
+
+      if (string.IsNullOrWhiteSpace(module.ProductionMode))
+      {
+        module.ProductionMode = string.Equals(module.Type, "buildmodule", StringComparison.Ordinal)
+          ? "commanded"
+          : "passive";
+      }
+
+      if (module.WorkforceNeeded <= 0f)
+      {
+        module.WorkforceNeeded = module.WorkForce?.Max ?? 0f;
+      }
+    }
+
+    return modules;
+  }
+}
+
+internal sealed record ScenarioCatalog(
+  List<SolarSystemDefinition> AuthoredSystems,
+  ScenarioDefinition Scenario,
+  BalanceDefinition Balance,
+  IReadOnlyDictionary<string, ModuleDefinition> ModuleDefinitions,
+  IReadOnlyDictionary<string, ShipDefinition> ShipDefinitions,
+  IReadOnlyDictionary<string, ItemDefinition> ItemDefinitions,
+  IReadOnlyDictionary<string, RecipeDefinition> Recipes,
+  IReadOnlyDictionary<string, ModuleRecipeDefinition> ModuleRecipes);

apps/backend/Universe/Scenario/LoaderSupport.cs

@@ -0,0 +1,171 @@
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal static class LoaderSupport
+{
+  internal const string DefaultFactionId = "sol-dominion";
+  internal const int WorldSeed = 1;
+  internal const float MinimumFactionCredits = 0f;
+  internal const float MinimumRefineryOre = 0f;
+  internal const float MinimumRefineryStock = 0f;
+  internal const float MinimumShipyardStock = 0f;
+  internal const float MinimumSystemSeparation = 3.2f;
+  internal const float LocalSpaceRadius = 10_000f;
+
+  internal static readonly string[] GeneratedSystemNames =
+  [
+    "Aquila Verge",
+    "Orion Fold",
+    "Draco Span",
+    "Lyra Shoal",
+    "Cygnus March",
+    "Vela Crossing",
+    "Carina Wake",
+    "Phoenix Rest",
+    "Hydra Loom",
+    "Cassio Reach",
+    "Lupus Chain",
+    "Pavo Line",
+    "Serpens Rise",
+    "Cetus Hollow",
+    "Delphin Crown",
+    "Volans Drift",
+    "Ara Bastion",
+    "Indus Veil",
+    "Pyxis Trace",
+    "Lacerta Bloom",
+    "Columba Shroud",
+    "Dorado Expanse",
+    "Reticulum Run",
+    "Norma Edge",
+    "Crux Horizon",
+    "Sagitta Corridor",
+    "Monoceros Deep",
+    "Eridan Spur",
+    "Centauri Shelf",
+    "Antlia Reach",
+    "Horologium Gate",
+    "Telescopium Strand",
+  ];
+
+  internal static readonly StarProfile[] StarProfiles =
+  [
+    new("main-sequence", "#ffd27a", "#ffb14a", 696340f),
+    new("blue-white", "#9dc6ff", "#66a0ff", 930000f),
+    new("white-dwarf", "#f1f5ff", "#b8caff", 12000f),
+    new("brown-dwarf", "#b97d56", "#8a5438", 70000f),
+    new("neutron-star", "#d9ebff", "#7ab4ff", 18f),
+    new("binary-main-sequence", "#ffe09f", "#ffbe6b", 780000f),
+    new("binary-white-dwarf", "#edf3ff", "#c8d6ff", 14000f),
+  ];
+
+  internal static readonly PlanetProfile[] PlanetProfiles =
+  [
+    new("barren", "sphere", "#bca48f", 2800f, 0.22f, 0, false),
+    new("terrestrial", "sphere", "#58a36c", 6400f, 0.28f, 1, false),
+    new("oceanic", "sphere", "#4f84c4", 7000f, 0.30f, 2, false),
+    new("desert", "sphere", "#d4a373", 5200f, 0.26f, 0, false),
+    new("ice", "sphere", "#c8e4ff", 5800f, 0.32f, 1, false),
+    new("gas-giant", "oblate", "#d9b06f", 45000f, 1.40f, 8, true),
+    new("ice-giant", "oblate", "#8fc0d8", 25000f, 1.00f, 5, true),
+    new("lava", "sphere", "#db6846", 3200f, 0.20f, 0, false),
+  ];
+
+  internal static Vector3 ToVector(float[] values) => new(values[0], values[1], values[2]);
+
+  internal static Vector3 NormalizeScenarioPoint(SystemRuntime system, float[] values)
+  {
+    var raw = ToVector(values);
+    var relativeToSystem = new Vector3(
+      raw.X - system.Position.X,
+      raw.Y - system.Position.Y,
+      raw.Z - system.Position.Z);
+
+    return relativeToSystem.LengthSquared() < raw.LengthSquared()
+      ? relativeToSystem
+      : raw;
+  }
+
+  internal static bool HasInstalledModules(StationRuntime station, params string[] modules) =>
+    modules.All(moduleId => station.Modules.Any(candidate => string.Equals(candidate.ModuleId, moduleId, StringComparison.Ordinal)));
+
+  internal static bool HasCapabilities(ShipDefinition definition, params string[] capabilities) =>
+    capabilities.All(capability => definition.Capabilities.Contains(capability, StringComparer.Ordinal));
+
+  internal static void AddStationModule(StationRuntime station, IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions, string moduleId)
+  {
+    if (!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(moduleDefinitions, station);
+  }
+
+  internal static float GetStationRadius(IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions, StationRuntime station)
+  {
+    var totalArea = station.Modules
+      .Select(module => 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 Vector3 Add(Vector3 left, Vector3 right) => new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+  internal static Vector3 Scale(Vector3 vector, float scale) => new(vector.X * scale, vector.Y * scale, vector.Z * scale);
+
+  internal static int CountModules(IEnumerable<string> modules, string moduleId) =>
+    modules.Count(candidate => string.Equals(candidate, moduleId, 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 float GetInventoryAmount(IReadOnlyDictionary<string, float> inventory, string itemId) =>
+    inventory.TryGetValue(itemId, out var amount) ? amount : 0f;
+
+  internal static float DegreesToRadians(float degrees) => degrees * (MathF.PI / 180f);
+
+  internal static Vector3 NormalizeOrFallback(Vector3 vector, Vector3 fallback)
+  {
+    var length = MathF.Sqrt(vector.LengthSquared());
+    if (length <= 0.0001f)
+    {
+      return fallback;
+    }
+
+    return vector.Divide(length);
+  }
+}
+
+internal sealed record StarProfile(
+  string Kind,
+  string StarColor,
+  string StarGlow,
+  float BaseSize);
+
+internal sealed record PlanetProfile(
+  string Type,
+  string Shape,
+  string Color,
+  float BaseSize,
+  float OrbitGapMin,
+  int BaseMoonCount,
+  bool CanHaveRing)
+{
+  public float OrbitGapMax => OrbitGapMin + MathF.Max(0.12f, OrbitGapMin * 0.45f);
+}

apps/backend/Universe/Scenario/ScenarioLoader.cs

@@ -0,0 +1,26 @@
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+public sealed class ScenarioLoader
+{
+  private readonly WorldBuilder _worldBuilder;
+
+  public ScenarioLoader(string contentRootPath, WorldGenerationOptions? worldGeneration = null)
+  {
+    var generationOptions = worldGeneration ?? new WorldGenerationOptions();
+    var dataRoot = Path.GetFullPath(Path.Combine(contentRootPath, "..", "..", "shared", "data"));
+    var dataLoader = new DataCatalogLoader(dataRoot);
+    var generationService = new SystemGenerationService();
+    var spatialBuilder = new SpatialBuilder();
+    var seedingService = new WorldSeedingService();
+
+    _worldBuilder = new WorldBuilder(
+      generationOptions,
+      dataLoader,
+      generationService,
+      spatialBuilder,
+      seedingService);
+  }
+
+  public SimulationWorld Load() => _worldBuilder.Build();
+}

apps/backend/Universe/Scenario/SpatialBuilder.cs

@@ -0,0 +1,303 @@
+using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal sealed class SpatialBuilder
+{
+  internal ScenarioSpatialLayout BuildLayout(IReadOnlyList<SystemRuntime> systems, BalanceDefinition balance)
+  {
+    var systemGraphs = systems.ToDictionary(
+      system => system.Definition.Id,
+      BuildSystemSpatialGraph,
+      StringComparer.Ordinal);
+    var celestials = systemGraphs.Values.SelectMany(graph => graph.Celestials).ToList();
+    var nodes = new List<ResourceNodeRuntime>();
+    var nodeIdCounter = 0;
+
+    foreach (var system in systems)
+    {
+      var systemGraph = systemGraphs[system.Definition.Id];
+      foreach (var node in system.Definition.ResourceNodes)
+      {
+        var anchorCelestial = ResolveResourceNodeAnchor(systemGraph, node);
+        nodes.Add(new ResourceNodeRuntime
+        {
+          Id = $"node-{++nodeIdCounter}",
+          SystemId = system.Definition.Id,
+          Position = ComputeResourceNodePosition(anchorCelestial, node, balance.YPlane),
+          SourceKind = node.SourceKind,
+          ItemId = node.ItemId,
+          CelestialId = anchorCelestial?.Id,
+          OrbitRadius = node.RadiusOffset,
+          OrbitPhase = node.Angle,
+          OrbitInclination = DegreesToRadians(node.InclinationDegrees),
+          OreRemaining = node.OreAmount,
+          MaxOre = node.OreAmount,
+        });
+      }
+    }
+
+    return new ScenarioSpatialLayout(systemGraphs, celestials, nodes);
+  }
+
+  private static SystemSpatialGraph BuildSystemSpatialGraph(SystemRuntime system)
+  {
+    var celestials = new List<CelestialRuntime>();
+    var lagrangeNodesByPlanetIndex = new Dictionary<int, Dictionary<string, CelestialRuntime>>();
+
+    for (var starIndex = 0; starIndex < system.Definition.Stars.Count; starIndex += 1)
+    {
+      AddCelestial(
+        celestials,
+        id: $"node-{system.Definition.Id}-star-{starIndex + 1}",
+        systemId: system.Definition.Id,
+        kind: SpatialNodeKind.Star,
+        position: Vector3.Zero,
+        localSpaceRadius: LocalSpaceRadius);
+    }
+
+    var primaryStarNodeId = $"node-{system.Definition.Id}-star-1";
+
+    for (var planetIndex = 0; planetIndex < system.Definition.Planets.Count; planetIndex += 1)
+    {
+      var planet = system.Definition.Planets[planetIndex];
+      var planetNodeId = $"node-{system.Definition.Id}-planet-{planetIndex + 1}";
+      var planetPosition = ComputePlanetPosition(planet);
+      var planetCelestial = AddCelestial(
+        celestials,
+        id: planetNodeId,
+        systemId: system.Definition.Id,
+        kind: SpatialNodeKind.Planet,
+        position: planetPosition,
+        localSpaceRadius: LocalSpaceRadius,
+        parentNodeId: primaryStarNodeId);
+
+      var lagrangeNodes = new Dictionary<string, CelestialRuntime>(StringComparer.Ordinal);
+      foreach (var point in EnumeratePlanetLagrangePoints(planetPosition, planet))
+      {
+        var lagrangeCelestial = AddCelestial(
+          celestials,
+          id: $"node-{system.Definition.Id}-planet-{planetIndex + 1}-{point.Designation.ToLowerInvariant()}",
+          systemId: system.Definition.Id,
+          kind: SpatialNodeKind.LagrangePoint,
+          position: point.Position,
+          localSpaceRadius: LocalSpaceRadius,
+          parentNodeId: planetCelestial.Id,
+          orbitReferenceId: point.Designation);
+        lagrangeNodes[point.Designation] = lagrangeCelestial;
+      }
+
+      lagrangeNodesByPlanetIndex[planetIndex] = lagrangeNodes;
+
+      for (var moonIndex = 0; moonIndex < planet.Moons.Count; moonIndex += 1)
+      {
+        var moon = planet.Moons[moonIndex];
+        var moonPosition = ComputeMoonPosition(planetPosition, moon);
+        AddCelestial(
+          celestials,
+          id: $"node-{system.Definition.Id}-planet-{planetIndex + 1}-moon-{moonIndex + 1}",
+          systemId: system.Definition.Id,
+          kind: SpatialNodeKind.Moon,
+          position: moonPosition,
+          localSpaceRadius: LocalSpaceRadius,
+          parentNodeId: planetCelestial.Id);
+      }
+    }
+
+    return new SystemSpatialGraph(system.Definition.Id, celestials, lagrangeNodesByPlanetIndex);
+  }
+
+  private static CelestialRuntime AddCelestial(
+    ICollection<CelestialRuntime> celestials,
+    string id,
+    string systemId,
+    SpatialNodeKind kind,
+    Vector3 position,
+    float localSpaceRadius,
+    string? parentNodeId = null,
+    string? orbitReferenceId = null)
+  {
+    var celestial = new CelestialRuntime
+    {
+      Id = id,
+      SystemId = systemId,
+      Kind = kind,
+      Position = position,
+      LocalSpaceRadius = localSpaceRadius,
+      ParentNodeId = parentNodeId,
+      OrbitReferenceId = orbitReferenceId,
+    };
+
+    celestials.Add(celestial);
+    return celestial;
+  }
+
+  private static IEnumerable<LagrangePointPlacement> EnumeratePlanetLagrangePoints(Vector3 planetPosition, PlanetDefinition planet)
+  {
+    var radial = NormalizeOrFallback(planetPosition, new Vector3(1f, 0f, 0f));
+    var tangential = new Vector3(-radial.Z, 0f, radial.X);
+    var orbitRadiusKm = MathF.Sqrt(planetPosition.X * planetPosition.X + planetPosition.Z * planetPosition.Z);
+    var offset = ComputePlanetLocalLagrangeOffset(orbitRadiusKm, planet);
+    var triangularAngle = MathF.PI / 3f;
+
+    yield return new LagrangePointPlacement("L1", Add(planetPosition, Scale(radial, -offset)));
+    yield return new LagrangePointPlacement("L2", Add(planetPosition, Scale(radial, offset)));
+    yield return new LagrangePointPlacement("L3", Scale(radial, -orbitRadiusKm));
+    yield return new LagrangePointPlacement(
+      "L4",
+      Add(
+        Scale(radial, orbitRadiusKm * MathF.Cos(triangularAngle)),
+        Scale(tangential, orbitRadiusKm * MathF.Sin(triangularAngle))));
+    yield return new LagrangePointPlacement(
+      "L5",
+      Add(
+        Scale(radial, orbitRadiusKm * MathF.Cos(triangularAngle)),
+        Scale(tangential, -orbitRadiusKm * MathF.Sin(triangularAngle))));
+  }
+
+  private static float ComputePlanetLocalLagrangeOffset(float orbitRadiusKm, PlanetDefinition planet)
+  {
+    var planetMassProxy = EstimatePlanetMassRatio(planet);
+    var hillLikeOffset = orbitRadiusKm * MathF.Cbrt(MathF.Max(planetMassProxy / 3f, 1e-9f));
+    var minimumOffset = MathF.Max(planet.Size * 4f, 25000f);
+    return MathF.Max(minimumOffset, hillLikeOffset);
+  }
+
+  private static float EstimatePlanetMassRatio(PlanetDefinition planet)
+  {
+    var earthRadiusRatio = MathF.Max(planet.Size / 6371f, 0.05f);
+    var densityFactor = planet.PlanetType switch
+    {
+      "gas-giant" => 0.24f,
+      "ice-giant" => 0.18f,
+      "oceanic" => 0.95f,
+      "ice" => 0.7f,
+      _ => 1f,
+    };
+
+    var earthMasses = MathF.Pow(earthRadiusRatio, 3f) * densityFactor;
+    return earthMasses / 332_946f;
+  }
+
+  internal static StationPlacement ResolveStationPlacement(
+    InitialStationDefinition plan,
+    SystemRuntime system,
+    SystemSpatialGraph graph,
+    IReadOnlyCollection<CelestialRuntime> existingCelestials)
+  {
+    if (plan.PlanetIndex is int planetIndex &&
+        graph.LagrangeNodesByPlanetIndex.TryGetValue(planetIndex, out var lagrangeNodes))
+    {
+      var designation = ResolveLagrangeDesignation(plan.LagrangeSide);
+      if (lagrangeNodes.TryGetValue(designation, out var lagrangeCelestial))
+      {
+        return new StationPlacement(lagrangeCelestial, lagrangeCelestial.Position);
+      }
+    }
+
+    if (plan.Position is { Length: 3 })
+    {
+      var targetPosition = NormalizeScenarioPoint(system, plan.Position);
+      var preferredCelestial = existingCelestials
+        .Where(c => c.SystemId == system.Definition.Id && c.Kind == SpatialNodeKind.LagrangePoint)
+        .OrderBy(c => c.Position.DistanceTo(targetPosition))
+        .FirstOrDefault()
+        ?? existingCelestials
+          .Where(c => c.SystemId == system.Definition.Id)
+          .OrderBy(c => c.Position.DistanceTo(targetPosition))
+          .First();
+      return new StationPlacement(preferredCelestial, preferredCelestial.Position);
+    }
+
+    var fallbackCelestial = graph.Celestials
+      .FirstOrDefault(c => c.Kind == SpatialNodeKind.LagrangePoint && string.IsNullOrEmpty(c.OccupyingStructureId))
+      ?? graph.Celestials.First(c => c.Kind == SpatialNodeKind.Planet);
+    return new StationPlacement(fallbackCelestial, fallbackCelestial.Position);
+  }
+
+  private static string ResolveLagrangeDesignation(int? lagrangeSide) => lagrangeSide switch
+  {
+    < 0 => "L4",
+    > 0 => "L5",
+    _ => "L1",
+  };
+
+  private static CelestialRuntime? ResolveResourceNodeAnchor(SystemSpatialGraph graph, ResourceNodeDefinition definition)
+  {
+    if (definition.AnchorPlanetIndex is not int planetIndex || planetIndex < 0)
+    {
+      return null;
+    }
+
+    if (definition.AnchorMoonIndex is int moonIndex && moonIndex >= 0)
+    {
+      var moonNodeId = $"node-{graph.SystemId}-planet-{planetIndex + 1}-moon-{moonIndex + 1}";
+      return graph.Celestials.FirstOrDefault(c => c.Id == moonNodeId);
+    }
+
+    var planetNodeId = $"node-{graph.SystemId}-planet-{planetIndex + 1}";
+    return graph.Celestials.FirstOrDefault(c => c.Id == planetNodeId);
+  }
+
+  private static Vector3 ComputeResourceNodePosition(CelestialRuntime? anchorCelestial, ResourceNodeDefinition definition, float yPlane)
+  {
+    var verticalOffset = MathF.Sin(DegreesToRadians(definition.InclinationDegrees)) * MathF.Min(definition.RadiusOffset * 0.04f, 25000f);
+    var offset = new Vector3(
+      MathF.Cos(definition.Angle) * definition.RadiusOffset,
+      verticalOffset,
+      MathF.Sin(definition.Angle) * definition.RadiusOffset);
+
+    if (anchorCelestial is null)
+    {
+      return new Vector3(offset.X, yPlane + offset.Y, offset.Z);
+    }
+
+    return Add(anchorCelestial.Position, offset);
+  }
+
+  private static Vector3 ComputePlanetPosition(PlanetDefinition planet)
+  {
+    var angle = DegreesToRadians(planet.OrbitPhaseAtEpoch);
+    var orbitRadiusKm = SimulationUnits.AuToKilometers(planet.OrbitRadius);
+    return new Vector3(MathF.Cos(angle) * orbitRadiusKm, 0f, MathF.Sin(angle) * orbitRadiusKm);
+  }
+
+  private static Vector3 ComputeMoonPosition(Vector3 planetPosition, MoonDefinition moon)
+  {
+    var angle = DegreesToRadians(moon.OrbitPhaseAtEpoch);
+    var local = new Vector3(MathF.Cos(angle) * moon.OrbitRadius, 0f, MathF.Sin(angle) * moon.OrbitRadius);
+    return Add(planetPosition, local);
+  }
+
+  internal static ShipSpatialStateRuntime CreateInitialShipSpatialState(string systemId, Vector3 position, IReadOnlyCollection<CelestialRuntime> celestials)
+  {
+    var nearestCelestial = celestials
+      .Where(c => c.SystemId == systemId)
+      .OrderBy(c => c.Position.DistanceTo(position))
+      .FirstOrDefault();
+
+    return new ShipSpatialStateRuntime
+    {
+      CurrentSystemId = systemId,
+      SpaceLayer = SpaceLayerKinds.LocalSpace,
+      CurrentCelestialId = nearestCelestial?.Id,
+      LocalPosition = position,
+      SystemPosition = position,
+      MovementRegime = MovementRegimeKinds.LocalFlight,
+    };
+  }
+}
+
+internal sealed record ScenarioSpatialLayout(
+  IReadOnlyDictionary<string, SystemSpatialGraph> SystemGraphs,
+  List<CelestialRuntime> Celestials,
+  List<ResourceNodeRuntime> Nodes);
+
+internal sealed record SystemSpatialGraph(
+  string SystemId,
+  List<CelestialRuntime> Celestials,
+  Dictionary<int, Dictionary<string, CelestialRuntime>> LagrangeNodesByPlanetIndex);
+
+internal sealed record LagrangePointPlacement(string Designation, Vector3 Position);
+
+internal sealed record StationPlacement(CelestialRuntime AnchorCelestial, Vector3 Position);

apps/backend/Universe/Scenario/SystemGenerationService.cs

@@ -0,0 +1,486 @@
+using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal sealed class SystemGenerationService
+{
+  private const string SolSystemId = "sol";
+  private const string DevelopmentCompanionSystemId = "helios";
+
+  internal List<SolarSystemDefinition> InjectSpecialSystems(IReadOnlyList<SolarSystemDefinition> authoredSystems) =>
+    authoredSystems
+      .Select(CloneSystemDefinition)
+      .ToList();
+
+  internal List<SolarSystemDefinition> ExpandSystems(
+    IReadOnlyList<SolarSystemDefinition> authoredSystems,
+    int targetSystemCount)
+  {
+    var systems = authoredSystems
+      .Select(CloneSystemDefinition)
+      .ToList();
+
+    if (targetSystemCount <= 0)
+    {
+      return [];
+    }
+
+    if (systems.Count > targetSystemCount)
+    {
+      return TrimSystemsToTarget(systems, targetSystemCount);
+    }
+
+    if (systems.Count >= targetSystemCount || authoredSystems.Count == 0)
+    {
+      return systems;
+    }
+
+    var existingIds = systems
+      .Select(system => system.Id)
+      .ToHashSet(StringComparer.Ordinal);
+    var generatedPositions = BuildGalaxyPositions(
+      authoredSystems.Select(system => ToVector(system.Position)).ToList(),
+      targetSystemCount - systems.Count);
+
+    for (var index = systems.Count; index < targetSystemCount; index += 1)
+    {
+      var template = authoredSystems[index % authoredSystems.Count];
+      var name = GeneratedSystemNames[(index - authoredSystems.Count) % GeneratedSystemNames.Length];
+      var id = BuildGeneratedSystemId(name, index + 1);
+      while (!existingIds.Add(id))
+      {
+        id = $"{id}-x";
+      }
+
+      systems.Add(CreateGeneratedSystem(template, name, id, index - authoredSystems.Count, generatedPositions[index - authoredSystems.Count]));
+    }
+
+    return systems;
+  }
+
+  private static List<SolarSystemDefinition> TrimSystemsToTarget(IReadOnlyList<SolarSystemDefinition> systems, int targetSystemCount)
+  {
+    var selected = new List<SolarSystemDefinition>(targetSystemCount);
+
+    void AddById(string systemId)
+    {
+      var system = systems.FirstOrDefault(candidate => string.Equals(candidate.Id, systemId, StringComparison.Ordinal));
+      if (system is not null && selected.All(candidate => !string.Equals(candidate.Id, systemId, StringComparison.Ordinal)))
+      {
+        selected.Add(system);
+      }
+    }
+
+    AddById(SolSystemId);
+    AddById(DevelopmentCompanionSystemId);
+
+    foreach (var system in systems)
+    {
+      if (selected.Count >= targetSystemCount)
+      {
+        break;
+      }
+
+      if (selected.Any(candidate => string.Equals(candidate.Id, system.Id, StringComparison.Ordinal)))
+      {
+        continue;
+      }
+
+      selected.Add(system);
+    }
+
+    if (selected.Count > 0 && selected.Count <= 4)
+    {
+      ApplyCompactGalaxyLayout(selected);
+    }
+
+    return selected;
+  }
+
+  private static void ApplyCompactGalaxyLayout(IReadOnlyList<SolarSystemDefinition> systems)
+  {
+    var compactPositions = new[]
+    {
+      new[] { 0f, 0f, 0f },
+      new[] { 2.6f, 0.02f, -0.42f },
+      new[] { -2.4f, -0.04f, 0.56f },
+      new[] { 0.52f, 0.04f, 2.48f },
+    };
+
+    for (var index = 0; index < systems.Count && index < compactPositions.Length; index += 1)
+    {
+      systems[index].Position = compactPositions[index];
+    }
+  }
+
+  private static SolarSystemDefinition CreateGeneratedSystem(
+    SolarSystemDefinition template,
+    string label,
+    string id,
+    int generatedIndex,
+    Vector3 position)
+  {
+    var starProfile = SelectStarProfile(generatedIndex);
+    var planets = BuildGeneratedPlanets(template, generatedIndex);
+    var resourceNodes = BuildProceduralResourceNodes(template, planets, generatedIndex)
+      .Select(node => new ResourceNodeDefinition
+      {
+        SourceKind = node.SourceKind,
+        Angle = node.Angle,
+        RadiusOffset = node.RadiusOffset,
+        InclinationDegrees = node.InclinationDegrees,
+        AnchorPlanetIndex = node.AnchorPlanetIndex,
+        AnchorMoonIndex = node.AnchorMoonIndex,
+        OreAmount = node.OreAmount,
+        ItemId = node.ItemId,
+        ShardCount = node.ShardCount,
+      })
+      .ToList();
+
+    return new SolarSystemDefinition
+    {
+      Id = id,
+      Label = label,
+      Position = [position.X, position.Y, position.Z],
+      Stars =
+      [
+        new StarDefinition
+        {
+          Kind = starProfile.Kind,
+          Color = starProfile.StarColor,
+          Glow = starProfile.StarGlow,
+          Size = starProfile.BaseSize + ((generatedIndex % 4) * 2f),
+        },
+      ],
+      AsteroidField = new AsteroidFieldDefinition
+      {
+        DecorationCount = template.AsteroidField.DecorationCount + ((generatedIndex % 5) * 10),
+        RadiusOffset = template.AsteroidField.RadiusOffset + ((generatedIndex % 4) * 18000f),
+        RadiusVariance = template.AsteroidField.RadiusVariance + ((generatedIndex % 3) * 12000f),
+        HeightVariance = template.AsteroidField.HeightVariance + ((generatedIndex % 4) * 4000f),
+      },
+      ResourceNodes = resourceNodes,
+      Planets = planets,
+    };
+  }
+
+  private static SolarSystemDefinition CloneSystemDefinition(SolarSystemDefinition definition)
+  {
+    return new SolarSystemDefinition
+    {
+      Id = definition.Id,
+      Label = definition.Label,
+      Position = definition.Position.ToArray(),
+      Stars = definition.Stars.Select(s => new StarDefinition { Kind = s.Kind, Color = s.Color, Glow = s.Glow, Size = s.Size, OrbitRadius = s.OrbitRadius, OrbitSpeed = s.OrbitSpeed, OrbitPhaseAtEpoch = s.OrbitPhaseAtEpoch }).ToList(),
+      AsteroidField = new AsteroidFieldDefinition
+      {
+        DecorationCount = definition.AsteroidField.DecorationCount,
+        RadiusOffset = definition.AsteroidField.RadiusOffset,
+        RadiusVariance = definition.AsteroidField.RadiusVariance,
+        HeightVariance = definition.AsteroidField.HeightVariance,
+      },
+      ResourceNodes = definition.ResourceNodes.Select(node => new ResourceNodeDefinition
+      {
+        SourceKind = node.SourceKind,
+        Angle = node.Angle,
+        RadiusOffset = node.RadiusOffset,
+        InclinationDegrees = node.InclinationDegrees,
+        AnchorPlanetIndex = node.AnchorPlanetIndex,
+        AnchorMoonIndex = node.AnchorMoonIndex,
+        OreAmount = node.OreAmount,
+        ItemId = node.ItemId,
+        ShardCount = node.ShardCount,
+      }).ToList(),
+      Planets = definition.Planets.Select(planet => new PlanetDefinition
+      {
+        Label = planet.Label,
+        PlanetType = planet.PlanetType,
+        Shape = planet.Shape,
+        Moons = planet.Moons.Select(moon => new MoonDefinition { Label = moon.Label, Size = moon.Size, Color = moon.Color, OrbitRadius = moon.OrbitRadius, OrbitSpeed = moon.OrbitSpeed, OrbitPhaseAtEpoch = moon.OrbitPhaseAtEpoch, OrbitInclination = moon.OrbitInclination, OrbitLongitudeOfAscendingNode = moon.OrbitLongitudeOfAscendingNode }).ToList(),
+        OrbitRadius = planet.OrbitRadius,
+        OrbitSpeed = planet.OrbitSpeed,
+        OrbitEccentricity = planet.OrbitEccentricity,
+        OrbitInclination = planet.OrbitInclination,
+        OrbitLongitudeOfAscendingNode = planet.OrbitLongitudeOfAscendingNode,
+        OrbitArgumentOfPeriapsis = planet.OrbitArgumentOfPeriapsis,
+        OrbitPhaseAtEpoch = planet.OrbitPhaseAtEpoch,
+        Size = planet.Size,
+        Color = planet.Color,
+        Tilt = planet.Tilt,
+        HasRing = planet.HasRing,
+      }).ToList(),
+    };
+  }
+
+  private static List<ResourceNodeDefinition> BuildProceduralResourceNodes(
+    SolarSystemDefinition template,
+    IReadOnlyList<PlanetDefinition> planets,
+    int generatedIndex)
+  {
+    var nodes = new List<ResourceNodeDefinition>();
+    if (template.ResourceNodes.Count > 0)
+    {
+      nodes.AddRange(template.ResourceNodes.Select(node => new ResourceNodeDefinition
+      {
+        SourceKind = node.SourceKind,
+        Angle = node.Angle,
+        RadiusOffset = node.RadiusOffset,
+        InclinationDegrees = node.InclinationDegrees,
+        AnchorPlanetIndex = node.AnchorPlanetIndex,
+        AnchorMoonIndex = node.AnchorMoonIndex,
+        OreAmount = node.OreAmount,
+        ItemId = node.ItemId,
+        ShardCount = node.ShardCount,
+      }));
+    }
+
+    nodes.AddRange(BuildAsteroidBeltNodes(generatedIndex, planets));
+    return nodes;
+  }
+
+  private static List<Vector3> BuildGalaxyPositions(IReadOnlyCollection<Vector3> occupiedPositions, int count)
+  {
+    var allPositions = occupiedPositions.ToList();
+    var generated = new List<Vector3>(count);
+
+    for (var index = 0; index < count; index += 1)
+    {
+      Vector3? accepted = null;
+      for (var attempt = 0; attempt < 64; attempt += 1)
+      {
+        var candidate = ComputeGeneratedSystemPosition(index, attempt);
+        if (allPositions.All(existing => existing.DistanceTo(candidate) >= MinimumSystemSeparation))
+        {
+          accepted = candidate;
+          break;
+        }
+      }
+
+      accepted ??= ComputeFallbackGeneratedSystemPosition(index);
+      generated.Add(accepted.Value);
+      allPositions.Add(accepted.Value);
+    }
+
+    return generated;
+  }
+
+  private static Vector3 ComputeGeneratedSystemPosition(int generatedIndex, int attempt)
+  {
+    const int armCount = 4;
+    const float baseInnerRadius = 9f;
+    const float radiusStep = 0.54f;
+    const float armOffset = MathF.PI * 2f / armCount;
+
+    var armIndex = (generatedIndex + attempt) % armCount;
+    var armDepth = generatedIndex / armCount;
+    var radius = baseInnerRadius + (armDepth * radiusStep) + Jitter(generatedIndex * 17 + attempt, 0, 0.9f);
+    var angle = (armIndex * armOffset) + (radius / 8.2f) + Jitter(generatedIndex, 1 + attempt, 0.16f);
+    var x = MathF.Cos(angle) * radius;
+    var z = MathF.Sin(angle) * radius * 0.58f;
+    var y = ComputeSystemHeight(radius, generatedIndex, attempt);
+    return new Vector3(x, y, z);
+  }
+
+  private static Vector3 ComputeFallbackGeneratedSystemPosition(int generatedIndex)
+  {
+    const int ringCount = 5;
+    const float fallbackRadius = 42f;
+    var angle = (generatedIndex % ringCount) * (MathF.PI * 2f / ringCount) + (generatedIndex / ringCount) * 0.22f;
+    var radius = fallbackRadius + (generatedIndex / ringCount) * 1.8f;
+    return new Vector3(
+      MathF.Cos(angle) * radius,
+      ComputeSystemHeight(radius, generatedIndex, 99),
+      MathF.Sin(angle) * radius * 0.6f);
+  }
+
+  private static string BuildGeneratedSystemId(string label, int ordinal)
+  {
+    var slug = string.Concat(label
+      .ToLowerInvariant()
+      .Select(character => char.IsLetterOrDigit(character) ? character : '-'))
+      .Trim('-');
+
+    return $"gen-{ordinal}-{slug}";
+  }
+
+  private static IEnumerable<ResourceNodeDefinition> BuildAsteroidBeltNodes(int generatedIndex, IReadOnlyList<PlanetDefinition> planets)
+  {
+    var nodeCount = 4 + (generatedIndex % 4);
+    var oreAmount = 1000f;
+
+    for (var index = 0; index < nodeCount; index += 1)
+    {
+      yield return new ResourceNodeDefinition
+      {
+        SourceKind = "asteroid-belt",
+        Angle = ((MathF.PI * 2f) / nodeCount) * index + Jitter(generatedIndex, 180 + index, 0.22f),
+        RadiusOffset = 120000f + Jitter(generatedIndex, 200 + index, 36000f),
+        InclinationDegrees = Jitter(generatedIndex, 280 + index, 12f),
+        AnchorPlanetIndex = ResolveAsteroidAnchorPlanetIndex(planets),
+        OreAmount = oreAmount,
+        ItemId = "ore",
+        ShardCount = 6 + (index % 4),
+      };
+    }
+  }
+
+  private static int ResolveAsteroidAnchorPlanetIndex(IReadOnlyList<PlanetDefinition> planets)
+  {
+    if (planets.Count == 0)
+    {
+      return 0;
+    }
+
+    var gasGiantIndex = -1;
+    for (var index = 0; index < planets.Count; index += 1)
+    {
+      if (planets[index].PlanetType is "gas-giant" or "ice-giant")
+      {
+        gasGiantIndex = index;
+        break;
+      }
+    }
+
+    if (gasGiantIndex > 0)
+    {
+      return gasGiantIndex - 1;
+    }
+
+    return Math.Clamp((planets.Count / 2) - 1, 0, planets.Count - 1);
+  }
+
+  private static List<PlanetDefinition> BuildGeneratedPlanets(SolarSystemDefinition template, int generatedIndex)
+  {
+    var planetCount = 2 + (int)MathF.Floor(Hash01(generatedIndex, 2) * 7f);
+    var planets = new List<PlanetDefinition>(planetCount);
+    var orbitRadius = 0.24f + (Hash01(generatedIndex, 3) * 0.12f);
+    var sourcePlanets = template.Planets.Count > 0 ? template.Planets : null;
+
+    for (var index = 0; index < planetCount; index += 1)
+    {
+      var profile = SelectPlanetProfile(generatedIndex, index);
+      var templatePlanet = sourcePlanets is not null && sourcePlanets.Count > 0
+        ? sourcePlanets[index % sourcePlanets.Count]
+        : null;
+
+      orbitRadius += profile.OrbitGapMin + (Hash01(generatedIndex, 10 + index) * (profile.OrbitGapMax - profile.OrbitGapMin));
+      var orbitEccentricity = 0.01f + (Hash01(generatedIndex, 20 + index) * 0.16f);
+      var orbitInclination = -9f + (Hash01(generatedIndex, 30 + index) * 18f);
+      var moonCount = profile.BaseMoonCount + (int)MathF.Floor(Hash01(generatedIndex, 40 + index) * 3f);
+      var planetLabel = $"{BuildPlanetBaseName(generatedIndex, index)}-{index + 1}";
+
+      planets.Add(new PlanetDefinition
+      {
+        Label = planetLabel,
+        PlanetType = profile.Type,
+        Shape = profile.Shape,
+        Moons = GenerateMoons(planetLabel, profile.BaseSize, moonCount),
+        OrbitRadius = orbitRadius,
+        OrbitSpeed = 0.11f / MathF.Sqrt(MathF.Max(orbitRadius * orbitRadius * orbitRadius, 0.02f)),
+        OrbitEccentricity = orbitEccentricity,
+        OrbitInclination = orbitInclination,
+        OrbitLongitudeOfAscendingNode = Hash01(generatedIndex, 120 + index) * 360f,
+        OrbitArgumentOfPeriapsis = Hash01(generatedIndex, 140 + index) * 360f,
+        OrbitPhaseAtEpoch = Hash01(generatedIndex, 160 + index) * 360f,
+        Size = profile.BaseSize + (Hash01(generatedIndex, 50 + index) * (profile.BaseSize * 0.35f)),
+        Color = templatePlanet?.Color ?? profile.Color,
+        Tilt = -0.45f + (Hash01(generatedIndex, 60 + index) * 0.9f),
+        HasRing = profile.CanHaveRing && Hash01(generatedIndex, 70 + index) > 0.55f,
+      });
+    }
+
+    return planets;
+  }
+
+  private static StarProfile SelectStarProfile(int generatedIndex)
+  {
+    var value = Hash01(generatedIndex, 80);
+    return value switch
+    {
+      < 0.32f => StarProfiles[0],
+      < 0.54f => StarProfiles[1],
+      < 0.68f => StarProfiles[5],
+      < 0.8f => StarProfiles[2],
+      < 0.9f => StarProfiles[3],
+      < 0.97f => StarProfiles[6],
+      _ => StarProfiles[4],
+    };
+  }
+
+  private static PlanetProfile SelectPlanetProfile(int generatedIndex, int planetIndex)
+  {
+    var value = Hash01(generatedIndex, 90 + planetIndex);
+    return value switch
+    {
+      < 0.14f => PlanetProfiles[7],
+      < 0.28f => PlanetProfiles[0],
+      < 0.46f => PlanetProfiles[3],
+      < 0.62f => PlanetProfiles[1],
+      < 0.74f => PlanetProfiles[2],
+      < 0.86f => PlanetProfiles[4],
+      < 0.94f => PlanetProfiles[6],
+      _ => PlanetProfiles[5],
+    };
+  }
+
+  private static string BuildPlanetBaseName(int generatedIndex, int planetIndex)
+  {
+    var source = GeneratedSystemNames[generatedIndex % GeneratedSystemNames.Length]
+      .Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)[0];
+    return source[..Math.Min(source.Length, 6)];
+  }
+
+  private static float ComputeSystemHeight(float radius, int generatedIndex, int salt)
+  {
+    var normalized = MathF.Min(1f, MathF.Max(0f, (radius - 8f) / 28f));
+    var band = 0.22f + (normalized * 0.76f);
+    return (Hash01(generatedIndex, 100 + salt) * 2f - 1f) * band;
+  }
+
+  private static float Jitter(int index, int salt, float amplitude) =>
+    (Hash01(index, salt) * 2f - 1f) * amplitude;
+
+  private static float Hash01(int index, int salt)
+  {
+    uint value = (uint)(index + 1);
+    value ^= (uint)(salt + 0x9e3779b9);
+    value *= 0x85ebca6b;
+    value ^= value >> 13;
+    value *= 0xc2b2ae35;
+    value ^= value >> 16;
+    return (value & 0x00ffffff) / 16777215f;
+  }
+
+  private static List<MoonDefinition> GenerateMoons(string planetLabel, float planetSize, int moonCount)
+  {
+    var seed = planetLabel.Aggregate(0, (acc, c) => acc * 31 + c);
+    var moons = new List<MoonDefinition>(moonCount);
+    for (var moonIndex = 0; moonIndex < moonCount; moonIndex += 1)
+    {
+      var spacing = planetSize * 1.4f;
+      var radiusVariance = Hash01(seed, 10 + moonIndex) * planetSize * 0.9f;
+      var orbitRadius = (planetSize * 1.8f) + (moonIndex * spacing) + radiusVariance;
+      var orbitSpeed = 0.9f / MathF.Sqrt(MathF.Max(orbitRadius, 1f)) + (moonIndex * 0.003f);
+      var phase = Hash01(seed, 20 + moonIndex) * 360f;
+      var inclination = (Hash01(seed, 30 + moonIndex) - 0.5f) * 28f;
+      var ascendingNode = Hash01(seed, 40 + moonIndex) * 360f;
+      var sizeBase = MathF.Max(2.2f, planetSize * 0.11f);
+      var sizeVariance = Hash01(seed, 50 + moonIndex) * MathF.Max(planetSize * 0.16f, 2.5f);
+      var size = MathF.Min(sizeBase + sizeVariance, planetSize * 0.42f);
+
+      moons.Add(new MoonDefinition
+      {
+        Label = $"{planetLabel}-m{moonIndex + 1}",
+        Size = size,
+        Color = "#c8c4bc",
+        OrbitRadius = orbitRadius,
+        OrbitSpeed = orbitSpeed,
+        OrbitPhaseAtEpoch = phase,
+        OrbitInclination = inclination,
+        OrbitLongitudeOfAscendingNode = ascendingNode,
+      });
+    }
+
+    return moons;
+  }
+}

apps/backend/Universe/Scenario/WorldBuilder.cs

@@ -0,0 +1,180 @@
+using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal sealed class WorldBuilder(
+  WorldGenerationOptions worldGeneration,
+  DataCatalogLoader dataLoader,
+  SystemGenerationService generationService,
+  SpatialBuilder spatialBuilder,
+  WorldSeedingService seedingService)
+{
+  internal SimulationWorld Build()
+  {
+    var catalog = dataLoader.LoadCatalog();
+    var systems = generationService.ExpandSystems(
+      generationService.InjectSpecialSystems(catalog.AuthoredSystems),
+      worldGeneration.TargetSystemCount);
+    var scenario = dataLoader.NormalizeScenarioToAvailableSystems(
+      catalog.Scenario,
+      systems.Select(system => system.Id).ToList());
+
+    var systemRuntimes = systems
+      .Select(definition => new SystemRuntime
+      {
+        Definition = definition,
+        Position = ToVector(definition.Position),
+      })
+      .ToList();
+    var systemsById = systemRuntimes.ToDictionary(system => system.Definition.Id, StringComparer.Ordinal);
+    var spatialLayout = spatialBuilder.BuildLayout(systemRuntimes, catalog.Balance);
+
+    var stations = CreateStations(
+      scenario,
+      systemsById,
+      spatialLayout.SystemGraphs,
+      spatialLayout.Celestials,
+      catalog.ModuleDefinitions);
+
+    seedingService.InitializeStationStockpiles(stations);
+    var refinery = seedingService.SelectRefineryStation(stations, scenario);
+    var patrolRoutes = BuildPatrolRoutes(scenario, systemsById);
+    var ships = CreateShips(scenario, systemsById, spatialLayout.Celestials, catalog.Balance, catalog.ShipDefinitions, patrolRoutes, refinery);
+
+    var factions = seedingService.CreateFactions(stations, ships);
+    seedingService.BootstrapFactionEconomy(factions, stations);
+    var policies = seedingService.CreatePolicies(factions);
+    var commanders = seedingService.CreateCommanders(factions, stations, ships);
+    var nowUtc = DateTimeOffset.UtcNow;
+    var claims = seedingService.CreateClaims(stations, spatialLayout.Celestials, nowUtc);
+    var (constructionSites, marketOrders) = seedingService.CreateConstructionSites(stations, claims, catalog.ModuleRecipes);
+
+    return new SimulationWorld
+    {
+      Label = "Split Viewer / Simulation World",
+      Seed = WorldSeed,
+      Balance = catalog.Balance,
+      Systems = systemRuntimes,
+      Celestials = spatialLayout.Celestials,
+      Nodes = spatialLayout.Nodes,
+      Stations = stations,
+      Ships = ships,
+      Factions = factions,
+      Commanders = commanders,
+      Claims = claims,
+      ConstructionSites = constructionSites,
+      MarketOrders = marketOrders,
+      Policies = policies,
+      ShipDefinitions = new Dictionary<string, ShipDefinition>(catalog.ShipDefinitions, StringComparer.Ordinal),
+      ItemDefinitions = new Dictionary<string, ItemDefinition>(catalog.ItemDefinitions, StringComparer.Ordinal),
+      ModuleDefinitions = new Dictionary<string, ModuleDefinition>(catalog.ModuleDefinitions, StringComparer.Ordinal),
+      ModuleRecipes = new Dictionary<string, ModuleRecipeDefinition>(catalog.ModuleRecipes, StringComparer.Ordinal),
+      Recipes = new Dictionary<string, RecipeDefinition>(catalog.Recipes, StringComparer.Ordinal),
+      OrbitalTimeSeconds = WorldSeed * 97d,
+      GeneratedAtUtc = DateTimeOffset.UtcNow,
+    };
+  }
+
+  private static List<StationRuntime> CreateStations(
+    ScenarioDefinition scenario,
+    IReadOnlyDictionary<string, SystemRuntime> systemsById,
+    IReadOnlyDictionary<string, SystemSpatialGraph> systemGraphs,
+    IReadOnlyCollection<CelestialRuntime> celestials,
+    IReadOnlyDictionary<string, ModuleDefinition> moduleDefinitions)
+  {
+    var stations = new List<StationRuntime>();
+    var stationIdCounter = 0;
+
+    foreach (var plan in scenario.InitialStations)
+    {
+      if (!systemsById.TryGetValue(plan.SystemId, out var system))
+      {
+        continue;
+      }
+
+      var placement = SpatialBuilder.ResolveStationPlacement(plan, system, systemGraphs[system.Definition.Id], celestials);
+      var station = new StationRuntime
+      {
+        Id = $"station-{++stationIdCounter}",
+        SystemId = system.Definition.Id,
+        Label = plan.Label,
+        Color = plan.Color,
+        Position = placement.Position,
+        FactionId = plan.FactionId ?? DefaultFactionId,
+        CelestialId = placement.AnchorCelestial.Id,
+      };
+
+      stations.Add(station);
+      placement.AnchorCelestial.OccupyingStructureId = station.Id;
+
+      var startingModules = plan.StartingModules.Count > 0
+        ? plan.StartingModules
+        : ["module_arg_dock_m_01_lowtech", "module_gen_prod_energycells_01", "module_arg_stor_solid_m_01", "module_arg_stor_liquid_m_01"];
+
+      foreach (var moduleId in startingModules)
+      {
+        AddStationModule(station, moduleDefinitions, moduleId);
+      }
+    }
+
+    return stations;
+  }
+
+  private static Dictionary<string, List<Vector3>> BuildPatrolRoutes(
+    ScenarioDefinition scenario,
+    IReadOnlyDictionary<string, SystemRuntime> systemsById)
+  {
+    return scenario.PatrolRoutes
+      .GroupBy(route => route.SystemId, StringComparer.Ordinal)
+      .ToDictionary(
+        group => group.Key,
+        group => group
+          .SelectMany(route => route.Points)
+          .Select(point => NormalizeScenarioPoint(systemsById[group.Key], point))
+          .ToList(),
+        StringComparer.Ordinal);
+  }
+
+  private static List<ShipRuntime> CreateShips(
+    ScenarioDefinition scenario,
+    IReadOnlyDictionary<string, SystemRuntime> systemsById,
+    IReadOnlyCollection<CelestialRuntime> celestials,
+    BalanceDefinition balance,
+    IReadOnlyDictionary<string, ShipDefinition> shipDefinitions,
+    IReadOnlyDictionary<string, List<Vector3>> patrolRoutes,
+    StationRuntime? refinery)
+  {
+    var ships = new List<ShipRuntime>();
+    var shipIdCounter = 0;
+
+    foreach (var formation in scenario.ShipFormations)
+    {
+      if (!shipDefinitions.TryGetValue(formation.ShipId, out var definition))
+      {
+        continue;
+      }
+
+      for (var index = 0; index < formation.Count; index += 1)
+      {
+        var offset = new Vector3((index % 3) * 18f, balance.YPlane, (index / 3) * 18f);
+        var position = Add(NormalizeScenarioPoint(systemsById[formation.SystemId], formation.Center), offset);
+
+        ships.Add(new ShipRuntime
+        {
+          Id = $"ship-{++shipIdCounter}",
+          SystemId = formation.SystemId,
+          Definition = definition,
+          FactionId = formation.FactionId ?? DefaultFactionId,
+          Position = position,
+          TargetPosition = position,
+          SpatialState = SpatialBuilder.CreateInitialShipSpatialState(formation.SystemId, position, celestials),
+          DefaultBehavior = WorldSeedingService.CreateBehavior(definition, formation.SystemId, scenario, patrolRoutes, refinery),
+          ControllerTask = new ControllerTaskRuntime { Kind = ControllerTaskKind.Idle, Threshold = balance.ArrivalThreshold, Status = WorkStatus.Pending },
+          Health = definition.MaxHealth,
+        });
+      }
+    }
+
+    return ships;
+  }
+}

apps/backend/Universe/Scenario/WorldSeedingService.cs

@@ -0,0 +1,434 @@
+using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
+
+namespace SpaceGame.Api.Universe.Scenario;
+
+internal sealed class WorldSeedingService
+{
+  internal List<FactionRuntime> CreateFactions(
+    IReadOnlyCollection<StationRuntime> stations,
+    IReadOnlyCollection<ShipRuntime> ships)
+  {
+    var factionIds = stations
+      .Select(station => station.FactionId)
+      .Concat(ships.Select(ship => ship.FactionId))
+      .Where(factionId => !string.IsNullOrWhiteSpace(factionId))
+      .Distinct(StringComparer.Ordinal)
+      .OrderBy(factionId => factionId, StringComparer.Ordinal)
+      .ToList();
+
+    if (factionIds.Count == 0)
+    {
+      factionIds.Add(DefaultFactionId);
+    }
+
+    return factionIds.Select(CreateFaction).ToList();
+  }
+
+  internal void BootstrapFactionEconomy(
+    IReadOnlyCollection<FactionRuntime> factions,
+    IReadOnlyCollection<StationRuntime> stations)
+  {
+    foreach (var faction in factions)
+    {
+      faction.Credits = MathF.Max(faction.Credits, MinimumFactionCredits);
+
+      var ownedStations = stations
+        .Where(station => station.FactionId == faction.Id)
+        .ToList();
+
+      var refineries = ownedStations
+        .Where(station => HasInstalledModules(station, "module_gen_prod_refinedmetals_01", "module_gen_prod_energycells_01", "module_arg_stor_liquid_m_01"))
+        .ToList();
+
+      if (refineries.Count > 0)
+      {
+        foreach (var refinery in refineries)
+        {
+          refinery.Inventory["refinedmetals"] = MathF.Max(GetInventoryAmount(refinery.Inventory, "refinedmetals"), MinimumRefineryStock);
+        }
+
+        if (refineries.All(station => GetInventoryAmount(station.Inventory, "ore") < MinimumRefineryOre))
+        {
+          refineries[0].Inventory["ore"] = MinimumRefineryOre;
+        }
+      }
+
+      foreach (var shipyard in ownedStations.Where(station => HasInstalledModules(station, "module_gen_build_l_01")))
+      {
+        shipyard.Inventory["refinedmetals"] = MathF.Max(GetInventoryAmount(shipyard.Inventory, "refinedmetals"), MinimumShipyardStock);
+      }
+    }
+  }
+
+  internal void InitializeStationStockpiles(IReadOnlyCollection<StationRuntime> stations)
+  {
+    foreach (var station in stations)
+    {
+      InitializeStationPopulation(station);
+      station.Inventory["refinedmetals"] = 120f;
+      if (station.Population > 0f)
+      {
+        station.Inventory["water"] = MathF.Max(80f, station.Population * 1.5f);
+      }
+    }
+  }
+
+  internal StationRuntime? SelectRefineryStation(IReadOnlyCollection<StationRuntime> stations, ScenarioDefinition scenario)
+  {
+    return stations.FirstOrDefault(station =>
+        HasInstalledModules(station, "module_gen_prod_energycells_01", "module_arg_stor_liquid_m_01") &&
+        station.SystemId == scenario.MiningDefaults.RefinerySystemId)
+      ?? stations.FirstOrDefault(station =>
+        HasInstalledModules(station, "module_gen_prod_energycells_01", "module_arg_stor_liquid_m_01"));
+  }
+
+  internal List<ClaimRuntime> CreateClaims(
+    IReadOnlyCollection<StationRuntime> stations,
+    IReadOnlyCollection<CelestialRuntime> celestials,
+    DateTimeOffset nowUtc)
+  {
+    var stationsByCelestialId = stations
+      .Where(station => station.CelestialId is not null)
+      .ToDictionary(station => station.CelestialId!, StringComparer.Ordinal);
+    var claims = new List<ClaimRuntime>();
+
+    foreach (var celestial in celestials.Where(c => c.Kind == SpatialNodeKind.LagrangePoint))
+    {
+      if (!stationsByCelestialId.TryGetValue(celestial.Id, out var station))
+      {
+        continue;
+      }
+
+      claims.Add(new ClaimRuntime
+      {
+        Id = $"claim-{celestial.Id}",
+        FactionId = station.FactionId,
+        SystemId = celestial.SystemId,
+        CelestialId = celestial.Id,
+        PlacedAtUtc = nowUtc,
+        ActivatesAtUtc = nowUtc.AddSeconds(8),
+        State = ClaimStateKinds.Activating,
+        Health = 100f,
+      });
+    }
+
+    return claims;
+  }
+
+  internal (List<ConstructionSiteRuntime> ConstructionSites, List<MarketOrderRuntime> MarketOrders) CreateConstructionSites(
+    IReadOnlyCollection<StationRuntime> stations,
+    IReadOnlyCollection<ClaimRuntime> claims,
+    IReadOnlyDictionary<string, ModuleRecipeDefinition> moduleRecipes)
+  {
+    var sites = new List<ConstructionSiteRuntime>();
+    var orders = new List<MarketOrderRuntime>();
+
+    foreach (var station in stations)
+    {
+      var moduleId = GetNextConstructionSiteModule(station, moduleRecipes);
+      if (moduleId is null || station.CelestialId is null)
+      {
+        continue;
+      }
+
+      var claim = claims.FirstOrDefault(candidate => candidate.CelestialId == station.CelestialId);
+      if (claim is null || !moduleRecipes.TryGetValue(moduleId, out var recipe))
+      {
+        continue;
+      }
+
+      var site = new ConstructionSiteRuntime
+      {
+        Id = $"site-{station.Id}",
+        FactionId = station.FactionId,
+        SystemId = station.SystemId,
+        CelestialId = station.CelestialId,
+        TargetKind = "station-module",
+        TargetDefinitionId = "station",
+        BlueprintId = moduleId,
+        ClaimId = claim.Id,
+        StationId = station.Id,
+        State = claim.State == ClaimStateKinds.Active ? ConstructionSiteStateKinds.Active : ConstructionSiteStateKinds.Planned,
+      };
+
+      foreach (var input in recipe.Inputs)
+      {
+        site.RequiredItems[input.ItemId] = input.Amount;
+        site.DeliveredItems[input.ItemId] = 0f;
+
+        var orderId = $"market-order-{station.Id}-{moduleId}-{input.ItemId}";
+        site.MarketOrderIds.Add(orderId);
+        station.MarketOrderIds.Add(orderId);
+        orders.Add(new MarketOrderRuntime
+        {
+          Id = orderId,
+          FactionId = station.FactionId,
+          StationId = station.Id,
+          ConstructionSiteId = site.Id,
+          Kind = MarketOrderKinds.Buy,
+          ItemId = input.ItemId,
+          Amount = input.Amount,
+          RemainingAmount = input.Amount,
+          Valuation = 1f,
+          State = MarketOrderStateKinds.Open,
+        });
+      }
+
+      sites.Add(site);
+    }
+
+    return (sites, orders);
+  }
+
+  internal List<PolicySetRuntime> CreatePolicies(IReadOnlyCollection<FactionRuntime> factions)
+  {
+    var policies = new List<PolicySetRuntime>(factions.Count);
+    foreach (var faction in factions)
+    {
+      var policyId = $"policy-{faction.Id}";
+      faction.DefaultPolicySetId = policyId;
+      policies.Add(new PolicySetRuntime
+      {
+        Id = policyId,
+        OwnerKind = "faction",
+        OwnerId = faction.Id,
+      });
+    }
+
+    return policies;
+  }
+
+  internal List<CommanderRuntime> CreateCommanders(
+    IReadOnlyCollection<FactionRuntime> factions,
+    IReadOnlyCollection<StationRuntime> stations,
+    IReadOnlyCollection<ShipRuntime> ships)
+  {
+    var commanders = new List<CommanderRuntime>();
+    var factionCommanders = new Dictionary<string, CommanderRuntime>(StringComparer.Ordinal);
+    var factionsById = factions.ToDictionary(faction => faction.Id, StringComparer.Ordinal);
+
+    foreach (var faction in factions)
+    {
+      var commander = new CommanderRuntime
+      {
+        Id = $"commander-faction-{faction.Id}",
+        Kind = CommanderKind.Faction,
+        FactionId = faction.Id,
+        ControlledEntityId = faction.Id,
+        PolicySetId = faction.DefaultPolicySetId,
+        Doctrine = "strategic-expansionist",
+      };
+
+      commander.Goals.Add("control-all-systems");
+      commander.Goals.Add("control-five-systems-fast");
+      commander.Goals.Add("expand-industrial-base");
+      commander.Goals.Add("grow-war-fleet");
+      commander.Goals.Add("deter-pirate-harassment");
+      commander.Goals.Add("contest-rival-expansion");
+
+      commanders.Add(commander);
+      factionCommanders[faction.Id] = commander;
+      faction.CommanderIds.Add(commander.Id);
+    }
+
+    foreach (var station in stations)
+    {
+      if (!factionCommanders.TryGetValue(station.FactionId, out var parentCommander))
+      {
+        continue;
+      }
+
+      var commander = new CommanderRuntime
+      {
+        Id = $"commander-station-{station.Id}",
+        Kind = CommanderKind.Station,
+        FactionId = station.FactionId,
+        ParentCommanderId = parentCommander.Id,
+        ControlledEntityId = station.Id,
+        PolicySetId = parentCommander.PolicySetId,
+        Doctrine = "station-default",
+      };
+
+      station.CommanderId = commander.Id;
+      station.PolicySetId = parentCommander.PolicySetId;
+      parentCommander.SubordinateCommanderIds.Add(commander.Id);
+      factionsById[station.FactionId].CommanderIds.Add(commander.Id);
+      commanders.Add(commander);
+    }
+
+    foreach (var ship in ships)
+    {
+      if (!factionCommanders.TryGetValue(ship.FactionId, out var parentCommander))
+      {
+        continue;
+      }
+
+      var commander = new CommanderRuntime
+      {
+        Id = $"commander-ship-{ship.Id}",
+        Kind = CommanderKind.Ship,
+        FactionId = ship.FactionId,
+        ParentCommanderId = parentCommander.Id,
+        ControlledEntityId = ship.Id,
+        PolicySetId = parentCommander.PolicySetId,
+        Doctrine = "ship-default",
+        ActiveBehavior = CopyBehavior(ship.DefaultBehavior),
+        ActiveTask = CopyTask(ship.ControllerTask, null),
+      };
+
+      if (ship.Order is not null)
+      {
+        commander.ActiveOrder = CopyOrder(ship.Order);
+      }
+
+      ship.CommanderId = commander.Id;
+      ship.PolicySetId = parentCommander.PolicySetId;
+      parentCommander.SubordinateCommanderIds.Add(commander.Id);
+      factionsById[ship.FactionId].CommanderIds.Add(commander.Id);
+      commanders.Add(commander);
+    }
+
+    return commanders;
+  }
+
+  internal static DefaultBehaviorRuntime CreateBehavior(
+    ShipDefinition definition,
+    string systemId,
+    ScenarioDefinition scenario,
+    IReadOnlyDictionary<string, List<Vector3>> patrolRoutes,
+    StationRuntime? refinery)
+  {
+    if (string.Equals(definition.Kind, "construction", StringComparison.Ordinal) && refinery is not null)
+    {
+      return new DefaultBehaviorRuntime
+      {
+        Kind = "construct-station",
+        StationId = refinery.Id,
+        Phase = "travel-to-station",
+      };
+    }
+
+    if (HasCapabilities(definition, "mining") && refinery is not null)
+    {
+      return CreateResourceHarvestBehavior("auto-mine", scenario.MiningDefaults.NodeSystemId, refinery.Id);
+    }
+
+    if (string.Equals(definition.Kind, "military", StringComparison.Ordinal) && patrolRoutes.TryGetValue(systemId, out var route))
+    {
+      return new DefaultBehaviorRuntime
+      {
+        Kind = "patrol",
+        PatrolPoints = route,
+        PatrolIndex = 0,
+      };
+    }
+
+    return new DefaultBehaviorRuntime
+    {
+      Kind = "idle",
+    };
+  }
+
+  private static FactionRuntime CreateFaction(string factionId)
+  {
+    return factionId switch
+    {
+      DefaultFactionId => new FactionRuntime
+      {
+        Id = factionId,
+        Label = "Sol Dominion",
+        Color = "#7ed4ff",
+        Credits = MinimumFactionCredits,
+      },
+      _ => new FactionRuntime
+      {
+        Id = factionId,
+        Label = ToFactionLabel(factionId),
+        Color = "#c7d2e0",
+        Credits = MinimumFactionCredits,
+      },
+    };
+  }
+
+  private static string? GetNextConstructionSiteModule(
+    StationRuntime station,
+    IReadOnlyDictionary<string, ModuleRecipeDefinition> moduleRecipes)
+  {
+    foreach (var (moduleId, targetCount) in new (string ModuleId, int TargetCount)[]
+    {
+      ("module_gen_prod_refinedmetals_01", 1),
+      ("module_arg_stor_container_m_01", 1),
+      ("module_gen_prod_hullparts_01", 2),
+      ("module_gen_prod_advancedelectronics_01", 1),
+      ("module_gen_build_l_01", 1),
+      ("module_gen_prod_energycells_01", 2),
+      ("module_arg_dock_m_01_lowtech", 2),
+    })
+    {
+      if (CountModules(station.InstalledModules, moduleId) < targetCount
+        && moduleRecipes.ContainsKey(moduleId))
+      {
+        return moduleId;
+      }
+    }
+
+    return null;
+  }
+
+  private static void InitializeStationPopulation(StationRuntime station)
+  {
+    var habitatModules = CountModules(station.InstalledModules, "module_arg_hab_m_01");
+    station.PopulationCapacity = 40f + (habitatModules * 220f);
+    station.WorkforceRequired = MathF.Max(12f, station.Modules.Count * 14f);
+    station.Population = habitatModules > 0
+      ? MathF.Min(station.PopulationCapacity * 0.65f, station.WorkforceRequired * 1.05f)
+      : MathF.Min(28f, station.PopulationCapacity);
+    station.WorkforceEffectiveRatio = ComputeWorkforceRatio(station.Population, station.WorkforceRequired);
+  }
+
+  private static string ToFactionLabel(string factionId)
+  {
+    return string.Join(" ",
+      factionId
+        .Split('-', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+        .Select(segment => char.ToUpperInvariant(segment[0]) + segment[1..]));
+  }
+
+  private static DefaultBehaviorRuntime CreateResourceHarvestBehavior(string kind, string areaSystemId, string stationId) => new()
+  {
+    Kind = kind,
+    AreaSystemId = areaSystemId,
+    StationId = stationId,
+    Phase = "travel-to-node",
+  };
+
+  private static CommanderBehaviorRuntime CopyBehavior(DefaultBehaviorRuntime behavior) => new()
+  {
+    Kind = behavior.Kind,
+    AreaSystemId = behavior.AreaSystemId,
+    ModuleId = behavior.ModuleId,
+    NodeId = behavior.NodeId,
+    Phase = behavior.Phase,
+    PatrolIndex = behavior.PatrolIndex,
+    StationId = behavior.StationId,
+  };
+
+  private static CommanderOrderRuntime CopyOrder(ShipOrderRuntime order) => new()
+  {
+    Kind = order.Kind,
+    Status = order.Status,
+    DestinationSystemId = order.DestinationSystemId,
+    DestinationPosition = order.DestinationPosition,
+  };
+
+  private static CommanderTaskRuntime CopyTask(ControllerTaskRuntime task, string? targetNodeId) => new()
+  {
+    Kind = task.Kind.ToContractValue(),
+    Status = task.Status,
+    TargetEntityId = task.TargetEntityId,
+    TargetNodeId = targetNodeId ?? task.TargetNodeId,
+    TargetPosition = task.TargetPosition,
+    TargetSystemId = task.TargetSystemId,
+    Threshold = task.Threshold,
+  };
+}

apps/backend/Universe/Simulation/OrbitalSimulationOptions.cs

@@ -0,0 +1,6 @@
+namespace SpaceGame.Api.Universe.Simulation;
+
+public sealed class OrbitalSimulationOptions
+{
+  public double SimulatedSecondsPerRealSecond { get; init; } = 0d;
+}

apps/backend/Universe/Simulation/OrbitalStateUpdater.cs

@@ -0,0 +1,293 @@
+using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
+
+namespace SpaceGame.Api.Universe.Simulation;
+
+internal sealed class OrbitalStateUpdater
+{
+    private readonly OrbitalSimulationOptions _orbitalSimulation;
+
+    internal OrbitalStateUpdater(OrbitalSimulationOptions orbitalSimulation)
+    {
+        _orbitalSimulation = orbitalSimulation;
+    }
+
+    private static Vector3 ComputePlanetPosition(PlanetDefinition planet, float timeSeconds)
+    {
+        var eccentricity = Math.Clamp(planet.OrbitEccentricity, 0f, 0.85f);
+        var meanAnomaly = DegreesToRadians(planet.OrbitPhaseAtEpoch) + (timeSeconds * planet.OrbitSpeed);
+        var eccentricAnomaly = meanAnomaly
+            + (eccentricity * MathF.Sin(meanAnomaly))
+            + (0.5f * eccentricity * eccentricity * MathF.Sin(2f * meanAnomaly));
+        var semiMajorAxis = SimulationUnits.AuToKilometers(planet.OrbitRadius);
+        var semiMinorAxis = semiMajorAxis * MathF.Sqrt(MathF.Max(1f - (eccentricity * eccentricity), 0.05f));
+        var local = new Vector3(
+            semiMajorAxis * (MathF.Cos(eccentricAnomaly) - eccentricity),
+            0f,
+            semiMinorAxis * MathF.Sin(eccentricAnomaly));
+
+        local = RotateAroundY(local, DegreesToRadians(planet.OrbitArgumentOfPeriapsis));
+        local = RotateAroundX(local, DegreesToRadians(planet.OrbitInclination));
+        local = RotateAroundY(local, DegreesToRadians(planet.OrbitLongitudeOfAscendingNode));
+        return local;
+    }
+
+    private static Vector3 ComputeMoonOffset(MoonDefinition moon, float timeSeconds)
+    {
+        var angle = DegreesToRadians(moon.OrbitPhaseAtEpoch) + (timeSeconds * moon.OrbitSpeed);
+        var local = new Vector3(
+            MathF.Cos(angle) * moon.OrbitRadius,
+            0f,
+            MathF.Sin(angle) * moon.OrbitRadius);
+        local = RotateAroundX(local, DegreesToRadians(moon.OrbitInclination));
+        local = RotateAroundY(local, DegreesToRadians(moon.OrbitLongitudeOfAscendingNode));
+        return local;
+    }
+
+    private static float ComputeResourceNodeOrbitSpeed(ResourceNodeRuntime node)
+    {
+        var baseSpeed = 0.24f;
+        return baseSpeed / MathF.Sqrt(MathF.Max(node.OrbitRadius / 180000f, 0.45f));
+    }
+
+    private static Vector3 ComputeResourceNodeOffset(ResourceNodeRuntime node, float timeSeconds)
+    {
+        var angle = node.OrbitPhase + (timeSeconds * ComputeResourceNodeOrbitSpeed(node));
+        var orbit = new Vector3(
+            MathF.Cos(angle) * node.OrbitRadius,
+            0f,
+            MathF.Sin(angle) * node.OrbitRadius);
+        return RotateAroundX(orbit, node.OrbitInclination);
+    }
+
+    private static IEnumerable<LagrangePointPlacement> EnumeratePlanetLagrangePoints(
+        Vector3 planetPosition,
+        PlanetDefinition planet)
+    {
+        var radial = NormalizeOrFallback(planetPosition, new Vector3(1f, 0f, 0f));
+        var tangential = new Vector3(-radial.Z, 0f, radial.X);
+        var orbitRadiusKm = MathF.Sqrt(planetPosition.X * planetPosition.X + planetPosition.Z * planetPosition.Z);
+        var offset = ComputePlanetLocalLagrangeOffset(orbitRadiusKm, planet);
+        var triangularAngle = MathF.PI / 3f;
+
+        yield return new LagrangePointPlacement("L1", Add(planetPosition, Scale(radial, -offset)));
+        yield return new LagrangePointPlacement("L2", Add(planetPosition, Scale(radial, offset)));
+        yield return new LagrangePointPlacement("L3", Scale(radial, -orbitRadiusKm));
+        yield return new LagrangePointPlacement(
+            "L4",
+            Add(
+                Scale(radial, orbitRadiusKm * MathF.Cos(triangularAngle)),
+                Scale(tangential, orbitRadiusKm * MathF.Sin(triangularAngle))));
+        yield return new LagrangePointPlacement(
+            "L5",
+            Add(
+                Scale(radial, orbitRadiusKm * MathF.Cos(triangularAngle)),
+                Scale(tangential, -orbitRadiusKm * MathF.Sin(triangularAngle))));
+    }
+
+    private static float ComputePlanetLocalLagrangeOffset(float orbitRadiusKm, PlanetDefinition planet)
+    {
+        var planetMassProxy = EstimatePlanetMassRatio(planet);
+        var hillLikeOffset = orbitRadiusKm * MathF.Cbrt(MathF.Max(planetMassProxy / 3f, 1e-9f));
+        var minimumOffset = MathF.Max(planet.Size * 4f, 25000f);
+        return MathF.Max(minimumOffset, hillLikeOffset);
+    }
+
+    private static float EstimatePlanetMassRatio(PlanetDefinition planet)
+    {
+        var earthRadiusRatio = MathF.Max(planet.Size / 6371f, 0.05f);
+        var densityFactor = planet.PlanetType switch
+        {
+            "gas-giant" => 0.24f,
+            "ice-giant" => 0.18f,
+            "oceanic" => 0.95f,
+            "ice" => 0.7f,
+            _ => 1f,
+        };
+
+        var earthMasses = MathF.Pow(earthRadiusRatio, 3f) * densityFactor;
+        return earthMasses / 332_946f;
+    }
+
+    private static Vector3 NormalizeOrFallback(Vector3 value, Vector3 fallback)
+    {
+        var length = MathF.Sqrt(value.LengthSquared());
+        if (length <= 0.0001f)
+        {
+            return fallback;
+        }
+
+        return value.Divide(length);
+    }
+
+    private static Vector3 RotateAroundX(Vector3 value, float angle)
+    {
+        var cos = MathF.Cos(angle);
+        var sin = MathF.Sin(angle);
+        return new Vector3(
+            value.X,
+            (value.Y * cos) - (value.Z * sin),
+            (value.Y * sin) + (value.Z * cos));
+    }
+
+    private static Vector3 RotateAroundY(Vector3 value, float angle)
+    {
+        var cos = MathF.Cos(angle);
+        var sin = MathF.Sin(angle);
+        return new Vector3(
+            (value.X * cos) + (value.Z * sin),
+            value.Y,
+            (-value.X * sin) + (value.Z * cos));
+    }
+
+    private static Vector3 Add(Vector3 left, Vector3 right) => new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+    private static Vector3 Scale(Vector3 value, float scalar) => new(value.X * scalar, value.Y * scalar, value.Z * scalar);
+
+    private static float DegreesToRadians(float degrees) => degrees * (MathF.PI / 180f);
+
+    private static float HashUnit(string input)
+    {
+        unchecked
+        {
+            var hash = 2166136261u;
+            foreach (var character in input)
+            {
+                hash ^= character;
+                hash *= 16777619u;
+            }
+
+            return (hash & 0x00FFFFFF) / (float)0x01000000;
+        }
+    }
+
+    internal void Update(SimulationWorld world)
+    {
+        var worldTimeSeconds = (float)world.OrbitalTimeSeconds;
+        var celestialsById = world.Celestials.ToDictionary(c => c.Id, StringComparer.Ordinal);
+
+        foreach (var system in world.Systems)
+        {
+            for (var starIndex = 0; starIndex < system.Definition.Stars.Count; starIndex += 1)
+            {
+                var star = system.Definition.Stars[starIndex];
+                var starNodeId = $"node-{system.Definition.Id}-star-{starIndex + 1}";
+                if (!celestialsById.TryGetValue(starNodeId, out var starNode))
+                {
+                    continue;
+                }
+
+                if (star.OrbitRadius <= 0f)
+                {
+                    starNode.Position = Vector3.Zero;
+                }
+                else
+                {
+                    var angle = DegreesToRadians(star.OrbitPhaseAtEpoch) + (worldTimeSeconds * star.OrbitSpeed);
+                    starNode.Position = new Vector3(MathF.Cos(angle) * star.OrbitRadius, 0f, MathF.Sin(angle) * star.OrbitRadius);
+                }
+            }
+
+            for (var planetIndex = 0; planetIndex < system.Definition.Planets.Count; planetIndex += 1)
+            {
+                var planet = system.Definition.Planets[planetIndex];
+                var planetNodeId = $"node-{system.Definition.Id}-planet-{planetIndex + 1}";
+                if (!celestialsById.TryGetValue(planetNodeId, out var planetNode))
+                {
+                    continue;
+                }
+
+                var planetPosition = ComputePlanetPosition(planet, worldTimeSeconds);
+                planetNode.Position = planetPosition;
+
+                foreach (var lagrange in EnumeratePlanetLagrangePoints(planetPosition, planet))
+                {
+                    var lagrangeId = $"node-{system.Definition.Id}-planet-{planetIndex + 1}-{lagrange.Designation.ToLowerInvariant()}";
+                    if (celestialsById.TryGetValue(lagrangeId, out var lagrangeNode))
+                    {
+                        lagrangeNode.Position = lagrange.Position;
+                    }
+                }
+
+                for (var moonIndex = 0; moonIndex < planet.Moons.Count; moonIndex += 1)
+                {
+                    var moonId = $"node-{system.Definition.Id}-planet-{planetIndex + 1}-moon-{moonIndex + 1}";
+                    if (!celestialsById.TryGetValue(moonId, out var moonNode))
+                    {
+                        continue;
+                    }
+
+                    moonNode.Position = Add(planetPosition, ComputeMoonOffset(planet.Moons[moonIndex], worldTimeSeconds));
+                }
+            }
+        }
+
+        foreach (var station in world.Stations)
+        {
+            if (station.CelestialId is null || !celestialsById.TryGetValue(station.CelestialId, out var anchorCelestial))
+            {
+                continue;
+            }
+
+            station.Position = anchorCelestial.Position;
+        }
+
+        foreach (var node in world.Nodes)
+        {
+            if (node.CelestialId is null || !celestialsById.TryGetValue(node.CelestialId, out var anchorCelestial))
+            {
+                continue;
+            }
+
+            node.Position = Add(anchorCelestial.Position, ComputeResourceNodeOffset(node, worldTimeSeconds));
+        }
+
+        foreach (var ship in world.Ships.Where(ship => ship.DockedStationId is not null))
+        {
+            var station = world.Stations.FirstOrDefault(candidate => candidate.Id == ship.DockedStationId);
+            if (station is null)
+            {
+                continue;
+            }
+
+            var dockedPosition = GetShipDockedPosition(ship, station);
+            ship.Position = dockedPosition;
+            ship.TargetPosition = dockedPosition;
+        }
+    }
+
+    internal void SyncSpatialState(SimulationWorld world)
+    {
+        foreach (var ship in world.Ships)
+        {
+            ship.SpatialState.CurrentSystemId = ship.SystemId;
+            ship.SpatialState.LocalPosition = ship.Position;
+            ship.SpatialState.SystemPosition = ship.Position;
+            if (ship.SpatialState.Transit is not null)
+            {
+                ship.SpatialState.CurrentCelestialId = null;
+                continue;
+            }
+
+            ship.SpatialState.SpaceLayer = SpaceLayerKinds.LocalSpace;
+            ship.SpatialState.MovementRegime = MovementRegimeKinds.LocalFlight;
+            var nearestCelestial = world.Celestials
+                .Where(candidate => candidate.SystemId == ship.SystemId)
+                .OrderBy(candidate => candidate.Position.DistanceTo(ship.Position))
+                .FirstOrDefault();
+            ship.SpatialState.CurrentCelestialId = nearestCelestial?.Id;
+
+            if (ship.DockedStationId is null)
+            {
+                continue;
+            }
+
+            var station = world.Stations.FirstOrDefault(candidate => candidate.Id == ship.DockedStationId);
+            if (station?.CelestialId is not null)
+            {
+                ship.SpatialState.CurrentCelestialId = station.CelestialId;
+            }
+        }
+    }
+
+    private readonly record struct LagrangePointPlacement(string Designation, Vector3 Position);
+}

apps/backend/Universe/Simulation/SimulationHostedService.cs

@@ -0,0 +1,19 @@
+namespace SpaceGame.Api.Universe.Simulation;
+
+public sealed class SimulationHostedService(WorldService worldService) : BackgroundService
+{
+  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+  {
+    using var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(200));
+    try
+    {
+      while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
+      {
+        worldService.Tick(0.2f);
+      }
+    }
+    catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+    {
+    }
+  }
+}

apps/backend/Universe/Simulation/WorldGenerationOptions.cs

@@ -0,0 +1,7 @@
+namespace SpaceGame.Api.Universe.Simulation;
+
+public sealed class WorldGenerationOptions
+{
+  public int TargetSystemCount { get; init; } = 160;
+
+}

apps/backend/Universe/Simulation/WorldService.cs

@@ -0,0 +1,275 @@
+using System.Threading.Channels;
+using Microsoft.Extensions.Options;
+
+namespace SpaceGame.Api.Universe.Simulation;
+
+public sealed class WorldService(
+  IWebHostEnvironment environment,
+  IOptions<WorldGenerationOptions> worldGenerationOptions,
+  IOptions<OrbitalSimulationOptions> orbitalSimulationOptions)
+{
+  private const int DeltaHistoryLimit = 256;
+
+  private readonly Lock _sync = new();
+  private readonly OrbitalSimulationSnapshot _orbitalSimulation = new(orbitalSimulationOptions.Value.SimulatedSecondsPerRealSecond);
+  private readonly ScenarioLoader _loader = new(environment.ContentRootPath, worldGenerationOptions.Value);
+  private readonly SimulationEngine _engine = new(orbitalSimulationOptions.Value);
+  private readonly Dictionary<Guid, SubscriptionState> _subscribers = [];
+  private readonly Queue<WorldDelta> _history = [];
+  private SimulationWorld _world = new ScenarioLoader(environment.ContentRootPath, worldGenerationOptions.Value).Load();
+  private long _sequence;
+
+  public WorldSnapshot GetSnapshot()
+  {
+    lock (_sync)
+    {
+      return _engine.BuildSnapshot(_world, _sequence);
+    }
+  }
+
+  public (long Sequence, DateTimeOffset GeneratedAtUtc) GetStatus()
+  {
+    lock (_sync)
+    {
+      return (_sequence, _world.GeneratedAtUtc);
+    }
+  }
+
+  public ChannelReader<WorldDelta> Subscribe(ObserverScope scope, long afterSequence, CancellationToken cancellationToken)
+  {
+    var channel = Channel.CreateUnbounded<WorldDelta>(new UnboundedChannelOptions
+    {
+      SingleReader = true,
+      SingleWriter = false,
+    });
+
+    Guid subscriberId;
+    lock (_sync)
+    {
+      subscriberId = Guid.NewGuid();
+      _subscribers.Add(subscriberId, new SubscriptionState(scope, channel));
+
+      foreach (var delta in _history.Where((candidate) => candidate.Sequence > afterSequence))
+      {
+        var filtered = FilterDeltaForScope(delta, scope);
+        if (HasMeaningfulDelta(filtered))
+        {
+          channel.Writer.TryWrite(filtered);
+        }
+      }
+    }
+
+    cancellationToken.Register(() => Unsubscribe(subscriberId));
+    return channel.Reader;
+  }
+
+  public void Tick(float deltaSeconds)
+  {
+    WorldDelta? delta = null;
+    lock (_sync)
+    {
+      delta = _engine.Tick(_world, deltaSeconds, ++_sequence);
+      if (!HasMeaningfulDelta(delta))
+      {
+        return;
+      }
+
+      _history.Enqueue(delta);
+      while (_history.Count > DeltaHistoryLimit)
+      {
+        _history.Dequeue();
+      }
+
+      foreach (var subscriber in _subscribers.Values.ToList())
+      {
+        var filtered = FilterDeltaForScope(delta, subscriber.Scope);
+        if (HasMeaningfulDelta(filtered))
+        {
+          subscriber.Channel.Writer.TryWrite(filtered);
+        }
+      }
+    }
+  }
+
+  public WorldSnapshot Reset()
+  {
+    lock (_sync)
+    {
+      _world = _loader.Load();
+      _sequence += 1;
+      _history.Clear();
+
+      var resetDelta = new WorldDelta(
+        _sequence,
+        _world.TickIntervalMs,
+        _world.OrbitalTimeSeconds,
+        _orbitalSimulation,
+        DateTimeOffset.UtcNow,
+        true,
+        [new SimulationEventRecord("world", "world", "reset", "World reset requested", DateTimeOffset.UtcNow, "world", "universe", "world")],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        []);
+
+      _history.Enqueue(resetDelta);
+      foreach (var subscriber in _subscribers.Values.ToList())
+      {
+        subscriber.Channel.Writer.TryWrite(FilterDeltaForScope(resetDelta, subscriber.Scope));
+      }
+
+      return _engine.BuildSnapshot(_world, _sequence);
+    }
+  }
+
+  private static bool HasMeaningfulDelta(WorldDelta delta) =>
+    delta.RequiresSnapshotRefresh
+    || delta.Events.Count > 0
+    || delta.Celestials.Count > 0
+    || delta.Nodes.Count > 0
+    || delta.Stations.Count > 0
+    || delta.Claims.Count > 0
+    || delta.ConstructionSites.Count > 0
+    || delta.MarketOrders.Count > 0
+    || delta.Policies.Count > 0
+    || delta.Ships.Count > 0
+    || delta.Factions.Count > 0;
+
+  private void Unsubscribe(Guid subscriberId)
+  {
+    lock (_sync)
+    {
+      if (!_subscribers.Remove(subscriberId, out var subscription))
+      {
+        return;
+      }
+
+      subscription.Channel.Writer.TryComplete();
+    }
+  }
+
+  private WorldDelta FilterDeltaForScope(WorldDelta delta, ObserverScope scope)
+  {
+    if (string.Equals(scope.ScopeKind, "universe", StringComparison.OrdinalIgnoreCase))
+    {
+      return delta with
+      {
+        Events = delta.Events.Select((evt) => EnrichEventScope(evt)).ToList(),
+        Scope = scope,
+      };
+    }
+
+    var systemFilter = scope.SystemId;
+    if (string.Equals(scope.ScopeKind, "local-celestial", StringComparison.OrdinalIgnoreCase) && systemFilter is null && scope.CelestialId is not null)
+    {
+      systemFilter = ResolveCelestialSystemId(scope.CelestialId);
+    }
+
+    return delta with
+    {
+      Events = delta.Events
+        .Select((evt) => EnrichEventScope(evt))
+        .Where((evt) => IsEventVisibleToScope(evt, scope, systemFilter))
+        .ToList(),
+      Celestials = delta.Celestials.Where((celestial) => systemFilter is null || celestial.SystemId == systemFilter).ToList(),
+      Nodes = delta.Nodes.Where((node) => systemFilter is null || node.SystemId == systemFilter).ToList(),
+      Stations = delta.Stations.Where((station) => systemFilter is null || station.SystemId == systemFilter).ToList(),
+      Claims = delta.Claims.Where((claim) => systemFilter is null || claim.SystemId == systemFilter).ToList(),
+      ConstructionSites = delta.ConstructionSites.Where((site) => systemFilter is null || site.SystemId == systemFilter).ToList(),
+      MarketOrders = delta.MarketOrders.Where((order) => IsOrderVisibleToScope(order, systemFilter)).ToList(),
+      Policies = string.Equals(scope.ScopeKind, "universe", StringComparison.OrdinalIgnoreCase) ? delta.Policies : [],
+      Ships = delta.Ships.Where((ship) => systemFilter is null || ship.SystemId == systemFilter).ToList(),
+      Factions = string.Equals(scope.ScopeKind, "universe", StringComparison.OrdinalIgnoreCase) ? delta.Factions : [],
+      Scope = scope,
+    };
+  }
+
+  private SimulationEventRecord EnrichEventScope(SimulationEventRecord evt)
+  {
+    if (!string.Equals(evt.ScopeKind, "universe", StringComparison.OrdinalIgnoreCase) || evt.ScopeEntityId is not null)
+    {
+      return evt;
+    }
+
+    return evt.EntityKind switch
+    {
+      "ship" => WithEntityScope(evt, "system", _world.Ships.FirstOrDefault((ship) => ship.Id == evt.EntityId)?.SystemId),
+      "station" => WithEntityScope(evt, "system", _world.Stations.FirstOrDefault((station) => station.Id == evt.EntityId)?.SystemId),
+      "node" => WithEntityScope(evt, "system", _world.Nodes.FirstOrDefault((node) => node.Id == evt.EntityId)?.SystemId),
+      "celestial" => WithEntityScope(evt, "system", _world.Celestials.FirstOrDefault((c) => c.Id == evt.EntityId)?.SystemId),
+      "claim" => WithEntityScope(evt, "system", _world.Claims.FirstOrDefault((claim) => claim.Id == evt.EntityId)?.SystemId),
+      "construction-site" => WithEntityScope(evt, "system", _world.ConstructionSites.FirstOrDefault((site) => site.Id == evt.EntityId)?.SystemId),
+      "market-order" => WithEntityScope(evt, "system", ResolveMarketOrderSystemId(evt.EntityId)),
+      _ => evt,
+    };
+  }
+
+  private static SimulationEventRecord WithEntityScope(SimulationEventRecord evt, string scopeKind, string? scopeEntityId) =>
+    evt with
+    {
+      Family = evt.Kind.Contains("power", StringComparison.Ordinal) ? "power" :
+        evt.Kind.Contains("construction", StringComparison.Ordinal) ? "construction" :
+        evt.Kind.Contains("population", StringComparison.Ordinal) ? "population" :
+        evt.Kind.Contains("claim", StringComparison.Ordinal) ? "claim" :
+        "simulation",
+      ScopeKind = scopeKind,
+      ScopeEntityId = scopeEntityId,
+    };
+
+  private string? ResolveCelestialSystemId(string celestialId) =>
+    _world.Celestials.FirstOrDefault((c) => c.Id == celestialId)?.SystemId;
+
+  private string? ResolveMarketOrderSystemId(string orderId)
+  {
+    var order = _world.MarketOrders.FirstOrDefault((candidate) => candidate.Id == orderId);
+    if (order?.StationId is not null)
+    {
+      return _world.Stations.FirstOrDefault((station) => station.Id == order.StationId)?.SystemId;
+    }
+
+    if (order?.ConstructionSiteId is not null)
+    {
+      return _world.ConstructionSites.FirstOrDefault((site) => site.Id == order.ConstructionSiteId)?.SystemId;
+    }
+
+    return null;
+  }
+
+  private bool IsOrderVisibleToScope(MarketOrderDelta order, string? systemFilter)
+  {
+    if (systemFilter is null)
+    {
+      return true;
+    }
+
+    if (order.StationId is not null)
+    {
+      return _world.Stations.Any((station) => station.Id == order.StationId && station.SystemId == systemFilter);
+    }
+
+    if (order.ConstructionSiteId is not null)
+    {
+      return _world.ConstructionSites.Any((site) => site.Id == order.ConstructionSiteId && site.SystemId == systemFilter);
+    }
+
+    return false;
+  }
+
+  private static bool IsEventVisibleToScope(SimulationEventRecord evt, ObserverScope scope, string? systemFilter)
+  {
+    return scope.ScopeKind switch
+    {
+      "universe" => true,
+      "system" => evt.ScopeKind == "universe" || evt.ScopeEntityId == systemFilter,
+      "local-celestial" => evt.ScopeKind == "universe" || evt.ScopeEntityId == systemFilter,
+      _ => true,
+    };
+  }
+
+  private sealed record SubscriptionState(ObserverScope Scope, Channel<WorldDelta> Channel);
+}