Merge eureka/aetheria-gravity-children-within-reach (children-within-reach, head cf242106)

Merged into master f937662d. No textual conflicts (auto-merged: ActionGameManager.cs,
Belt.cs, LockOn.cs, RunStartTests.cs, ScenarioTests.cs, AetherDb/Program.cs).
GameData/Aetheria.cc untouched by the merge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-10-17 11:52:44 +02:00
commit 6fe7f7cecb
19 changed files with 1041 additions and 218 deletions

BIN
Assets/Resources/Settings.asset (Stored with Git LFS)

Binary file not shown.

View file

@ -722,6 +722,7 @@ public class ActionGameManager : MonoBehaviour
galaxyZone.PackedContents ??= ZoneGenerator.GenerateZone(
ItemManager,
Settings.ZoneSettings,
Settings.PlanetSettings,
CurrentGalaxy,
galaxyZone,
CurrentGalaxy.IsPrelude
@ -845,7 +846,7 @@ public class ActionGameManager : MonoBehaviour
{
staged = RunSave.Replace(CultCache, () =>
{
RunStart.GenerateArena(ItemManager, Settings.ZoneSettings, CurrentGalaxy, scenario);
RunStart.GenerateArena(ItemManager, Settings.ZoneSettings, Settings.PlanetSettings, CurrentGalaxy, scenario);
PopulateLevel(CurrentGalaxy.Entrance);
return RunStart.Stage(ItemManager, Zone, scenario, Settings.StartingHullName, Settings.TutorialGenerationSettings, failures);
});

View file

@ -23,11 +23,11 @@ public static class RunStart
return scenario.Generate(stage) ?? throw new InvalidOperationException($"Scenario {scenario.Name} generated no galaxy.");
}
public static ZonePack GenerateArena(ItemManager itemManager, ZoneGenerationSettings zoneSettings, Galaxy galaxy, Scenario scenario)
public static ZonePack GenerateArena(ItemManager itemManager, ZoneGenerationSettings zoneSettings, PlanetSettings planetSettings, Galaxy galaxy, Scenario scenario)
{
SeedItems(itemManager, galaxy, 1);
return galaxy.Entrance.PackedContents = ZoneGenerator.GenerateZone(
itemManager, zoneSettings, galaxy, galaxy.Entrance, galaxy.IsPrelude, scenario.Ambient);
itemManager, zoneSettings, planetSettings, galaxy, galaxy.Entrance, galaxy.IsPrelude, scenario.Ambient);
}
// Runs the scenario's Stage, then admits its player and everything it placed: each entity's stance set both ways

View file

@ -10,9 +10,10 @@ public sealed class Belt : Scenario
"across the belt without a hitch; Previous with nothing targeted takes the farthest rock; the target indicator " +
"sits on the rock it names.";
// Seeds 1-256 scanned for the arena whose entrance zone holds the belt with the most asteroids: seed 24, a belt of
// 615 rocks. The next four: 179 (553), 251 (548), 221 (532), 29 (515).
public override uint Seed => 24;
// Seeds 1-90 scanned for the arena whose entrance zone holds the belt with the most asteroids once the generator
// placed belts by their parent's window (children-within-reach): seed 86, a belt of 484 rocks. The next four:
// 55 (478), 83 (402), 64 (383), 63 (323). 37 of the 90 arenas hold no belt.
public override uint Seed => 86;
public override bool Ambient => false;
public override Galaxy Generate(GalaxyStage stage) => stage.Prelude(DemoTerminus.Cast);

View file

@ -7,7 +7,7 @@ public sealed class LockOn : Scenario
public override string Brief => "A hostile closes from out of sight, finds you and locks. Verify: no warning at first; once it locks, one " +
"indicator appears toward it and tightens as the lock grows; break line of sight or range and it vanishes; " +
"your own ping shows no incoming paint on its side, only the lock does.";
public override uint Seed => 113;
public override uint Seed => 1;
public override bool Ambient => false;
// The hostile starts about 4000 m off, ahead and to port of the player, facing the player. At that range its passive

View file

