/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ using System; using System.Collections.Generic; using System.IO; using System.Linq; using GameCult.Caching; using GameCult.Caching.MessagePack; using MessagePack; using Xunit; // Ore geography (aetheria-living-world, cut ore-geography): regions cut at the links out of boss zones, provinces grown inside // them, province types dealt per region from a deck, and the kind draw and ore yields they weight. Galaxies are built the way // the game builds them, from the authored settings and the shipped catalog. public sealed class OreGeographyTests : IDisposable { private static readonly AuthoredSettings Authored = AuthoredSettings.Load(RunStartTests.FindRepoRoot()); private static readonly CultCache Shared = RestoredHullsTests.OpenCatalog(); private static readonly Dictionary<(bool, uint), Galaxy> Built = new(); private readonly string _root = Path.Combine(Path.GetTempPath(), "aetheria-oregeography-" + Guid.NewGuid().ToString("N")); private readonly List _caches = new(); private int _count; public OreGeographyTests() => Directory.CreateDirectory(_root); public void Dispose() { foreach (var cache in _caches) cache.Dispose(); Directory.Delete(_root, true); } // ---- fixtures private (string Catalog, string Run) NewPaths() { var dir = Path.Combine(_root, $"cache{_count++}"); Directory.CreateDirectory(dir); return (Path.Combine(dir, "Aetheria.cc"), Path.Combine(dir, "run.cc")); } // An empty writable catalog. private CultCache Empty() { var (catalog, run) = NewPaths(); var cache = AetheriaStores.Open(catalog, run, catalogWritable: true); _caches.Add(cache); return cache; } private static CultCache OpenCopy(string catalog, string run) { var cache = new CultCache(TestCatalog.Registry()); cache.AddBackingStore(new SingleFileMessagePackBackingStore(catalog, false), AetheriaStores.CatalogTypes); cache.AddBackingStore(new SingleFileMessagePackBackingStore(run), AetheriaStores.RunTypes); return cache; } // A writable copy of the shipped catalog and a scratch run store. private (CultCache Cache, string Catalog, string Run) Shipped() { var (catalog, run) = NewPaths(); File.Copy(TestCatalog.Repo, catalog); var cache = OpenCopy(catalog, run); _caches.Add(cache); return (cache, catalog, run); } private static CultRecordRef Put(CultCache cache, string key, T document) where T : class { cache.Commit(batch => batch.Upsert(typeof(T), document, new CultRecordKey(key))); return new CultRecordRef(new CultRecordKey(key)); } private static CultRecordRef Kind(CultCache cache, string name, float weight) => Put(cache, "field-kind:" + name, new FieldKindData { Name = name, CrossSection = 1f, GenerationWeight = weight }); private static CultRecordRef Province(CultCache cache, string name, int cards, ProvinceKindWeight[] kinds = null, ProvinceOre[] ores = null) => Put(cache, "province:" + name, new ProvinceData { Name = name, GenerationWeight = cards, Kinds = kinds?.ToList() ?? new List(), Ores = ores?.ToList() ?? new List() }); private static ProvinceKindWeight KindFactor(CultRecordRef kind, float weight) => new ProvinceKindWeight {Kind = kind, Weight = weight}; private static ProvinceOre OreFactor(CultRecordRef ore, float weight) => new ProvinceOre {Commodity = ore, Weight = weight}; private static CultRecordRef Ore(string name) => new CultRecordRef(new CultRecordKey("ore:" + name)); private static FieldYield Yield(string ore, float abundance, bool regional = false) => new FieldYield {Commodity = Ore(ore), Abundance = abundance, Regional = regional}; private static int[][] Graph(int count, params (int, int)[] links) { var adjacency = Enumerable.Range(0, count).Select(_ => new List()).ToArray(); foreach (var (a, b) in links) { adjacency[a].Add(b); adjacency[b].Add(a); } return adjacency.Select(list => list.OrderBy(i => i).ToArray()).ToArray(); } private static int[][] Line(int count) => Graph(count, Enumerable.Range(0, count - 1).Select(i => (i, i + 1)).ToArray()); private static int[][] AdjacencyOf(Galaxy galaxy) => galaxy.Zones.Select(zone => zone.AdjacentZones.Select(next => Array.IndexOf(galaxy.Zones, next)).ToArray()).ToArray(); private static int[] BossesOf(Galaxy galaxy) => galaxy.BossZones.Values.Select(zone => Array.IndexOf(galaxy.Zones, zone)).ToArray(); private static int ExitOf(Galaxy galaxy) => galaxy.Exit == null ? -1 : Array.IndexOf(galaxy.Zones, galaxy.Exit); private static int[] RegionsOf(Galaxy galaxy) => Provinces.Regions(AdjacencyOf(galaxy), BossesOf(galaxy), ExitOf(galaxy)); private static bool[] ReachableAvoiding(int[][] adjacency, int from, int avoid) { var reached = new bool[adjacency.Length]; var stack = new Stack(); reached[from] = true; stack.Push(from); while (stack.Count > 0) foreach (var next in adjacency[stack.Pop()]) if (next != avoid && !reached[next]) { reached[next] = true; stack.Push(next); } return reached; } private static Galaxy Build(CultCache cache, bool prelude, uint seed, TutorialGenerationSettings cast = null) => prelude ? new Galaxy(cast ?? Authored.Read("TutorialGenerationSettings"), Authored.Read("TutorialBackgroundSettings"), cache, new PlayerSettings(), new DirectoryInfo(Path.GetTempPath()), _ => { }, null, seed) : new Galaxy(Authored.Read("SectorGenerationSettings"), Authored.Read("SectorBackgroundSettings"), cache, _ => { }, null, seed); // Galaxy refuses some seeds (RestoredHullsTests calls it seed-dependent flakiness); those are skipped. private static Galaxy TryBuild(CultCache cache, bool prelude, uint seed, TutorialGenerationSettings cast = null) { try { return Build(cache, prelude, seed, cast); } catch (Exception) { return null; } } private static Galaxy SharedGalaxy(bool prelude, uint seed) { lock (Built) return Built.TryGetValue((prelude, seed), out var known) ? known : Built[(prelude, seed)] = TryBuild(Shared, prelude, seed); } private static IEnumerable Galaxies(bool prelude, uint last) => Enumerable.Range(1, (int) last).Select(seed => SharedGalaxy(prelude, (uint) seed)).Where(galaxy => galaxy != null); // The demo's cast: the same fixed cast, with the province size chosen. private static TutorialGenerationSettings Cast(int provinceZones) { var cast = DemoTerminus.Cast; return new TutorialGenerationSettings { ProtagonistFaction = cast.ProtagonistFaction, AntagonistFaction = cast.AntagonistFaction, BufferFaction = cast.BufferFaction, NeutralFactions = cast.NeutralFactions, QuestFaction = cast.QuestFaction, ZoneCount = cast.ZoneCount, LinkDensity = cast.LinkDensity, ProvinceZones = provinceZones }; } private static Galaxy DemoGalaxy(CultCache cache, uint seed, int provinceZones = Provinces.DefaultZonesPerProvince) { var galaxy = TryBuild(cache, true, seed, Cast(provinceZones)); galaxy?.PlaceGate(galaxy.ResolveFaction(DemoTerminus.Cast.AntagonistFaction)); return galaxy; } private static bool ExitIsACutVertex(Galaxy galaxy) { var adjacency = AdjacencyOf(galaxy); var exit = ExitOf(galaxy); var start = Enumerable.Range(0, adjacency.Length).First(zone => zone != exit); return ReachableAvoiding(adjacency, start, exit).Count(reached => reached) < adjacency.Length - 1; } private static string[] Shape(Galaxy galaxy) => galaxy.Provinces .Select(province => $"{Array.IndexOf(galaxy.Zones, province.Seed)}:{province.Type.Key.Value}:" + string.Join(",", province.Zones.Select(zone => Array.IndexOf(galaxy.Zones, zone)).OrderBy(i => i))) .ToArray(); // The live run as plain documents, as the game writes it, then Continue: Capture, Commit, and a Galaxy from the committed save. private (SavedGame Game, SavedZone[] Zones) Capture(CultCache cache, Galaxy galaxy) { var items = new ItemManager(1u, cache, new ProvenanceLedger(), Authored.Read("GameplaySettings"), _ => { }); var zone = new Zone(items, RestoredHullsTests.AuthoredPlanetSettings(), new ZonePack(), galaxy.Entrance, galaxy); return RunSave.Capture(cache, galaxy, zone, null, new SavedActionBarBinding[0], 0); } private static Galaxy Continue(CultCache cache, SavedGame game, SavedZone[] zones) { RunSave.Commit(cache, game, zones, new ProvenanceLedger()); return new Galaxy(cache, cache.GetGlobal(), _ => { }); } // ---- the kind draw and the yields // The pick as it stood before ore geography, spelled out here: one weighted draw by a stable hash of the site. private static string BasePick(string site, CultCache catalog) { var kinds = catalog.GetAll() .Where(kind => kind.GenerationWeight > 0f) .Select(kind => (Key: catalog.RefOf(kind).Key, Weight: kind.GenerationWeight)) .OrderBy(kind => kind.Key.Value, StringComparer.Ordinal) .ToArray(); if (kinds.Length == 0) return null; var pick = site.StableHash() / 4294967296.0 * kinds.Sum(kind => (double) kind.Weight); foreach (var kind in kinds) { if (pick < kind.Weight) return kind.Key.Value; pick -= kind.Weight; } return kinds[kinds.Length - 1].Key.Value; } [Fact] public void NoProvinceTypeIsTodaysPick() { var cache = Empty(); Kind(cache, "a", 1f); Kind(cache, "b", 2f); Kind(cache, "never", 0f); Kind(cache, "c", 3.5f); var dangling = new CultRecordRef(new CultRecordKey("province:missing")); var seen = new HashSet(); for (var i = 0; i < 2000; i++) { var site = $"belt-{i}"; var expected = BasePick(site, cache); seen.Add(expected); Assert.Equal(expected, FieldKinds.Assign(site, cache, default).Key.Value); Assert.Equal(expected, FieldKinds.Assign(site, cache, dangling).Key.Value); } Assert.Equal(3, seen.Count); Assert.False(FieldKinds.Assign("belt-0", Empty(), default).IsSet()); } [Fact] public void ProvinceWeightsTheKindDraw() { var cache = Empty(); var light = Kind(cache, "light", 1f); var middle = Kind(cache, "middle", 2f); Kind(cache, "heavy", 3f); Kind(cache, "never", 0f); var province = Province(cache, "p", 1, new[] {KindFactor(light, 0f), KindFactor(middle, 3f)}); var counts = new Dictionary(); const int sites = 3000; for (var i = 0; i < sites; i++) { var picked = FieldKinds.Assign($"belt-{i}", cache, province).Key.Value; counts[picked] = counts.GetValueOrDefault(picked) + 1; } // light 1 x 0 = 0, middle 2 x 3 = 6, heavy 3 x 1 (unlisted) = 3 Assert.Equal(0, counts.GetValueOrDefault("field-kind:light")); Assert.Equal(0, counts.GetValueOrDefault("field-kind:never")); Assert.InRange(counts["field-kind:middle"] / (float) sites, 2f / 3 - .04f, 2f / 3 + .04f); Assert.InRange(counts["field-kind:heavy"] / (float) sites, 1f / 3 - .04f, 1f / 3 + .04f); // A province that zeroes every kind leaves the belt without one rather than ignoring it. var barren = Province(cache, "barren", 1, new[] {KindFactor(light, 0f), KindFactor(middle, 0f), KindFactor(new CultRecordRef(new CultRecordKey("field-kind:heavy")), 0f)}); Assert.False(FieldKinds.Assign("belt-0", cache, barren).IsSet()); } [Fact] public void YieldScalesAbundanceByProvince() { var cache = Empty(); var kind = Put(cache, "field-kind:rock", new FieldKindData { Name = "rock", Yields = new List {Yield("iron", .5f), Yield("copper", 1f), Yield("copper", 1f), Yield("nothing", 0f), Yield("tin", 1f)} }); var province = Province(cache, "p", 1, ores: new[] {OreFactor(Ore("iron"), 4f), OreFactor(Ore("tin"), 0f)}); var here = FieldKinds.Yield(kind, province, cache); // copper's two entries are summed; iron is .5 x 4; tin is scaled to nothing; the zero-abundance ore is dropped; commodity key order Assert.Equal(new[] {("ore:copper", 2f), ("ore:iron", 2f)}, here.Select(y => (y.Commodity.Key.Value, y.Amount)).ToArray()); var nowhere = FieldKinds.Yield(kind, default, cache); Assert.Equal(new[] {("ore:copper", 2f), ("ore:iron", .5f), ("ore:tin", 1f)}, nowhere.Select(y => (y.Commodity.Key.Value, y.Amount)).ToArray()); Assert.Empty(FieldKinds.Yield(default, province, cache)); Assert.Empty(FieldKinds.Yield(new CultRecordRef(new CultRecordKey("field-kind:missing")), province, cache)); } [Fact] public void ARegionalOreYieldsOnlyWhereItsProvinceListsIt() { var cache = Empty(); var kind = Put(cache, "field-kind:rock", new FieldKindData { Name = "rock", Yields = new List {Yield("stone", 2f), Yield("iridium", 3f, regional: true)} }); var lists = Province(cache, "lists", 1, ores: new[] {OreFactor(Ore("iridium"), 1f)}); var silent = Province(cache, "silent", 1); string[] Held(CultRecordRef province) => FieldKinds.Yield(kind, province, cache).Select(y => y.Commodity.Key.Value).ToArray(); Assert.Equal(new[] {"ore:iridium", "ore:stone"}, Held(lists)); Assert.Equal(new[] {"ore:stone"}, Held(silent)); Assert.Equal(new[] {"ore:stone"}, Held(default)); Assert.Equal(3f, FieldKinds.Yield(kind, lists, cache).Single(y => y.Commodity.Key.Value == "ore:iridium").Amount); } // ---- regions [Fact] public void ARegionIsCutAtTheLinksOutOfABossZone() { // Two boss cut vertices on a path give three regions; each boss zone stays with the zone before it. Assert.Equal(new[] {0, 0, 0, 3, 3, 5, 5}, Provinces.Regions(Line(7), new[] {2, 4}, 6)); // A boss zone with two links into the far side has both cut, and the far neighbours are one region. var diamond = Graph(7, (0, 1), (1, 2), (2, 3), (2, 4), (3, 5), (4, 5), (5, 6)); Assert.Equal(new[] {0, 0, 0, 3, 3, 3, 3}, Provinces.Regions(diamond, new[] {2}, 6)); // A branch hanging off a boss zone is not on the exit side, so it stays near. var pendant = Graph(6, (0, 1), (1, 2), (2, 3), (3, 4), (2, 5)); Assert.Equal(new[] {0, 0, 0, 3, 3, 0}, Provinces.Regions(pendant, new[] {2}, 4)); // Two adjacent boss zones: the link between them is the first one's crossing link, and the second is alone on its near side. Assert.Equal(new[] {0, 0, 2, 3, 3}, Provinces.Regions(Line(5), new[] {1, 2}, 4)); // The exit may be zone 0. Assert.Equal(new[] {0, 0, 2, 2, 2}, Provinces.Regions(Line(5), new[] {2}, 0)); // No boss zone, no exit, or a boss zone that is the exit: nothing is cut. Assert.All(Provinces.Regions(Line(7), new int[0], 6), region => Assert.Equal(0, region)); Assert.All(Provinces.Regions(Line(7), new[] {2, 4}, -1), region => Assert.Equal(0, region)); Assert.All(Provinces.Regions(Line(7), new[] {6}, 6), region => Assert.Equal(0, region)); // Every zone is in exactly one region, named by its least zone. var regions = Provinces.Regions(diamond, new[] {2}, 6); for (var zone = 0; zone < regions.Length; zone++) { Assert.True(regions[zone] <= zone); Assert.Equal(regions[zone], regions[regions[zone]]); } } [Fact] public void EveryBossZoneIsInTheRegionOfItsEntranceSide() { var checkedBosses = 0; foreach (var galaxy in Galaxies(false, 8)) { var adjacency = AdjacencyOf(galaxy); var exit = ExitOf(galaxy); var regionOf = RegionsOf(galaxy); var bosses = BossesOf(galaxy).Distinct().Where(boss => boss != exit).ToArray(); foreach (var boss in bosses) { var exitSide = ReachableAvoiding(adjacency, exit, boss); foreach (var next in adjacency[boss]) { if (exitSide[next]) Assert.NotEqual(regionOf[boss], regionOf[next]); else Assert.Equal(regionOf[boss], regionOf[next]); } checkedBosses++; } Assert.Equal(bosses.Length + 1, regionOf.Distinct().Count()); } Assert.True(checkedBosses >= 4, $"only {checkedBosses} boss zones were exercised"); } // ---- provinces [Fact] public void PartitionIsContiguousCompleteAndInsideRegions() { var galaxies = Galaxies(false, 6).Concat(Galaxies(true, 6)).ToArray(); Assert.True(galaxies.Length >= 6); foreach (var galaxy in galaxies) { var regionOf = RegionsOf(galaxy); Assert.All(galaxy.Zones, zone => Assert.NotNull(zone.Province)); var members = galaxy.Provinces.SelectMany(province => province.Zones).ToArray(); Assert.Equal(galaxy.Zones.Length, members.Length); Assert.Equal(galaxy.Zones.Length, members.Distinct().Count()); Assert.Equal(galaxy.Provinces.Select(province => Array.IndexOf(galaxy.Zones, province.Seed)).OrderBy(i => i), galaxy.Provinces.Select(province => Array.IndexOf(galaxy.Zones, province.Seed))); foreach (var province in galaxy.Provinces) { Assert.Contains(province.Seed, province.Zones); Assert.All(province.Zones, zone => Assert.Same(province, zone.Province)); var indices = province.Zones.Select(zone => Array.IndexOf(galaxy.Zones, zone)).ToArray(); Assert.Single(indices.Select(zone => regionOf[zone]).Distinct()); var reached = new HashSet {province.Seed}; var stack = new Stack(reached); while (stack.Count > 0) foreach (var next in stack.Pop().AdjacentZones.Where(next => province.Zones.Contains(next) && reached.Add(next))) stack.Push(next); Assert.Equal(province.Zones.Length, reached.Count); } } } [Fact] public void PartitionCountFollowsProvinceZones() { int Count(int[][] graph, int[] bosses, int exit, int perProvince, out int[] seedOf) { var regionOf = Provinces.Regions(graph, bosses, exit); seedOf = Provinces.Partition(graph, regionOf, 7u, perProvince); return seedOf.Distinct().Count(); } Assert.Equal(3, Count(Line(20), new int[0], -1, 8, out _)); // 2.5 rounds up Assert.Equal(2, Count(Line(12), new int[0], -1, 8, out _)); // 1.5 rounds up Assert.Equal(1, Count(Line(5), new int[0], -1, 8, out _)); // a region smaller than ProvinceZones is one province Assert.Equal(5, Count(Line(20), new int[0], -1, 4, out _)); Assert.Equal(1, Count(Line(20), new int[0], -1, 100, out _)); // Per region: a boss zone at 11 on a path of 30 leaves regions of 12 and 18 zones. var path = Line(30); var count = Count(path, new[] {11}, 29, 6, out var seedOf); Assert.Equal(2 + 3, count); Assert.Equal(2, seedOf.Take(12).Distinct().Count()); Assert.Equal(3, seedOf.Skip(12).Distinct().Count()); Assert.All(seedOf.Distinct(), seed => Assert.Equal(seed, seedOf[seed])); } [Fact] public void PartitionIsDeterministic() { var links = new List<(int, int)>(); for (var i = 0; i < 36; i++) { if (i % 6 != 5) links.Add((i, i + 1)); if (i + 6 < 36) links.Add((i, i + 6)); } var grid = Graph(36, links.ToArray()); var regionOf = Provinces.Regions(grid, new int[0], -1); var first = Provinces.Partition(grid, regionOf, 1u, 8); Assert.Equal(first, Provinces.Partition(grid, regionOf, 1u, 8)); Assert.Equal(first.Distinct().Count(), 5); // 36 / 8 = 4.5 rounds up var differing = Enumerable.Range(2, 30).Count(seed => !Provinces.Partition(grid, regionOf, (uint) seed, 8).SequenceEqual(first)); Assert.True(differing > 20, $"only {differing} of 30 other run seeds moved the seeds"); } [Fact] public void TheDemoGalaxyIsOneRegionOfSeveralProvinces() { var cutVertexExits = 0; var checkedGalaxies = 0; for (uint seed = 1; seed <= 24; seed++) { var galaxy = TryBuild(Shared, true, seed, Cast(Provinces.DefaultZonesPerProvince)); if (galaxy == null) continue; checkedGalaxies++; Assert.All(RegionsOf(galaxy), region => Assert.Equal(0, region)); Assert.Equal(8, galaxy.Provinces.Length); // 64 zones / 8 per province var before = Shape(galaxy); galaxy.PlaceGate(galaxy.ResolveFaction(DemoTerminus.Cast.AntagonistFaction)); if (ExitIsACutVertex(galaxy)) cutVertexExits++; // The boss zone is the exit: re-deriving from the saved graph, boss zones and Exit still finds one region, and PlaceGate moved nothing. Assert.All(RegionsOf(galaxy), region => Assert.Equal(0, region)); Assert.Equal(before, Shape(galaxy)); } Assert.True(checkedGalaxies >= 10); Assert.True(cutVertexExits >= 3, $"only {cutVertexExits} demo galaxies had a cut-vertex Exit, so the case that splits a naive cut went unexercised"); } [Fact] public void ProvincesTakeNothingFromTheGalaxyStream() { string[] Describe(Galaxy g) => g.Zones.Select((zone, i) => $"{zone.Name}|{zone.Position.x:R},{zone.Position.y:R}|{string.Join(",", zone.AdjacentZones.Select(next => Array.IndexOf(g.Zones, next)))}|{zone.Owner?.Name}|{string.Join(",", zone.Factions.Select(f => f.Name))}") .Concat(new[] { $"entrance {Array.IndexOf(g.Zones, g.Entrance)}", $"exit {ExitOf(g)}", "bosses " + string.Join(",", g.BossZones.Select(b => $"{b.Key.Name}={Array.IndexOf(g.Zones, b.Value)}")), "homes " + string.Join(",", g.HomeZones.Select(b => $"{b.Key.Name}={Array.IndexOf(g.Zones, b.Value)}")) }).ToArray(); var (cache, _, _) = Shipped(); Province(cache, "one", 2); Province(cache, "two", 1); var compared = 0; foreach (var prelude in new[] {false, true}) for (uint seed = 1; seed <= 4; seed++) { var without = SharedGalaxy(prelude, seed); var with = TryBuild(cache, prelude, seed); Assert.Equal(without == null, with == null); if (without == null) continue; Assert.Equal(Describe(without), Describe(with)); Assert.All(without.Provinces, province => Assert.False(province.Type.IsSet())); Assert.All(with.Provinces, province => Assert.True(province.Type.IsSet())); compared++; } Assert.True(compared >= 4); } [Fact] public void PartitionSeedsAreTheLeastHashThenTheFarthestAndTiesGoToTheEarlierSeed() { var line = Line(9); var regionOf = Provinces.Regions(line, new int[0], -1); var zones = Enumerable.Range(0, 9).ToArray(); var tied = 0; for (uint seed = 1; seed <= 60; seed++) { uint Hash(int zone) => $"{seed}:province-seed:{zone}".StableHash(); var first = zones.OrderBy(Hash).ThenBy(zone => zone).First(); var reach = zones.Max(zone => Math.Abs(zone - first)); var second = zones.Where(zone => Math.Abs(zone - first) == reach).OrderBy(Hash).First(); if (zones.Any(zone => Math.Abs(zone - first) == Math.Abs(zone - second))) tied++; // 9 zones at 5 per province is two seeds; a zone midway between them goes to the first. var expected = zones.Select(zone => Math.Abs(zone - first) <= Math.Abs(zone - second) ? first : second).ToArray(); Assert.Equal(expected, Provinces.Partition(line, regionOf, seed, 5)); // One province: the seed is the least hash. Assert.All(Provinces.Partition(line, regionOf, seed, 100), seedOf => Assert.Equal(first, seedOf)); } Assert.True(tied > 5, "fixture: too few run seeds put a zone midway between the seeds"); } [Fact] public void ListingAnEntryTwiceSumsItsWeights() { var cache = Empty(); var a = Kind(cache, "a", 1f); Kind(cache, "b", 1f); var twice = Province(cache, "twice", 1, new[] {KindFactor(a, 2f), KindFactor(a, 2f)}, new[] {OreFactor(Ore("iron"), 2f), OreFactor(Ore("iron"), 3f)}); var rock = Put(cache, "field-kind:rock", new FieldKindData {Name = "rock", GenerationWeight = 0f, Yields = new List {Yield("iron", 1f)}}); Assert.Equal(5f, FieldKinds.Yield(rock, twice, cache).Single().Amount); const int sites = 3000; var share = Enumerable.Range(0, sites).Count(i => FieldKinds.Assign($"belt-{i}", cache, twice).Key.Value == "field-kind:a") / (float) sites; Assert.InRange(share, 4f / 5 - .04f, 4f / 5 + .04f); // a: 1 x (2 + 2) against b: 1 Assert.InRange(Enumerable.Range(0, sites).Count(i => FieldKinds.Assign($"belt-{i}", cache, default).Key.Value == "field-kind:a") / (float) sites, .46f, .54f); } // ---- the deal private static int[] Counts(CultRecordRef[] hand, params string[] types) => types.Select(type => hand.Count(card => card.Key.Value == "province:" + type)).ToArray(); [Fact] public void ARegionWithAsManyProvincesAsCardsHoldsEveryType() { var cache = Empty(); Province(cache, "a", 3); Province(cache, "b", 1); Province(cache, "c", 2); Province(cache, "zero", 0); for (uint seed = 1; seed <= 40; seed++) { Assert.Equal(new[] {3, 1, 2}, Counts(Provinces.Deal(5, 6, seed, cache), "a", "b", "c")); Assert.Equal(new[] {6, 2, 4}, Counts(Provinces.Deal(5, 12, seed, cache), "a", "b", "c")); var more = Provinces.Deal(5, 8, seed, cache); Assert.All(new[] {"a", "b", "c"}, type => Assert.Contains(more, card => card.Key.Value == "province:" + type)); Assert.DoesNotContain(more, card => card.Key.Value == "province:zero"); } } [Fact] public void TheSameRunSeedDealsTheSameHand() { var cache = Empty(); Province(cache, "a", 1); Province(cache, "b", 1); Province(cache, "never", 0); string[] Hand(int region, uint seed) => Provinces.Deal(region, 6, seed, cache).Select(card => card.Key.Value).ToArray(); for (uint seed = 1; seed <= 20; seed++) { Assert.Equal(Hand(3, seed), Hand(3, seed)); Assert.DoesNotContain("province:never", Hand(3, seed)); } Assert.Contains(Enumerable.Range(2, 30), seed => !Hand(3, (uint) seed).SequenceEqual(Hand(3, 1u))); // No card to deal: every province is unset, whether the catalog holds no type or only types of weight zero. Assert.All(Provinces.Deal(0, 4, 1u, Empty()), card => Assert.False(card.IsSet())); var zeroes = Empty(); Province(zeroes, "never", 0); var hand = Provinces.Deal(0, 4, 1u, zeroes); Assert.Equal(4, hand.Length); Assert.All(hand, card => Assert.False(card.IsSet())); } [Fact] public void CardCountNotProbabilityIsTheWeight() { var cache = Empty(); Province(cache, "common", 3); Province(cache, "rare", 1); for (uint seed = 1; seed <= 200; seed++) { Assert.Equal(new[] {3, 1}, Counts(Provinces.Deal(0, 4, seed, cache), "common", "rare")); Assert.Equal(new[] {6, 2}, Counts(Provinces.Deal(0, 8, seed, cache), "common", "rare")); } } [Fact] public void ARegionsHandDoesNotDependOnOtherRegions() { var (cache, _, _) = Shipped(); Province(cache, "a", 1); Province(cache, "b", 1); Province(cache, "c", 1); var hands = new List(); var regionsChecked = 0; foreach (var galaxy in new[] {false, true}.SelectMany(prelude => Enumerable.Range(1, 5).Select(seed => TryBuild(cache, prelude, (uint) seed))).Where(g => g != null)) { var regionOf = RegionsOf(galaxy); foreach (var region in Enumerable.Range(0, galaxy.Zones.Length).GroupBy(zone => regionOf[zone])) { var provinces = galaxy.Provinces.Where(province => regionOf[Array.IndexOf(galaxy.Zones, province.Seed)] == region.Key).ToArray(); var expected = Provinces.Deal(region.Key, provinces.Length, galaxy.Seed, cache); // Keyed by the region's least zone: nothing outside the region and the run seed enters the hand. Assert.Equal(expected.Select(card => card.Key.Value), provinces.Select(province => province.Type.Key.Value)); if (provinces.Length >= 3) hands.Add(string.Join(",", expected.Select(card => card.Key.Value))); regionsChecked++; } } Assert.True(regionsChecked >= 10); Assert.True(hands.Distinct().Count() > 1, "every region of three or more provinces was dealt the same hand"); } [Fact] public void TheDealDrawsFromTheDeckInKeyOrderAndReshufflesWhenItRunsOut() { var cache = Empty(); Province(cache, "c", 3); Province(cache, "a", 2); Province(cache, "b", 1); for (uint seed = 1; seed <= 30; seed++) { // The rule restated: cards per type in key order, one weighted pick per draw at the draw's own site. var types = new[] {"province:a", "province:b", "province:c"}; var full = new[] {2, 1, 3}; var remaining = (int[]) full.Clone(); var expected = new List(); for (var n = 0; n < 10; n++) { if (remaining.Sum() == 0) remaining = (int[]) full.Clone(); var pick = $"{seed}:province-deal:7:{n}".StableHash() / 4294967296.0 * remaining.Sum(); var card = 0; while (pick >= remaining[card]) pick -= remaining[card++]; remaining[card]--; expected.Add(types[card]); } Assert.Equal(expected, Provinces.Deal(7, 10, seed, cache).Select(card => card.Key.Value)); } } // ---- belts private static IEnumerable<(AsteroidBeltData Belt, GalaxyZone Zone, ZonePack Pack)> Belts(CultCache cache, Galaxy galaxy, ItemManager items, int zones) { foreach (var zone in galaxy.Zones.Take(zones)) { var pack = ZoneGenerator.GenerateZone(items, RestoredHullsTests.TutorialZoneSettings(), RestoredHullsTests.AuthoredPlanetSettings(), galaxy, zone, isTutorial: zone == galaxy.Entrance); foreach (var belt in pack.Planets.Select(body => cache.Get(body)).OfType()) yield return (belt, zone, pack); } } private ItemManager Items(CultCache cache) => new ItemManager(1u, cache, new ProvenanceLedger(), Authored.Read("GameplaySettings"), _ => { }); private static void SilenceShippedKinds(CultCache cache) { foreach (var existing in cache.GetAll().ToArray()) { existing.GenerationWeight = 0f; cache.Upsert(existing); } } [Fact] public void GeneratedBeltsDrawByTheirZonesProvince() { var firstOnly = 0; var secondOnly = 0; for (uint seed = 1; seed <= 25 && (firstOnly < 3 || secondOnly < 3); seed++) { var (cache, _, _) = Shipped(); SilenceShippedKinds(cache); var a = Kind(cache, "a", 1f); var b = Kind(cache, "b", 1f); Province(cache, "no-a", 1, new[] {KindFactor(a, 0f)}); Province(cache, "no-b", 1, new[] {KindFactor(b, 0f)}); var galaxy = TryBuild(cache, true, seed, Cast(Provinces.DefaultZonesPerProvince)); if (galaxy == null) continue; foreach (var (belt, zone, _) in Belts(cache, galaxy, Items(cache), 24)) { var kind = belt.Kind.Key.Value; if (zone.Province.Type.Key.Value == "province:no-a") { Assert.Equal("field-kind:b", kind); firstOnly++; } else { Assert.Equal("field-kind:a", kind); secondOnly++; } } } Assert.True(firstOnly >= 3 && secondOnly >= 3, $"belts exercised: {firstOnly} and {secondOnly}"); } [Fact] public void FirstLoadAssignsByTheZonesProvince() { for (uint seed = 1; seed <= 25; seed++) { var (cache, catalogPath, runPath) = Shipped(); SilenceShippedKinds(cache); var galaxy = TryBuild(cache, true, seed, Cast(Provinces.DefaultZonesPerProvince)); if (galaxy == null) continue; var items = Items(cache); // Generated while no kind could be picked: every belt is kindless, as one saved before field kinds existed. var generated = Belts(cache, galaxy, items, 16).ToArray(); if (generated.Length < 4) continue; Assert.All(generated, g => Assert.False(g.Belt.Kind.IsSet())); var a = Kind(cache, "a", 1f); Kind(cache, "b", 1f); var noA = Province(cache, "no-a", 1, new[] {KindFactor(a, 0f)}); var packs = generated.GroupBy(g => g.Pack).ToArray(); var inProvince = packs[0].First().Zone; inProvince.Province = new GalaxyProvince {Seed = inProvince, Type = noA, Zones = new[] {inProvince}}; var settings = RestoredHullsTests.AuthoredPlanetSettings(); var loaded = new Zone(items, settings, packs[0].Key, inProvince, galaxy); foreach (var key in packs[0].Select(g => cache.RefOf(g.Belt).Key)) Assert.Equal(FieldKinds.Assign(key.Value, cache, noA).Key.Value, ((AsteroidBeltData) loaded.Planets[key]).Kind.Key.Value); Assert.All(packs[0].Select(g => cache.RefOf(g.Belt).Key), key => Assert.Equal("field-kind:b", ((AsteroidBeltData) loaded.Planets[key]).Kind.Key.Value)); // No GalaxyZone: the unweighted pick. var unweighted = 0; foreach (var pack in packs.Skip(1)) { var bare = new Zone(items, settings, pack.Key, null, null); foreach (var key in pack.Select(g => cache.RefOf(g.Belt).Key)) { var kind = ((AsteroidBeltData) bare.Planets[key]).Kind.Key.Value; Assert.Equal(FieldKinds.Assign(key.Value, cache, default).Key.Value, kind); if (kind == "field-kind:a") unweighted++; } } Assert.True(unweighted > 0, "fixture: no unweighted belt drew the kind the province forbids, so the province could not be told from none"); // Kept: a kind that would now win every pick changes nothing about a belt that has one. var keys = packs[0].Select(g => cache.RefOf(g.Belt).Key).ToArray(); var assigned = keys.ToDictionary(key => key.Value, key => ((AsteroidBeltData) loaded.Planets[key]).Kind.Key.Value); Kind(cache, "z", 1e6f); var again = new Zone(items, settings, packs[0].Key, null, null); foreach (var key in keys) Assert.Equal(assigned[key.Value], ((AsteroidBeltData) again.Planets[key]).Kind.Key.Value); // Saved: a fresh open of the stores reads the assignment back. cache.FlushAsync().Wait(); cache.Dispose(); _caches.Remove(cache); var reopened = OpenCopy(catalogPath, runPath); _caches.Add(reopened); foreach (var key in keys) Assert.Equal(assigned[key.Value], ((AsteroidBeltData) reopened.Get(key)).Kind.Key.Value); return; } Assert.Fail("no seed generated enough belts; the first-load path went unexercised"); } // ---- save and continue [Fact] public void ProvincesSurviveSaveAndContinue() { var (cache, catalog, run) = Shipped(); Province(cache, "a", 1); Province(cache, "b", 1); Province(cache, "c", 1); // Four zones to a province, so a galaxy's saved provinces differ from what the save constructor's default would derive. var galaxy = Enumerable.Range(1, 25).Select(seed => DemoGalaxy(cache, (uint) seed, 4)).First(g => g != null); Assert.Equal(16, galaxy.Provinces.Length); var (game, zones) = Capture(cache, galaxy); Assert.Equal(galaxy.Provinces.Length, game.Provinces.Count); RunSave.Commit(cache, game, zones, new ProvenanceLedger()); cache.FlushAsync().Wait(); cache.Dispose(); _caches.Remove(cache); // Reopened from disk with a type of overwhelming weight added: a saved run keeps what it was dealt. var reopened = OpenCopy(catalog, run); _caches.Add(reopened); Put(reopened, "province:huge", new ProvinceData {Name = "huge", GenerationWeight = 1000000}); var restored = new Galaxy(reopened, reopened.GetGlobal(), _ => { }); Assert.Equal(Shape(galaxy), Shape(restored)); Assert.DoesNotContain(restored.Provinces, province => province.Type.Key.Value == "province:huge"); } [Fact] public void AnOlderSaveGetsProvincesByTheSameRule() { var (cache, _, _) = Shipped(); var a = Province(cache, "a", 1); Province(cache, "b", 1); Province(cache, "c", 1); var galaxy = Enumerable.Range(1, 40).Select(seed => DemoGalaxy(cache, (uint) seed)).First(g => g != null && ExitIsACutVertex(g)); // No key 15: the same Regions, Partition and Deal, from the saved graph, boss zones, Exit and seed. var (older, olderZones) = Capture(cache, galaxy); older.Provinces = null; foreach (var zone in olderZones) zone.Province = 0; Assert.Equal(Shape(galaxy), Shape(Continue(cache, older, olderZones))); // A saved type that no longer resolves takes the card the region's Deal gives that province's place; the others are kept. var (game, zones) = Capture(cache, galaxy); game.Provinces[0].Type = new CultRecordRef(new CultRecordKey("province:gone")); foreach (var province in game.Provinces.Skip(1)) province.Type = a; var deal = Provinces.Deal(0, galaxy.Provinces.Length, galaxy.Seed, cache); Assert.Contains(deal.Skip(1), card => card.Key.Value != a.Key.Value); var restored = Continue(cache, game, zones); Assert.Equal(deal[0].Key.Value, restored.Provinces[0].Type.Key.Value); Assert.All(restored.Provinces.Skip(1), province => Assert.Equal(a.Key.Value, province.Type.Key.Value)); Assert.Equal(galaxy.Provinces.Select(p => Array.IndexOf(galaxy.Zones, p.Seed)), restored.Provinces.Select(p => Array.IndexOf(restored.Zones, p.Seed))); } // ---- the documents [Fact] public void YieldsAndProvincesRoundTrip() { var (cache, catalog, run) = Shipped(); var ore = Ore("iron"); var kind = Put(cache, "field-kind:rock", new FieldKindData {Name = "rock", Yields = new List {Yield("iron", 1.5f), Yield("gold", 2f, regional: true)}}); var province = Put(cache, "province:rich", new ProvinceData { Name = "rich", GenerationWeight = 3, Kinds = new List {KindFactor(kind, 2.5f)}, Ores = new List {OreFactor(ore, 4f)} }); cache.FlushAsync().Wait(); cache.Dispose(); _caches.Remove(cache); var reopened = OpenCopy(catalog, run); _caches.Add(reopened); var rock = reopened.Get(kind); Assert.Equal(new[] {("ore:iron", 1.5f, false), ("ore:gold", 2f, true)}, rock.Yields.Select(y => (y.Commodity.Key.Value, y.Abundance, y.Regional)).ToArray()); var rich = reopened.Get(province); Assert.Equal(3, rich.GenerationWeight); Assert.Equal(new[] {("field-kind:rock", 2.5f)}, rich.Kinds.Select(k => (k.Kind.Key.Value, k.Weight)).ToArray()); Assert.Equal(new[] {("ore:iron", 4f)}, rich.Ores.Select(o => (o.Commodity.Key.Value, o.Weight)).ToArray()); // A kind written before key 3 loads with no yields. var options = CultDocumentMessagePackSerialization.OptionsFor(typeof(ItemData).Assembly); var old = MessagePackSerializer.Deserialize(MessagePackSerializer.Serialize(new object[] {"Old", 1.5f, 2f}), options); Assert.Equal("Old", old.Name); Assert.Equal(2f, old.GenerationWeight); Assert.Empty(old.Yields); } [Fact] public void ABodySavedWithResourcesStillLoads() { var options = CultDocumentMessagePackSerialization.OptionsFor(typeof(ItemData).Assembly); var belt = new AsteroidBeltData {Name = "retired-key", Mass = 12f, Asteroids = new Asteroid[0]}; var bytes = MessagePackSerializer.Serialize(typeof(AsteroidBeltData), belt, options); // The same record with a non-empty key 4, the stored Resources of a body from before the key was retired. var source = new System.Buffers.ReadOnlySequence(bytes); var reader = new MessagePackReader(source); var length = reader.ReadArrayHeader(); Assert.True(length > 4); var output = new System.Buffers.ArrayBufferWriter(); var writer = new MessagePackWriter(output); writer.WriteArrayHeader(length); for (var key = 0; key < length; key++) { var start = reader.Position; reader.Skip(); if (key == 4) { writer.WriteMapHeader(1); writer.Write("ore:iron"); writer.Write(3.5f); } else writer.WriteRaw(source.Slice(start, reader.Position)); } writer.Flush(); var loaded = (AsteroidBeltData) MessagePackSerializer.Deserialize(typeof(AsteroidBeltData), output.WrittenMemory, options); Assert.Equal("retired-key", loaded.Name); Assert.Equal(12f, loaded.Mass); Assert.Empty(loaded.Asteroids); } }