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:
commit
d233194cb2
24 changed files with 1060 additions and 52 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
141
Assets/Scripts/ServerShared/StationKinds.cs
Normal file
141
Assets/Scripts/ServerShared/StationKinds.cs
Normal 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();
|
||||
}
|
||||
11
Assets/Scripts/ServerShared/StationKinds.cs.meta
Normal file
11
Assets/Scripts/ServerShared/StationKinds.cs.meta
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 7b3e1a94c2d84f6e9a05d1c8e4f27b63
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
BIN
GameData/Aetheria.cc
(Stored with Git LFS)
Binary file not shown.
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
458
tests/Aetheria.Shared.Tests/StationKindTests.cs
Normal file
458
tests/Aetheria.Shared.Tests/StationKindTests.cs
Normal 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));
|
||||
}
|
||||
}
|
||||
177
tests/Aetheria.Shared.Tests/StationKindsCatalogTests.cs
Normal file
177
tests/Aetheria.Shared.Tests/StationKindsCatalogTests.cs
Normal 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));
|
||||
}
|
||||
}
|
||||
|
|
@ -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()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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++;
|
||||
|
|
|
|||
102
tools/AetherDb/StationKindsCatalog.cs
Normal file
102
tools/AetherDb/StationKindsCatalog.cs
Normal 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;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue