Merge eureka/aetheria-living-world-station-kind-datum: station kinds are one catalog list; stations and fields are placed by seed; bad station packages are excluded by name

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
soul 2026-10-23 02:14:33 +02:00
commit d233194cb2
24 changed files with 1060 additions and 52 deletions

View file

@ -7,17 +7,19 @@ using GameCult.Caching.MessagePack;
// Aetheria's stores: one home store per type, composed here and nowhere else.
public static class AetheriaStores
{
public static readonly Type[] CatalogTypes = { typeof(ItemData), typeof(ShipAuthoring), typeof(Faction), typeof(FactionProductData), typeof(PersonalityAttribute), typeof(InputLayout), typeof(Loadout), typeof(FieldKindData), typeof(VerseGrammar), typeof(VerseVerb) };
public static readonly Type[] CatalogTypes = { typeof(ItemData), typeof(ShipAuthoring), typeof(Faction), typeof(FactionProductData), typeof(PersonalityAttribute), typeof(InputLayout), typeof(Loadout), typeof(FieldKindData), typeof(VerseGrammar), typeof(VerseVerb), typeof(StationKindData) };
public static readonly Type[] RunTypes = { typeof(OrbitData), typeof(BodyData), typeof(SavedZone), typeof(SavedGame), typeof(ProvenanceLedger) };
public static readonly Type[] PlayerTypes = { typeof(PlayerSettings) };
// Attaches (hydrates) the catalog read-only unless catalogWritable, then the run and player stores when given.
// Throws when a [CultGlobal] type routed to the catalog has no record. The one exemption is a writable catalog with
// no records at all, a seed store being authored from nothing; a populated catalog is held to it however it opens.
// A catalog's station hull with no Kind is refused, unless the caller gives kindlessStation: the tool that repairs a catalog
// is told the hull's name and goes on.
// The registry is the process-wide one unless the caller scopes it (the test host does, so its own document types never
// become catalog globals); the global check above is judged against whichever registry opened the cache.
public static CultCache Open(string catalogPath, string runPath = null, string playerPath = null, bool catalogWritable = false,
CultDocumentRegistry registry = null)
CultDocumentRegistry registry = null, Action<string> kindlessStation = null)
{
// A read-only open of an absent catalog would hydrate an empty game; a shipped player missing its catalog stops here.
if (!catalogWritable && !File.Exists(catalogPath))
@ -42,6 +44,7 @@ public static class AetheriaStores
foreach (var data in cache.GetAll<ConsumableItemData>()) CultRecordRefs.Validate(data);
VerseGrammarValidation.ValidateAll(cache.GetAll<VerseVerb>());
ValidateBins(cache);
StationKinds.Validate(cache, kindlessStation);
return cache;
}
catch

View file