@ -111,7 +111,6 @@ public class TutorialGenerationSettings
[Serializable, MessagePackObject(keyAsPropertyName:true), JsonObject]
public class ZoneGenerationSettings
{
public ExponentialCurve PlanetSafetyRadius;
public float MassFloor = 1;
public float SunMass = 10000;

View file

@ -257,19 +257,29 @@ public sealed class WellTree
}
}
// A root's reach. The one place the subzone shape is decided (question multi-root-zone-shape): a sole massive root is the
// whole zone (+inf, so its global term is the far field); with several, isolated-subzones bounds each root to Reach x the
// distance to the nearest other massive root, or its floor (Beta x support) if more. The superposed-inside option
// (Beta x max(pack radius, max over massive roots of |anchor - Centre| + support)) is not a change to this return: it needs
// every massive root's support, and roots are processed one at a time here, so it would take a second pass over the roots
// once their supports exist.
// A root's reach: the floor (Beta x support) or the subzone reach, whichever is more. The subzone shape is decided in the
// public static SubzoneReach (multi-root-isolated-subzones): the generator calls the same function, so Reach x the nearest
// root's distance is spelled once and the roots' windows are fitted to it (root-window-floor).
private float SubzoneReach(int root, float floor)
{
if (_massiveRoots.Length < 2) return float.PositiveInfinity;
var anchors = new List<float2>();
foreach (var other in _massiveRoots) anchors.Add(_anchor[other]);
return Math.Max(SubzoneReach(anchors, Array.IndexOf(_massiveRoots, root)), floor);
}
/// <summary>
/// A subzone root's reach among the zone's massive roots' anchors: a sole massive root is the whole zone (+inf, so its
/// global term is the far field); with several, each root is bounded to GravityField.Reach x the distance to the nearest
/// other root (multi-root-isolated-subzones). The superposed-inside option is not a change to this return: it needs every
/// root's support, and roots are processed one at a time.
/// </summary>
public static float SubzoneReach(IReadOnlyList<float2> anchors, int root)
{
if (anchors.Count < 2) return float.PositiveInfinity;
var nearest = float.PositiveInfinity;
foreach (var other in _massiveRoots)
if (other != root) nearest = Math.Min(nearest, length(_anchor[other] - _anchor[root]));
return Math.Max(GravityField.Reach * nearest, floor);
for (var other = 0; other < anchors.Count; other++)
if (other != root) nearest = Math.Min(nearest, length(anchors[other] - anchors[root]));
return GravityField.Reach * nearest;
}
private void EmitTerms(int[] parent, float[] body, float[] family, int[][] ring, float[] lower, RingGroup[] group,
@ -395,8 +405,7 @@ public sealed class WellTree
/// <summary>
/// The pull (toward the node, u/s^2) a rail at `distance` round `parentOrbit` is given: the node's own terms at that
/// distance. A ring member of a bodyless node adds each other member's own terms at their chord (positions at t = 0),
/// projected toward the node; a strengthless orbit on that ring (a station, a turret) takes the mean of what the ring's
/// members feel, so it keeps their period. Infinite period for a pull of 0 is the caller's.
/// projected toward the node. Infinite period for a pull of 0 is the caller's.
/// </summary>
public float PullAround(CultRecordKey parentOrbit, float distance, CultRecordKey self)
{
@ -405,12 +414,7 @@ public sealed class WellTree
var members = _ring[node];
if (members == null || members.Length < 2) return pull;
if (_index.TryGetValue(self, out var me) && Array.IndexOf(members, me) >= 0) return pull + PartnersPull(members, me);
var inner = float.PositiveInfinity;
foreach (var m in members) inner = Math.Min(inner, _distance[m]);
if (Math.Abs(distance - inner) > RingWindow) return pull;
var mean = 0f;
foreach (var m in members) mean += PartnersPull(members, m) / members.Length;
return pull + mean;
return pull;
}
// What the other members of a ring pull member m with, along the direction from m to the node.

View file

@ -40,6 +40,7 @@ public static class ZoneGenerator
public static ZonePack GenerateZone(
ItemManager itemManager,
ZoneGenerationSettings zoneSettings,
PlanetSettings planetSettings,
Galaxy galaxy,
GalaxyZone galaxyZone,
bool isTutorial = false,
@ -88,13 +89,17 @@ public static class ZoneGenerator
}
var totalArea = occupiedAreas.Sum(c => c.Area);
foreach (var c in occupiedAreas)
// Every area root is massive, so a root's reach is Reach x its nearest area's centre (WellTree.SubzoneReach)
var centres = occupiedAreas.Select(c => c.Center).ToList();
for (var k = 0; k < occupiedAreas.Count; k++)
{
planets.AddRange(GenerateEntities(zoneSettings, ref random, c.Area / totalArea * pack.Mass, c.Radius, c.Center));
var c = occupiedAreas[k];
planets.AddRange(GenerateEntities(zoneSettings, planetSettings, ref random, c.Area / totalArea * pack.Mass, c.Radius, c.Center,
WellTree.SubzoneReach(centres, k)));
}
}
else
planets.AddRange(GenerateEntities(zoneSettings, ref random, pack.Mass, pack.Radius, float2.zero));
planets.AddRange(GenerateEntities(zoneSettings, planetSettings, ref random, pack.Mass, pack.Radius, float2.zero, float.PositiveInfinity));
// Every orbit is a record; parents link to records, so each orbit holds its key before any child names it
var orbitMap = new Dictionary<GeneratorPlanet, OrbitData>();
@ -147,7 +152,7 @@ public static class ZoneGenerator
Enumerable.Range(0, (int) zoneSettings.AsteroidCount.Evaluate(beltData.Mass * orbitMap[planet].Distance))
.Select(_ => new Asteroid
{
Distance = orbitMap[planet].Distance + random.NextFloat()*(random.NextFloat()-.5f)*zoneSettings.AsteroidBeltWidth.Evaluate(orbitMap[planet].Distance),
Distance = orbitMap[planet].Distance + random.NextFloat()*(random.NextFloat()-.5f)*2*planet.BeltHalfWidth,
Phase = random.NextFloat(),
Size = random.NextFloat(),
RotationSpeed = zoneSettings.AsteroidRotationSpeed.Evaluate(random.NextFloat())
@ -209,6 +214,20 @@ public static class ZoneGenerator
return cache.Upsert(planetData);
}).ToList();
// The generator's own well tree, for clearance only (the Zone builds its own): what a rail must stay out of is the body's
// support, or its Roche margin if more.
var wellNodes = planets.Select(p => new WellNode(cache.RefOf(orbitMap[p]).Key, p.Parent == null ? default : cache.RefOf(orbitMap[p.Parent]).Key,
p.Distance, p.Phase, p.Empty || p.Belt ? 0f : p.Mass,
p.Belt ? p.Distance + p.BeltHalfWidth : p.Distance, p.FixedPosition)).ToList();
var wells = WellTree.Build(wellNodes, planetSettings, pack.Radius);
float Extent(GeneratorPlanet p)
{
var key = cache.RefOf(orbitMap[p]).Key;
var roche = p.Empty || p.Belt ? 0f : WellTree.Curves(planetSettings, p.Mass).Softening * RocheMargin;
return Math.Max(wells.Support(key), roche);
}
bool Massive(GeneratorPlanet p) => wells.Reach(cache.RefOf(orbitMap[p]).Key) > 0f;
var nearestFaction = galaxy.Factions.MinBy(f => galaxy.HomeZones[f].Distance[galaxyZone]);
var nearestFactionHomeZone = galaxy.HomeZones[nearestFaction];
var factionPresence = galaxy.InfluenceOf(nearestFaction) - nearestFactionHomeZone.Distance[galaxyZone] + 1;
@ -224,30 +243,39 @@ public static class ZoneGenerator
// seed. galaxy.Entrance is reference-identity, not a name comparison.
var isTutorialEntrance = isTutorial && galaxyZone == galaxy.Entrance;
if (isTutorialEntrance && stationCount < 1) stationCount = 1;
var potentialLagrangePoints = planets
.Where(p => p.Parent != null && p.Parent.Children
.TrueForAll(c => !(c != p && abs(c.Distance - p.Distance) < .1f))) // Filter Rosettes
// A station's source is a well-bearing body alone on its ring whose rail clears every massive sibling's extent (the
// sibling's support, or its Roche margin if more) and the largest reach of any station or turret hull: whatever hull
// is built there, its Lagrange orbit then sits clear of any other body.
var cellSize = itemManager.GameplaySettings.SchematicCellSize;
var largestReach = cache.GetAll<HullData>().Where(h => h.HullType == HullType.Station || h.HullType == HullType.Turret)
.Select(h => h.Reach(cellSize)).DefaultIfEmpty(0f).Max();
var candidates = planets
.Where(p => p.Parent != null && !p.Empty && !p.Belt
&& p.Parent.Children.TrueForAll(c => c == p || (abs(c.Distance - p.Distance) >= WellTree.RingWindow
&& (!Massive(c) || abs(c.Distance - p.Distance) > Extent(c) + largestReach))))
.OrderBy(p => p.Distance)
.ToArray();
// The entrance's own station count is the floor above; its orbit always comes from this same selection.
// Ordinarily that selection is potentialLagrangePoints (non-rosette planet orbits). If the entrance zone
// has none of those (a boring single-body system, or a system that is entirely one rosette), widen to
// every planet orbit ordinary placement's own candidate pool is drawn from before the rosette filter --
// still a real, parented planet orbit with a positive Distance -- rather than inventing an unparented,
// zero-distance orbit (that gave PlaceTurret's phase = 20*multiplier/orbit.Distance a division by zero,
// and left an orbit record with no planet behind it).
var lagrangeCandidates = potentialLagrangePoints;
if (isTutorialEntrance && lagrangeCandidates.Length == 0)
lagrangeCandidates = planets.Where(p => p.Parent != null).OrderBy(p => p.Distance).ToArray();
// Pick a selection from the middle of the distribution
var selectedStationOrbits = lagrangeCandidates
.Skip(lagrangeCandidates.Length / 2)
.Take(stationCount)
.Select(p=>orbitMap[p])
.ToArray();
if (isTutorialEntrance && lagrangeCandidates.Length == 0)
throw new InvalidOperationException(
"The tutorial entrance zone must always get a station, but it has no candidate orbit at all -- every planet in the zone is a parentless root.");
// (the rail, how far a body on it keeps others out, whether it is a station's own orbit rather than a base's)
var sources = candidates.Skip(candidates.Length / 2).Take(stationCount)
.Select(p => (orbit: orbitMap[p], extent: Extent(p), direct: false)).ToArray();
if (isTutorialEntrance && candidates.Length == 0)
{
// The entrance gets a station whatever its bodies: it orbits a root node beyond its ring group (or, for a body, its
// whole family), never at a ring member's distance, and sits there, not at a Lagrange point.
var roots = planets.Where(p => p.Parent == null).ToList();
var rootNode = roots.FirstOrDefault(p => p.Children.Count > 0) ?? (roots.Count > 1 ? roots.OrderByDescending(p => p.Mass).First() : null);
if (rootNode == null)
throw new InvalidOperationException(
"The tutorial entrance zone must always get a station, but it has no candidate orbit at all -- every planet in the zone is a parentless root.");
var distance = rootNode.Empty
? (1 + GravityField.RingReach) * GravityField.Beta * rootNode.Children.Where(Massive).Min(c => c.Distance)
: Extent(rootNode);
var direct = new OrbitData { Parent = cache.RefOf(orbitMap[rootNode]), Distance = distance, Phase = random.NextFloat() };
pack.Orbits.Add(cache.Upsert(direct));
sources = new[] { (orbit: direct, extent: float.NegativeInfinity, direct: true) };
}
var selectedStationOrbits = sources.Select(x => x.orbit).ToArray();
var extentOf = sources.ToDictionary(x => x.orbit, x => x.extent);
var loadoutGenerators = new Dictionary<Faction, LoadoutGenerator>();
@ -261,6 +289,7 @@ public static class ZoneGenerator
// L4 or L5: 60 degrees (one sixth of a turn) ahead of or behind the planet on its orbit. Phase is in turns.
OrbitData CreateLagrangeOrbit(OrbitData baseOrbit)
{
if (sources.First(x => x.orbit == baseOrbit).direct) return baseOrbit;
var lagrangeOrbit = new OrbitData
{
Parent = baseOrbit.Parent,
@ -276,36 +305,48 @@ public static class ZoneGenerator
// body's. Every body's reach counts, so turrets of differing reach clear each other. Phase is in turns, so the
// arc length divides by the orbit's circumference. Returns where the turret sits (signed arc from the station)
// and its reach, or null when there is no turret hull to generate, before any orbit is created.
(float arc, float reach)? PlaceTurret(OrbitData orbit, LoadoutGenerator loadoutGenerator, float side, float innerArc, float innerReach)
(float arc, float reach, bool placed)? PlaceTurret(OrbitData orbit, LoadoutGenerator loadoutGenerator, float side, float innerArc, float innerReach,
OrbitData baseOrbit)
{
var turret = loadoutGenerator.GenerateTurretLoadout();
if (turret == null) return null;
var turretReach = (itemManager.GetData(turret.Hull) as HullData).Reach(itemManager.GameplaySettings.SchematicCellSize);
var arc = innerArc + side * (innerReach + 2 * turretReach);
// A turret whose centre is within the base body's extent plus its own reach of the base is not placed: its side stops.
var phase = orbit.Phase + arc / (2 * PI * orbit.Distance);
if (2 * orbit.Distance * abs(sin(PI * (phase - baseOrbit.Phase))) < extentOf[baseOrbit] + turretReach)
{
itemManager.Log("A turret was not placed: its station's base body is within its reach (story-turret-tail-clearance).");
return (arc, turretReach, false);
}
var turretOrbit = new OrbitData
{
Parent = orbit.Parent,
Distance = orbit.Distance,
Phase = orbit.Phase + arc / (2 * PI * orbit.Distance)
Phase = phase
};
pack.Orbits.Add(cache.Upsert(turretOrbit));
turret.Orbit = cache.RefOf(turretOrbit);
pack.Entities.Add(turret);
return (arc, turretReach);
return (arc, turretReach, true);
}
// Turrets flank the station alternately, behind then ahead, each side growing outward from the station.
void PlaceTurrets(OrbitData orbit, LoadoutGenerator loadoutGenerator, int count, float stationReach)
void PlaceTurrets(OrbitData orbit, LoadoutGenerator loadoutGenerator, int count, float stationReach, OrbitData baseOrbit)
{
var arcs = new float[2];
var stopped = new bool[2];
var reaches = new[] { stationReach, stationReach };
for(int t=0; t<count; t++)
{
var side = t % 2;
var placed = PlaceTurret(orbit, loadoutGenerator, side == 0 ? -1f : 1f, arcs[side], reaches[side]);
if (placed == null) return;
(arcs[side], reaches[side]) = placed.Value;
if (stopped[side]) continue;
var placed = PlaceTurret(orbit, loadoutGenerator, side == 0 ? -1f : 1f, arcs[side], reaches[side], baseOrbit);
if (placed == null) return;
if (!placed.Value.placed) { stopped[side] = true; continue; }
(arcs[side], reaches[side]) = (placed.Value.arc, placed.Value.reach);
}
}
@ -315,6 +356,7 @@ public static class ZoneGenerator
for (var i = 0; i < storyStations.Length; i++)
{
var story = storyStations[i];
if (i >= selectedStationOrbits.Length) { itemManager.Log($"Story station for {story.Faction?.Name} has no rail clear of the bodies; its story has nowhere to live!"); continue; }
var orbit = selectedStationOrbits[i];
var lagrangeOrbit = CreateLagrangeOrbit(orbit);
var station = GetLoadoutGenerator(story.Faction).GenerateStationLoadout();
@ -329,7 +371,7 @@ public static class ZoneGenerator
station.Story = i;
pack.Entities.Add(station);
if (ambient) PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(story.Faction), story.Turrets, StationReach(station));
if (ambient) PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(story.Faction), story.Turrets, StationReach(station), orbit);
}
for (var i = storyStations.Length; i < selectedStationOrbits.Length; i++)
@ -351,7 +393,7 @@ public static class ZoneGenerator
station.SecurityRadius = pack.Radius;
pack.Entities.Add(station);
if (ambient) PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(nearestFaction), 2, StationReach(station));
if (ambient) PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(nearestFaction), 2, StationReach(station), orbit);
}
// A boss zone gets its faction's boss whether or not the zone is ambient: the boss is the run's goal, not
@ -413,16 +455,15 @@ public static class ZoneGenerator
// 1 / lerp(settings.ResourceDensityMinimum, settings.ResourceDensityMaximum, density));
// }
public static GeneratorPlanet[] GenerateEntities(ZoneGenerationSettings settings, ref Random random, float mass, float radius, float2 fixedPosition)
public static GeneratorPlanet[] GenerateEntities(ZoneGenerationSettings settings, PlanetSettings planetSettings, ref Random random, float mass, float radius, float2 fixedPosition,
float rootReach)
{
var root = new GeneratorPlanet
{
FixedPosition = fixedPosition,
Settings = settings,
Mass = mass,
ChildDistanceMaximum = radius * .75f,
ChildDistanceMinimum = settings.PlanetSafetyRadius.Evaluate(mass)
};
Mass = mass
};
// There is some chance of generating a rosette or binary system
// Probabilities which are fixed for the entire galaxy are in GlobalData, contained in the GameContext
@ -439,8 +480,6 @@ public static class ZoneGenerator
count: (int)(random.NextFloat(1, 3) * random.NextFloat(1, 2)),
massMulMin: .6f,
massMulMax: .8f,
distMulMin: 1.25f,
distMulMax: 1.75f,
jupiterJump: 1,
massFraction: .1f);
@ -454,8 +493,6 @@ public static class ZoneGenerator
count: (int) (random.NextFloat(1, 3 * m) + random.NextFloat(1, 3 * m)),
massMulMin: 0.75f,
massMulMax: 2.5f,
distMulMin: 1 + m * .25f,
distMulMax: 1.05f + m * .5f,
jupiterJump: random.NextFloat() * random.NextFloat() * 10 + 1,
massFraction: .5f
);
@ -469,8 +506,6 @@ public static class ZoneGenerator
count: random.NextInt(5, 15),
massMulMin: 0.75f,
massMulMax: 2.5f,
distMulMin: 1.1f,
distMulMax: 1.25f,
jupiterJump: random.NextFloat() * random.NextFloat() * 10 + 1,
massFraction: .25f
);
@ -511,8 +546,6 @@ public static class ZoneGenerator
count: planet.Mass < settings.GasGiantMass ? random.NextInt(1, 3) : random.NextInt(2, 6),
massMulMin: .75f,
massMulMax: 1.5f,
distMulMin: 1.05f,
distMulMax: 1.25f,
jupiterJump: 1,
massFraction: .15f); // Planetary satellites are not nearly as massive as planets themselves
}
@ -535,8 +568,131 @@ public static class ZoneGenerator
foreach (var planet in root.AllPlanets())
planet.Mass = (planet.Mass / totalMass) * rootMass;
Place(root, planetSettings, radius, rootReach);
return root.AllPlanets().ToArray();
}
// Placement (tail-taming-law-r3-band-loose-cusp, c4-proceed-and-fly): a child sits at least RocheMargin of its parent's Roche
// limits out; a massive child of a body also far enough that its own pull peak beats CuspMargin times its parent's pull there;
// siblings sit SiblingSpacing of a reach apart. Every other number is a GravityField constant.
public const float RocheMargin = 1.5f;
public const float CuspMargin = 1.5f;
public const float SiblingSpacing = .5f;
/// <summary>
/// The one placement pass: gives every generated node its distance and every belt its half width, top-down. A body's children
/// are laid inside-out at the nearest the rules allow, the lightest family is folded into the parent (its mass kept) while the
/// outermost overflows the window, and the rest are stretched geometrically so the outermost sits at the window's edge. A
/// non-root's window ends before its own fade (Gamma x Reach x its distance); a root's, in a zone of several, ends under
/// rootReach / Beta so its support never meets another root's (root-window-floor), and is 0.75 x the area radius at most.
/// A rosette's ring is one orbit; it folds into its node, which becomes a body, if it cannot keep the heavy member outside
/// its Roche margin. Ported from docs/research/gravity-well-law/replace.py.
/// </summary>
public static void Place(GeneratorPlanet root, PlanetSettings planetSettings, float radius, float rootReach)
{
var q = 1 / (1 - SiblingSpacing * GravityField.Reach);
float Roche(float mass) => WellTree.Curves(planetSettings, mass).Softening;
float Strength(float mass) => WellTree.Curves(planetSettings, mass).Strength;
float WellMass(GeneratorPlanet p) => p.Empty || p.Belt ? 0f : p.Mass;
float Family(GeneratorPlanet p) => (p.Empty ? 0f : p.Mass) + p.Children.Sum(c => Family(c));
void Fold(GeneratorPlanet node, GeneratorPlanet into)
{
into.Mass += Family(node);
node.Parent.Children.Remove(node);
}
void PlaceChildren(List<GeneratorPlanet> children, Func<float> lower, float upper, GeneratorPlanet into)
{
upper *= 1 - 1e-6f;
float AtLeast(GeneratorPlanet child, float edge)
{
// A bodyless node stands in for one body of its family's mass, which it becomes if its ring cannot stand
var m = child.Empty ? Family(child) : WellMass(child);
var mInto = WellMass(into);
return m <= 0 || mInto <= 0 ? edge : Math.Max(edge, 2 * CuspMargin * Roche(m) * Strength(mInto) / Strength(m));
}
var lo = 0f;
var positions = new List<float>();
while (children.Count > 0)
{
lo = lower();
positions.Clear();
for (var k = 0; k < children.Count; k++)
positions.Add(AtLeast(children[k], k == 0 ? lo : Math.Max(lo, positions[k - 1] * q)));
if (positions[positions.Count - 1] <= upper) break;
var lightest = children.OrderBy(c => Family(c)).First();
Fold(lightest, into);
children.Remove(lightest);
}
if (children.Count == 0) return;
var g = children.Count > 1 ? pow(upper / positions[positions.Count - 1], 1f / (children.Count - 1)) : 1f;
for (var k = 0; k < children.Count; k++)
children[k].Distance = positions[k] * pow(g, k);
// A belt is an interval inside its slot: inner edge outside the lower bound and the previous sibling's spacing, outer edge
// inside the next sibling's spacing and the window; the authored width is the widest it may be.
var outer = 0f;
for (var k = 0; k < children.Count; k++)
{
var c = children[k];
if (!c.Belt) { outer = c.Distance; continue; }
var inner = Math.Max(lo, outer * q);
var outerLimit = k + 1 < children.Count ? Math.Min(upper, children[k + 1].Distance / q) : upper;
c.Distance = (inner + outerLimit) / 2;
var half = Math.Max(0f, Math.Min(c.Settings.AsteroidBeltWidth.Evaluate(c.Distance), outerLimit - inner) / 2);
c.BeltHalfWidth = half;
outer = c.Distance + half;
}
}
var chordCap = new Dictionary<GeneratorPlanet, float>(); // a ring member's children stay within .2 of the nearest partner's chord
void Settle(GeneratorPlanet node)
{
var isRoot = node.Parent == null;
var reach = isRoot ? rootReach : GravityField.Reach * node.Distance;
var share = isRoot ? 1 / GravityField.Beta : GravityField.Gamma;
var cap = isRoot ? .75f * radius : float.PositiveInfinity;
var upper = Math.Min(cap, share * reach / Math.Max(GravityField.Beta, 1 + GravityField.Reach));
if (chordCap.TryGetValue(node, out var chord)) upper = Math.Min(upper, chord);
if (WellMass(node) > 0)
{
PlaceChildren(node.Children.ToList(), () => RocheMargin * Roche(WellMass(node)), upper, node);
return;
}
var ring = node.Children.Where(c => c.Ring && WellMass(c) > 0).ToList();
if (ring.Count == 0) return;
var heavy = ring.OrderByDescending(c => c.Mass).First();
var ringDistance = Math.Min(.5f * cap, share * reach / (GravityField.Beta * GravityField.Beta * (1 + GravityField.RingReach)));
PlaceChildren(node.Children.Where(c => !ring.Contains(c)).ToList(),
() => (1 + GravityField.RingReach) * ringDistance * GravityField.Beta, upper, heavy);
// The heavy member's mass is final only now (the outer children fold into it).
if (ringDistance < RocheMargin * Roche(heavy.Mass))
{
// The pair cannot keep its heavy member outside its Roche margin inside its node's reach: the node is one body.
node.Empty = false;
node.Mass = 0;
foreach (var child in node.Children.ToList()) Fold(child, node);
return;
}
foreach (var member in ring)
{
member.Distance = ringDistance;
chordCap[member] = .2f * 2 * ringDistance * sin(PI / ring.Count);
}
}
var queue = new Queue<GeneratorPlanet>();
queue.Enqueue(root);
while (queue.Count > 0)
{
var node = queue.Dequeue();
Settle(node);
foreach (var child in node.Children) queue.Enqueue(child);
}
}
}
// All orbiting bodies are referred to here as "Planets"
@ -548,10 +704,13 @@ public class GeneratorPlanet
public float Distance;
public float Phase;
public float Mass;
public float ChildDistanceMinimum;
public float ChildDistanceMaximum;
// A belt's half width, written by ZoneGenerator.Place: the belt fills the slot between its siblings' spacing, the parent's
// Roche margin and the parent's window, up to the authored width (ruling belt-fills-its-slot).
public float BeltHalfWidth;
public bool Empty = false;
public bool Belt = false;
// A member of a rosette's ring, which Place puts on one orbit round its bodyless parent.
public bool Ring = false;
public List<GeneratorPlanet> Children = new List<GeneratorPlanet>(); // Planets orbiting this one are referred to as children
public GeneratorPlanet Parent;
public float2 FixedPosition;
@ -562,12 +721,10 @@ public class GeneratorPlanet
return new[]{this}.Concat(Children.SelectMany(c=>c.AllPlanets()));
}
// Create children that fill a single orbit, equally spaced
// Create children that fill a single orbit, equally spaced; Place sets the orbit's radius
// https://en.wikipedia.org/wiki/Klemperer_rosette
public void ExpandRosette(ref Random random, int vertices)
{
//Debug.Log("Expanding Rosette");
// Rosette children replace the parent, parent orbital node is left empty
Empty = true;
@ -577,60 +734,37 @@ public class GeneratorPlanet
// Proportion of the masses of sequential pairs is random, but only for even vertex counts
var proportion = vertices % 2 == 0 ? random.NextFloat(.5f,.95f) : .5f;
// Place children at a fixed distance in the center of the range
var dist = (ChildDistanceMinimum + ChildDistanceMaximum) / 2;
// Position of first child
var p0 = new float2(0, dist);
// Position of second child
var p1 = OrbitData.Evaluate(1.0f / vertices) * dist;
// Maximum child distance is half the distance to the neighbor minus the neighbor's radius
var p0ChildDist = (distance(p0, p1) * proportion - Settings.PlanetSafetyRadius.Evaluate(sharedMass * (1 - proportion))) * .75f;
var p1ChildDist = (distance(p0, p1) * (1 - proportion) - Settings.PlanetSafetyRadius.Evaluate(sharedMass * proportion)) * .75f;
for (int i = 0; i < vertices; i++)
{
var child = new GeneratorPlanet
Children.Add(new GeneratorPlanet
{
Settings = Settings,
Parent = this,
Mass = sharedMass * (i % 2 == 0 ? proportion : 1 - proportion), // Masses alternate
Distance = dist,
Phase = (float) i / vertices,
ChildDistanceMaximum = (i % 2 == 0 ? p0ChildDist : p1ChildDist)
};
child.ChildDistanceMinimum = Settings.PlanetSafetyRadius.Evaluate(child.Mass) * 2;
Children.Add(child);
Ring = true
});
}
ChildDistanceMinimum = dist + p0ChildDist;
}
// Create children that mimic the distribution of planetary masses in the solar system
public void ExpandSolar(ref Random random, int count, float massMulMin, float massMulMax, float distMulMin, float distMulMax, float jupiterJump, float massFraction)
// Create children that mimic the distribution of planetary masses in the solar system, inside-out in list order;
// Place gives them their distances
public void ExpandSolar(ref Random random, int count, float massMulMin, float massMulMax, float jupiterJump, float massFraction)
{
//Debug.Log("Expanding Solar");
// Expansion is impossible when child space is full
if (count == 0 || ChildDistanceMaximum < ChildDistanceMinimum)
if (count == 0)
return;
var masses = new float[count];
var distances = new float[count];
// Accumulate total mass
// Initialize first mass and distance, actual number doesn't matter since total mass will be divided proportionally
float massTotal = distances[0] = masses[0] = 1;
// Initialize first mass, actual number doesn't matter since total mass will be divided proportionally
float massTotal = masses[0] = 1;
// Masses and distances multiply from one planet to the next
// Masses multiply from one planet to the next
// Mass typically increases exponentially as you go further out
// jupiterJump is an additional mass multiplier applied after half of the planets
for (var i = 1; i < count; i++)
{
massTotal += masses[i] = masses[i - 1] * random.NextFloat(massMulMin, massMulMax) * (count/2==i ? jupiterJump : 1);
distances[i] = distances[i - 1] * random.NextFloat(distMulMin, distMulMax);
}
// Add some randomness to child masses
for (var i = 0; i < masses.Length; i++)
@ -640,37 +774,17 @@ public class GeneratorPlanet
for (var i = 0; i < count; i++)
masses[i] = masses[i] / massTotal * Mass * massFraction;
// Map child distances to range between minimum and maximum
if (count > 1)
{
var oldDistances = (float[]) distances.Clone();
for (var i = 0; i < count; i++)
distances[i] = lerp(ChildDistanceMinimum, ChildDistanceMaximum,
(oldDistances[i] - oldDistances[0]) / (oldDistances[count - 1] - oldDistances[0])) + Settings.PlanetSafetyRadius.Evaluate(masses[i]);
}
for (var i = 0; i < count; i++)
{
// Only instantiate children above the mass floor
if (masses[i] > Settings.MassFloor)
{
var child = new GeneratorPlanet
Children.Add(new GeneratorPlanet
{
Settings = Settings,
Parent = this,
Mass = masses[i],
Distance = distances[i],
Phase = random.NextFloat()
};
child.ChildDistanceMinimum = Settings.PlanetSafetyRadius.Evaluate(child.Mass) * 2;
// Maximum child distance of child is the smallest distance to either of its neighbors
child.ChildDistanceMaximum = min(i == 0 ? child.Distance - ChildDistanceMinimum : child.Distance - distances[i - 1],
i < count - 1 ? distances[i + 1] - child.Distance : float.PositiveInfinity);
if (float.IsNaN(child.Distance))
throw new NotFiniteNumberException($"Planet created with NaN distance, something went very wrong!");
if (child.ChildDistanceMaximum > child.ChildDistanceMinimum)
Children.Add(child);
}
});
}
}
}

