Jonas Reith
4cb0ef9328
Cultures stop being static one-per-continent blocs. Culture identities are now stateful: the list is append-only (seeded once at the dawn, schism children appended later, records frozen after creation) and the per-settlement culture is mutable state. - stepCulture(year) in the yearly tick (pure hashes, no RNG): assimilation (a conquered settlement adopts its ruler's culture, which drops the Step-5 revolt cultBonus -> assimilation pacifies provinces), border conversion (population x trade-prestige pressure; realm capitals exempt), schism (a far-flung coherent cluster -- typically overseas colonies -- breaks away as a new people with a local-bank NameGen name and ethos/faith re-derived from its own lands). - computeCultures() became a pure derived refresh (seeds only when the list is empty); seedCultures() reproduces the old per-continent peoples byte-identically for the dawn and pre-v23 loads. - Colonies inherit the founder's culture at founding; the Step-3 mono-cultural vassalage rule is culture-matched (regionId fallback) so schism clusters found their own realms -> colonial independence wars. - Per-cell culture view colours by the owning settlement's culture, so a conquered city keeps its colour until it assimilates. - Save v23: culture identities + sSettleCulture + next-id counter, also in the step-back frames; snapshots rewind via truncate-and-replay. Pre-v23 saves re-seed on the next refresh. - Kind-7 world events; Cultures tab hides extinct peoples and shows a schism child's founding year. Knobs cult* in planet.cfg. - New test_cultevo.cpp (30 checks); all 15 existing suites still pass. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
316 lines
17 KiB
C++
316 lines
17 KiB
C++
// Headless test for civilization Step 8 (cultural evolution). No display needed.
|
|
//
|
|
// g++ -std=c++17 -O2 -Isrc/sim test_cultevo.cpp src/sim/IcoSphere.cpp src/sim/Planet.cpp
|
|
// src/sim/PlanetTectonics.cpp src/sim/PlanetDrift.cpp src/sim/PlanetErosion.cpp
|
|
// src/sim/PlanetHydrology.cpp src/sim/PlanetBiomes.cpp src/sim/PlanetClimate.cpp
|
|
// src/sim/PlanetLive.cpp src/sim/PlanetOcean.cpp src/sim/PlanetWeather.cpp
|
|
// src/sim/PlanetVolcano.cpp src/sim/PlanetBiota.cpp src/sim/PlanetFloraGen.cpp
|
|
// src/sim/PlanetFaunaGen.cpp src/sim/PlanetFungiGen.cpp src/sim/NameGen.cpp
|
|
// src/sim/PlanetGeography.cpp src/sim/PlanetEcoregions.cpp src/sim/PlanetCiv.cpp
|
|
// src/sim/PlanetNation.cpp src/sim/PlanetCulture.cpp src/sim/PlanetConflict.cpp
|
|
// src/sim/PlanetTrade.cpp src/sim/PlanetIO.cpp -o /tmp/tcev && /tmp/tcev
|
|
//
|
|
// Verifies: seeding parity (one culture per continent, frozen identities); colonies inherit the
|
|
// founder's culture; assimilation under foreign allegiance; border conversion (capitals exempt);
|
|
// schism (a distant cluster becomes a new people); determinism + RNG isolation; snapshot
|
|
// truncate-and-replay; save-v23 round-trip + corrupt-stream rejection; pre-v23 compatibility.
|
|
|
|
#include "Planet.hpp"
|
|
#include <cstdio>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
#include <set>
|
|
#include <sstream>
|
|
|
|
static int failures = 0;
|
|
static void check(bool cond, const char* what) {
|
|
std::printf(" [%s] %s\n", cond ? "PASS" : "FAIL", what);
|
|
if (!cond) ++failures;
|
|
}
|
|
static void settle(Planet& p, int maxSteps = 800) {
|
|
int run = 0;
|
|
for (int s = 0; s < maxSteps; ++s) { double mc = p.step(); if (mc < 2.0) { if (++run >= 3) break; } else run = 0; }
|
|
p.computeClimate(); p.classifyBiomes();
|
|
}
|
|
static void drift(Planet& p, int iters) {
|
|
p.drifting = true;
|
|
for (int k = 0; k < iters; ++k) { double dt = p.cflDtMy(); p.advect(dt); p.step(); p.erode(dt); if (k >= iters/2) p.hydrology(dt*0.2); }
|
|
p.computeClimate(); p.classifyBiomes();
|
|
}
|
|
static void quietCulture(Planet& p) { // no evolution: state should then never change
|
|
p.cfg.cultAssimRate = 0.0; p.cfg.cultConvertRate = 0.0; p.cfg.cultSchismRate = 0.0;
|
|
}
|
|
static bool culturesEqual(const std::vector<Culture>& a, const std::vector<Culture>& b) {
|
|
if (a.size() != b.size()) return false;
|
|
for (size_t i = 0; i < a.size(); ++i)
|
|
if (a[i].id != b[i].id || a[i].regionId != b[i].regionId || a[i].bank != b[i].bank
|
|
|| a[i].ethos != b[i].ethos || a[i].faith != b[i].faith
|
|
|| a[i].parentId != b[i].parentId || a[i].foundedYear != b[i].foundedYear
|
|
|| a[i].name != b[i].name || a[i].faithName != b[i].faithName) return false;
|
|
return true;
|
|
}
|
|
// The shared yearly civ sequence (mirrors the viewer's year tick, minus weather).
|
|
static std::vector<WarEvent> civYear(Planet& p, long yr, bool wars = false, bool colonize = false) {
|
|
p.computeTerritory(); p.computeCultures();
|
|
if (wars) p.stepConflict(yr);
|
|
std::vector<WarEvent> ev = p.stepCulture(yr);
|
|
if (colonize) for (WarEvent& e : p.stepColonization(yr)) ev.push_back(e);
|
|
return ev;
|
|
}
|
|
|
|
int main() {
|
|
PlanetConfig cfg; cfg.subdivisions = 5; cfg.seed = 4242;
|
|
Planet p; p.generate(cfg); settle(p); drift(p, 400);
|
|
const int n = (int)p.cells.size();
|
|
const double yearH = p.cfg.dayLengthHours * p.cfg.yearLengthDays;
|
|
|
|
std::printf("Cultural evolution: seeding parity (frozen one-per-continent identities)\n");
|
|
p.placeSettlements();
|
|
double lt = 0.0; for (int yr = 0; yr < 600; ++yr) { lt += 2.0 * yearH; p.stepCivilization(2.0 * yearH, lt); }
|
|
p.computeTerritory(); p.computeCultures();
|
|
{
|
|
check(!p.cultureList().empty(), "cultures seeded at the dawn");
|
|
// One culture per distinct key (continent regionId / -1-bank fallback) among living settlements.
|
|
std::set<int> keys;
|
|
for (size_t k = 0; k < p.settlements.size(); ++k) {
|
|
const Settlement& s = p.settlements[k];
|
|
if (s.population < p.cfg.civAbandonPop) continue;
|
|
keys.insert(s.regionId >= 0 ? s.regionId : (-1 - s.bank));
|
|
}
|
|
check(p.cultureList().size() == keys.size(), "one culture per inhabited continent");
|
|
bool rootsOk = true, idsOk = true;
|
|
for (size_t i = 0; i < p.cultureList().size(); ++i) {
|
|
const Culture& cu = p.cultureList()[i];
|
|
if (cu.parentId != -1 || cu.foundedYear != -1 || cu.name.empty() || cu.faithName.empty()) rootsOk = false;
|
|
if (cu.id != (uint32_t)i + 1) idsOk = false;
|
|
}
|
|
check(rootsOk, "all seeded cultures are roots (no parent, present since the dawn)");
|
|
check(idsOk, "culture ids are dense from 1");
|
|
// A quiet world (all rates 0) never mutates culture state.
|
|
Planet q0 = p; quietCulture(q0);
|
|
std::vector<int> sc0 = q0.settleCulture();
|
|
for (long yr = 0; yr < 30; ++yr) civYear(q0, yr);
|
|
check(q0.settleCulture() == sc0 && q0.cultureList().size() == p.cultureList().size(),
|
|
"no evolution with all cult* rates 0 (Steps 3-7 behaviour preserved)");
|
|
}
|
|
|
|
std::printf("Cultural evolution: colonies inherit the founder's culture\n");
|
|
{
|
|
Planet c = p; quietCulture(c);
|
|
c.computeHabitability();
|
|
c.cfg.civColonizeRate = 1.0; c.cfg.civColonyMinPop = 1000.0; c.cfg.civColonyMinHab = 0.1;
|
|
size_t before = c.settlements.size();
|
|
for (long yr = 0; yr < 40 && c.settlements.size() < before + 6; ++yr) civYear(c, yr, false, true);
|
|
std::printf(" %zu colonies founded\n", c.settlements.size() - before);
|
|
check(c.settlements.size() > before, "colonies are founded");
|
|
bool inherit = c.settlements.size() > before;
|
|
for (size_t k = before; k < c.settlements.size(); ++k) {
|
|
int ov = c.settleAllegiance()[k];
|
|
if (ov < 0 || c.settleCulture()[k] != c.settleCulture()[ov]) inherit = false;
|
|
}
|
|
check(inherit, "every colony carries its founder capital's culture");
|
|
}
|
|
|
|
std::printf("Cultural evolution: assimilation under foreign rule\n");
|
|
{
|
|
Planet a = p; quietCulture(a); a.cfg.cultAssimRate = 1.0;
|
|
// Force a conquest scenario: a living settlement held by a living foreign-culture capital
|
|
// (allegiance + culture are snapshot fields, so a hacked snapshot injects the state cleanly).
|
|
int s = -1, ov = -1;
|
|
const auto& sc = a.settleCulture();
|
|
for (size_t i = 0; i < a.settlements.size() && s < 0; ++i)
|
|
for (size_t j = 0; j < a.settlements.size(); ++j)
|
|
if (i != j && a.settlements[i].population >= a.cfg.civAbandonPop
|
|
&& a.settlements[j].population >= a.cfg.civAbandonPop
|
|
&& sc[i] >= 0 && sc[j] >= 0 && sc[i] != sc[j]) { s = (int)i; ov = (int)j; break; }
|
|
if (s < 0) { std::printf(" (single-culture world: skipping)\n"); }
|
|
else {
|
|
WeatherSnapshot snap = a.captureWeather();
|
|
if (snap.settlementAllegiance.size() != a.settlements.size()) // no war has sized it yet
|
|
snap.settlementAllegiance.assign(a.settlements.size(), -1);
|
|
snap.settlementAllegiance[s] = ov;
|
|
a.restoreWeather(snap);
|
|
int want = a.settleCulture()[ov];
|
|
std::vector<WarEvent> ev = a.stepCulture(1);
|
|
bool flipped = a.settleCulture()[s] == want;
|
|
bool logged = false;
|
|
for (const WarEvent& e : ev)
|
|
if (e.kind == 7 && e.title.find("adopts the culture of") != std::string::npos) logged = true;
|
|
check(flipped, "a conquered settlement assimilates into its ruler's culture");
|
|
check(logged, "assimilation emits a kind-7 event");
|
|
}
|
|
}
|
|
|
|
std::printf("Cultural evolution: border conversion (capitals exempt)\n");
|
|
{
|
|
Planet b = p; quietCulture(b);
|
|
b.cfg.cultConvertRate = 1.0; b.cfg.cultConvertDominance = 0.01; b.cfg.cultSpreadRange = 3.0;
|
|
b.computeTerritory(); b.computeCultures();
|
|
std::vector<int> caps;
|
|
for (const Nation& nat : b.nationList()) caps.push_back(nat.capital);
|
|
std::vector<int> capCultBefore;
|
|
for (int c : caps) capCultBefore.push_back(b.settleCulture()[c]);
|
|
int conversions = 0;
|
|
for (long yr = 0; yr < 5; ++yr)
|
|
for (const WarEvent& e : civYear(b, yr))
|
|
if (e.kind == 7 && e.title.find("embraces the ways of") != std::string::npos) ++conversions;
|
|
std::printf(" %d conversions in 5 years\n", conversions);
|
|
check(conversions > 0, "settlements convert under dominant foreign cultural pressure");
|
|
bool capsStable = true; // capitals anchor identity: only assimilation/schism may move them (both off/limited here)
|
|
for (size_t i = 0; i < caps.size(); ++i)
|
|
if (b.settleCulture()[caps[i]] != capCultBefore[i]) capsStable = false;
|
|
check(capsStable, "realm capitals never convert via border pressure");
|
|
}
|
|
|
|
std::printf("Cultural evolution: schism (a distant cluster becomes a new people)\n");
|
|
long schismYear = -1;
|
|
{
|
|
quietCulture(p);
|
|
p.cfg.cultSchismRate = 1.0; p.cfg.cultSchismRange = 0.10; p.cfg.cultSchismMinMembers = 3;
|
|
p.cfg.cultSchismMinCluster = 1;
|
|
size_t before = p.cultureList().size();
|
|
for (long yr = 0; yr < 20 && p.cultureList().size() == before; ++yr) {
|
|
for (const WarEvent& e : civYear(p, yr))
|
|
if (e.kind == 7 && e.title.find("break away from") != std::string::npos) schismYear = yr;
|
|
}
|
|
check(p.cultureList().size() > before, "a schism appends a new culture");
|
|
if (p.cultureList().size() > before) {
|
|
const Culture& child = p.cultureList().back();
|
|
bool parentOk = false;
|
|
for (size_t i = 0; i < before; ++i) if ((int)p.cultureList()[i].id == child.parentId) parentOk = true;
|
|
check(parentOk, "the child records its parent culture");
|
|
check(child.foundedYear >= 0 && child.foundedYear == schismYear, "the child records its founding year");
|
|
bool nameUnique = !child.name.empty();
|
|
for (size_t i = 0; i + 1 < p.cultureList().size(); ++i)
|
|
if (p.cultureList()[i].name == child.name) nameUnique = false;
|
|
check(nameUnique, "the child's people name is unique");
|
|
int adopted = 0;
|
|
for (int c : p.settleCulture()) if (c == (int)p.cultureList().size() - 1) ++adopted;
|
|
check(adopted >= 1, "the breakaway cluster adopted the new culture");
|
|
p.computeTerritory(); p.computeCultures(); // the child cluster may found its own realm
|
|
check((int)p.cultureList().back().members == adopted, "derived tallies pick the child up");
|
|
}
|
|
check(p.cultureList().size() <= 64, "the culture list stays bounded");
|
|
}
|
|
|
|
std::printf("Cultural evolution: determinism\n");
|
|
{
|
|
Planet q; q.generate(cfg); settle(q); drift(q, 400);
|
|
q.placeSettlements();
|
|
double lt2 = 0.0; for (int yr = 0; yr < 600; ++yr) { lt2 += 2.0 * yearH; q.stepCivilization(2.0 * yearH, lt2); }
|
|
q.computeTerritory(); q.computeCultures();
|
|
quietCulture(q);
|
|
q.cfg.cultSchismRate = 1.0; q.cfg.cultSchismRange = 0.10; q.cfg.cultSchismMinMembers = 3;
|
|
q.cfg.cultSchismMinCluster = 1;
|
|
size_t before = q.cultureList().size();
|
|
for (long yr = 0; yr < 20 && q.cultureList().size() == before; ++yr) civYear(q, yr);
|
|
check(culturesEqual(q.cultureList(), p.cultureList()) && q.settleCulture() == p.settleCulture(),
|
|
"two identical worlds evolve identical cultures");
|
|
}
|
|
|
|
std::printf("Cultural evolution: RNG isolation from tectonics\n");
|
|
{
|
|
Planet x; x.generate(cfg); settle(x);
|
|
Planet y; y.generate(cfg); settle(y);
|
|
for (int k = 0; k < 40; ++k) {
|
|
double dx = x.cflDtMy(); x.advect(dx); x.step(); x.erode(dx);
|
|
double dy = y.cflDtMy(); y.advect(dy); y.step(); y.erode(dy);
|
|
if (k == 20) {
|
|
y.placeSettlements(); y.stepCivilization(yearH, yearH);
|
|
y.cfg.cultConvertRate = 1.0; y.cfg.cultConvertDominance = 0.01; y.cfg.cultSpreadRange = 3.0;
|
|
for (long yr = 0; yr < 3; ++yr) civYear(y, yr);
|
|
}
|
|
}
|
|
bool same = true;
|
|
for (int i = 0; i < n; ++i) if (std::fabs(x.cells[i].elevation - y.cells[i].elevation) > 1e-9) same = false;
|
|
check(same, "stepCulture never perturbs tectonic evolution");
|
|
}
|
|
{
|
|
// Interleaved no-op stepCulture calls must not disturb the war RNG stream.
|
|
Planet w1 = p, w2 = p; quietCulture(w1); quietCulture(w2);
|
|
w1.cfg.warDeclareRate = 2.0; w1.cfg.warMinRealmPop = 1.0;
|
|
w2.cfg.warDeclareRate = 2.0; w2.cfg.warMinRealmPop = 1.0;
|
|
for (long yr = 100; yr < 130; ++yr) {
|
|
w1.computeTerritory(); w1.computeCultures(); w1.stepConflict(yr);
|
|
w2.computeTerritory(); w2.computeCultures(); w2.stepConflict(yr); w2.stepCulture(yr);
|
|
}
|
|
bool warsSame = w1.warList().size() == w2.warList().size()
|
|
&& w1.settleAllegiance() == w2.settleAllegiance();
|
|
check(warsSame, "stepCulture uses no RNG (interleaving leaves wars identical)");
|
|
}
|
|
|
|
std::printf("Cultural evolution: snapshot truncate-and-replay\n");
|
|
{
|
|
WeatherSnapshot snap = p.captureWeather();
|
|
std::vector<Culture> cBefore = p.cultureList();
|
|
std::vector<int> scBefore = p.settleCulture();
|
|
// Mutate: aggressive conversion + schism for 15 years.
|
|
p.cfg.cultConvertRate = 1.0; p.cfg.cultConvertDominance = 0.01; p.cfg.cultSpreadRange = 3.0;
|
|
p.cfg.cultSchismRate = 1.0; p.cfg.cultSchismRange = 0.10;
|
|
for (long yr = 50; yr < 65; ++yr) civYear(p, yr);
|
|
std::vector<Culture> cAfter = p.cultureList();
|
|
std::vector<int> scAfter = p.settleCulture();
|
|
bool changed = !culturesEqual(cAfter, cBefore) || scAfter != scBefore;
|
|
p.restoreWeather(snap);
|
|
p.computeTerritory(); p.computeCultures(); // the derived refresh after a step-back
|
|
check(changed, "the mutation actually changed the culture state");
|
|
check(p.cultureList().size() == cBefore.size() && p.settleCulture() == scBefore,
|
|
"restoreWeather truncates schism children + rewinds settlement cultures");
|
|
// Deterministic replay re-creates the same children + conversions.
|
|
for (long yr = 50; yr < 65; ++yr) civYear(p, yr);
|
|
check(culturesEqual(p.cultureList(), cAfter) && p.settleCulture() == scAfter,
|
|
"replaying the same years re-creates identical schisms/conversions");
|
|
// Out-of-range snapshot entries are clamped on restore.
|
|
WeatherSnapshot odd = p.captureWeather();
|
|
if (!odd.settlementCulture.empty()) {
|
|
odd.settlementCulture[0] = 9999;
|
|
p.restoreWeather(odd);
|
|
check(p.settleCulture()[0] == -1, "restoreWeather clamps out-of-range culture entries");
|
|
odd.settlementCulture[0] = -1; // leave p in a sane (clamped) state for the save tests
|
|
}
|
|
}
|
|
|
|
std::printf("Cultural evolution: save v23 round-trip\n");
|
|
p.computeTerritory(); p.computeCultures();
|
|
{
|
|
std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
|
|
p.writeState(ss);
|
|
Planet r;
|
|
bool ok = r.readState(ss);
|
|
check(ok, "readState accepts the v23 stream");
|
|
check(culturesEqual(r.cultureList(), p.cultureList()), "culture identities survive save/load");
|
|
check(r.settleCulture() == p.settleCulture(), "per-settlement culture survives save/load");
|
|
}
|
|
{
|
|
Planet bad = p;
|
|
if (!bad.cultures.empty()) {
|
|
bad.cultures[0].ethos = (CultureEthos)200;
|
|
std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
|
|
bad.writeState(ss);
|
|
Planet r;
|
|
check(!r.readState(ss), "readState rejects an out-of-range culture ethos");
|
|
}
|
|
}
|
|
|
|
std::printf("Cultural evolution: pre-v23 compatibility\n");
|
|
{
|
|
std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
|
|
p.writeState(ss);
|
|
Planet r;
|
|
// The culture block is the last one; reading with hasCultures=false ignores the trailing bytes.
|
|
bool ok = r.readState(ss, true, true, true, true, true, true, true, true, true, true, true,
|
|
true, true, false);
|
|
check(ok, "readState accepts the stream as pre-v23");
|
|
check(r.cultureList().empty(), "pre-v23 load has no culture state");
|
|
r.computeTerritory(); r.computeCultures();
|
|
check(!r.cultureList().empty(), "cultures re-seed on the next refresh");
|
|
bool allRoots = true;
|
|
for (const Culture& cu : r.cultureList())
|
|
if (cu.parentId != -1 || cu.foundedYear != -1) allRoots = false;
|
|
check(allRoots, "re-seeded cultures are one-per-continent roots");
|
|
}
|
|
|
|
std::printf(failures ? "\nFAILURES: %d\n" : "\nALL CULTURAL-EVOLUTION CHECKS PASSED\n", failures);
|
|
return failures ? 1 : 0;
|
|
}
|