@ -16,7 +16,8 @@ public static class EntitySerializer
{
Orbit = new CultRecordRef<OrbitData>(orbital.OrbitData),
SecurityLevel = orbital.SecurityLevel,
SecurityRadius = orbital.SecurityRadius
SecurityRadius = orbital.SecurityRadius,
Kind = orbital.Kind
};
else if (entity is Ship ship)
pack = new ShipPack
@ -120,6 +121,7 @@ public static class EntitySerializer
Restore(itemManager, zone, pack, entity);
entity.SecurityLevel = pack.SecurityLevel;
entity.SecurityRadius = pack.SecurityRadius;
entity.Kind = pack.Kind;
if (pack.Story >= 0) entity.Story = zone.GalaxyZone.Locations[pack.Story];
return entity;
}
@ -214,6 +216,7 @@ public class OrbitalEntityPack : EntityPack
[Key(18)] public int Story = -1;
[Key(19)] public SecurityLevel SecurityLevel;
[Key(20)] public float SecurityRadius;
[Key(22)] public CultRecordRef<StationKindData> Kind;
}
[MessagePackObject,
@ -237,7 +240,7 @@ public abstract class EntityPack
[Key(14)] public EntitySettings Settings;
[Key(15)] public CultRecordRef<Faction> Faction;
[Key(16)] public int[][] WeaponGroups;
// Keys 17-20 belong to the subclasses; the base's next free key is 21.
// Keys 17-20 belong to the subclasses; the base's next free key is 23 (Boss is 21, the orbital pack's Kind is 22).
[Key(21)] public bool Boss;
private int _price;

View file

@ -549,6 +549,12 @@ public class HullData : EquippableItemData
[Inspectable, JsonProperty("visual"), Key(32)]
public CultRecordRef<ShipAuthoring> Visual;
// What a station hull is built to be (StationKinds): set on every Station hull and on no other. The hull names its kind
// and the kind names no hull, so a package can add a faction's model of a kind without editing any kind record.
// Key 33 is the next free key.
[Inspectable, JsonProperty("kind"), Key(33)]
public CultRecordRef<StationKindData> Kind;
// The farthest corner of any occupied hull cell from the centre of mass the schematic frame uses, in world
// units: a true bound on how far the hull reaches from its position (the half-diagonal of the bounding box is not,
// as FireControl.Detonate's comment records). A cell at (x, y) spans x +/- .5 and y +/- .5.

View file

@ -74,9 +74,12 @@ public class LoadoutGenerator
return EntitySerializer.Pack(entity) as OrbitalEntityPack;
}
public OrbitalEntityPack GenerateStationLoadout()
// A station of one kind: the hull is drawn among the station hulls the kind calls for in this faction's hands
// (StationKinds.HullKindFor), so a faction with no model of the kind builds its stand-in's hull and keeps the kind.
public OrbitalEntityPack GenerateStationLoadout(CultRecordRef<StationKindData> kind)
{
var (hullProduct, hullData) = RandomHull(HullType.Station);
var hullKind = StationKinds.HullKindFor(ItemManager.ItemData, Faction, kind);
var (hullProduct, hullData) = RandomHull(HullType.Station, hull => hull.Kind.Key.Equals(hullKind.Key));
if(hullData==null)
{
ItemManager.Log("Unable to generate station loadout: no compatible hull found!");
@ -85,6 +88,9 @@ public class LoadoutGenerator
var hull = ItemManager.CreateInstance(hullProduct) as EquippableItem;
var entity = new OrbitalEntity(ItemManager, null, hull, default, ItemManager.GameplaySettings.DefaultEntitySettings);
entity.Faction = Faction;
entity.Kind = kind;
// A stand-in hull keeps its own model but not its own name: the station is what its kind says it is.
if (!hullData.Kind.Key.Equals(kind.Key) && ItemManager.ItemData.Get(kind) is { } kindData) entity.Name = kindData.Name;
// Hardpoint gear goes in first so the docking bay can only take space that gear left free
EquipHardpoints(entity);

View file

@ -17,6 +17,8 @@ public class OrbitalEntity : Entity
public float SecurityRadius;
public LocationStory Story;
public bool CanTow;
// What this station is for (StationKinds): its own fact, which under a stand-in hull differs from the hull's kind.
public CultRecordRef<StationKindData> Kind;
public OrbitalEntity(ItemManager itemManager, Zone zone, EquippableItem hull, CultRecordKey orbit, EntitySettings settings) : base(itemManager, zone, hull, settings)
{

View file

@ -108,6 +108,7 @@ public static class ShipModCatalog
Exclude(directory, $"hull name '{hull.Name}' collides with an existing catalog item.");
if (shipIds.Contains(ship.Id))
Exclude(directory, $"ship ID collides with an existing catalog ship authoring record.");
if (StationKinds.HullKindFault(cache, hull) is { } kindFault) Exclude(directory, kindFault);
foreach (var product in package.Products)
{
if (!factionKeys.Contains(product.Manufacturer.Key))

View file

@ -0,0 +1,141 @@
using System;
using System.Collections.Generic;
using System.Linq;
using GameCult.Caching;
using MessagePack;
using Newtonsoft.Json;
// What a station is for: one authored catalog record per kind (mining, trade-hub, shipyard...). The catalog's list of
// these records is the one list of station kinds. A kind names no hull: the hull names its kind (HullData.Kind), and
// which hull a faction builds for a kind is derived from the products that faction makes (StationKinds), so a package can
// add a faction's model of a kind without editing any kind record. Records are keyed station-kind:<id>.
[CultDocument("aetheria.stationkinddata", "1"), MessagePackObject, JsonObject(MemberSerialization.OptIn)]
public class StationKindData
{
[CultName, JsonProperty("name"), Key(0)]
public string Name;
[JsonProperty("description"), Key(1)]
public string Description;
// A faction with no model of this kind builds the stand-in's hull and the station stays this kind. Ignored once the
// faction offers a model of this kind.
[JsonProperty("standIns"), Key(2)]
public List<StationKindStandIn> StandIns = new List<StationKindStandIn>();
public static CultRecordKey KeyOf(string id) => new CultRecordKey("station-kind:" + id);
}
[MessagePackObject, JsonObject(MemberSerialization.OptIn)]
public class StationKindStandIn
{
[JsonProperty("faction"), Key(0)]
public CultRecordRef<Faction> Faction;
// The kind whose model this faction builds in place of the owning kind's.
[JsonProperty("kind"), Key(1)]
public CultRecordRef<StationKindData> Kind;
}
// The one owner of which kinds a faction builds, which kind a station gets, and which hull kind stands in.
public static class StationKinds
{
// The kinds this faction can place: those of the station hulls its products offer, and those that stand in for it.
// Ordered by key so a choice never depends on store order. Empty for no faction.
public static CultRecordRef<StationKindData>[] KindsOf(CultCache catalog, Faction faction)
{
if (faction == null) return Array.Empty<CultRecordRef<StationKindData>>();
var kinds = new HashSet<string>(OfferedStationHulls(catalog, faction).Select(hull => hull.Kind.Key.Value), StringComparer.Ordinal);
foreach (var kind in catalog.GetAll<StationKindData>())
if (kind.StandIns.Any(standIn => catalog.Get(standIn.Faction) == faction))
kinds.Add(catalog.RefOf(kind).Key.Value);
return Ordered(kinds);
}
// A station's kind: a stable pick among the faction's kinds by the station's site, which generation names by the zone's
// seed and the station's place in its orbit order (never by a key the cache mints). It draws nothing from any random
// stream, so adding the kind to generation moves no other roll. A faction with no kinds falls back to any kind some
// offered station hull carries, logged, and the hull draw then falls back to any maker. Unset when the catalog has none.
public static CultRecordRef<StationKindData> Choose(CultCache catalog, Faction faction, string site, Action<string> log = null)
{
var pool = KindsOf(catalog, faction);
if (pool.Length == 0)
{
pool = Ordered(new HashSet<string>(
catalog.GetAll<FactionProductData>().Where(product => LoadoutGenerator.IsOffered(catalog, product))
.Select(product => catalog.Get(product.Design) as HullData)
.Where(hull => hull != null && hull.HullType == HullType.Station && hull.Kind.IsSet())
.Select(hull => hull.Kind.Key.Value), StringComparer.Ordinal));
if (pool.Length == 0) return default;
log?.Invoke($"{faction?.Name ?? "This galaxy"} builds no station kind; placing a station of any kind some maker offers.");
}
return pool[(int) (site.StableHash() % (uint) pool.Length)];
}
// The kind of hull a faction builds for a station kind: the kind itself when the faction offers a model of it (a model
// wins over a stale stand-in), else the kind its stand-in names, else the kind itself (the hull draw then falls back to
// any maker).
public static CultRecordRef<StationKindData> HullKindFor(CultCache catalog, Faction faction, CultRecordRef<StationKindData> kind)
{
if (!kind.IsSet()) return kind;
if (OfferedStationHulls(catalog, faction).Any(hull => hull.Kind.Key.Equals(kind.Key))) return kind;
var standIn = catalog.Get(kind)?.StandIns.FirstOrDefault(entry => catalog.Get(entry.Faction) == faction);
return standIn != null && standIn.Kind.IsSet() ? standIn.Kind : kind;
}
// What is wrong with a hull's kind, or null: a Station hull names a kind the catalog holds, and no other hull names one.
// The one rule, applied to the catalog on Open and to each mod package on Compose.
public static string HullKindFault(CultCache catalog, HullData hull)
{
if (hull.HullType == HullType.Station)
{
if (!hull.Kind.IsSet())
return $"Station hull '{hull.Name}' has no Kind; a station hull names the station kind it is built to be.";
if (catalog.Get(hull.Kind) == null)
return $"Station hull '{hull.Name}' Kind names no station kind this catalog holds.";
}
else if (hull.Kind.IsSet())
return $"Hull '{hull.Name}' is a {hull.HullType} and names a Kind; only a station hull has one.";
return null;
}
// Open refuses a malformed kind catalog, naming the record and field. Every Station hull names a kind the catalog holds
// and no other hull names one; every stand-in names a faction and a kind the catalog holds, is never its own kind, and
// does not stand on another stand-in for the same faction (one hop). A caller that gives kindlessStation is the owner
// of the catalog being repaired: a Station hull with no Kind is reported to it by name instead of refused.
public static void Validate(CultCache catalog, Action<string> kindlessStation = null)
{
foreach (var hull in catalog.GetAll<HullData>())
{
var fault = HullKindFault(catalog, hull);
if (fault == null) continue;
if (kindlessStation != null && hull.HullType == HullType.Station && !hull.Kind.IsSet()) kindlessStation(fault);
else throw new InvalidOperationException(fault);
}
foreach (var kind in catalog.GetAll<StationKindData>())
{
var self = catalog.RefOf(kind).Key;
for (var i = 0; i < kind.StandIns.Count; i++)
{
var entry = kind.StandIns[i];
var at = $"Station kind '{kind.Name}' StandIns[{i}]";
var faction = catalog.Get(entry.Faction);
if (faction == null) throw new InvalidOperationException($"{at}.Faction names no faction this catalog holds.");
var other = catalog.Get(entry.Kind);
if (other == null) throw new InvalidOperationException($"{at}.Kind names no station kind this catalog holds.");
if (entry.Kind.Key.Equals(self)) throw new InvalidOperationException($"{at}.Kind is the kind itself; a kind cannot stand in for itself.");
if (other.StandIns.Any(next => catalog.Get(next.Faction) == faction))
throw new InvalidOperationException($"{at}.Kind stands in for the same faction itself; a stand-in is one hop.");
}
}
}
private static IEnumerable<HullData> OfferedStationHulls(CultCache catalog, Faction faction) =>
catalog.GetAll<FactionProductData>()
.Where(product => LoadoutGenerator.IsOffered(catalog, product) && catalog.Get(product.Manufacturer) == faction)
.Select(product => catalog.Get(product.Design) as HullData)
.Where(hull => hull != null && hull.HullType == HullType.Station && hull.Kind.IsSet());
private static CultRecordRef<StationKindData>[] Ordered(IEnumerable<string> keys) =>
keys.OrderBy(key => key, StringComparer.Ordinal).Select(key => new CultRecordRef<StationKindData>(new CultRecordKey(key))).ToArray();
}

View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7b3e1a94c2d84f6e9a05d1c8e4f27b63
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View file

@ -196,7 +196,7 @@ public class Zone
case AsteroidBeltData belt:
// Mining Cut 3 (Q16 B): a belt from before field kinds existed gets its kind here, once, by
// the rule generation uses, and keeps it.
FieldKinds.Ensure(body.Key, belt, cache);
FieldKinds.Ensure(body.Key.Value, belt, cache);
AsteroidBelts[body.Key] = new AsteroidBelt(belt);
break;
case SunData sun:

View file

@ -134,10 +134,11 @@ public class FieldKindData
// Mining Cut 3 (Q16 B): the one owner of which kind a belt is.
public static class FieldKinds
{
// A weighted pick among the catalog's kinds, by a stable hash of the belt's key: the same belt and the same
// catalog always give the same kind. Kinds are ordered by key so the pick does not depend on store order.
// A weighted pick among the catalog's kinds, by a stable hash of the belt's site: the same site and the same
// catalog always give the same kind. Generation names a belt by the zone's seed and the belt's place in generation
// order (never by the key the cache mints, which differs every run); a belt saved without a kind is named by its key. Kinds are ordered by key so the pick does not depend on store order.
// Unset when the catalog has no kind with positive weight.
public static CultRecordRef<FieldKindData> Assign(CultRecordKey field, CultCache catalog)
public static CultRecordRef<FieldKindData> Assign(string site, CultCache catalog)
{
var kinds = catalog.GetAll<FieldKindData>()
.Where(kind => kind.GenerationWeight > 0f)
@ -146,7 +147,7 @@ public static class FieldKinds
.ToArray();
if (kinds.Length == 0) return default;
var pick = field.Value.StableHash() / 4294967296.0 * kinds.Sum(kind => (double) kind.Weight);
var pick = site.StableHash() / 4294967296.0 * kinds.Sum(kind => (double) kind.Weight);
foreach (var kind in kinds)
{
if (pick < kind.Weight) return new CultRecordRef<FieldKindData>(kind.Key);
@ -157,10 +158,10 @@ public static class FieldKinds
// Gives a belt with no kind its kind and saves it; a belt that has one keeps it, whatever the catalog now says.
// Generation (ZoneGenerator) and first load (Zone) both call this, so there is one assignment rule.
public static void Ensure(CultRecordKey field, AsteroidBeltData belt, CultCache cache)
public static void Ensure(string site, AsteroidBeltData belt, CultCache cache)
{
if (belt.Kind.IsSet()) return;
belt.Kind = Assign(field, cache);
belt.Kind = Assign(site, cache);
if (belt.Kind.IsSet()) cache.Upsert(belt);
}
}

View file

@ -119,7 +119,7 @@ public static class ZoneGenerator
pack.Orbits = planets.Select(planet => cache.RefOf(orbitMap[planet])).ToList();
var beltOf = new Dictionary<GeneratorPlanet, AsteroidBeltData>();
pack.Planets = planets.Where(p=>!p.Empty).Select(planet =>
pack.Planets = planets.Where(p=>!p.Empty).Select((planet, index) =>
{
BodyType bodyType = planet.Belt ? BodyType.Asteroid :
planet.Mass > zoneSettings.SunMass ? BodyType.Sun :
@ -213,7 +213,7 @@ public static class ZoneGenerator
var bodyKey = cache.Upsert(planetData).Key;
planetData.Name = bodyKey.Value.Substring(0, 8);
// Mining Cut 3 (Q16 B): a belt's field kind is chosen here, at generation, and saved with it.
if (planetData is AsteroidBeltData generatedBelt) FieldKinds.Ensure(bodyKey, generatedBelt, cache);
if (planetData is AsteroidBeltData generatedBelt) FieldKinds.Ensure($"{seed}:belt:{index}", generatedBelt, cache);
return cache.Upsert(planetData);
}).ToList();
@ -239,7 +239,7 @@ public static class ZoneGenerator
BodyData swarmBody = swarm;
var swarmKey = cache.Upsert(swarmBody).Key;
swarm.Name = swarmKey.Value.Substring(0, 8);
FieldKinds.Ensure(swarmKey, swarm, cache);
FieldKinds.Ensure($"{seed}:swarm:{swarmHosts.Count}", swarm, cache);
pack.Planets.Add(cache.Upsert(swarmBody));
}
@ -268,7 +268,7 @@ public static class ZoneGenerator
BodyData lanedBody = laned;
var lanedKey = cache.Upsert(lanedBody).Key;
laned.Name = lanedKey.Value.Substring(0, 8);
FieldKinds.Ensure(lanedKey, laned, cache);
FieldKinds.Ensure($"{seed}:lane:{shaped.Count}", laned, cache);
pack.Planets.Add(cache.Upsert(lanedBody));
}
@ -419,7 +419,8 @@ public static class ZoneGenerator
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();
var station = GetLoadoutGenerator(story.Faction).GenerateStationLoadout(
StationKinds.Choose(cache, story.Faction, $"{seed}:station:{i}", itemManager.Log));
if (station == null)
{
itemManager.Log($"Story station for {story.Faction?.Name} could not be generated; its story has nowhere to live!");
@ -440,7 +441,8 @@ public static class ZoneGenerator
var security = (SecurityLevel) ((int) ((1f - pow(random.NextFloat(), factionPresence / 2f)) * 3f));
var lagrangeOrbit = CreateLagrangeOrbit(orbit);
var station = GetLoadoutGenerator(nearestFaction).GenerateStationLoadout();
var station = GetLoadoutGenerator(nearestFaction).GenerateStationLoadout(
StationKinds.Choose(cache, nearestFaction, $"{seed}:station:{i}", itemManager.Log));
if (station == null)
{
if (isTutorialEntrance)

BIN
GameData/Aetheria.cc (Stored with Git LFS)

Binary file not shown.

View file

@ -60,6 +60,7 @@ public sealed class ConsumableSupplyTests : IDisposable
public ItemManager Items;
public Galaxy Galaxy;
public Faction Maker;
public CultRecordRef<StationKindData> Kind;
public LoadoutGenerator Generator(ref Random random) => new LoadoutGenerator(ref random, Items, Galaxy, null, Maker, .5f);
}
@ -84,8 +85,9 @@ public sealed class ConsumableSupplyTests : IDisposable
maker = seed.Upsert(new Faction { Name = "Maker", ShortName = "MKR", Allegiance = { { ally, 1f } } });
// Interior for the crate, the capacitor and the tractor beam every generated ship carries.
var hub = new CultRecordRef<StationKindData>(seed.Upsert(new StationKindData { Name = "Hub" }).Key);
var skiff = seed.Upsert(new HullData { Name = "Skiff", HullType = HullType.Ship, Shape = Solid(5, 3), Price = 100 });
var platform = seed.Upsert(new HullData { Name = "Platform", HullType = HullType.Station, Shape = Solid(5, 5), Price = 100 });
var platform = seed.Upsert(new HullData { Name = "Platform", HullType = HullType.Station, Kind = hub, Shape = Solid(5, 5), Price = 100 });
// A hold with no cell cannot take a consumable.
var crate = seed.Upsert(new CargoBayData
{
@ -107,7 +109,7 @@ public sealed class ConsumableSupplyTests : IDisposable
if (holds != Holds.Pinned)
{
sold.Add(("Cutter", seed.Upsert(new HullData { Name = "Cutter", HullType = HullType.Ship, Shape = Solid(5, 3), Price = 100 }).Key));
sold.Add(("Outpost", seed.Upsert(new HullData { Name = "Outpost", HullType = HullType.Station, Shape = Solid(4, 4), Price = 100 }).Key));
sold.Add(("Outpost", seed.Upsert(new HullData { Name = "Outpost", HullType = HullType.Station, Kind = hub, Shape = Solid(4, 4), Price = 100 }).Key));
sold.Add(("Plate", seed.Upsert(new GearData { Name = "Plate", Hardpoint = HardpointType.Tool, Shape = Solid(2, 2), Price = 1 }).Key));
}
@ -155,7 +157,8 @@ public sealed class ConsumableSupplyTests : IDisposable
Cache = cache,
Items = new ItemManager(1u, cache, new ProvenanceLedger(), RunSaveTests.TestSettings(), _ => { }),
Galaxy = new Galaxy(cache, cache.GetGlobal<SavedGame>(), _ => { }),
Maker = cache.GetByName<Faction>("Maker")
Maker = cache.GetByName<Faction>("Maker"),
Kind = new CultRecordRef<StationKindData>(cache.GetAll<StationKindData>().Select(k => cache.RefOf(k).Key).Single())
};
}
@ -193,7 +196,7 @@ public sealed class ConsumableSupplyTests : IDisposable
for (var i = 0; i < Seeds; i++)
{
var random = new Random(SeedOf(i));
var pack = rig.Generator(ref random).GenerateStationLoadout();
var pack = rig.Generator(ref random).GenerateStationLoadout(rig.Kind);
Assert.NotEmpty(pack.CargoContents.SelectMany(bay => bay)); // the gear stock is read from the same pack
var held = Consumables(pack);
var hull = rig.Items.GetData(pack.Hull).Name;
@ -255,7 +258,7 @@ public sealed class ConsumableSupplyTests : IDisposable
for (var i = 0; i < Seeds; i++)
{
var random = new Random(SeedOf(i));
if (Consumables(rig.Generator(ref random).GenerateStationLoadout()).Length > 0) stocked++;
if (Consumables(rig.Generator(ref random).GenerateStationLoadout(rig.Kind)).Length > 0) stocked++;
}
AssertWithinThreeSigma(stocked, Seeds, StationChance, "stations stocking a consumable past a refusing first bay");
}
@ -289,7 +292,7 @@ public sealed class ConsumableSupplyTests : IDisposable
items.Random = new Random(SeedOf(i));
var random = new Random(SeedOf(i));
var generator = new LoadoutGenerator(ref random, items, galaxy, galaxy.Entrance, null, .5f);
if (Consumables(generator.GenerateStationLoadout()).Length > 0) stations++;
if (Consumables(generator.GenerateStationLoadout(TestStationKinds.TradeHub)).Length > 0) stations++;
if (Consumables(generator.GenerateShipLoadout()).Length > 0) ships++;
}
AssertWithinThreeSigma(stations, Seeds, StationChance, "shipped stations stocking a consumable");
@ -327,7 +330,7 @@ public sealed class ConsumableSupplyTests : IDisposable
rig.Items.Random = new Random(99);
var random = new Random(5);
var generator = rig.Generator(ref random);
generator.GenerateStationLoadout();
generator.GenerateStationLoadout(rig.Kind);
for (var i = 0; i < 3; i++) generator.GenerateShipLoadout();
return Enumerable.Range(0, 4).Select(_ => generator.Random.NextFloat())
.Concat(Enumerable.Range(0, 4).Select(_ => rig.Items.Random.NextFloat())).ToArray();

View file

@ -264,7 +264,7 @@ public sealed partial class RunStartTests
var shipHulls = LoadoutGenerator.SoldHulls(_cache).Where(h => h.HullType == HullType.Ship).Select(h => h.Name).ToList();
var generator = new LoadoutGenerator(ref _items.Random, _items, _galaxy, _galaxy.Entrance, _protagonist, .5f);
var packs = shipHulls.SelectMany(name => Enumerable.Range(0, 2).Select(_ => generator.GenerateShipLoadout(h => h.Name == name)))
.Concat(Enumerable.Range(0, 4).Select(_ => generator.GenerateStationLoadout()))
.Concat(Enumerable.Range(0, 4).Select(_ => generator.GenerateStationLoadout(TestStationKinds.TradeHub)))
.Concat(Enumerable.Range(0, 4).Select(_ => generator.GenerateTurretLoadout()))
.ToList();
var readers = 0;

View file

@ -638,7 +638,7 @@ public sealed partial class MiningCut3Tests : IDisposable
var counts = new Dictionary<string, int> { ["Light"] = 0, ["Never"] = 0, ["Middle"] = 0, ["Heavy"] = 0 };
for (var i = 0; i < 2000; i++)
{
var key = new CultRecordKey($"belt-{i}");
var key = $"belt-{i}";
var picked = FieldKinds.Assign(key, s.Cache);
Assert.True(picked.Key.Equals(FieldKinds.Assign(key, s.Cache).Key));
counts[s.Cache.Get(picked).Name]++;
@ -649,7 +649,7 @@ public sealed partial class MiningCut3Tests : IDisposable
Assert.InRange(counts["Heavy"] / 2000f, 3f / 6 - .04f, 3f / 6 + .04f);
var empty = BuildScene(new[] { never });
Assert.False(FieldKinds.Assign(new CultRecordKey("belt-0"), empty.Cache).IsSet());
Assert.False(FieldKinds.Assign("belt-0", empty.Cache).IsSet());
}
// Q16 B, first load: a belt saved before field kinds existed gets its kind when a zone first loads it, by the
@ -664,7 +664,7 @@ public sealed partial class MiningCut3Tests : IDisposable
var beltKey = s.Belts[0];
var belt = (AsteroidBeltData) s.Zone.Planets[beltKey];
Assert.True(belt.Kind.IsSet());
Assert.True(belt.Kind.Key.Equals(FieldKinds.Assign(beltKey, s.Cache).Key));
Assert.True(belt.Kind.Key.Equals(FieldKinds.Assign(beltKey.Value, s.Cache).Key));
var assigned = belt.Kind.Key;
// Saved: a fresh open of the same stores reads the kind back.
@ -678,7 +678,7 @@ public sealed partial class MiningCut3Tests : IDisposable
// Kept: a new, overwhelmingly weighted kind now wins the pick for this belt, yet loading it again leaves it.
reopened.Upsert(Kind("Overwhelming", 9f, 1e6f));
Assert.False(FieldKinds.Assign(beltKey, reopened).Key.Equals(assigned));
Assert.False(FieldKinds.Assign(beltKey.Value, reopened).Key.Equals(assigned));
var items = new ItemManager(1u, reopened, new ProvenanceLedger(), GameSettings(), _ => { });
var reloaded = new Zone(items, PlanetSettings(), s.Pack, new GalaxyZone { Name = "MiningCut3Reload", Owner = null }, null);
Assert.True(((AsteroidBeltData) reloaded.Planets[beltKey]).Kind.Key.Equals(assigned));
@ -786,11 +786,11 @@ public sealed partial class MiningCut3Tests : IDisposable
return cache;
}
// Q16 B, generation: every belt ZoneGenerator makes carries its kind already, chosen by FieldKinds.Assign on
// the belt's own key. Runs against a scratch copy of the shipped catalog with three kinds of different
// Q16 B, generation: every belt ZoneGenerator makes carries its kind already, chosen by FieldKinds.Assign. Runs against
// a scratch copy of the shipped catalog with three kinds of different
// weights, so a pick by any other rule would disagree on some belt.
[Fact]
public void GenerationChoosesTheKindByTheSameFunction()
public void GenerationAssignsEveryBeltItsKind()
{
var shipped = TestCatalog.Repo;
var belts = 0;
@ -826,13 +826,57 @@ public sealed partial class MiningCut3Tests : IDisposable
if (!(cache.Get(body) is AsteroidBeltData belt)) continue;
belts++;
Assert.True(belt.Kind.IsSet());
Assert.True(belt.Kind.Key.Equals(FieldKinds.Assign(body.Key, cache).Key));
Assert.StartsWith("Gen ", cache.Get(belt.Kind).Name);
}
}
}
Assert.True(belts > 0, "no seed generated a belt; the generation path went unexercised");
}
// The kind of a belt is a function of the zone's seed, not of the key the cache mints for it: the same seed generated
// again, through the real key minting, gives the same belts the same kinds.
[Fact]
public void SameSeedGivesTheSameBeltKinds()
{
string[] Generate(uint seed, int run)
{
var dir = Path.Combine(_root, $"same{seed}-{run}");
Directory.CreateDirectory(dir);
var catalog = Path.Combine(dir, "Aetheria.cc");
File.Copy(TestCatalog.Repo, catalog);
using var cache = OpenShippedCatalogCopy(catalog, Path.Combine(dir, "run.cc"));
foreach (var existing in cache.GetAll<FieldKindData>().ToArray())
{
existing.GenerationWeight = 0f;
cache.Upsert(existing);
}
// Authored kinds have fixed keys; the pick orders kinds by key, so the fixture's keys are fixed too.
cache.Commit(batch => batch.Upsert(typeof(FieldKindData), Kind("Gen A", 1f, 1f), new CultRecordKey("field-kind:gen-a")));
cache.Commit(batch => batch.Upsert(typeof(FieldKindData), Kind("Gen B", 1f, 2f), new CultRecordKey("field-kind:gen-b")));
cache.Commit(batch => batch.Upsert(typeof(FieldKindData), Kind("Gen C", 1f, 4f), new CultRecordKey("field-kind:gen-c")));
Galaxy galaxy;
try
{
galaxy = new Galaxy(RestoredHullsTests.TutorialGalaxySettings(), RestoredHullsTests.TutorialBackgroundSettings(),
cache, new PlayerSettings(), new DirectoryInfo(dir), _ => { }, null, seed);
}
catch (Exception) { return null; }
var items = new ItemManager(1u, cache, new ProvenanceLedger(), GameSettings(), _ => { });
return galaxy.Zones.Take(6).SelectMany(zone =>
ZoneGenerator.GenerateZone(items, RestoredHullsTests.TutorialZoneSettings(), RestoredHullsTests.AuthoredPlanetSettings(), galaxy, zone, isTutorial: zone == galaxy.Entrance)
.Planets.Select(body => cache.Get(body)).OfType<AsteroidBeltData>().Select(belt => cache.Get(belt.Kind).Name))
.ToArray();
}
for (uint seed = 1; seed <= 25; seed++)
{
var first = Generate(seed, 0);
if (first == null || first.Length < 4) continue;
for (var run = 1; run < 4; run++) Assert.Equal(first, Generate(seed, run));
return;
}
Assert.Fail("no seed generated enough belts; the generation path went unexercised");
}
// ==== Mining Cut 3 fix batch (Soul's findings) ====
// Q12 A ("launchers cannot mine") in the reach rule: reach counts only weapons that can mine (Weapon.CanMine).

View file

@ -37,7 +37,7 @@ public sealed partial class RunStartTests
// Stations and turrets share the interior outfitting and get none.
for (var i = 0; i < 4; i++)
{
Assert.Equal(0, PickupGear(generator.GenerateStationLoadout()));
Assert.Equal(0, PickupGear(generator.GenerateStationLoadout(TestStationKinds.TradeHub)));
Assert.Equal(0, PickupGear(generator.GenerateTurretLoadout()));
}
Assert.All(main.arena.Pack.Entities.Where(pack => !(pack is ShipPack)), pack => Assert.Equal(0, PickupGear(pack)));

View file

@ -318,7 +318,7 @@ public sealed partial class RunStartTests
var ship = generator.GenerateShipLoadout();
Assert.NotNull(ship);
Assert.NotEqual(hull.Name, HullName(items, ship));
var station = generator.GenerateStationLoadout();
var station = generator.GenerateStationLoadout(TestStationKinds.TradeHub);
Assert.DoesNotContain(EntitySerializer.Items(station), item => items.GetData(item).Name == hull.Name);
Assert.Null(generator.ChooseProduct(hull));
Assert.Null(generator.GenerateShipLoadout(candidate => candidate == hull));

View file

@ -107,7 +107,7 @@ public sealed partial class RunStartTests : IDisposable
var generator = new LoadoutGenerator(ref _items.Random, _items, _galaxy, _galaxy.Entrance, _protagonist, .5f);
for (var i = 0; i < 8; i++)
{
var station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout());
var station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout(TestStationKinds.TradeHub));
Assert.True(station.Equipment.Count(IsHeater) == 1, $"station {i} carries {station.Equipment.Count(IsHeater)} heaters");
Assert.True(station.Equipment.Any(item => item.Behaviors.OfType<Reactor>().Any()), $"station {i} has no reactor");
}
@ -168,7 +168,7 @@ public sealed partial class RunStartTests : IDisposable
var generator = new LoadoutGenerator(ref _items.Random, _items, galaxy, galaxy.Entrance, faction, .5f);
for (var i = 0; i < 3; i++)
{
var station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout());
var station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout(TestStationKinds.TradeHub));
Assert.True(station.Equipment.Count(IsHeater) == 1, $"{faction.Name} station {i}: no heater");
Assert.True(station.Equipment.Any(item => item.Behaviors.OfType<Reactor>().Any()), $"{faction.Name} station {i}: no reactor");
var unreachable = Made(station).Where(made => made.product == null || !generator.IsAvailable(made.product)).ToList();
@ -219,7 +219,7 @@ public sealed partial class RunStartTests : IDisposable
Entity station = null;
for (var i = 0; i < 8; i++)
{
station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout());
station = EntitySerializer.Unpack(_items, zone, generator.GenerateStationLoadout(TestStationKinds.TradeHub));
Assert.True(station.Equipment.Any(item => item.Behaviors.OfType<Reactor>().Any()), $"station {i}: no reactor");
var foreign = Made(station).Where(made => made.product == null || !generator.IsAvailable(made.product) ||
made.product.Manufacturer.Key.Equals(_cache.RefOf(zhestokost).Key)).ToList();
@ -313,7 +313,7 @@ public sealed partial class RunStartTests : IDisposable
.OrderBy(design => design.Shape.Coordinates.Length).ThenBy(design => design.Name, StringComparer.Ordinal).First();
var shape = new Shape(bay.Shape.Width + 2, bay.Shape.Height + 2);
foreach (var cell in shape.AllCoordinates) shape[cell] = true;
var cramped = new HullData { Name = "Cramped Station", HullType = HullType.Station, Shape = shape, Durability = 100, Mass = 1000, Price = 1 };
var cramped = new HullData { Name = "Cramped Station", HullType = HullType.Station, Kind = TestStationKinds.TradeHub, Shape = shape, Durability = 100, Mass = 1000, Price = 1 };
_cache.Upsert(cramped);
_cache.Upsert(new FactionProductData
{
@ -323,7 +323,7 @@ public sealed partial class RunStartTests : IDisposable
hull.Price = 0; // generation offers no zero-price design, so the cramped hull is the only station
var generator = new LoadoutGenerator(ref _items.Random, _items, _galaxy, _galaxy.Entrance, _protagonist, .5f);
var failure = Assert.Throws<InvalidLoadoutException>(() => generator.GenerateStationLoadout());
var failure = Assert.Throws<InvalidLoadoutException>(() => generator.GenerateStationLoadout(TestStationKinds.TradeHub));
Assert.Contains("heater", failure.Message);
}

View file

@ -49,6 +49,36 @@ public sealed class ShipModCatalogTests : IDisposable
AssertOnlyTheDerivedFile();
}
// A package's station kind is checked per package: a bad one is left out, named with its reason, and the derived catalog
// still opens. The shipped catalog's own check is unchanged.
[Fact]
public void ComposeExcludesPackagesWithBadStationKinds()
{
using (var cache = AetheriaStores.Open(Shipped, catalogWritable: true))
{
cache.Upsert(new StationKindData { Name = "Hub" });
cache.FlushAsync().Wait();
}
string kindKey;
using (var cache = AetheriaStores.Open(Shipped)) kindKey = cache.RefOf(cache.GetAll<StationKindData>().Single()).Key.Value;
var held = new CultRecordRef<StationKindData>(new CultRecordKey(kindKey));
WritePackage("mod.kindless", "Kindless", tweak: p => p.Hull.HullType = HullType.Station);
WritePackage("mod.unknown", "Unknown", tweak: p => { p.Hull.HullType = HullType.Station; p.Hull.Kind = new CultRecordRef<StationKindData>(new CultRecordKey("station-kind:nowhere")); });
WritePackage("mod.shipkind", "ShipKind", tweak: p => p.Hull.Kind = held);
WritePackage("mod.good", "GoodStation", tweak: p => { p.Hull.HullType = HullType.Station; p.Hull.Kind = held; });
var composition = ShipModCatalog.Compose(Shipped, Derived, Mods);
Assert.Equal(new[] { "mod.good" }, composition.Included);
Assert.Equal(new[] { "mod.kindless", "mod.shipkind", "mod.unknown" }, composition.Excluded.Select(e => e.Package).OrderBy(n => n, StringComparer.Ordinal));
Assert.Contains("no Kind", composition.Excluded.Single(e => e.Package == "mod.kindless").Reason);
Assert.Contains("names no station kind", composition.Excluded.Single(e => e.Package == "mod.unknown").Reason);
Assert.Contains("only a station hull has one", composition.Excluded.Single(e => e.Package == "mod.shipkind").Reason);
using var derived = AetheriaStores.Open(Derived);
Assert.Contains("GoodStation", derived.GetAll<HullData>().Select(hull => hull.Name));
Assert.DoesNotContain("Kindless", derived.GetAll<HullData>().Select(hull => hull.Name));
}
// Correction 2 of the S0 map: the derived catalog held each mod hull twice, once as a HullData and once inside the
// ship's authoring record. The hull is now one record, and the visual holds no hull.
[Fact]