View file

@ -7,9 +7,9 @@ using static CultMath.math;
// mining-merge-on-agent-proof). The test launches the scenario the way New Game does and reads what it staged.
public sealed partial class RunStartTests
{
// The scan behind Belt's seed: seeds 1-256 of the demo cast's arena, no ambient traffic, the most asteroids in one belt
// per seed. Seed 24 holds 615; seed 1 holds 299.
private const int ScannedBeltAsteroids = 615;
// The scan behind Belt's seed: seeds 1-90 of the demo cast's arena, no ambient traffic, the most asteroids in one belt
// per seed. Seed 86 holds 484.
private const int ScannedBeltAsteroids = 484;
// Belt: the arena carries a belt of at least the scanned asteroid count, nothing else flies in it, the player stands
// 100 m outside the ring on the side nearest the origin and faces along it, and the player's sensors see rocks within

View file

@ -0,0 +1,505 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CultMath;
using GameCult.Caching;
using Xunit;
using Xunit.Abstractions;
using static CultMath.math;
using float2 = CultMath.float2;
// Aetheria gravity, children within reach: the production generator's zones (every zone of seeds 1-6, ambient off) read back
// through the Zone's own tree, orbits and bodies. Each expectation is spelled from the rule it names and the law's constants
// (GravityField), never from ZoneGenerator.Place's helpers.
public sealed class ChildrenWithinReachTests : IClassFixture<ChildrenWithinReachTests.Zones>
{
public sealed class Zones : IDisposable
{
private readonly ZoneWorlds _worlds = new ZoneWorlds();
public readonly List<(uint Seed, Zone Zone)> All = new List<(uint, Zone)>();
public ZoneGenerationSettings Settings;
public Zones() : this(1, 6, null) { }
// Not public: xunit builds the fixture through its one public constructor; a test that wants a tuned sample builds its own.
internal Zones(uint first, uint last, Action<ZoneGenerationSettings> tune)
{
for (uint seed = first; seed <= last; seed++)
{
var dir = Path.Combine(_worlds.Root, $"galaxy{seed}");
Directory.CreateDirectory(dir);
var catalog = Path.Combine(dir, "Aetheria.cc");
File.Copy(TestCatalog.Repo, catalog);
var cache = new CultCache(TestCatalog.Registry());
_worlds.Caches.Add(cache);
cache.AddBackingStore(new GameCult.Caching.MessagePack.SingleFileMessagePackBackingStore(catalog), AetheriaStores.CatalogTypes);
cache.AddBackingStore(new GameCult.Caching.MessagePack.SingleFileMessagePackBackingStore(Path.Combine(dir, "run.cc")), AetheriaStores.RunTypes);
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot());
var galaxy = new Galaxy(authored.Read<TutorialGenerationSettings>("TutorialGenerationSettings"),
authored.Read<SectorBackgroundSettings>("TutorialBackgroundSettings"),
authored.Read<NameGeneratorSettings>("NameGeneratorSettings"), cache, new PlayerSettings(),
Directory.CreateDirectory(Path.Combine(dir, "Narrative")), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), authored.Read<GameplaySettings>("GameplaySettings"), _ => { });
var planetSettings = authored.Read<PlanetSettings>("PlanetSettings");
foreach (var galaxyZone in galaxy.Zones)
{
Settings = authored.Read<ZoneGenerationSettings>("ZoneSettings");
tune?.Invoke(Settings);
var pack = ZoneGenerator.GenerateZone(items, Settings, planetSettings, galaxy, galaxyZone,
galaxyZone == galaxy.Entrance && galaxy.IsPrelude, false);
All.Add((seed, new Zone(items, planetSettings, pack, galaxyZone, galaxy)));
}
}
}
public void Dispose() => _worlds.Dispose();
}
private readonly Zones _zones;
private readonly ITestOutputHelper _out;
public ChildrenWithinReachTests(Zones zones, ITestOutputHelper output)
{
_zones = zones;
_out = output;
}
private const float Tolerance = 1e-3f;
// A child's own family folded into it after it was placed raises its mass, and the cusp bound grows as mass^.05.
private const float CuspTolerance = 1e-2f;
private const float RocheMargin = 1.5f, CuspMargin = 1.5f; // the rulings tail-taming-law-r3-band-loose-cusp and c4-proceed-and-fly
private static float Roche(Zone zone, float mass) => zone.Settings.RocheLimit.Evaluate(mass);
private static float Strength(Zone zone, float mass) => zone.Settings.WellStrength.Evaluate(mass);
// Orbits that carry a well-bearing body, with its mass; belts and bodyless nodes carry none.
private static Dictionary<CultRecordKey, float> BodyMass(Zone zone) =>
zone.Planets.Values.Where(b => !(b is AsteroidBeltData)).GroupBy(b => b.Orbit.Key).ToDictionary(g => g.Key, g => g.First().Mass);
// The generated orbits: every body's and its ancestors', which leaves out stations, turrets and Lagrange copies.
private static HashSet<CultRecordKey> Placed(Zone zone)
{
var placed = new HashSet<CultRecordKey>();
foreach (var body in zone.Planets.Values)
for (var key = body.Orbit.Key; placed.Add(key) && zone.Orbits[key].Data.Parent.IsSet();) key = zone.Orbits[key].Data.Parent.Key;
return placed;
}
private static List<CultRecordKey> ChildrenOf(Zone zone, CultRecordKey parent, HashSet<CultRecordKey> placed) =>
placed.Where(k => zone.Orbits[k].Data.Parent.IsSet() && zone.Orbits[k].Data.Parent.Key.Equals(parent))
.OrderBy(k => zone.Orbits[k].Data.Distance).ToList();
private static float DistanceOf(Zone zone, CultRecordKey orbit) => zone.Orbits[orbit].Data.Distance;
private static List<CultRecordKey> MassiveRoots(Zone zone) =>
zone.Orbits.Keys.Where(k => !zone.Orbits[k].Data.Parent.IsSet() && zone.Wells.Reach(k) > 0f).ToList();
private static float2 Anchor(Zone zone, CultRecordKey root) => zone.Orbits[root].Data.FixedPosition;
private static IEnumerable<CultRecordKey> Descendants(Zone zone, CultRecordKey root, HashSet<CultRecordKey> placed)
{
foreach (var child in ChildrenOf(zone, root, placed))
{
yield return child;
foreach (var below in Descendants(zone, child, placed)) yield return below;
}
}
[Fact]
public void SubzonesAreIsolated()
{
var zonesChecked = 0;
var pairs = 0;
var violatingPairs = 0;
var orbits = 0;
var violatingOrbits = 0;
foreach (var (seed, zone) in _zones.All)
{
var roots = MassiveRoots(zone);
if (roots.Count < 2) continue;
zonesChecked++;
var placed = Placed(zone);
foreach (var i in roots)
{
var nearest = roots.Where(j => !j.Equals(i)).Min(j => length(Anchor(zone, i) - Anchor(zone, j)));
Assert.True(Math.Abs(zone.Wells.Reach(i) - GravityField.Reach * nearest) <= Tolerance * nearest,
$"seed {seed}: a root's reach {zone.Wells.Reach(i)} is not Reach x the nearest root's distance {nearest} (its floor binds)");
foreach (var j in roots.Where(j => !j.Equals(i)))
{
pairs++;
if (zone.Wells.Reach(i) + zone.Wells.Support(j) > length(Anchor(zone, i) - Anchor(zone, j)) * (1 + Tolerance)) violatingPairs++;
foreach (var orbit in Descendants(zone, i, placed))
{
orbits++;
if (length(zone.OrbitPositionAt(orbit, 0) - Anchor(zone, j)) < zone.Wells.Reach(j) * (1 - Tolerance)) violatingOrbits++;
}
}
}
}
_out.WriteLine($"subzones isolated: {zonesChecked} multi-root zones, {pairs} ordered root pairs ({violatingPairs} with reach_i + support_j > d), " +
$"{orbits} orbit-vs-root checks ({violatingOrbits} inside another root's reach)");
Assert.True(zonesChecked > 0 && pairs > 0 && orbits > 0, "the seeds generated no zone with two massive roots");
Assert.True(violatingPairs == 0, $"{violatingPairs} of {pairs} ordered root pairs overlap");
Assert.True(violatingOrbits == 0, $"{violatingOrbits} of {orbits} orbits sit inside another root's reach");
}
[Fact]
public void NoChildSitsInsideItsParentsRocheMargin()
{
var children = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
foreach (var parent in placed.Where(mass.ContainsKey))
foreach (var child in ChildrenOf(zone, parent, placed))
{
children++;
var margin = RocheMargin * Roche(zone, mass[parent]);
Assert.True(DistanceOf(zone, child) >= margin * (1 - Tolerance), $"seed {seed}: a child sits at {DistanceOf(zone, child)}, inside {margin}");
}
}
Assert.True(children > 100, $"only {children} children checked");
}
[Fact]
public void EveryMassiveChildKeepsACusp()
{
var checkedChildren = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
foreach (var parent in placed.Where(mass.ContainsKey))
foreach (var child in ChildrenOf(zone, parent, placed).Where(mass.ContainsKey))
{
checkedChildren++;
var cusp = 2 * CuspMargin * Roche(zone, mass[child]) * Strength(zone, mass[parent]) / Strength(zone, mass[child]);
Assert.True(DistanceOf(zone, child) >= cusp * (1 - CuspTolerance), $"seed {seed}: a massive child sits at {DistanceOf(zone, child)}, inside its cusp bound {cusp}");
}
}
Assert.True(checkedChildren > 50, $"only {checkedChildren} massive children checked");
}
[Fact]
public void AFamilyEndsBeforeItsParentsFade()
{
var families = 0;
foreach (var (seed, zone) in _zones.All)
{
var placed = Placed(zone);
var mass = BodyMass(zone);
foreach (var node in placed.Where(k => zone.Orbits[k].Data.Parent.IsSet() && zone.Wells.Reach(k) > 0f))
{
var kids = ChildrenOf(zone, node, placed);
if (!kids.Any(k => zone.Wells.Reach(k) > 0f)) continue;
families++;
Assert.True(zone.Wells.Support(node) <= GravityField.Gamma * zone.Wells.Reach(node) * (1 + Tolerance),
$"seed {seed}: a family's support {zone.Wells.Support(node)} runs past Gamma x its reach {zone.Wells.Reach(node)}");
var parent = zone.Orbits[node].Data.Parent.Key;
if (mass.ContainsKey(parent)) // a ring member's reach is RingReach x D; a body's child's is Reach x D
Assert.True(Math.Abs(zone.Wells.Reach(node) - GravityField.Reach * DistanceOf(zone, node)) <= Tolerance * DistanceOf(zone, node),
$"seed {seed}: a family's reach {zone.Wells.Reach(node)} is not Reach x its distance {DistanceOf(zone, node)}");
}
}
Assert.True(families > 20, $"only {families} families checked");
}
[Fact]
public void SiblingsSitHalfAReachApart()
{
var q = 1 / (1 - GravityField.Reach / 2);
var pairs = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
foreach (var parent in placed.Where(mass.ContainsKey))
{
var kids = ChildrenOf(zone, parent, placed);
for (var k = 1; k < kids.Count; k++)
{
pairs++;
Assert.True(DistanceOf(zone, kids[k]) >= DistanceOf(zone, kids[k - 1]) * q * (1 - Tolerance),
$"seed {seed}: siblings at {DistanceOf(zone, kids[k - 1])} and {DistanceOf(zone, kids[k])} are closer than a factor {q}");
}
}
}
Assert.True(pairs > 100, $"only {pairs} sibling pairs checked");
}
// The same random stream makes the same tree; only the window differs, so a small one (tight) folds some of what a huge one
// (wide) keeps whole. No rosette or binary: a bodyless node's own mass is renormalised with the rest.
private static IEnumerable<(uint Seed, GeneratorPlanet[] Tight, GeneratorPlanet[] Wide)> TightAndWideTrees(float mass)
{
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot());
var zoneSettings = authored.Read<ZoneGenerationSettings>("ZoneSettings");
var planetSettings = authored.Read<PlanetSettings>("PlanetSettings");
zoneSettings.RosetteProbability = 0;
zoneSettings.BinaryCreationProbability = 0;
for (uint seed = 1; seed <= 200; seed++)
{
var tight = new CultMath.Random(seed);
var tightTree = ZoneGenerator.GenerateEntities(zoneSettings, planetSettings, ref tight, mass, 1500f, float2.zero, float.PositiveInfinity);
var wide = new CultMath.Random(seed);
var wideTree = ZoneGenerator.GenerateEntities(zoneSettings, planetSettings, ref wide, mass, 1e7f, float2.zero, float.PositiveInfinity);
yield return (seed, tightTree, wideTree);
}
}
// Folding moves a family's mass into its parent body, so a tree's masses still sum to its root's.
[Fact]
public void FoldingConservesMass()
{
const float mass = 300000f;
var folded = 0;
foreach (var (seed, tight, wide) in TightAndWideTrees(mass))
{
if (tight.Length < wide.Length) folded++;
Assert.True(Math.Abs(tight.Sum(p => p.Mass) - mass) <= 1e-3f * mass, $"seed {seed}: a folded tree's bodies sum to {tight.Sum(p => p.Mass)}, not {mass}");
}
_out.WriteLine($"folding: {folded} of 200 trees with a fold");
Assert.True(folded > 10, $"only {folded} trees folded");
}
// Under one parent the families folded away are never heavier than the ones kept (rule 4: the lightest goes first).
[Fact]
public void FoldingTakesTheLightestFamily()
{
float Family(GeneratorPlanet p) => p.Mass + p.Children.Sum(Family);
var parentsThatFolded = 0;
foreach (var (seed, tight, wide) in TightAndWideTrees(300000f))
{
var tightByPhase = tight.ToDictionary(p => p.Phase);
void Compare(GeneratorPlanet w)
{
if (w.Children.Count == 0 || !tightByPhase.TryGetValue(w.Phase, out var t)) return;
var keptPhases = t.Children.Select(c => c.Phase).ToHashSet();
var kept = w.Children.Where(c => keptPhases.Contains(c.Phase)).ToList();
var gone = w.Children.Where(c => !keptPhases.Contains(c.Phase)).ToList();
if (gone.Count > 0 && kept.Count > 0)
{
parentsThatFolded++;
Assert.True(gone.Max(Family) <= kept.Min(Family) * (1 + 1e-4f), $"seed {seed}: a folded family outweighs one that was kept");
}
foreach (var child in kept) Compare(child);
}
Compare(wide[0]);
}
Assert.True(parentsThatFolded > 10, $"only {parentsThatFolded} parents folded part of their children");
}
[Fact]
public void RingsKeepTheirMembersApartAndCircumbinaryChildrenFar()
{
var rings = 0;
var outer = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
foreach (var node in placed.Where(k => !mass.ContainsKey(k) && !zone.Planets.Values.Any(b => b.Orbit.Key.Equals(k))))
{
var kids = ChildrenOf(zone, node, placed);
var members = kids.Where(mass.ContainsKey).ToList();
if (members.Count < 2) continue;
var ring = members.Where(k => DistanceOf(zone, k) - DistanceOf(zone, members[0]) <= WellTree.RingWindow).ToList();
if (ring.Count < 2) continue;
rings++;
var radius = DistanceOf(zone, ring[0]);
var heavy = ring.Max(k => mass[k]);
Assert.True(radius >= RocheMargin * Roche(zone, heavy) * (1 - Tolerance),
$"seed {seed}: a ring of radius {radius} sits inside its heavy member's Roche margin");
foreach (var far in kids.Where(k => !ring.Contains(k)))
{
outer++;
Assert.True(DistanceOf(zone, far) >= (1 + GravityField.RingReach) * GravityField.Beta * radius * (1 - Tolerance),
$"seed {seed}: a circumbinary child at {DistanceOf(zone, far)} is inside the ring group of radius {radius}");
}
}
}
Assert.True(rings > 3, $"only {rings} rings checked");
_out.WriteLine($"rings {rings}, circumbinary children {outer}");
}
[Fact]
public void BeltsKeepTheirEdges()
{
var belts = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
foreach (var (beltKey, belt) in zone.AsteroidBelts)
{
belts++;
var orbit = zone.Planets[beltKey].Orbit.Key;
var parent = zone.Orbits[orbit].Data.Parent.Key;
var inner = belt.Data.Asteroids.Min(a => a.Distance);
var outermost = belt.Data.Asteroids.Max(a => a.Distance);
Assert.True(inner > 0f, $"seed {seed}: an asteroid sits at {inner}");
if (mass.TryGetValue(parent, out var m))
Assert.True(inner >= RocheMargin * Roche(zone, m) * (1 - Tolerance), $"seed {seed}: a belt's inner edge {inner} is inside its parent's Roche margin");
// The belt keeps clear of its neighbours' rails by a sibling spacing (rule 3), inner and outer.
var sibling = ChildrenOf(zone, parent, Placed(zone));
var at = sibling.IndexOf(orbit);
if (at > 0)
Assert.True(inner >= DistanceOf(zone, sibling[at - 1]) * (1 / (1 - GravityField.Reach / 2)) * (1 - Tolerance), $"seed {seed}: a belt reaches in to {inner}, within a spacing of its inner neighbour");
if (at < sibling.Count - 1)
Assert.True(outermost <= DistanceOf(zone, sibling[at + 1]) * (1 - GravityField.Reach / 2) * (1 + Tolerance), $"seed {seed}: a belt reaches out to {outermost}, within a spacing of its outer neighbour");
if (zone.Orbits[parent].Data.Parent.IsSet())
Assert.True(outermost <= GravityField.Gamma * GravityField.Reach * DistanceOf(zone, parent) / Math.Max(GravityField.Beta, 1 + GravityField.Reach) * (1 + Tolerance),
$"seed {seed}: a belt reaches {outermost}, past its parent's window");
}
}
Assert.True(belts > 20, $"only {belts} belts checked");
}
private static float Percentile(List<float> sorted, float fraction) => sorted[Math.Min(sorted.Count - 1, (int) (fraction * sorted.Count))];
// A belt fills the slot between its neighbours' spacing, its parent's Roche margin and the parent's window, up to the
// authored width (ruling belt-fills-its-slot): it sits at the slot's midpoint where the test can spell both edges, and
// none collapses to a line (finding belts-collapse-to-a-line). Rocks are scattered inside the belt's half width, so their
// spread is at most the belt's width; a belt beside another belt has an edge only the generator knows, and is checked
// against the weaker bound.
[Fact]
public void BeltsFillTheirSlots()
{
var q = 1 / (1 - GravityField.Reach / 2);
var ratios = new List<float>();
int belts = 0, bounded = 0, midpoints = 0, lines = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
var beltAt = zone.AsteroidBelts.ToDictionary(b => zone.Planets[b.Key].Orbit.Key, b => b.Value.Data.Asteroids);
foreach (var (orbit, rocks) in beltAt)
{
var parent = zone.Orbits[orbit].Data.Parent.Key;
if (rocks.Length == 0 || !mass.TryGetValue(parent, out var parentMass)) continue;
belts++;
var sibling = ChildrenOf(zone, parent, placed);
var at = sibling.IndexOf(orbit);
var d = DistanceOf(zone, orbit);
var spread = rocks.Max(a => a.Distance) - rocks.Min(a => a.Distance);
var width = _zones.Settings.AsteroidBeltWidth.Evaluate(d);
ratios.Add(spread / width);
if (spread < 1e-3f) lines++;
var prevIsBelt = at > 0 && beltAt.ContainsKey(sibling[at - 1]);
var nextIsBelt = at < sibling.Count - 1 && beltAt.ContainsKey(sibling[at + 1]);
var prevEdge = at == 0 ? 0f : prevIsBelt && beltAt[sibling[at - 1]].Length > 0 ? beltAt[sibling[at - 1]].Max(a => a.Distance) : DistanceOf(zone, sibling[at - 1]);
var inner = Math.Max(RocheMargin * Roche(zone, parentMass), prevEdge * q);
var grand = zone.Orbits[parent].Data.Parent;
var window = grand.IsSet() ? GravityField.Gamma * GravityField.Reach * DistanceOf(zone, parent) / Math.Max(GravityField.Beta, 1 + GravityField.Reach) : float.PositiveInfinity;
var next = at < sibling.Count - 1 && !nextIsBelt ? DistanceOf(zone, sibling[at + 1]) / q : float.PositiveInfinity;
var outerLimit = Math.Min(window, next);
if (!nextIsBelt) bounded++;
Assert.True(spread <= Math.Min(width, outerLimit - inner) * (1 + Tolerance),
$"seed {seed}: a belt spreads {spread} in a slot of {outerLimit - inner} and an authored width of {width}");
// Past the last sibling a root's window is its own to spell, and a ring member's child is held by a chord as well.
var upperKnown = at < sibling.Count - 1 || (grand.IsSet() && mass.ContainsKey(grand.Key));
if (prevIsBelt || nextIsBelt || !upperKnown) continue;
midpoints++;
Assert.True(Math.Abs(d - (inner + outerLimit) / 2) <= Tolerance * d,
$"seed {seed}: a belt at {d} is not the midpoint {(inner + outerLimit) / 2} of its slot [{inner}, {outerLimit}]");
}
}
ratios.Sort();
_out.WriteLine($"belts {belts}, with a slot bound {bounded}, midpoints checked {midpoints}, rock spread under 0.001: {lines}; " +
$"spread / authored width at p10/25/50/75/90/max: {string.Join(" / ", new[] { .1f, .25f, .5f, .75f, .9f }.Select(f => Percentile(ratios, f).ToString("F3")))} / {ratios[ratios.Count - 1]:F3}");
Assert.True(belts > 20 && bounded > 0 && midpoints > 0, $"{belts} belts, {bounded} bounded, {midpoints} midpoints: the seeds do not exercise the rule");
Assert.True(lines == 0, $"{lines} of {belts} belts have no radial width");
}
// With the authored width narrower than the slot the width is the ceiling and the belt keeps it: neither wider (W/2 -> W, a
// deleted cap) nor reduced to the slot.
[Fact]
public void ANarrowAuthoredBeltKeepsItsWidth()
{
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot()).Read<ZoneGenerationSettings>("ZoneSettings").AsteroidBeltWidth;
using var narrow = new Zones(1, 3, z => z.AsteroidBeltWidth = new ExponentialCurve
{ Exponent = authored.Exponent, Multiplier = authored.Multiplier * .02f, Constant = authored.Constant * .02f });
int belts = 0, filled = 0;
foreach (var (seed, zone) in narrow.All)
foreach (var (key, belt) in zone.AsteroidBelts)
{
var rocks = belt.Data.Asteroids;
if (rocks.Length < 2) continue;
var width = narrow.Settings.AsteroidBeltWidth.Evaluate(DistanceOf(zone, zone.Planets[key].Orbit.Key));
var spread = rocks.Max(a => a.Distance) - rocks.Min(a => a.Distance);
belts++;
Assert.True(spread <= width * (1 + Tolerance), $"seed {seed}: a belt spreads {spread}, past its authored width {width}");
if (spread >= .5f * width) filled++;
}
_out.WriteLine($"narrow belts {belts}, spreading at least half the authored width {filled}");
Assert.True(filled >= 10, $"only {filled} of {belts} belts fill the authored width");
}
private static GeneratorPlanet Body(GeneratorPlanet parent, float mass, float phase = 0, bool ring = false)
{
var node = new GeneratorPlanet { Parent = parent, Mass = mass, Phase = phase, Ring = ring };
parent.Children.Add(node);
return node;
}
private static PlanetSettings AuthoredPlanetSettings() => AuthoredSettings.Load(RunStartTests.FindRepoRoot()).Read<PlanetSettings>("PlanetSettings");
// A rosette's ring round a root with no reach limit of its own sits at half the root's 0.75 x radius window, 3/8 of the radius.
[Fact]
public void ASoleRootRingSitsAtThreeEighthsOfItsRadius()
{
const float radius = 1e6f;
var root = new GeneratorPlanet { Empty = true };
var members = new[] { Body(root, 100f, 0, true), Body(root, 100f, .5f, true) };
ZoneGenerator.Place(root, AuthoredPlanetSettings(), radius, float.PositiveInfinity);
Assert.True(root.Empty && root.Children.Count == 2, "the ring folded into its node");
foreach (var member in members)
Assert.True(Math.Abs(member.Distance - .375f * radius) <= 1e-4f * radius, $"a ring member sits at {member.Distance}, not {.375f * radius}");
}
// A ring member's children end within a fifth of the chord to the member's nearest partner, where the chord, not the member's
// fade, is what holds them.
[Fact]
public void ARingMembersChildrenStayWithinAFifthOfTheChord()
{
const float radius = 1e6f;
const int count = 12;
var root = new GeneratorPlanet { Empty = true };
var members = Enumerable.Range(0, count).Select(i => Body(root, 100f, (float) i / count, true)).ToList();
foreach (var member in members) { Body(member, 10f); Body(member, 10f); }
ZoneGenerator.Place(root, AuthoredPlanetSettings(), radius, float.PositiveInfinity);
foreach (var member in members)
{
Assert.True(root.Children.Count == count && member.Children.Count == 2, "a ring member or its children folded");
var chord = .2f * 2 * member.Distance * (float) Math.Sin(Math.PI / count);
var fade = GravityField.Gamma * GravityField.Reach * member.Distance / Math.Max(GravityField.Beta, 1 + GravityField.Reach);
Assert.True(chord < fade, "the fade, not the chord, would hold these children");
var outermost = member.Children.Max(c => c.Distance);
Assert.True(Math.Abs(outermost - chord) <= 1e-4f * chord, $"a ring member's outermost child sits at {outermost}, not at the chord's fifth {chord}");
}
}
[Fact]
public void NoStrengthlessOrbitRidesARing()
{
var rings = 0;
foreach (var (seed, zone) in _zones.All)
{
var mass = BodyMass(zone);
var placed = Placed(zone);
foreach (var node in placed.Where(k => !mass.ContainsKey(k) && !zone.Planets.Values.Any(b => b.Orbit.Key.Equals(k))))
{
var members = ChildrenOf(zone, node, placed).Where(mass.ContainsKey).ToList();
if (members.Count < 2) continue;
rings++;
var radius = DistanceOf(zone, members[0]);
// Every orbit of the zone, stations and turrets included, that hangs on the node and carries no body.
foreach (var orbit in zone.Orbits.Keys.Where(k => zone.Orbits[k].Data.Parent.IsSet() && zone.Orbits[k].Data.Parent.Key.Equals(node) && !mass.ContainsKey(k)))
Assert.True(DistanceOf(zone, orbit) >= (1 + GravityField.RingReach) * radius * (1 - Tolerance),
$"seed {seed}: a strengthless orbit at {DistanceOf(zone, orbit)} rides the ring group of radius {radius}");
}
}
Assert.True(rings > 3, $"only {rings} rings checked");
}
}

