460 lines
19 KiB
C#
460 lines
19 KiB
C#
using static SpaceGame.Api.Universe.Scenario.LoaderSupport;
|
|
|
|
namespace SpaceGame.Api.Universe.Scenario;
|
|
|
|
public sealed class SpatialBuilder
|
|
{
|
|
internal static bool IsConstructibleAnchorKind(SpatialNodeKind kind) => kind is SpatialNodeKind.Planet or SpatialNodeKind.Moon or SpatialNodeKind.LagrangePoint;
|
|
|
|
internal static string? ResolveCompatibleCelestialId(AnchorRuntime? anchor) =>
|
|
anchor is not null && string.Equals(anchor.SourceEntityKind, "celestial", StringComparison.Ordinal)
|
|
? anchor.SourceEntityId
|
|
: null;
|
|
|
|
internal ScenarioSpatialLayout BuildLayout(IReadOnlyList<SystemRuntime> systems)
|
|
{
|
|
var systemGraphs = systems.ToDictionary(
|
|
system => system.Definition.Id,
|
|
BuildSystemSpatialGraph,
|
|
StringComparer.Ordinal);
|
|
var celestials = systemGraphs.Values.SelectMany(graph => graph.Celestials).ToList();
|
|
var anchors = celestials.Select(celestial => new AnchorRuntime
|
|
{
|
|
Id = celestial.Id,
|
|
SystemId = celestial.SystemId,
|
|
Kind = celestial.Kind,
|
|
Position = celestial.Position,
|
|
LocalSpaceRadius = celestial.LocalSpaceRadius,
|
|
ParentAnchorId = celestial.ParentAnchorId,
|
|
OrbitReferenceId = celestial.OrbitReferenceId,
|
|
OccupyingStructureId = celestial.OccupyingStructureId,
|
|
SourceEntityKind = "celestial",
|
|
SourceEntityId = celestial.Id,
|
|
}).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);
|
|
var nodeId = $"node-{++nodeIdCounter}";
|
|
var localPosition = ComputeResourceNodeLocalPosition(node);
|
|
var anchorPosition = anchorCelestial is null
|
|
? localPosition
|
|
: Add(anchorCelestial.Position, localPosition);
|
|
nodes.Add(new ResourceNodeRuntime
|
|
{
|
|
Id = nodeId,
|
|
AnchorId = nodeId,
|
|
SystemId = system.Definition.Id,
|
|
Position = localPosition,
|
|
SourceKind = node.SourceKind,
|
|
ItemId = node.ItemId,
|
|
LocalSpaceRadius = LocalSpaceRadius,
|
|
OrbitRadius = node.RadiusOffset,
|
|
OrbitPhase = node.Angle,
|
|
OrbitInclination = DegreesToRadians(node.InclinationDegrees),
|
|
OreRemaining = node.OreAmount,
|
|
MaxOre = node.OreAmount,
|
|
});
|
|
nodes[^1].Deposits.AddRange(BuildResourceDeposits(system.Definition.Id, nodeId, node, node.OreAmount));
|
|
|
|
anchors.Add(new AnchorRuntime
|
|
{
|
|
Id = nodeId,
|
|
SystemId = system.Definition.Id,
|
|
Kind = SpatialNodeKind.ResourceNode,
|
|
Position = anchorPosition,
|
|
LocalSpaceRadius = LocalSpaceRadius,
|
|
ParentAnchorId = anchorCelestial?.Id,
|
|
SourceEntityKind = "resource-node",
|
|
SourceEntityId = nodeId,
|
|
});
|
|
}
|
|
}
|
|
|
|
return new ScenarioSpatialLayout(systemGraphs, anchors, 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,
|
|
parentAnchorId: 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,
|
|
parentAnchorId: 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,
|
|
parentAnchorId: 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? parentAnchorId = null,
|
|
string? orbitReferenceId = null)
|
|
{
|
|
var celestial = new CelestialRuntime
|
|
{
|
|
Id = id,
|
|
SystemId = systemId,
|
|
Kind = kind,
|
|
Position = position,
|
|
LocalSpaceRadius = localSpaceRadius,
|
|
ParentAnchorId = parentAnchorId,
|
|
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<AnchorRuntime> existingAnchors)
|
|
{
|
|
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))
|
|
{
|
|
var lagrangeAnchor = existingAnchors.First(anchor => string.Equals(anchor.Id, lagrangeCelestial.Id, StringComparison.Ordinal));
|
|
return new StationPlacement(lagrangeAnchor, lagrangeCelestial, lagrangeAnchor.Position);
|
|
}
|
|
}
|
|
|
|
if (plan.Position is { Length: 3 })
|
|
{
|
|
var targetPosition = NormalizeScenarioPoint(system, plan.Position);
|
|
var preferredAnchor = existingAnchors
|
|
.Where(anchor => anchor.SystemId == system.Definition.Id && anchor.Kind == SpatialNodeKind.LagrangePoint)
|
|
.OrderBy(anchor => anchor.Position.DistanceTo(targetPosition))
|
|
.FirstOrDefault()
|
|
?? existingAnchors
|
|
.Where(anchor => anchor.SystemId == system.Definition.Id && IsConstructibleAnchorKind(anchor.Kind))
|
|
.OrderBy(anchor => anchor.Position.DistanceTo(targetPosition))
|
|
.First();
|
|
var preferredCelestial = graph.Celestials.FirstOrDefault(c => string.Equals(c.Id, ResolveCompatibleCelestialId(preferredAnchor), StringComparison.Ordinal));
|
|
return new StationPlacement(preferredAnchor, preferredCelestial, preferredAnchor.Position);
|
|
}
|
|
|
|
var fallbackAnchor = existingAnchors
|
|
.Where(anchor => anchor.SystemId == system.Definition.Id)
|
|
.FirstOrDefault(anchor => anchor.Kind == SpatialNodeKind.LagrangePoint && string.IsNullOrEmpty(anchor.OccupyingStructureId))
|
|
?? existingAnchors.First(anchor => anchor.SystemId == system.Definition.Id && anchor.Kind == SpatialNodeKind.Planet);
|
|
var fallbackCelestial = graph.Celestials.FirstOrDefault(c => string.Equals(c.Id, ResolveCompatibleCelestialId(fallbackAnchor), StringComparison.Ordinal));
|
|
return new StationPlacement(fallbackAnchor, fallbackCelestial, fallbackAnchor.Position);
|
|
}
|
|
|
|
private static string ResolveLagrangeDesignation(int? lagrangeSide) => lagrangeSide switch
|
|
{
|
|
< 0 => "L4",
|
|
> 0 => "L5",
|
|
_ => "L1",
|
|
};
|
|
|
|
private static CelestialRuntime? ResolveResourceNodeAnchor(SystemSpatialGraph graph, ResourceNodeDefinition definition)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(definition.AnchorReference))
|
|
{
|
|
var anchorId = definition.AnchorReference.ToLowerInvariant() switch
|
|
{
|
|
var reference when reference.StartsWith("star-", StringComparison.Ordinal)
|
|
=> $"node-{graph.SystemId}-{reference}",
|
|
var reference when reference.StartsWith("planet-", StringComparison.Ordinal)
|
|
=> $"node-{graph.SystemId}-{reference}",
|
|
_ => null,
|
|
};
|
|
|
|
if (anchorId is not null)
|
|
{
|
|
return graph.Celestials.FirstOrDefault(c => string.Equals(c.Id, anchorId, StringComparison.Ordinal));
|
|
}
|
|
}
|
|
|
|
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 ComputeResourceNodeLocalPosition(ResourceNodeDefinition definition)
|
|
{
|
|
var verticalOffset = MathF.Sin(DegreesToRadians(definition.InclinationDegrees)) * MathF.Min(definition.RadiusOffset * 0.04f, 25000f);
|
|
return new Vector3(
|
|
MathF.Cos(definition.Angle) * definition.RadiusOffset,
|
|
verticalOffset,
|
|
MathF.Sin(definition.Angle) * definition.RadiusOffset);
|
|
}
|
|
|
|
private static IReadOnlyList<ResourceDepositRuntime> BuildResourceDeposits(
|
|
string systemId,
|
|
string nodeId,
|
|
ResourceNodeDefinition definition,
|
|
float oreAmount)
|
|
{
|
|
var derivedDepositCount = Math.Clamp((int)MathF.Round(MathF.Sqrt(MathF.Max(oreAmount, 1f)) / 18f), 4, 18);
|
|
var depositCount = Math.Clamp(definition.ShardCount > 0 ? definition.ShardCount : derivedDepositCount, 4, 48);
|
|
var deposits = new List<ResourceDepositRuntime>(depositCount);
|
|
var weightTotal = 0f;
|
|
var weights = new float[depositCount];
|
|
var random = new Random(ComputeDeterministicSeed(systemId, nodeId, "resource-deposits"));
|
|
for (var index = 0; index < depositCount; index += 1)
|
|
{
|
|
var weight = 0.8f + (NextFloat01(random) * 1.6f);
|
|
weights[index] = weight;
|
|
weightTotal += weight;
|
|
}
|
|
|
|
// Resource node localspace should read as a compact mineable field around the node core,
|
|
// not as sparse debris spread across the entire anchor volume.
|
|
var scatterRadius = MathF.Max(120f, MathF.Min(LocalSpaceRadius * 0.2f, 900f));
|
|
for (var index = 0; index < depositCount; index += 1)
|
|
{
|
|
var angle = NextFloat01(random) * MathF.PI * 2f;
|
|
var radiusFactor = 0.12f + (NextFloat01(random) * 0.82f);
|
|
var radius = scatterRadius * MathF.Sqrt(radiusFactor);
|
|
var vertical = (NextFloat01(random) - 0.5f) * MathF.Max(40f, scatterRadius * 0.18f);
|
|
var localPosition = new Vector3(
|
|
MathF.Cos(angle) * radius,
|
|
vertical,
|
|
MathF.Sin(angle) * radius);
|
|
var maxOre = oreAmount * (weights[index] / MathF.Max(weightTotal, 0.001f));
|
|
deposits.Add(new ResourceDepositRuntime
|
|
{
|
|
Id = $"{nodeId}-deposit-{index + 1}",
|
|
NodeId = nodeId,
|
|
AnchorId = nodeId,
|
|
Position = localPosition,
|
|
OreRemaining = maxOre,
|
|
MaxOre = maxOre,
|
|
});
|
|
}
|
|
|
|
return deposits;
|
|
}
|
|
|
|
private static int ComputeDeterministicSeed(string systemId, string nodeId, string salt)
|
|
{
|
|
unchecked
|
|
{
|
|
var hash = 17;
|
|
foreach (var character in systemId)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
foreach (var character in nodeId)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
foreach (var character in salt)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
}
|
|
|
|
private static float NextFloat01(Random random) => (float)random.NextDouble();
|
|
|
|
private static float Hash01(string systemId, string nodeId, string salt)
|
|
{
|
|
unchecked
|
|
{
|
|
var hash = 17;
|
|
foreach (var character in systemId)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
foreach (var character in nodeId)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
foreach (var character in salt)
|
|
{
|
|
hash = (hash * 31) + character;
|
|
}
|
|
|
|
return (hash & 0x7fffffff) / (float)int.MaxValue;
|
|
}
|
|
}
|
|
|
|
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<AnchorRuntime> anchors)
|
|
{
|
|
var systemPosition = SimulationUnits.MetersToKilometers(position);
|
|
var nearestAnchor = anchors
|
|
.Where(anchor => anchor.SystemId == systemId)
|
|
.OrderBy(anchor => anchor.Position.DistanceTo(systemPosition))
|
|
.FirstOrDefault();
|
|
var localPosition = position;
|
|
var resolvedSystemPosition = nearestAnchor is null
|
|
? systemPosition
|
|
: Add(nearestAnchor.Position, SimulationUnits.MetersToKilometers(localPosition));
|
|
|
|
return new ShipSpatialStateRuntime
|
|
{
|
|
CurrentSystemId = systemId,
|
|
SpaceLayer = SpaceLayerKind.LocalSpace,
|
|
CurrentAnchorId = nearestAnchor?.Id,
|
|
LocalPosition = localPosition,
|
|
SystemPosition = resolvedSystemPosition,
|
|
MovementRegime = MovementRegimeKind.LocalFlight,
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed record ScenarioSpatialLayout(
|
|
IReadOnlyDictionary<string, SystemSpatialGraph> SystemGraphs,
|
|
List<AnchorRuntime> Anchors,
|
|
List<CelestialRuntime> Celestials,
|
|
List<ResourceNodeRuntime> Nodes);
|
|
|
|
public 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(AnchorRuntime Anchor, CelestialRuntime? Celestial, Vector3 Position);
|