View file

@ -0,0 +1,458 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CultMath;
using GameCult.Caching;
using GameCult.Caching.MessagePack;
using MessagePack;
using Xunit;
using Random = CultMath.Random;
// Test-side handle on the shipped catalog's trade-hub kind, the one Zenith carries (ruling zenith-is-a-trade-hub).
internal static class TestStationKinds
{
public static readonly CultRecordRef<StationKindData> TradeHub = new CultRecordRef<StationKindData>(StationKindData.KeyOf("trade-hub"));
}
// Station kinds (aetheria-living-world, cut station-kind-datum): the one list of kinds in the catalog, a hull's kind, a
// placed station's kind, and the stand-in rule for a faction with no model of a kind. Worlds here are the composed shipped
// catalog copied to a temp directory, with Zenith taken off the market so the only station hulls are the ones a test adds.
public sealed class StationKindTests : IDisposable
{
private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-stationkinds-" + Guid.NewGuid().ToString("N"));
private readonly List<CultCache> _caches = new List<CultCache>();
private int _worlds;
public StationKindTests() => Directory.CreateDirectory(_root);
public void Dispose()
{
foreach (var cache in _caches) cache.Dispose();
Directory.Delete(_root, true);
}
private static CultRecordRef<StationKindData> Kind(string id) => new CultRecordRef<StationKindData>(StationKindData.KeyOf(id));
private sealed class World
{
public CultCache Cache;
public ItemManager Items;
public List<string> Log = new List<string>();
public Faction Zh, Au, Lucent;
public HullData Zenith;
private FactionProductData _zenithProduct;
private int _added;
public static World Make(StationKindTests host, bool zenithOffered)
{
var dir = Path.Combine(host._root, "world" + host._worlds++);
Directory.CreateDirectory(dir);
File.Copy(TestCatalog.Repo, Path.Combine(dir, "Aetheria.cc"));
var cache = new CultCache(TestCatalog.Registry());
host._caches.Add(cache);
cache.AddBackingStore(new SingleFileMessagePackBackingStore(Path.Combine(dir, "Aetheria.cc")), AetheriaStores.CatalogTypes);
cache.AddBackingStore(new SingleFileMessagePackBackingStore(Path.Combine(dir, "run.cc")), AetheriaStores.RunTypes);
var world = new World { Cache = cache };
world.Items = new ItemManager(1u, cache, new ProvenanceLedger(), RunSaveTests.TestSettings(), world.Log.Add);
world.Zh = cache.GetAll<Faction>().Single(f => f.Name == "Zhestokost");
world.Au = cache.GetAll<Faction>().Single(f => f.ShortName == "AU");
world.Lucent = cache.GetAll<Faction>().Single(f => f.ShortName == "Lucent");
world.Zenith = cache.GetAll<HullData>().Single(h => h.Name == "Zenith");
world._zenithProduct = cache.GetAll<FactionProductData>().Single(p => cache.Get(p.Design) == world.Zenith);
if (!zenithOffered)
{
world._zenithProduct.NotOffered = true;
cache.Upsert(world._zenithProduct);
}
return world;
}
// A station hull of the given kind that this faction sells: a copy of Zenith's body, so it takes the same docking bay
// and heater, with its own name and kind.
public HullData Sell(Faction maker, string kindId, string name = null)
{
var options = CultDocumentMessagePackSerialization.OptionsFor(typeof(HullData).Assembly);
var hull = MessagePackSerializer.Deserialize<HullData>(MessagePackSerializer.Serialize(Zenith, options), options);
hull.Name = name ?? $"{maker.ShortName} {kindId} {_added++}";
hull.Kind = Kind(kindId);
var hullRef = Cache.Upsert(hull);
var product = MessagePackSerializer.Deserialize<FactionProductData>(MessagePackSerializer.Serialize(_zenithProduct, options), options);
product.Name = hull.Name;
product.Design = new CultRecordRef<CraftedItemData>(hullRef.Key);
product.Manufacturer = Cache.RefOf(maker);
product.NotOffered = false;
Cache.Upsert(product);
return hull;
}
public void StandIn(string kindId, Faction faction, string asKindId)
{
var kind = Cache.Get(Kind(kindId));
kind.StandIns.Add(new StationKindStandIn { Faction = Cache.RefOf(faction), Kind = Kind(asKindId) });
Cache.Upsert(kind);
}
public LoadoutGenerator Generator(Faction faction, uint seed = 1)
{
var random = new Random(seed);
Items.Random = new Random(seed);
return new LoadoutGenerator(ref random, Items, null, null, faction, .5f);
}
public string HullName(OrbitalEntityPack pack) => Items.GetData(pack.Hull).Name;
public HullData HullOf(OrbitalEntityPack pack) => (HullData) Items.GetData(pack.Hull);
}
// ---- Open ----
private CultCache SeedAndReopen(Action<CultCache> seed, out string path)
{
path = Path.Combine(_root, "open" + _worlds++ + ".cc");
using (var cache = AetheriaStores.Open(path, catalogWritable: true))
{
cache.Upsert(new VerseGrammar { Revision = 1 });
cache.Upsert(new InputLayout { Rows = new InputLayoutRow[] { new InputLayoutRowSpacer { Height = 1 } } });
seed(cache);
cache.FlushAsync().Wait();
}
return null;
}
private string OpenRefusal(Action<CultCache> seed)
{
SeedAndReopen(seed, out var path);
var failure = Assert.Throws<InvalidOperationException>(() => AetheriaStores.Open(path));
return failure.Message;
}
private static HullData Hull(HullType type, CultRecordRef<StationKindData> kind = default) =>
new HullData { Name = "Probe " + type, HullType = type, Shape = new Shape(2, 2), Price = 1, Kind = kind };
[Fact]
public void OpenRefusesKindlessStationHull()
{
Assert.Contains("has no Kind", OpenRefusal(cache => cache.Upsert(Hull(HullType.Station))));
Assert.Contains("names no station kind", OpenRefusal(cache => cache.Upsert(Hull(HullType.Station, Kind("nowhere")))));
var shipWithKind = OpenRefusal(cache =>
{
var kind = new CultRecordRef<StationKindData>(cache.Upsert(new StationKindData { Name = "Hub" }).Key);
cache.Upsert(Hull(HullType.Ship, kind));
});
Assert.Contains("only a station hull has one", shipWithKind);
var turretWithKind = OpenRefusal(cache =>
{
var kind = new CultRecordRef<StationKindData>(cache.Upsert(new StationKindData { Name = "Hub" }).Key);
cache.Upsert(Hull(HullType.Turret, kind));
});
Assert.Contains("only a station hull has one", turretWithKind);
}
[Fact]
public void OpenRefusesBadStandIn()
{
CultRecordRef<StationKindData> Mint(CultCache cache, string name, Action<StationKindData> shape = null)
{
var kind = new StationKindData { Name = name };
shape?.Invoke(kind);
return new CultRecordRef<StationKindData>(cache.Upsert(kind).Key);
}
Assert.Contains("kind itself", OpenRefusal(cache =>
{
CultRecordRef<Faction> faction = cache.Upsert(new Faction { Name = "F", ShortName = "F" });
var kind = new StationKindData { Name = "Self" };
var handle = cache.Upsert(kind);
kind.StandIns.Add(new StationKindStandIn { Faction = faction, Kind = new CultRecordRef<StationKindData>(handle.Key) });
cache.Upsert(kind);
}));
Assert.Contains("StandIns[0].Faction names no faction", OpenRefusal(cache =>
{
var other = Mint(cache, "Other");
Mint(cache, "Lonely", kind => kind.StandIns.Add(new StationKindStandIn { Faction = new CultRecordRef<Faction>(new CultRecordKey("nobody")), Kind = other }));
}));
Assert.Contains("StandIns[0].Kind names no station kind", OpenRefusal(cache =>
{
CultRecordRef<Faction> faction = cache.Upsert(new Faction { Name = "F", ShortName = "F" });
Mint(cache, "Lonely", kind => kind.StandIns.Add(new StationKindStandIn { Faction = faction, Kind = Kind("nowhere") }));
}));
// A stand-in whose kind stands in for another faction only is one hop for this faction: Open accepts it.
SeedAndReopen(cache =>
{
CultRecordRef<Faction> mine = cache.Upsert(new Faction { Name = "F", ShortName = "F" });
CultRecordRef<Faction> other = cache.Upsert(new Faction { Name = "G", ShortName = "G" });
var third = Mint(cache, "Third");
var second = Mint(cache, "Second", kind => kind.StandIns.Add(new StationKindStandIn { Faction = other, Kind = third }));
Mint(cache, "First", kind => kind.StandIns.Add(new StationKindStandIn { Faction = mine, Kind = second }));
}, out var accepted);
AetheriaStores.Open(accepted).Dispose();
// Any one of the stand-in kind's entries for the same faction makes a second hop.
Assert.Contains("one hop", OpenRefusal(cache =>
{
CultRecordRef<Faction> mine = cache.Upsert(new Faction { Name = "F", ShortName = "F" });
CultRecordRef<Faction> other = cache.Upsert(new Faction { Name = "G", ShortName = "G" });
var third = Mint(cache, "Third");
var second = Mint(cache, "Second", kind =>
{
kind.StandIns.Add(new StationKindStandIn { Faction = other, Kind = third });
kind.StandIns.Add(new StationKindStandIn { Faction = mine, Kind = third });
});
Mint(cache, "First", kind => kind.StandIns.Add(new StationKindStandIn { Faction = mine, Kind = second }));
}));
Assert.Contains("one hop", OpenRefusal(cache =>
{
CultRecordRef<Faction> faction = cache.Upsert(new Faction { Name = "F", ShortName = "F" });
var third = Mint(cache, "Third");
var second = Mint(cache, "Second", kind => kind.StandIns.Add(new StationKindStandIn { Faction = faction, Kind = third }));
Mint(cache, "First", kind => kind.StandIns.Add(new StationKindStandIn { Faction = faction, Kind = second }));
}));
}
// ---- generation ----
[Fact]
public void StationsArePlacedByKind()
{
var world = World.Make(this, zenithOffered: false);
world.Sell(world.Au, "mining");
world.Sell(world.Au, "shipyard");
world.Sell(world.Au, "mining");
var kinds = StationKinds.KindsOf(world.Cache, world.Au).Select(kind => kind.Key.Value).ToArray();
Assert.Equal(new[] { StationKindData.KeyOf("mining").Value, StationKindData.KeyOf("shipyard").Value }, kinds);
var seen = new HashSet<string>();
for (var site = 0; site < 40; site++)
{
var kind = StationKinds.Choose(world.Cache, world.Au, "site-" + site);
Assert.Contains(kind.Key.Value, kinds);
seen.Add(kind.Key.Value);
var pack = world.Generator(world.Au, (uint) site + 1).GenerateStationLoadout(kind);
Assert.NotNull(pack);
Assert.Equal(kind.Key, pack.Kind.Key);
Assert.Equal(kind.Key, world.HullOf(pack).Kind.Key);
}
Assert.Equal(kinds.Length, seen.Count);
}
[Fact]
public void StandInUsesFactionModelAndKeepsName()
{
var world = World.Make(this, zenithOffered: false);
var hub = world.Sell(world.Zh, "trade-hub", "Zh Hub");
world.StandIn("mining", world.Zh, "trade-hub");
var mining = world.Cache.Get(Kind("mining"));
Assert.Contains(Kind("mining").Key.Value, StationKinds.KindsOf(world.Cache, world.Zh).Select(kind => kind.Key.Value));
Assert.Equal(Kind("trade-hub").Key, StationKinds.HullKindFor(world.Cache, world.Zh, Kind("mining")).Key);
for (uint seed = 1; seed <= 10; seed++)
{
var pack = world.Generator(world.Zh, seed).GenerateStationLoadout(Kind("mining"));
Assert.Equal("Zh Hub", world.HullName(pack));
Assert.Equal(Kind("mining").Key, pack.Kind.Key);
Assert.Equal(mining.Name, pack.Name);
}
var own = world.Generator(world.Zh).GenerateStationLoadout(Kind("trade-hub"));
Assert.Equal(hub.Name, own.Name);
}
[Fact]
public void ModelWinsOverStaleStandIn()
{
var world = World.Make(this, zenithOffered: false);
world.Sell(world.Zh, "trade-hub", "Zh Hub");
world.Sell(world.Zh, "mining", "Zh Mine");
world.StandIn("mining", world.Zh, "trade-hub");
Assert.Equal(Kind("mining").Key, StationKinds.HullKindFor(world.Cache, world.Zh, Kind("mining")).Key);
for (uint seed = 1; seed <= 10; seed++)
{
var pack = world.Generator(world.Zh, seed).GenerateStationLoadout(Kind("mining"));
Assert.Equal("Zh Mine", world.HullName(pack));
Assert.Equal("Zh Mine", pack.Name);
}
}
[Fact]
public void FactionWithoutModelsFallsBack()
{
var world = World.Make(this, zenithOffered: false);
world.Sell(world.Au, "shipyard");
Assert.Empty(StationKinds.KindsOf(world.Cache, world.Lucent));
var logged = new List<string>();
var kind = StationKinds.Choose(world.Cache, world.Lucent, "site", logged.Add);
Assert.Equal(Kind("shipyard").Key, kind.Key);
Assert.Single(logged);
Assert.Contains(world.Lucent.Name, logged[0]);
var anonymous = new List<string>();
StationKinds.Choose(world.Cache, null, "site", anonymous.Add);
Assert.Contains("This galaxy", Assert.Single(anonymous));
world.StandIn("mining", world.Au, "shipyard");
Assert.Equal(Kind("mining").Key, StationKinds.HullKindFor(world.Cache, null, Kind("mining")).Key);
Assert.False(StationKinds.HullKindFor(world.Cache, world.Au, default).IsSet());
var pack = world.Generator(world.Lucent).GenerateStationLoadout(kind);
Assert.NotNull(pack);
Assert.Equal(kind.Key, pack.Kind.Key);
}
[Fact]
public void KindChoiceLeavesRandomStream()
{
var world = World.Make(this, zenithOffered: false);
world.Sell(world.Au, "mining");
world.Sell(world.Au, "shipyard");
world.Sell(world.Au, "depot");
var keys = Enumerable.Range(0, 30).Select(i => "orbit-" + i).ToArray();
var first = keys.Select(key => StationKinds.Choose(world.Cache, world.Au, key).Key.Value).ToArray();
Assert.Equal(first, keys.Reverse().Select(key => StationKinds.Choose(world.Cache, world.Au, key).Key.Value).Reverse().ToArray());
Assert.True(first.Distinct().Count() > 1, "the stable hash spreads sites over the faction's kinds");
// Generating a zone with one station kind in the catalog and with several draws the same orbits and turrets.
(float, float)[] Orbits(Action<World> stock)
{
var w = World.Make(this, zenithOffered: true);
stock?.Invoke(w);
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot());
var dir = Path.Combine(_root, "galaxy" + _worlds++);
var galaxy = new Galaxy(authored.Read<TutorialGenerationSettings>("TutorialGenerationSettings"),
authored.Read<SectorBackgroundSettings>("TutorialBackgroundSettings"), w.Cache, new PlayerSettings(),
Directory.CreateDirectory(Path.Combine(dir, "Narrative")), _ => { }, null, 3);
var pack = ZoneGenerator.GenerateZone(w.Items, authored.Read<ZoneGenerationSettings>("ZoneSettings"),
authored.Read<PlanetSettings>("PlanetSettings"), galaxy, galaxy.Entrance, galaxy.IsPrelude, true);
Assert.NotEmpty(pack.Entities.OfType<OrbitalEntityPack>());
return pack.Orbits.Select(orbit => w.Cache.Get(orbit)).Select(orbit => (orbit.Distance, orbit.Phase)).ToArray();
}
var one = Orbits(null);
var several = Orbits(w => { w.Sell(w.Au, "mining"); w.Sell(w.Zh, "shipyard"); w.Sell(w.Lucent, "depot"); });
Assert.Equal(one, several);
}
// A station's kind is a function of the zone's seed and the orbit's place in generation, not of a key the cache mints:
// the same zone generated again, through the real key minting, gives the same stations the same kinds in the same order.
[Fact]
public void SameSeedGivesTheSameStationKinds()
{
string[] Kinds()
{
var w = World.Make(this, zenithOffered: true);
foreach (var faction in new[] { w.Au, w.Zh, w.Lucent })
foreach (var kind in new[] { "mining", "shipyard", "depot", "power" }) w.Sell(faction, kind);
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot());
var galaxy = new Galaxy(authored.Read<TutorialGenerationSettings>("TutorialGenerationSettings"),
authored.Read<SectorBackgroundSettings>("TutorialBackgroundSettings"), w.Cache, new PlayerSettings(),
Directory.CreateDirectory(Path.Combine(_root, "galaxy" + _worlds++, "Narrative")), _ => { }, null, 3);
return galaxy.Zones.Take(8).SelectMany(zone => ZoneGenerator.GenerateZone(w.Items, authored.Read<ZoneGenerationSettings>("ZoneSettings"),
authored.Read<PlanetSettings>("PlanetSettings"), galaxy, zone, zone == galaxy.Entrance && galaxy.IsPrelude, true)
.Entities.OfType<OrbitalEntityPack>().Where(e => e.Kind.IsSet()).Select(e => e.Kind.Key.Value)).ToArray();
}
var first = Kinds();
Assert.True(first.Length >= 3, "the sample placed stations");
for (var run = 1; run < 6; run++) Assert.Equal(first, Kinds());
}
[Fact]
public void GeneratedZonesPlaceStationsByKind()
{
var w = World.Make(this, zenithOffered: true);
w.Sell(w.Au, "mining");
w.Sell(w.Au, "shipyard");
var authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot());
var galaxy = new Galaxy(authored.Read<TutorialGenerationSettings>("TutorialGenerationSettings"),
authored.Read<SectorBackgroundSettings>("TutorialBackgroundSettings"), w.Cache, new PlayerSettings(),
Directory.CreateDirectory(Path.Combine(_root, "zones", "Narrative")), _ => { }, null, 5);
var stations = 0;
foreach (var galaxyZone in galaxy.Zones.Take(8))
{
var pack = ZoneGenerator.GenerateZone(w.Items, authored.Read<ZoneGenerationSettings>("ZoneSettings"),
authored.Read<PlanetSettings>("PlanetSettings"), galaxy, galaxyZone, galaxyZone == galaxy.Entrance && galaxy.IsPrelude, true);
foreach (var station in pack.Entities.OfType<OrbitalEntityPack>().Where(e => w.HullOf(e).HullType == HullType.Station))
{
stations++;
Assert.True(station.Kind.IsSet(), "a placed station has a kind");
Assert.Equal(station.Kind.Key, w.HullOf(station).Kind.Key);
var faction = w.Cache.Get(station.Faction);
var kinds = StationKinds.KindsOf(w.Cache, faction);
if (kinds.Length > 0) Assert.Contains(station.Kind.Key.Value, kinds.Select(kind => kind.Key.Value));
}
}
Assert.True(stations > 0, "the sample generated stations");
}
[Fact]
public void KindSurvivesSave()
{
var world = World.Make(this, zenithOffered: false);
world.Sell(world.Au, "research");
var pack = world.Generator(world.Au).GenerateStationLoadout(Kind("research"));
var options = CultDocumentMessagePackSerialization.OptionsFor(typeof(HullData).Assembly);
var bytes = MessagePackSerializer.Serialize<EntityPack>(pack, options);
var restored = Assert.IsType<OrbitalEntityPack>(MessagePackSerializer.Deserialize<EntityPack>(bytes, options));
Assert.Equal(Kind("research").Key, restored.Kind.Key);
var entity = Assert.IsType<OrbitalEntity>(EntitySerializer.Unpack(world.Items, null, restored));
Assert.Equal(Kind("research").Key, entity.Kind.Key);
Assert.Equal(Kind("research").Key, ((OrbitalEntityPack) EntitySerializer.Pack(entity)).Kind.Key);
}
// ---- the shipped catalog ----
[Fact]
public void ShippedCatalogHoldsOneKindList()
{
using var cache = AetheriaStores.Open(Path.Combine(RunStartTests.FindRepoRoot(), "GameData", "Aetheria.cc"));
var ids = new[]
{
"mining", "volatiles", "agriculture", "processing", "fabrication", "shipyard", "depot", "trade-hub", "residential",
"habitat-support", "urban", "administrative", "power", "research", "salvage", "black-market", "waystation"
};
Assert.Equal(ids.Select(id => StationKindData.KeyOf(id).Value).OrderBy(key => key, StringComparer.Ordinal),
cache.GetAll<StationKindData>().Select(kind => cache.RefOf(kind).Key.Value).OrderBy(key => key, StringComparer.Ordinal));
Assert.Equal(StationKindData.KeyOf("trade-hub").Value, cache.GetAll<HullData>().Single(h => h.Name == "Zenith").Kind.Key.Value);
}
private static void AssertStandInsLive(CultCache cache)
{
foreach (var kind in cache.GetAll<StationKindData>())
foreach (var standIn in kind.StandIns)
{
var faction = cache.Get(standIn.Faction);
var models = StationKinds.KindsOf(cache, faction);
var own = cache.GetAll<FactionProductData>().Where(p => cache.Get(p.Manufacturer) == faction && LoadoutGenerator.IsOffered(cache, p))
.Select(p => cache.Get(p.Design) as HullData).Where(h => h != null && h.HullType == HullType.Station).Select(h => h.Kind.Key).ToArray();
Assert.DoesNotContain(cache.RefOf(kind).Key, own);
Assert.Contains(standIn.Kind.Key, own);
Assert.NotEmpty(models);
}
}
[Fact]
public void ShippedStandInsAreLive()
{
using var cache = AetheriaStores.Open(TestCatalog.Repo);
AssertStandInsLive(cache);
}
// The retirement check is not vacuous: given a stand-in it passes when the faction offers the kind it stands in with and
// not the owning kind, and fails when the faction has gained its own model of the owning kind or has no model to use.
[Fact]
public void StandInRetirementCheckCanFail()
{
var live = World.Make(this, zenithOffered: false);
live.Sell(live.Au, "mining");
live.StandIn("shipyard", live.Au, "mining");
Assert.Single(live.Cache.GetAll<StationKindData>().SelectMany(kind => kind.StandIns));
AssertStandInsLive(live.Cache);
var retired = World.Make(this, zenithOffered: false);
retired.Sell(retired.Au, "mining");
retired.Sell(retired.Au, "shipyard");
retired.StandIn("shipyard", retired.Au, "mining");
Assert.ThrowsAny<Exception>(() => AssertStandInsLive(retired.Cache));
var hollow = World.Make(this, zenithOffered: false);
hollow.StandIn("shipyard", hollow.Au, "mining");
Assert.ThrowsAny<Exception>(() => AssertStandInsLive(hollow.Cache));
}
}