View file

@ -820,7 +820,7 @@ public sealed partial class MiningCut3Tests : IDisposable
var items = new ItemManager(cache, new ProvenanceLedger(), GameSettings(), _ => { });
foreach (var zone in galaxy.Zones.Take(4))
{
var pack = ZoneGenerator.GenerateZone(items, RestoredHullsTests.TutorialZoneSettings(), galaxy, zone, isTutorial: zone == galaxy.Entrance);
var pack = ZoneGenerator.GenerateZone(items, RestoredHullsTests.TutorialZoneSettings(), RestoredHullsTests.AuthoredPlanetSettings(), galaxy, zone, isTutorial: zone == galaxy.Entrance);
foreach (var body in pack.Planets)
{
if (!(cache.Get(body) is AsteroidBeltData belt)) continue;

View file

@ -150,41 +150,6 @@ public sealed class OrbitsFromFieldTests : IDisposable
Assert.Equal(zone.Orbits[planet2].Period, zone.Orbits[companion2].Period);
}
// A station on a binary's ring, with nothing inside, feels what the pair's members feel (the mean of what each does),
// and so does one a hair off the ring's distance but within its window.
[Theory]
[InlineData(0f)]
[InlineData(.05f)]
[InlineData(-.05f)]
public void ACompanionOnABinarysRingTakesTheMembersPeriod(float offset)
{
var w = NewWorld();
var node = w.Orbit(default, 0f);
var light = w.Orbit(node, 400f, 0f);
var heavy = w.Orbit(node, 400f, .5f);
var lightBody = w.Body(light, 100f);
var heavyBody = w.Body(heavy, 2000f);
var companion = w.Orbit(node, 400f + offset, .25f);
var zone = w.Build();
Assert.True(C(zone, heavyBody) > 1.5f * C(zone, lightBody), "fixture: unequal members");
AssertPeriod(PeriodUnder((Pull(zone, lightBody, 800f) + Pull(zone, heavyBody, 800f)) / 2, 400f + offset), zone.Orbits[companion].Period,
"the companion, between its two members");
// An equal pair: the companion has the members' period.
w = NewWorld();
node = w.Orbit(default, 0f);
var a = w.Orbit(node, 400f, 0f);
var b = w.Orbit(node, 400f, .5f);
w.Body(a, 300f);
w.Body(b, 300f);
companion = w.Orbit(node, 400f, .25f);
zone = w.Build();
Assert.True(float.IsFinite(zone.Orbits[a].Period));
AssertPeriod(zone.Orbits[a].Period, zone.Orbits[companion].Period, "the companion, against the first member");
AssertPeriod(zone.Orbits[b].Period, zone.Orbits[companion].Period, "the companion, against the second member");
}
// The ring is the 0.1 u window about the innermost massive distance: a member just inside it is a ring partner (felt at
// the chord), one just outside it is not a partner and the rail has the node's own terms alone, which give a
// ring's own member next to no pull.
@ -291,7 +256,7 @@ public sealed class OrbitsFromFieldTests : IDisposable
authored.Read<NameGeneratorSettings>("NameGeneratorSettings"), cache, new PlayerSettings(),
Directory.CreateDirectory(Path.Combine(dir, "Narrative")), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), authored.Read<GameplaySettings>("GameplaySettings"), _ => { });
var pack = ZoneGenerator.GenerateZone(items, authored.Read<ZoneGenerationSettings>("ZoneSettings"), galaxy, galaxy.Entrance,
var pack = ZoneGenerator.GenerateZone(items, authored.Read<ZoneGenerationSettings>("ZoneSettings"), authored.Read<PlanetSettings>("PlanetSettings"), galaxy, galaxy.Entrance,
galaxy.IsPrelude, false);
var zone = new Zone(items, authored.Read<PlanetSettings>("PlanetSettings"), pack, galaxy.Entrance, galaxy);

View file

@ -57,9 +57,10 @@ public sealed class RestoredHullsTests
// Shared tutorial-galaxy construction settings (Assets/Resources/Settings.asset's own values), factored out
// so every test that needs a real tutorial Galaxy -- not just EntranceZoneAlwaysGetsADockedStationAcrossSeeds
// -- builds it the same way instead of re-inlining the same ~20 fields.
internal static PlanetSettings AuthoredPlanetSettings() => AuthoredSettings.Load(RunStartTests.FindRepoRoot()).Read<PlanetSettings>("PlanetSettings");
internal static ZoneGenerationSettings TutorialZoneSettings() => new ZoneGenerationSettings
{
PlanetSafetyRadius = new ExponentialCurve { Exponent = .25f, Multiplier = 2.5f, Constant = 0 },
MassFloor = 1, SunMass = 5000, GasGiantMass = 1000, PlanetMass = 100,
SatellitePasses = 5, SatelliteCreationMassFloor = 100, SatelliteCreationProbability = .25f,
BinaryCreationProbability = .1f, RosetteProbability = .1f,
@ -156,7 +157,7 @@ public sealed class RestoredHullsTests
cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed);
foreach (var zone in galaxy.Zones.Where(z => !ReferenceEquals(z, galaxy.Entrance)))
{
var orbits = ParentedPlanetOrbits(cache, ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), galaxy, zone, isTutorial: false, ambient: false));
var orbits = ParentedPlanetOrbits(cache, ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), AuthoredPlanetSettings(), galaxy, zone, isTutorial: false, ambient: false));
if (orbits.Length > 0 && !HasGenuineLagrangeCandidate(orbits)) return (seed, zone.Name);
}
}
@ -377,7 +378,7 @@ public sealed class RestoredHullsTests
var galaxy = new Galaxy(tutorialSettings, background, names, cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var dockedStation = pack.Entities.OfType<OrbitalEntityPack>()
.FirstOrDefault(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station && e.DockingBays.Length > 0);
@ -418,7 +419,7 @@ public sealed class RestoredHullsTests
var galaxy = new Galaxy(tutorialSettings, background, names, cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var planetOrbits = pack.Planets.Select(p => cache.Get(cache.Get(p).Orbit)).Where(o => o.Parent.IsSet()).ToArray();
var hasGenuineCandidate = planetOrbits.Any(o => planetOrbits.Count(c => c.Parent.Key.Equals(o.Parent.Key) && abs(c.Distance - o.Distance) < .1f) == 1);
@ -460,9 +461,11 @@ public sealed class RestoredHullsTests
var zoneSettings = TutorialZoneSettings();
zoneSettings.RosetteProbability = 0;
zoneSettings.MassFloor = 1e9f;
// One subzone: the zone's only body is a parentless root. (Several roots give the station a root to orbit.)
zoneSettings.SubZoneCount = new ExponentialLerp { Exponent = 1, Minimum = 0, Maximum = 0 };
Assert.Throws<InvalidOperationException>(() =>
ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, galaxy.Entrance, isTutorial: true));
ZoneGenerator.GenerateZone(items, zoneSettings, AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true));
}
finally
{
@ -497,13 +500,10 @@ public sealed class RestoredHullsTests
zoneSettings.SatelliteCreationProbability = 0;
zoneSettings.BinaryCreationProbability = 0;
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var roots = pack.Planets.Select(p => cache.Get(p).Orbit)
.Select(cache.Get)
.Select(o => o.Parent.IsSet() ? o.Parent.Key.Value : "(root)")
.Distinct().Count();
Assert.True(roots > 1, $"this fixture no longer produces a multi-root entrance (only {roots} distinct parent); it no longer tests the fragmented-topology case.");
var roots = pack.Planets.Select(p => cache.Get(cache.Get(p).Orbit)).Count(o => !o.Parent.IsSet());
Assert.True(roots > 1, $"this fixture no longer produces a multi-root entrance (only {roots} root); it no longer tests the fragmented-topology case.");
var stations = pack.Entities.OfType<OrbitalEntityPack>()
.Where(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station).ToArray();
@ -545,7 +545,7 @@ public sealed class RestoredHullsTests
var galaxy = new Galaxy(tutorialSettings, background, names, cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var dockedStation = pack.Entities.OfType<OrbitalEntityPack>()
.FirstOrDefault(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station && e.DockingBays.Length > 0);
@ -740,7 +740,7 @@ public sealed class RestoredHullsTests
var galaxy = BuildGalaxyWithForcedEntrance(cache, seed, zoneName);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var station = pack.Entities.OfType<OrbitalEntityPack>()
.FirstOrDefault(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station && e.DockingBays.Length > 0);
@ -749,7 +749,11 @@ public sealed class RestoredHullsTests
// Confirms this fixture still exercises the widened path (a regression here would mean the fixture no
// longer probes what this test claims to probe).
Assert.True(IsRosetteMember(cache, pack, stationOrbit), "the entrance station no longer sits on a rosette-only orbit -- this fixture no longer tests the widened candidate path.");
// The zone has no body alone on its ring, so the station orbits the root node beyond its ring group.
var rootOrbit = cache.Get(stationOrbit.Parent);
Assert.False(rootOrbit.Parent.IsSet(), "the entrance station no longer orbits a root node -- this fixture no longer tests the no-candidate path.");
var ring = pack.Planets.Select(p => cache.Get(cache.Get(p).Orbit)).Where(o => o.Parent.IsSet() && o.Parent.Key.Equals(stationOrbit.Parent.Key)).Select(o => o.Distance).DefaultIfEmpty(0f).Min();
Assert.True(stationOrbit.Distance >= (1 + GravityField.RingReach) * GravityField.Beta * ring * .999f, $"the entrance station at {stationOrbit.Distance} sits inside its node's ring group of radius {ring}.");
var turrets = pack.Entities.OfType<OrbitalEntityPack>()
.Where(e => (cache.Get(e.Hull.Data) as HullData)?.HullType != HullType.Station).ToArray();
@ -790,7 +794,7 @@ public sealed class RestoredHullsTests
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
int StationCount(GalaxyZone zone, bool isTutorial) =>
ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), galaxy, zone, isTutorial)
ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), AuthoredPlanetSettings(), galaxy, zone, isTutorial)
.Entities.OfType<OrbitalEntityPack>()
.Count(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station);
@ -830,7 +834,7 @@ public sealed class RestoredHullsTests
cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed: 1u);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), AuthoredPlanetSettings(), galaxy, galaxy.Entrance, isTutorial: true);
var stationCount = pack.Entities.OfType<OrbitalEntityPack>().Count(e => (cache.Get(e.Hull.Data) as HullData)?.HullType == HullType.Station);
// Soul's finding (this cut's fix batch 3): pack.Entities.OfType<ShipPack>().Count() also counts the
// zone's neutral wanderers (ZoneGenerator.cs's own EligibleWandererFactions spawn, keyed to
@ -914,7 +918,7 @@ public sealed class RestoredHullsTests
Assert.NotSame(galaxy.Entrance, zone);
var items = new ItemManager(cache, new ProvenanceLedger(), Settings(), _ => { });
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), galaxy, zone, isTutorial: true);
var pack = ZoneGenerator.GenerateZone(items, TutorialZoneSettings(), AuthoredPlanetSettings(), galaxy, zone, isTutorial: true);
// Confirms this fixture still has no genuine (non-rosette) Lagrange candidate -- a regression here
// would mean the fixture no longer probes what this test claims to probe.

