Station kinds: StationKindData catalog list, HullData.Kind, placed station Kind; GenerateStationLoadout takes a kind (the kindless draw is deleted)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
soul 2026-10-22 18:24:10 +02:00
commit fba7bd1b47
17 changed files with 700 additions and 24 deletions

View file

@ -7,7 +7,7 @@ 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) };
@ -42,6 +42,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);
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

@ -0,0 +1,128 @@
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 key. 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, CultRecordKey siteKey, 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) (siteKey.Value.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() || faction == null) 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;
}
// 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).
public static void Validate(CultCache catalog)
{
foreach (var hull in catalog.GetAll<HullData>())
{
if (hull.HullType == HullType.Station)
{
if (!hull.Kind.IsSet())
throw new InvalidOperationException($"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)
throw new InvalidOperationException($"Station hull '{hull.Name}' Kind names no station kind this catalog holds.");
}
else if (hull.Kind.IsSet())
throw new InvalidOperationException($"Hull '{hull.Name}' is a {hull.HullType} and names a Kind; only a station hull has one.");
}
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

@ -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, cache.RefOf(lagrangeOrbit).Key, 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, cache.RefOf(lagrangeOrbit).Key, itemManager.Log));
if (station == null)
{
if (isTutorialEntrance)

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

@ -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

@ -0,0 +1,378 @@
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);
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") }));
}));
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, new CultRecordKey("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, new CultRecordKey("site"), logged.Add);
Assert.Equal(Kind("shipyard").Key, kind.Key);
Assert.Single(logged);
var pack = world.Generator(world.Lucent).GenerateStationLoadout(kind);
Assert.NotNull(pack);
Assert.Equal(kind.Key, pack.Kind.Key);
Assert.Contains(world.Log, line => line.Contains("any manufacturer"));
}
[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 => new CultRecordKey("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);
}
[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);
}
[Fact]
public void ShippedStandInsAreLive()
{
using var cache = AetheriaStores.Open(TestCatalog.Repo);
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);
}
}
}

View file

@ -0,0 +1,53 @@
using System;
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);
[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))
{
Assert.Equal(0, StationKindsCatalog.Run(cache, false, new StringWriter()));
cache.FlushAsync().Wait();
Assert.Empty(cache.GetAll<StationKindData>());
}
Assert.Equal(before, File.ReadAllBytes(path));
using (var cache = AetheriaStores.Open(path, catalogWritable: true))
{
Assert.Equal(0, StationKindsCatalog.Run(cache, true, new StringWriter()));
cache.FlushAsync().Wait();
Assert.Equal(17, cache.GetAll<StationKindData>().Count());
}
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, cache.GetAll<StationKindData>().Count());
}
Assert.Equal(applied, File.ReadAllBytes(path));
}
}

View file

@ -61,9 +61,10 @@ public static class Program
case "place-names":
Console.OutputEncoding = new System.Text.UTF8Encoding(false);
return PlaceNamesCommand.Run(args.Skip(1).ToArray());
case "station-kinds": return StationKindsCatalog.Run(StationKindsCatalog.OpenCatalog(args.Contains("apply")), args.Contains("apply"), Console.Out);
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 [apply]");
return 1;
}
}
@ -824,7 +825,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,82 @@
using System;
using System.IO;
using System.Linq;
using GameCult.Caching;
using GameCult.Caching.MessagePack;
// 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."),
};
// The catalog opened without AetheriaStores.Open's checks: the catalog this command first runs on holds a station hull with no
// kind, which StationKinds.Validate refuses, and this command is what gives it one.
public static CultCache OpenCatalog(bool apply)
{
var cache = new CultCache();
cache.AddBackingStore(new SingleFileMessagePackBackingStore(Path.Combine(AetherDb.FindRoot(), "GameData", "Aetheria.cc"), !apply), AetheriaStores.CatalogTypes);
return cache;
}
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");
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;
}
}