View file

@ -0,0 +1,177 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using GameCult.Caching;
using Xunit;
public sealed class StationKindsCatalogTests : IDisposable
{
private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-stationkindscmd-" + Guid.NewGuid().ToString("N"));
public StationKindsCatalogTests() => Directory.CreateDirectory(_root);
public void Dispose() => Directory.Delete(_root, true);
private static readonly string[] Ids =
{
"mining", "volatiles", "agriculture", "processing", "fabrication", "shipyard", "depot", "trade-hub", "residential",
"habitat-support", "urban", "administrative", "power", "research", "salvage", "black-market", "waystation"
};
// The catalog this command first runs on holds a station hull with no kind. The game's Open refuses it; the tool's Open
// names the hull and goes on, so the command can give it one: Zenith gets the ruled kind, a kind it already has is kept.
[Fact]
public void ZenithGetsTheRuledKindAndAKindedOneIsKept()
{
var path = Path.Combine(_root, "Zenith.cc");
using (var seed = AetheriaStores.Open(path, catalogWritable: true))
{
seed.Upsert(new VerseGrammar { Revision = 1 });
seed.Upsert(new InputLayout { Rows = new InputLayoutRow[] { new InputLayoutRowSpacer { Height = 1 } } });
seed.Upsert(new HullData { Name = "Zenith", HullType = HullType.Station, Shape = new Shape(2, 2), Price = 1 });
seed.Upsert(new HullData { Name = "Cutter", HullType = HullType.Ship, Shape = new Shape(2, 2), Price = 1 });
seed.FlushAsync().Wait();
}
Assert.Throws<InvalidOperationException>(() => AetheriaStores.Open(path));
var named = new List<string>();
var dry = new StringWriter();
using (var cache = AetheriaStores.Open(path, kindlessStation: named.Add)) StationKindsCatalog.Run(cache, false, dry);
Assert.Contains("Zenith", Assert.Single(named));
Assert.Contains("Zenith: kind trade-hub", dry.ToString());
var applied = new StringWriter();
using (var cache = AetheriaStores.Open(path, catalogWritable: true, kindlessStation: _ => { }))
{
StationKindsCatalog.Run(cache, true, applied);
cache.FlushAsync().Wait();
}
Assert.Contains("and Zenith's kind", applied.ToString());
using (var cache = AetheriaStores.Open(path))
{
Assert.Equal(StationKindData.KeyOf("trade-hub").Value, cache.GetAll<HullData>().Single(h => h.Name == "Zenith").Kind.Key.Value);
Assert.False(cache.GetAll<HullData>().Single(h => h.Name == "Cutter").Kind.IsSet());
}
var again = new StringWriter();
using (var cache = AetheriaStores.Open(path, catalogWritable: true, kindlessStation: _ => { })) StationKindsCatalog.Run(cache, true, again);
Assert.Contains("Zenith: already has a kind, kept", again.ToString());
Assert.Contains("Nothing to author", again.ToString());
}
private string SeedRoot(params string[] kindlessStations)
{
var root = Path.Combine(_root, "root" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(Path.Combine(root, "GameData"));
using var seed = AetheriaStores.Open(Path.Combine(root, "GameData", "Aetheria.cc"), catalogWritable: true);
seed.Upsert(new VerseGrammar { Revision = 1 });
seed.Upsert(new InputLayout { Rows = new InputLayoutRow[] { new InputLayoutRowSpacer { Height = 1 } } });
foreach (var name in kindlessStations) seed.Upsert(new HullData { Name = name, HullType = HullType.Station, Shape = new Shape(2, 2), Price = 1 });
seed.Upsert(new HullData { Name = "Cutter", HullType = HullType.Ship, Shape = new Shape(2, 2), Price = 1 });
seed.FlushAsync().Wait();
return root;
}
// One kindless station hull does not lock the owner out of the catalog: the tool opens it, names the hull, and the
// command that sets kinds is reachable. The game's own Open still refuses until every station hull has a kind.
[Fact]
public void AKindlessStationHullDoesNotLockTheToolOut()
{
var root = SeedRoot("Zenith", "Second Station");
var catalog = Path.Combine(root, "GameData", "Aetheria.cc");
Assert.Throws<InvalidOperationException>(() => AetheriaStores.Open(catalog));
var warned = new List<string>();
var applied = new StringWriter();
using (var db = AetherDb.Open(catalogWritable: true, root: root, warn: warned.Add))
{
Assert.Contains(warned, line => line.Contains("Zenith"));
Assert.Contains(warned, line => line.Contains("Second Station"));
Assert.Equal(0, StationKindsCatalog.Run(db.Cache, true, applied));
Assert.Contains("Second Station", applied.ToString());
db.Cache.FlushAsync().Wait();
}
Assert.Throws<InvalidOperationException>(() => AetheriaStores.Open(catalog));
using (var db = AetherDb.Open(catalogWritable: true, root: root, warn: _ => { }))
{
var dry = new StringWriter();
Assert.Equal(0, StationKindsCatalog.SetHullKind(db.Cache, "Second Station", "mining", false, dry));
Assert.Contains("Dry run", dry.ToString());
Assert.False(db.Cache.GetAll<HullData>().Single(h => h.Name == "Second Station").Kind.IsSet());
var set = new StringWriter();
Assert.Equal(0, StationKindsCatalog.SetHullKind(db.Cache, "Second Station", "mining", true, set));
db.Cache.FlushAsync().Wait();
}
using var strict = AetheriaStores.Open(catalog);
Assert.Equal(StationKindData.KeyOf("mining").Value, strict.GetAll<HullData>().Single(h => h.Name == "Second Station").Kind.Key.Value);
}
[Fact]
public void SetHullKindRefusesWhatIsNotAStationHullOrAHeldKind()
{
var root = SeedRoot("Zenith");
using var db = AetherDb.Open(catalogWritable: true, root: root, warn: _ => { });
StationKindsCatalog.Run(db.Cache, true, new StringWriter());
string Refusal(string hull, string kind)
{
var output = new StringWriter();
Assert.Equal(1, StationKindsCatalog.SetHullKind(db.Cache, hull, kind, true, output));
return output.ToString();
}
Assert.Contains("no station kind", Refusal("Zenith", "nowhere"));
Assert.Contains("no station hull", Refusal("Cutter", "mining"));
Assert.Contains("no station hull", Refusal("Missing", "mining"));
Assert.False(db.Cache.GetAll<HullData>().Single(h => h.Name == "Cutter").Kind.IsSet());
}
[Fact]
public void DryRunWritesNothingApplyIsIdempotent()
{
var path = Path.Combine(_root, "Aetheria.cc");
using (var seed = AetheriaStores.Open(path, catalogWritable: true))
{
seed.Upsert(new VerseGrammar { Revision = 1 });
seed.Upsert(new InputLayout { Rows = new InputLayoutRow[] { new InputLayoutRowSpacer { Height = 1 } } });
seed.FlushAsync().Wait();
}
var before = File.ReadAllBytes(path);
using (var cache = AetheriaStores.Open(path, catalogWritable: true))
{
var dry = new StringWriter();
Assert.Equal(0, StationKindsCatalog.Run(cache, false, dry));
cache.FlushAsync().Wait();
Assert.Equal(17, dry.ToString().Split((char) 10).Count(line => line.TrimEnd().EndsWith("authors")));
Assert.Contains("Dry run", dry.ToString());
Assert.Contains("Zenith: no such hull", dry.ToString());
Assert.Empty(cache.GetAll<StationKindData>());
}
Assert.Equal(before, File.ReadAllBytes(path));
using (var cache = AetheriaStores.Open(path, catalogWritable: true))
{
var output = new StringWriter();
Assert.Equal(0, StationKindsCatalog.Run(cache, true, output));
cache.FlushAsync().Wait();
Assert.Contains("Authored 17 station kinds in", output.ToString());
var kinds = cache.GetAll<StationKindData>().ToArray();
Assert.Equal(Ids.Select(id => StationKindData.KeyOf(id).Value).OrderBy(key => key, StringComparer.Ordinal),
kinds.Select(kind => cache.RefOf(kind).Key.Value).OrderBy(key => key, StringComparer.Ordinal));
Assert.All(kinds, kind => { Assert.False(string.IsNullOrWhiteSpace(kind.Name)); Assert.False(string.IsNullOrWhiteSpace(kind.Description)); });
}
var applied = File.ReadAllBytes(path);
using (var cache = AetheriaStores.Open(path, catalogWritable: true))
{
var output = new StringWriter();
StationKindsCatalog.Run(cache, true, output);
cache.FlushAsync().Wait();
Assert.Contains("Nothing to author", output.ToString());
Assert.Equal(17, output.ToString().Split((char) 10).Count(line => line.TrimEnd().EndsWith("kept")));
Assert.Equal(17, cache.GetAll<StationKindData>().Count());
}
Assert.Equal(applied, File.ReadAllBytes(path));
}
}

View file

@ -3,25 +3,29 @@ using System.IO;
using GameCult.Caching;
// Opens GameData/Aetheria.cc through AetheriaStores, the game's own store composition. The catalog attaches read-only
// unless a command writes it, so a command that only reads cannot write.
public sealed class AetherDb
// unless a command writes it, so a command that only reads cannot write. A station hull with no kind does not lock the
// catalog: it is named to warn (stderr by default) and the commands that repair it stay reachable.
public sealed class AetherDb : IDisposable
{
public string Root { get; }
public CultCache Cache { get; }
private AetherDb(string root, bool catalogWritable, bool withRun)
public void Dispose() => Cache.Dispose();
private AetherDb(string root, bool catalogWritable, bool withRun, Action<string> warn)
{
Root = root;
var gameData = Path.Combine(root, "GameData");
Cache = AetheriaStores.Open(
Path.Combine(gameData, "Aetheria.cc"),
runPath: withRun ? Path.Combine(gameData, "run.cc") : null,
catalogWritable: catalogWritable);
catalogWritable: catalogWritable,
kindlessStation: warn ?? Console.Error.WriteLine);
}
// With no root given, walks up from the working directory to the game folder: the first folder whose GameData holds Aetheria.cc
public static AetherDb Open(bool catalogWritable = false, bool withRun = false, string root = null) =>
new AetherDb(root ?? FindRoot(), catalogWritable, withRun);
public static AetherDb Open(bool catalogWritable = false, bool withRun = false, string root = null, Action<string> warn = null) =>
new AetherDb(root ?? FindRoot(), catalogWritable, withRun, warn);
public static string FindRoot()
{

View file

@ -61,9 +61,23 @@ public static class Program
case "place-names":
Console.OutputEncoding = new System.Text.UTF8Encoding(false);
return PlaceNamesCommand.Run(args.Skip(1).ToArray());
case "station-kinds":
{
var apply = args.Contains("apply");
using var db = AetherDb.Open(catalogWritable: apply);
int code;
if (args.Length > 1 && args[1] == "hull")
{
if (args.Length != (apply ? 5 : 4)) { Console.WriteLine("station-kinds hull \"<hull name>\" <kind> [apply]"); return 1; }
code = StationKindsCatalog.SetHullKind(db.Cache, args[2], args[3], apply, Console.Out);
}
else code = StationKindsCatalog.Run(db.Cache, apply, Console.Out);
if (apply) db.Cache.FlushAsync().GetAwaiter().GetResult();
return code;
}
case "doctrine-catalog": return DoctrineCatalog.Run(AetherDb.Open(catalogWritable: args.Contains("apply")).Cache, args.Contains("apply"), Console.Out);
default:
Console.WriteLine("commands: census, factions, station-fit, hardpoint-fit, loadout [seed], save, settings, settings-dump, dangling [clear <Type.Member>]... [apply], shield-migrate [apply], brownout-migrate [apply], roles-migrate [apply], firing-arc-migrate [apply], range-falloff [apply] [--effective <fraction>] [--end <multiplier>], targeting-catalog [apply], targeting-catalog-6c [apply], targeting-catalog-6d [apply], ship-authoring create|inspect|validate|compose, field-kinds [apply], mine-launcher [apply], smoke-hull [apply], smoke-rounds [apply], roles-backfill [apply], pd-gear [apply], consumables-first-set [apply], launch-suppressor [apply], pirates-faction [apply], verse-grammar [apply], generic-designs [apply], sensor-stat-set [apply], inspection-scanner [apply], minor-power-factions [apply], place-names [apply], product-lines weapons|minor-powers|gear|tiers [apply], doctrine-catalog [apply], assembly-from-maker [apply]");
Console.WriteLine("commands: census, factions, station-fit, hardpoint-fit, loadout [seed], save, settings, settings-dump, dangling [clear <Type.Member>]... [apply], shield-migrate [apply], brownout-migrate [apply], roles-migrate [apply], firing-arc-migrate [apply], range-falloff [apply] [--effective <fraction>] [--end <multiplier>], targeting-catalog [apply], targeting-catalog-6c [apply], targeting-catalog-6d [apply], ship-authoring create|inspect|validate|compose, field-kinds [apply], mine-launcher [apply], smoke-hull [apply], smoke-rounds [apply], roles-backfill [apply], pd-gear [apply], consumables-first-set [apply], launch-suppressor [apply], pirates-faction [apply], verse-grammar [apply], generic-designs [apply], sensor-stat-set [apply], inspection-scanner [apply], minor-power-factions [apply], place-names [apply], product-lines weapons|minor-powers|gear|tiers [apply], doctrine-catalog [apply], assembly-from-maker [apply], station-kinds [hull \"<name>\" <kind>] [apply]");
return 1;
}
}
@ -824,7 +838,7 @@ public static class Program
{
HullType.Ship => generator.GenerateShipLoadout(candidate => candidate == hull),
HullType.Turret => generator.GenerateTurretLoadout(),
_ => generator.GenerateStationLoadout()
_ => generator.GenerateStationLoadout(hull.Kind)
};
outcome = pack == null ? "NO LOADOUT (nothing suitable found)" : "ok";
if (pack == null) failures++;