View file

@ -19,7 +19,7 @@ public sealed partial class RunStartTests
private ZonePack BossZonePack(Galaxy galaxy, ItemManager items, GalaxyZone zone, bool ambient = true)
{
items.Random = new CultMath.Random(7);
return ZoneGenerator.GenerateZone(items, _zoneSettings, galaxy, zone, galaxy.IsPrelude, ambient);
return ZoneGenerator.GenerateZone(items, _zoneSettings, _planetSettings, galaxy, zone, galaxy.IsPrelude, ambient);
}
private Zone ZoneOf(Galaxy galaxy, GalaxyZone zone) =>

View file

@ -78,7 +78,7 @@ public sealed partial class RunStartTests : IDisposable
// The fixture galaxy's arena, with or without its generated ships and turrets.
private Zone Arena(bool ambient) =>
new Zone(_items, _planetSettings, RunStart.GenerateArena(_items, _zoneSettings, _galaxy, new Scripted(ambient, _ => { })), _galaxy.Entrance, _galaxy);
new Zone(_items, _planetSettings, RunStart.GenerateArena(_items, _zoneSettings, _planetSettings, _galaxy, new Scripted(ambient, _ => { })), _galaxy.Entrance, _galaxy);
private HullData Hull(string name) => _cache.GetAll<HullData>().Single(hull => hull.Name == name);
@ -311,8 +311,14 @@ public sealed partial class RunStartTests : IDisposable
[Fact]
public void NoOrbitStandsStillAgainstItsParent()
{
var zone = Arena(false); // no ships: nothing but the zone runs
Assert.True(zone.AsteroidBelts.Count > 0, "the arena has an asteroid belt to race against");
// No ships: nothing but the zone runs. Belts are rarer than they were, so the first galaxy seed whose entrance holds one.
Zone zone = null;
for (uint seed = GalaxySeed; zone == null && seed < GalaxySeed + 60; seed++)
{
var (_, arena, _, _) = Launch(new Scripted(false, _ => { }, seed), Inputs());
if (arena.AsteroidBelts.Count > 0) zone = arena;
}
Assert.True(zone != null, "no arena of the first 60 seeds has an asteroid belt to race against");
float2 Relative(Orbit orbit, bool previous) =>
(previous ? orbit.PreviousPosition : orbit.Position) -
(zone.Orbits.TryGetValue(orbit.Data.Parent.Key, out var parent) ? previous ? parent.PreviousPosition : parent.Position : orbit.Data.FixedPosition);
@ -673,7 +679,7 @@ public sealed partial class RunStartTests : IDisposable
[Fact]
public void AdmitIsTheOnlyAgentCreator()
{
var pack = RunStart.GenerateArena(_items, _zoneSettings, _galaxy, new Scripted(true, _ => { }));
var pack = RunStart.GenerateArena(_items, _zoneSettings, _planetSettings, _galaxy, new Scripted(true, _ => { }));
var packedPlayer = pack.Entities.OfType<ShipPack>().First();
packedPlayer.IsPlayerShip = true;
var zone = new Zone(_items, _planetSettings, pack, _galaxy.Entrance, _galaxy);

View file

@ -64,7 +64,7 @@ public sealed partial class RunStartTests
private (Galaxy galaxy, Zone arena, RunStart.Staged staged, List<string> failures) Launch(Scenario scenario, GalaxyStage inputs = null, Action beforeStaging = null)
{
var galaxy = RunStart.Generate(scenario, inputs ?? Inputs());
var arena = new Zone(_items, _planetSettings, RunStart.GenerateArena(_items, _zoneSettings, galaxy, scenario), galaxy.Entrance, galaxy);
var arena = new Zone(_items, _planetSettings, RunStart.GenerateArena(_items, _zoneSettings, _planetSettings, galaxy, scenario), galaxy.Entrance, galaxy);
beforeStaging?.Invoke();
var failures = new List<string>();
var staged = RunStart.Stage(_items, arena, scenario, _startingHull, _tutorialSettings, failures);
@ -392,8 +392,8 @@ public sealed partial class RunStartTests
{
Zone = _galaxy.Entrance, Name = "story", Type = LocationType.Station, Faction = _protagonist, Turrets = 2
});
var ambient = Census(RunStart.GenerateArena(_items, _zoneSettings, _galaxy, new Scripted(true, _ => { })));
var quietPack = RunStart.GenerateArena(_items, _zoneSettings, _galaxy, new Scripted(false, _ => { }));
var ambient = Census(RunStart.GenerateArena(_items, _zoneSettings, _planetSettings, _galaxy, new Scripted(true, _ => { })));
var quietPack = RunStart.GenerateArena(_items, _zoneSettings, _planetSettings, _galaxy, new Scripted(false, _ => { }));
var quiet = Census(quietPack);
Assert.Same(quietPack, _galaxy.Entrance.PackedContents);

View file

@ -5,6 +5,7 @@ using System.Linq;
using CultMath;
using GameCult.Caching;
using Xunit;
using Xunit.Abstractions;
using static CultMath.math;
using float2 = CultMath.float2;
@ -16,8 +17,15 @@ public sealed class StationPlacementTests : IDisposable
{
private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-stationplacement-" + Guid.NewGuid().ToString("N"));
private readonly List<CultCache> _caches = new List<CultCache>();
private int _generation;
public StationPlacementTests() => Directory.CreateDirectory(_root);
private readonly ITestOutputHelper _output;
public StationPlacementTests(ITestOutputHelper output)
{
_output = output;
Directory.CreateDirectory(_root);
}
public void Dispose()
{
@ -29,11 +37,12 @@ public sealed class StationPlacementTests : IDisposable
// stock may rearrange the catalog before a galaxy is generated; storyTurrets > 0 gives every zone a story station that
// authors that many turrets (the '#turrets' tag), the way a narrative does.
private IEnumerable<Built> GeneratedZones(Action<ItemManager> stock = null, int storyTurrets = 0, uint seeds = 6, int zonesPerSeed = int.MaxValue)
private IEnumerable<Built> GeneratedZones(Action<ItemManager> stock = null, int storyTurrets = 0, uint seeds = 6, int zonesPerSeed = int.MaxValue,
Action<ZoneGenerationSettings> tune = null, bool entranceOnly = false)
{
for (uint seed = 1; seed <= seeds; seed++)
{
var dir = Path.Combine(_root, $"galaxy{seed}");
var dir = Path.Combine(_root, $"galaxy{seed}-{_generation++}");
Directory.CreateDirectory(dir);
var catalog = Path.Combine(dir, "Aetheria.cc");
File.Copy(TestCatalog.Repo, catalog);
@ -49,11 +58,13 @@ public sealed class StationPlacementTests : IDisposable
Directory.CreateDirectory(Path.Combine(dir, "Narrative")), _ => { }, null, seed);
var items = new ItemManager(cache, new ProvenanceLedger(), settings, _ => { });
stock?.Invoke(items);
foreach (var galaxyZone in galaxy.Zones.Take(zonesPerSeed))
foreach (var galaxyZone in entranceOnly ? new[] { galaxy.Entrance } : galaxy.Zones.Take(zonesPerSeed))
{
if (storyTurrets > 0)
galaxyZone.Locations.Add(new LocationStory { Zone = galaxyZone, Name = "Test station", Faction = galaxy.Factions[0], Type = LocationType.Station, Turrets = storyTurrets });
var pack = ZoneGenerator.GenerateZone(items, authored.Read<ZoneGenerationSettings>("ZoneSettings"), galaxy, galaxyZone,
var zoneSettings = authored.Read<ZoneGenerationSettings>("ZoneSettings");
tune?.Invoke(zoneSettings);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, authored.Read<PlanetSettings>("PlanetSettings"), galaxy, galaxyZone,
galaxyZone == galaxy.Entrance && galaxy.IsPrelude, true);
var zone = new Zone(items, authored.Read<PlanetSettings>("PlanetSettings"), pack, galaxyZone, galaxy);
zone.Update(.02f);
@ -74,6 +85,7 @@ public sealed class StationPlacementTests : IDisposable
public void AStationSitsAtItsPlanetsL4OrL5()
{
var checkedStations = 0;
var rootStations = 0;
var ahead = 0;
var behind = 0;
foreach (var built in GeneratedZones())
@ -85,7 +97,21 @@ public sealed class StationPlacementTests : IDisposable
{
var orbit = zone.Orbits[station.OrbitData];
var sources = zone.Orbits.Where(o => !ridden.Contains(o.Key) && SameRing(o.Value, orbit)).ToList();
if (sources.Count == 0)
{
// The tutorial entrance's one exception: a station on its own orbit round a root node, beyond the node's ring
// group (or, for a body, its whole family), at no Lagrange point.
var rootKey = orbit.Data.Parent.Key;
Assert.False(zone.Orbits[rootKey].Data.Parent.IsSet(), $"seed {built.Seed}: a station with no source orbit does not orbit a root node");
var innermost = zone.Orbits.Where(o => o.Value.Data.Parent.IsSet() && o.Value.Data.Parent.Key.Equals(rootKey) && zone.Wells.Reach(o.Key) > 0f && !o.Key.Equals(station.OrbitData))
.Select(o => o.Value.Data.Distance).DefaultIfEmpty(0f).Min();
Assert.True(orbit.Data.Distance >= zone.Wells.Support(rootKey) * .999f || orbit.Data.Distance >= (1 + GravityField.RingReach) * GravityField.Beta * innermost * .999f,
$"seed {built.Seed}: a root-node station at {orbit.Data.Distance} sits inside its node's family");
rootStations++;
continue;
}
Assert.True(sources.Count == 1, $"seed {built.Seed}: a station shares its ring with {sources.Count} unridden orbits, not one");
Assert.Contains(zone.Planets.Values, b => b.Orbit.Key.Equals(sources[0].Key) && !(b is AsteroidBeltData));
var planet = sources[0].Value;
var offset = Turns(orbit.Data.Phase - planet.Data.Phase);
@ -103,9 +129,100 @@ public sealed class StationPlacementTests : IDisposable
}
}
Assert.True(checkedStations > 0, "the seeds generated no station");
Assert.True(rootStations == 0 || rootStations < checkedStations, "every station is a root-node fallback");
Assert.True(ahead > 0 && behind > 0, $"the seeds put stations on one side only (ahead {ahead}, behind {behind})");
}
// A binary is a bodyless node under its parent; the station's source is never such a node, however many binaries there are.
[Fact]
public void AStationNeverSitsOnABinarysBodylessNode()
{
var binaries = 0;
var stations = 0;
foreach (var built in GeneratedZones(null, 0, 4, int.MaxValue, z => { z.SatelliteCreationProbability = 1; z.BinaryCreationProbability = 1; }))
{
var zone = built.Zone;
var bodyOrbits = zone.Planets.Values.Select(b => b.Orbit.Key).ToHashSet();
binaries += zone.Orbits.Count(o => o.Value.Data.Parent.IsSet() && !bodyOrbits.Contains(o.Key) && zone.Wells.Reach(o.Key) > 0f);
var ridden = zone.Entities.OfType<OrbitalEntity>().Select(e => e.OrbitData).ToHashSet();
foreach (var station in Orbitals(built).Where(e => TypeOf(built.Items, e) == HullType.Station))
{
var orbit = zone.Orbits[station.OrbitData];
var sources = zone.Orbits.Where(o => !ridden.Contains(o.Key) && SameRing(o.Value, orbit)).ToList();
if (sources.Count == 0) continue; // the tutorial entrance's own orbit round a root
stations++;
Assert.Contains(bodyOrbits, key => key.Equals(sources[0].Key));
}
}
Assert.True(binaries > 5 && stations > 5, $"{binaries} bodyless nodes and {stations} stations: the seeds do not exercise the rule");
}
// The zone's own well tree counts a station's rail as a member of its root's family, so the extent the generator checked
// (the bodies' alone) is rebuilt here from the generated bodies' orbits and their ancestors.
private static float ExtentOfBodies(Zone zone, CultRecordKey orbit)
{
var mass = zone.Planets.Values.Where(b => !(b is AsteroidBeltData)).GroupBy(b => b.Orbit.Key).ToDictionary(g => g.Key, g => g.First().Mass);
var placed = new HashSet<CultRecordKey>();
foreach (var body in zone.Planets.Values)
for (var key = body.Orbit.Key; placed.Add(key) && zone.Orbits[key].Data.Parent.IsSet();) key = zone.Orbits[key].Data.Parent.Key;
var beltExtent = zone.AsteroidBelts.ToDictionary(b => zone.Planets[b.Key].Orbit.Key, b => b.Value.Data.Asteroids.Select(a => a.Distance).DefaultIfEmpty(0f).Max());
var nodes = placed.Select(k =>
{
var d = zone.Orbits[k].Data;
return new WellNode(k, d.Parent.Key, d.Distance, d.Phase, mass.TryGetValue(k, out var m) ? m : 0f,
beltExtent.TryGetValue(k, out var e) ? Math.Max(e, d.Distance) : d.Distance, d.FixedPosition + OrbitData.Evaluate(frac(d.Phase)) * d.Distance);
}).ToList();
var wells = WellTree.Build(nodes, zone.Settings, zone.Pack.Radius);
return Math.Max(wells.Support(orbit), 1.5f * zone.Settings.RocheLimit.Evaluate(mass[orbit]));
}
// How far a body keeps others out: its family's support, or 1.5 Roche limits (tail-taming-law-r3-band-loose-cusp) if more.
private static float BaseExtent(Zone zone, CultRecordKey orbit)
{
var body = zone.Planets.Values.FirstOrDefault(b => b.Orbit.Key.Equals(orbit) && !(b is AsteroidBeltData));
return Math.Max(zone.Wells.Support(orbit), body == null ? 0f : 1.5f * zone.Settings.RocheLimit.Evaluate(body.Mass));
}
// Over 64 instants of the longest period in the zone, no station or turret centre is within 1.5 Roche limits plus its
// reach of any body other than its base (station-orbit-choice-residuals item 1).
[Fact]
public void NoStationOrTurretSitsOnAnUnrelatedBody()
{
var checkedEntities = 0;
foreach (var built in GeneratedZones())
{
var zone = built.Zone;
var longest = zone.Orbits.Values.Select(o => o.Period).Where(float.IsFinite).DefaultIfEmpty(1f).Max();
var bodies = zone.Planets.Values.Where(b => !(b is AsteroidBeltData)).ToList();
foreach (var entity in Orbitals(built).Where(e => TypeOf(built.Items, e) is HullType.Station or HullType.Turret))
{
var orbit = zone.Orbits[entity.OrbitData];
checkedEntities++;
foreach (var body in bodies)
{
var bodyOrbit = zone.Orbits[body.Orbit.Key];
if (SameRing(bodyOrbit, orbit)) continue; // its base
if (IsAncestorBody(zone, orbit, body.Orbit.Key)) continue; // the body it orbits round: it keeps its distance by its own Roche margin
var margin = 1.5f * zone.Settings.RocheLimit.Evaluate(body.Mass) + Contacts.Radius(entity);
for (var k = 0; k < 64; k++)
{
var t = k / 64.0 * longest;
Assert.True(length(zone.OrbitPositionAt(entity.OrbitData, t) - zone.OrbitPositionAt(body.Orbit.Key, t)) >= margin * .999f,
$"seed {built.Seed}: a {TypeOf(built.Items, entity)} on a ring of {orbit.Data.Distance} passes within {margin} of an unrelated body (mass {body.Mass}, ring {bodyOrbit.Data.Distance}, same parent {bodyOrbit.Data.Parent.Key.Equals(orbit.Data.Parent.Key)}) at instant {k}");
}
}
}
}
Assert.True(checkedEntities > 0, "the seeds generated no station");
}
private static bool IsAncestorBody(Zone zone, Orbit orbit, CultRecordKey bodyOrbit)
{
for (var parent = orbit.Data.Parent; parent.IsSet(); parent = zone.Orbits[parent.Key].Data.Parent)
if (parent.Key.Equals(bodyOrbit)) return true;
return false;
}
private static List<OrbitalEntity> Orbitals(Built built) => built.Zone.Entities.OfType<OrbitalEntity>().ToList();
// Every turret belongs to one station on its ring. Each side of a station grows outward from it: a turret's centre sits
@ -139,8 +256,7 @@ public sealed class StationPlacementTests : IDisposable
var behind = arcs.Where(a => a.arc < 0).OrderByDescending(a => a.arc).ToList();
var ahead = arcs.Where(a => a.arc > 0).OrderBy(a => a.arc).ToList();
// Turrets alternate behind then ahead, so behind holds the extra one when the count is odd.
Assert.Equal((mine.Count + 1) / 2, behind.Count);
Assert.Equal(mine.Count / 2, ahead.Count);
// (A side whose next turret would reach the base body stops, so the sides need not stay level.)
if (mine.Select(Contacts.Radius).Distinct().Count() > 1) mixedReach++;
foreach (var (side, sign) in new[] { (behind, -1f), (ahead, 1f) })
@ -157,6 +273,17 @@ public sealed class StationPlacementTests : IDisposable
}
}
// No turret reaches its base body: the planet whose Lagrange orbit the station rides (the ring's one unridden orbit).
var ridden = built.Zone.Entities.OfType<OrbitalEntity>().Select(e => e.OrbitData).ToHashSet();
var source = built.Zone.Orbits.Where(o => !ridden.Contains(o.Key) && SameRing(o.Value, orbit)).Select(o => o.Key).ToList();
if (source.Count == 1)
{
var extent = BaseExtent(built.Zone, source[0]);
foreach (var turret in mine)
Assert.True(length(turret.Position.xz - built.Zone.Orbits[source[0]].Position) >= (extent + Contacts.Radius(turret)) * .999f,
$"seed {built.Seed}: a turret sits within the base body's extent {extent} and its reach of the base");
}
var bodies = new List<OrbitalEntity> { station };
bodies.AddRange(mine);
for (var a = 0; a < bodies.Count; a++)
@ -193,13 +320,15 @@ public sealed class StationPlacementTests : IDisposable
[Fact]
public void ANarrativeStationsTurretsKeepFlankingAndClearEachOtherWhateverTheirReach()
{
const int authored = 5;
var flanked = 0;
var flanked = 0;
var mixed = 0;
var most = 0;
foreach (var built in GeneratedZones(WithALargerTurretHull, authored, 3, 3))
most = Math.Max(most, AssertFlanks(built, ref flanked, ref mixed));
Assert.True(most == authored, $"no story station carried its {authored} authored turrets (most {most})");
foreach (var authored in new[] { 3, 5, 9 })
{
var most = 0;
foreach (var built in GeneratedZones(WithALargerTurretHull, authored, 6, 6))
most = Math.Max(most, AssertFlanks(built, ref flanked, ref mixed));
Assert.True(most > 0 && most <= authored, $"the most turrets a station carried is {most} of {authored} authored");
}
Assert.True(mixed > 0, "no station carried turrets of differing reach");
}
@ -224,6 +353,84 @@ public sealed class StationPlacementTests : IDisposable
Assert.True(stations > 0, "the seeds generated no station");
}
// A side of a station grows outward until its next turret would sit within the base body's extent plus that turret's reach of
// the base (story-turret-tail-clearance). With a single wide turret hull on offer and sixteen story turrets a station
// reaches the base: a side that placed fewer than its half stopped, and its would-be next turret, spelled from the zone, is
// inside that distance. Ambient stations carry at most two turrets, so only a station with three or more is a story one.
[Fact]
public void ATurretTailStopsAtItsBaseBody()
{
const int turrets = 16;
int stations = 0, ambiguous = 0, sides = 0, stops = 0, nearBase = 0;
foreach (var built in GeneratedZones(WithOnlyAWiderTurretHull, turrets, 6))
{
var zone = built.Zone;
var orbitals = Orbitals(built);
var ridden = orbitals.Select(e => e.OrbitData).ToHashSet();
foreach (var station in orbitals.Where(e => TypeOf(built.Items, e) == HullType.Station))
{
var orbit = zone.Orbits[station.OrbitData];
var mine = orbitals.Where(e => TypeOf(built.Items, e) == HullType.Turret && SameRing(zone.Orbits[e.OrbitData], orbit)).ToList();
var source = zone.Orbits.Where(o => !ridden.Contains(o.Key) && SameRing(o.Value, orbit)).Select(o => o.Key).ToList();
if (mine.Count < 3 || source.Count != 1) continue;
var extent = BaseExtent(zone, source[0]);
var reach = Contacts.Radius(mine[0]);
var circumference = 2 * PI * orbit.Data.Distance;
var arcs = mine.Select(t => { var turn = Turns(zone.Orbits[t.OrbitData].Data.Phase - orbit.Data.Phase); return (turn > .5f ? turn - 1 : turn) * circumference; }).ToList();
// Half the ring away a turret's side is ambiguous (its signed arc wraps). A belt in the base's family has an extent the
// generator spelled from its authored width and the zone reads from its rocks, so the stop distance is not known to the
// test. Neither station is read.
bool InFamily(CultRecordKey key) { for (; zone.Orbits[key].Data.Parent.IsSet(); key = zone.Orbits[key].Data.Parent.Key) if (key.Equals(source[0])) return true; return key.Equals(source[0]); }
if (arcs.Any(a => Math.Abs(a) > .45f * circumference) || zone.AsteroidBelts.Any(b => InFamily(zone.Planets[b.Key].Orbit.Key))) { ambiguous++; continue; }
stations++;
foreach (var sign in new[] { -1f, 1f })
{
var side = arcs.Where(a => a * sign > 0).OrderBy(a => a * sign).ToList();
sides++;
foreach (var placed in side)
{
var at = 2 * orbit.Data.Distance * Math.Abs((float) Math.Sin(PI * (orbit.Data.Phase + placed / circumference - zone.Orbits[source[0]].Data.Phase)));
Assert.True(at >= (extent + reach) * .999f, $"seed {built.Seed}: a turret sits {at} from its base, inside {extent + reach}");
}
var wouldBe = (side.Count == 0 ? 0f : side[side.Count - 1]) + sign * ((side.Count == 0 ? Contacts.Radius(station) : reach) + 2 * reach);
var phase = orbit.Data.Phase + wouldBe / circumference;
var chord = 2 * orbit.Data.Distance * Math.Abs((float) Math.Sin(PI * (phase - zone.Orbits[source[0]].Data.Phase)));
if (side.Count >= turrets / 2) continue;
stops++;
Assert.True(chord < (extent + reach) * (1 + 1e-3f), $"seed {built.Seed}: a side stopped at {side.Count} turrets with its next turret still {chord} from the base, outside {extent + reach}");
if (chord >= .8f * (extent + reach)) nearBase++;
}
}
}
_output.WriteLine($"story stations {stations} (not read: {ambiguous}), sides {sides}, sides that stopped {stops}, of them with the next turret at 0.8 to 1 of the stop distance {nearBase}");
Assert.True(stops > 0 && nearBase > 0, $"{stops} stops, {nearBase} in the 0.8 band: the seeds do not exercise the rule");
}
// The entrance always gets a station. With no candidate orbit (a station hull so large that no rail clears a massive sibling
// by its reach) it orbits a body root outside that root's extent, not at a Lagrange point.
[Fact]
public void ATutorialEntranceWithNoCandidateOrbitsItsBodyRootOutsideItsExtent()
{
var fired = 0;
foreach (var built in GeneratedZones(WithAnUnofferedHugeStationHull, 0, 20, 1,
z => { z.RosetteProbability = 0; z.BinaryCreationProbability = 0; z.SatelliteCreationProbability = 0; }, true))
{
var zone = built.Zone;
var station = Orbitals(built).FirstOrDefault(e => TypeOf(built.Items, e) == HullType.Station);
if (station == null) continue;
var orbit = zone.Orbits[station.OrbitData];
var root = orbit.Data.Parent.IsSet() ? orbit.Data.Parent.Key : default;
if (!orbit.Data.Parent.IsSet() || zone.Orbits[root].Data.Parent.IsSet() || !zone.Planets.Values.Any(b => !(b is AsteroidBeltData) && b.Orbit.Key.Equals(root))) continue;
if (zone.Planets.Values.Any(b => SameRing(zone.Orbits[b.Orbit.Key], orbit))) continue;
fired++;
var extent = ExtentOfBodies(zone, root);
Assert.True(Math.Abs(orbit.Data.Distance - extent) <= 1e-4f * extent, $"seed {built.Seed}: the entrance station orbits its root at {orbit.Data.Distance}, not at its extent {extent}");
}
_output.WriteLine($"entrance zones where the fallback seated a station at a body root: {fired}");
Assert.True(fired > 0, "no entrance zone of seeds 1-20 took the fallback for a body root");
}
private static List<FactionProductData> TurretProducts(ItemManager items) =>
items.ItemData.GetAll<FactionProductData>().Where(p => items.ItemData.Get(p.Design) is HullData { HullType: HullType.Turret }).ToList();
@ -235,7 +442,24 @@ public sealed class StationPlacementTests : IDisposable
// The shipped catalog has one turret hull. A copy with a bigger solid shape (a larger reach) and its own product
// gives the generator two turret hulls to choose between.
private static void WithALargerTurretHull(ItemManager items)
private static void WithALargerTurretHull(ItemManager items) => AddATurretHull(items, 2, false);
// Only the wider hull is on offer: the shipped turret is priced at zero once the wider copy has its price.
private static void WithOnlyAWiderTurretHull(ItemManager items) => AddATurretHull(items, 6, true);
// A station hull with no product, so nothing builds it, but wide enough that its reach is the largest in the catalog.
private static void WithAnUnofferedHugeStationHull(ItemManager items)
{
var copyOf = typeof(object).GetMethod("MemberwiseClone", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
var hull = items.ItemData.GetAll<HullData>().First(h => h.HullType == HullType.Station);
var huge = (HullData) copyOf.Invoke(hull, null);
huge.Name = hull.Name + " (huge)";
huge.Shape = new Shape(20000, 1);
foreach (var cell in huge.Shape.AllCoordinates) huge.Shape[cell] = true;
items.ItemData.Upsert(huge);
}
private static void AddATurretHull(ItemManager items, int extraCells, bool only)
{
var copyOf = typeof(object).GetMethod("MemberwiseClone", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
foreach (var product in TurretProducts(items))
@ -243,12 +467,13 @@ public sealed class StationPlacementTests : IDisposable
var hull = (HullData) items.ItemData.Get(product.Design);
var larger = (HullData) copyOf.Invoke(hull, null);
larger.Name = hull.Name + " (large)";
larger.Shape = new Shape(hull.Shape.Width + 2, hull.Shape.Height + 2);
larger.Shape = new Shape(hull.Shape.Width + extraCells, hull.Shape.Height + extraCells);
foreach (var cell in larger.Shape.AllCoordinates) larger.Shape[cell] = true;
var largerProduct = (FactionProductData) copyOf.Invoke(product, null);
largerProduct.Name = product.Name + " (large)";
largerProduct.Design = new CultRecordRef<CraftedItemData>(items.ItemData.Upsert(larger).Key);
items.ItemData.Upsert(largerProduct);
if (only) hull.Price = 0;
}
}

View file

@ -191,7 +191,7 @@ public sealed class SunsNeverGreenTests : IDisposable
foreach (var zone in galaxy.Zones)
{
zones++;
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, galaxy, zone, false, false);
var pack = ZoneGenerator.GenerateZone(items, zoneSettings, RestoredHullsTests.AuthoredPlanetSettings(), galaxy, zone, false, false);
suns.AddRange(pack.Planets.Select(p => cache.Get(p)).OfType<SunData>());
}
}

View file

@ -563,7 +563,6 @@ public static class Program
var missing = new List<string>();
if (zones.ZoneRadius == null || zones.ZoneRadius.Maximum <= 0) missing.Add("ZoneSettings.ZoneRadius");
if (zones.SubZoneCount == null || zones.SubZoneCount.Maximum <= 0) missing.Add("ZoneSettings.SubZoneCount");
if (zones.PlanetSafetyRadius == null || zones.PlanetSafetyRadius.Multiplier <= 0) missing.Add("ZoneSettings.PlanetSafetyRadius");
if (gameplay.Tiers == null || gameplay.Tiers.Length != 5) missing.Add($"GameplaySettings.Tiers (expected 5, got {gameplay.Tiers?.Length ?? 0})");
else if (gameplay.Tiers.Any(t => string.IsNullOrEmpty(t.Name) || t.Quality <= 0)) missing.Add("GameplaySettings.Tiers (a tier parsed without a name or quality)");
if (gameplay.DefaultEntitySettings == null) missing.Add("GameplaySettings.DefaultEntitySettings");