View file

@ -0,0 +1,102 @@
using System;
using System.IO;
using System.Linq;
using GameCult.Caching;
// Authors the catalog's one list of station kinds (aetheria-living-world, cut station-kind-datum) and gives Zenith, the
// one station hull in the repo, its ruled kind (ruling zenith-is-a-trade-hub: provisional, one edit here to change).
// The 17 kinds are the station-round bench's economic roles; descriptions are its produces/consumes column. A kind that
// already has a record is kept as it is and Zenith keeps a kind it already has, so a rerun that finds nothing to author
// writes nothing. Dry run unless apply.
public static class StationKindsCatalog
{
public const string ZenithKind = "trade-hub";
private static readonly (string id, string name, string description)[] Table =
{
("mining", "Mining Station", "Extracts ore (Rock, New Metals, Gold, Uranium, Potassium) from bodies and belts; consumes tools and food."),
("volatiles", "Volatiles Station", "Skims Hydrogen, Methane and Water from gas giants and ice; consumes tools."),
("agriculture", "Agriculture Station", "Grows Organics (Algae, Fungi, Bacteria, Animal Products) from Water and Potassium; feeds residential."),
("processing", "Processing Station", "Refines ore and volatiles into Metals, Alloys and Compounds."),
("fabrication", "Fabrication Station", "Turns Alloys and Compounds into Manufacturing compounds, Assemblies, gear, Ammo and consumer goods."),
("shipyard", "Shipyard", "Assembles hulls from Assemblies and Alloys."),
("depot", "Depot", "Stores and dispatches stock; loads haulers and tenders."),
("trade-hub", "Trade Hub", "Exchanges every bloc's goods between haulers and takes a cut; produces nothing."),
("residential", "Residential Station", "A bloom: consumes food, water, Wearables, Consumables and Luxuries; supplies crews."),
("habitat-support", "Habitat Support Station", "Air, water recycling, life support and medicine for nearby habitats; consumes Bacteria, Water, Compounds."),
("urban", "Urban Station", "Dense city and services: market, media, repair; consumes luxuries and food."),
("administrative", "Administrative Station", "Issues quotas, contracts and security; consumes luxuries."),
("power", "Power Station", "Makes reactor fuel, reservoirs and capacitors from Uranium and Hydrogen."),
("research", "Research Station", "Certification, compute, prototypes; consumes Assemblies."),
("salvage", "Salvage Station", "Breaks wrecks into Metals and second-hand gear."),
("black-market", "Black Market", "Buys anything, fences stolen cargo."),
("waystation", "Waystation", "Fuel, repair and medicine along a corridor."),
};
public static int Run(CultCache cache, bool apply, TextWriter output)
{
var held = cache.GetAll<StationKindData>().Select(kind => cache.RefOf(kind).Key.Value).ToHashSet(StringComparer.Ordinal);
var missing = Table.Where(row => !held.Contains(StationKindData.KeyOf(row.id).Value)).ToArray();
foreach (var row in Table)
output.WriteLine($"{row.id,-16} {(missing.Any(m => m.id == row.id) ? "authors" : "kept")}");
var zenith = cache.GetAll<HullData>().Where(h => h.HullType == HullType.Station && h.Name == "Zenith").SingleOrDefault();
var setZenith = zenith != null && !zenith.Kind.IsSet();
output.WriteLine(zenith == null ? "Zenith: no such hull, kind not set"
: setZenith ? $"Zenith: kind {ZenithKind}" : "Zenith: already has a kind, kept");
foreach (var hull in cache.GetAll<HullData>().Where(h => h.HullType == HullType.Station && !h.Kind.IsSet() && h != zenith).OrderBy(h => h.Name, StringComparer.Ordinal))
output.WriteLine($"Station hull '{hull.Name}' has no kind; set one with: station-kinds hull \"{hull.Name}\" <kind> apply");
if (!apply)
{
output.WriteLine("\nDry run. Pass \"apply\" to author them.");
return 0;
}
if (missing.Length == 0 && !setZenith)
{
output.WriteLine("Nothing to author.");
return 0;
}
cache.Commit(batch =>
{
foreach (var (id, name, description) in missing)
batch.Upsert(typeof(StationKindData), new StationKindData { Name = name, Description = description }, StationKindData.KeyOf(id));
if (setZenith)
{
zenith.Kind = new CultRecordRef<StationKindData>(StationKindData.KeyOf(ZenithKind));
batch.Upsert(typeof(HullData), zenith, cache.RefOf(zenith).Key);
}
});
output.WriteLine($"\nAuthored {missing.Length} station kinds{(setZenith ? " and Zenith's kind" : "")} in Aetheria.cc");
return 0;
}
// Gives a station hull its kind: the way to repair a hull the catalog holds without one. Dry run unless apply.
public static int SetHullKind(CultCache cache, string hullName, string kindId, bool apply, TextWriter output)
{
var hull = cache.GetAll<HullData>().FirstOrDefault(h => h.HullType == HullType.Station && h.Name == hullName);
if (hull == null)
{
output.WriteLine($"The catalog holds no station hull named '{hullName}'.");
return 1;
}
var kind = new CultRecordRef<StationKindData>(StationKindData.KeyOf(kindId));
if (cache.Get(kind) == null)
{
output.WriteLine($"The catalog holds no station kind '{kindId}'.");
return 1;
}
output.WriteLine($"{hull.Name}: kind {kindId}");
if (!apply)
{
output.WriteLine("\nDry run. Pass \"apply\" to set it.");
return 0;
}
hull.Kind = kind;
cache.Upsert(hull);
output.WriteLine($"\nSet {hull.Name}'s kind in Aetheria.cc");
return 0;
}
}