Files
aevolution/tests/cellular_revamp_owner_tests.cpp
T
dingoandClaude Opus 5.5 8a48e405fd
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 5s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m28s
Foundation / postgres-tools (push) Successful in 22s
Foundation / server-image (push) Successful in 4m21s
Foundation / image (push) Successful in 5m1s
fix(lifecycle): a bud's fee comes on top of its cost, or the bud is refused
DEV region 14 stalled at tick 6068 with a conservation error. The bud fee was
checked against the reserve before funding the bud, then deducted with a clamp
after: a parent whose reserve covered the bud but not the fee as well paid less
than the fee while the region reclaimed all of it, creating matter. The fee
was zero until the budding playtest tuning, so it never showed.

Funding now requires the reserve left after the bud to cover the fee; a parent
that cannot is refused for insufficient funding, and the fee is subtracted
exactly. No committed tick changes: a short-fee bud never committed. The
regression runs seeded wildlife under the DEV fee until a bud (it failed with
the conservation error before this fix).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 12:46:00 -04:00

838 lines
44 KiB
C++

#include "evo/biology/budding.hpp"
#include "evo/biology/founder.hpp"
#include "evo/server/lifecycle/cellular_batch.hpp"
#include "evo/server/lifecycle/cellular_play_summary.hpp"
#include "fixtures/cellular_ecology.hpp"
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
// Rules 13 owner (Cellular_Revamp_Build_Plan.md phase 1, ADR-0179): the format 10 -> 11 upgrade,
// founder 6 births, the declared revamp rules and exact restore and replay.
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::fixture;
CellularLiquidRules liquid(std::uint32_t side = 48'000) {
return {.currents = {5, side, side, 250, 2, 4, side / 16, side / 8, 60, 300},
.founder = {.thrust_q10 = 20'480,
.reverse_thrust_q10 = 20'480,
.forward_drag_ppm = 95'163,
.lateral_drag_ppm = 95'163,
.turn = 3'276},
.deposits = {.drift_radius_um = 200,
.max_drift_q10 = 100 * 1'024,
.drift_decay_ppm = 95'163,
.merged_cap = 8,
.bubble_radius_um = biology::cellular_mote_radius_um}};
}
// The trial revamp rules (deploy/kubernetes/region/dev/tuning/cellular-revamp.tuning).
CellularRevampRules revamp(std::uint32_t essential = 250) {
return {.body = {.essential_upkeep_per_thousand = essential},
.burn_pj_per_kfg = {2'000, 2'000, 2'000, 2'000},
.step = {.membrane_collection_per_mille_per_point = 2,
.engulf_ratio_milli = 1'500,
.engulf_reserve_percent = 100,
.kill_bubble_per_thousand = 500},
.drip_interval_ticks = 20,
.drip_bubble_pj = 20'000'000,
.drip_bubble_fg = 1'000'000,
.reserve_load_per_thousand = 1'000};
}
// Reserve matter slows thrust and turning and raises thrust costs in proportion to the body.
void carried_matter_is_load() {
const biology::CellularHandling base{.thrust_q10 = 20'480,
.reverse_thrust_q10 = 10'240,
.forward_drag_ppm = 95'163,
.lateral_drag_ppm = 95'163,
.turn = 3'276,
.thrust_cost = {1'000},
.reverse_cost = {500}};
require(cellular_loaded_handling(base, 8'000'000, 0, revamp()) == base,
"an empty reserve changed the handling");
const auto heavy = cellular_loaded_handling(base, 8'000'000, 8'000'000, revamp());
require(heavy.thrust_q10 == 10'240 && heavy.reverse_thrust_q10 == 5'120 &&
heavy.turn == 1'638 && heavy.thrust_cost.value == 2'000 &&
heavy.reverse_cost.value == 1'000 &&
heavy.forward_drag_ppm == base.forward_drag_ppm,
"carrying the body's mass again did not halve thrust and double its cost");
auto none = revamp();
none.reserve_load_per_thousand = 0;
require(cellular_loaded_handling(base, 8'000'000, 8'000'000, none) == base,
"a zero load share still loaded the cell");
}
LifeAccount account(std::uint8_t last) {
LifeAccount value{};
value.back() = last;
return value;
}
// A rules-13 region with a founder 5 born before the upgrade and a founder 6 born after it.
Owner revamp_region(std::uint32_t essential = 250, std::uint64_t fee_pj = 0) {
auto rules = revamp(essential);
rules.bud_fee.energy.value = fee_pj;
rules.bud_fee_scale_percent = fee_pj == 0 ? 0 : 100;
auto state = opening(7, true, 2, false); // Funds two founders.
checked(state->advance_tick({}), "genesis tick");
state = checked(state->migration_upgrade_candidate(), "boundary upgrade");
state = checked(state->maturation_upgrade_candidate(), "maturation upgrade");
state = checked(state->inheritance_upgrade_candidate(), "inheritance upgrade");
state = checked(state->photosynthesis_upgrade_candidate({0, 1, {0}}), "light upgrade");
require(!state->revamp_upgrade_candidate(revamp()), "revamp upgrade skipped rules 12");
state = checked(state->liquid_upgrade_candidate(liquid()), "liquid upgrade");
state = checked(state->birth_candidate({account(1), 1}, {100, 100, 100, 100, {state->tick()}}),
"founder 5 birth");
require(!state->revamp_upgrade_candidate(revamp(1'001)), "an invalid essential share accepted");
state = checked(state->revamp_upgrade_candidate(rules), "revamp upgrade");
require(state->format_version() == cellular_lives_revamp_format &&
state->rules_version() == cellular_lives_revamp_rules &&
state->revamp_rules() == rules && state->liquid_rules() == liquid() &&
state->flow_field() != nullptr && !state->revamp_upgrade_candidate(revamp()),
"revamp upgrade repeated, wrong versions or lost rules");
state = checked(state->birth_candidate({account(2), 1}, {101, 101, 101, 101, {state->tick()}}),
"founder 6 birth");
const auto old = state->archive().find(100);
const auto fresh = state->archive().find(101);
require(old && old->schema_version() == biology::genome_schema_v6,
"the founder 5 life lost its genome in the upgrade");
require(fresh && fresh->schema_version() == biology::genome_schema_v7 &&
fresh->development_version() == 7 &&
fresh->cellular_traits() == biology::founder_cellular_traits,
"a rules-13 founder is not founder 6");
return state;
}
std::vector<CellularLifeIntent> swim(const CellularLives& state, biology::CellularIntent movement,
std::uint8_t exclude = 0) {
std::vector<CellularLifeIntent> result;
for (const auto& life : state.lives()) {
CellularLifeIntent input{life.identity.life, {}};
input.intent.movement = movement;
input.intent.exclude = exclude;
result.push_back(input);
}
return result;
}
void closed(const CellularLives& state) {
const auto& ledger = state.boundary_ledger();
auto expected = state.opening_total();
expected.energy.value += ledger.incoming.energy.value - ledger.outgoing.energy.value;
for (std::size_t channel = 0; channel < expected.matter.size(); ++channel)
expected.matter[channel].value +=
ledger.incoming.matter[channel].value - ledger.outgoing.matter[channel].value;
require(state.current_total() == expected, "revamp region broke closure");
}
void starting_wildlife_is_a_funded_opening() {
auto source = opening(77, true, 64, false);
checked(source->advance_tick({}), "opening tick");
source = checked(source->migration_upgrade_candidate(), "boundary");
source = checked(source->maturation_upgrade_candidate(), "maturation");
source = checked(source->inheritance_upgrade_candidate(), "inheritance");
source = checked(source->photosynthesis_upgrade_candidate({0, 1, {0}}), "light");
source = checked(source->liquid_upgrade_candidate(liquid()), "liquid");
const auto before = source->snapshot();
auto seeded = checked(source->revamp_upgrade_candidate(revamp(), 32, 900'000), "wildlife");
require(source->snapshot() == before && seeded->lives().size() == 32,
"seeding changed source or count");
auto again = checked(source->revamp_upgrade_candidate(revamp(), 32, 900'000), "same seed");
require(again->snapshot() == seeded->snapshot(), "opening is not deterministic");
require(!seeded->revamp_upgrade_candidate(revamp(), 32, 900'000), "reseeded a region");
require(!source->revamp_upgrade_candidate(revamp(), 256, 900'000), "accepted excessive count");
require(!source->revamp_upgrade_candidate(revamp(), 1, 0), "accepted zero identity");
require(!source->revamp_upgrade_candidate(revamp(), 1, cellular_bud_namespace),
"accepted bud namespace for a root");
require(!source->revamp_upgrade_candidate(revamp(), 0, 900'000), "accepted unused identity");
require(restore(*seeded)->snapshot() == seeded->snapshot(), "fixture restore diverged");
bool varied = false;
for (const auto& life : seeded->lives()) {
const auto genome = seeded->archive().find(life.identity.genome);
require(genome && life.account == LifeAccount{} && life.parent_life == 0 &&
life.growth == biology::GrowthState{1000, 0} &&
life.reserve.matter == accounting::Inventory{}.matter,
"fixture changed founder starting rules");
const auto budget =
checked(biology::metabolic_budget(*genome, life.growth,
{seeded->ambient_temperature_millikelvin(), {}}, 1000,
seeded->revamp_rules().body),
"wildlife budget");
require(life.reserve.energy.value ==
budget.demand.value * biology::founder_reserve_seconds &&
life.body == budget.body && life.offspring_genome == genome->id(),
"wildlife endowment or inherited plan wrong");
varied = varied || genome->cellular_traits() != biology::founder_cellular_traits;
}
require(varied && seeded->nursery() != source->nursery(), "wildlife was free or unvaried");
closed(*seeded);
for (int tick = 0; tick < 5; ++tick) {
const auto intents =
checked(wildlife_intents(*seeded, seeded->tick() + 1), "wildlife intents");
checked(seeded->advance_tick(intents), "wildlife tick");
closed(*seeded);
}
require(restore(*seeded)->snapshot() == seeded->snapshot(), "running fixture restore");
// A player is born into the seeded region from the nursery's remainder and plays on.
seeded = checked(seeded->birth_candidate(
{account(9), 1}, {800'000, 800'000, 800'000, 800'000, {seeded->tick()}}),
"player birth after seeding");
for (int tick = 0; tick < 40; ++tick) {
auto intents = checked(wildlife_intents(*seeded, seeded->tick() + 1), "wildlife intents");
CellularLifeIntent player{800'000, {}};
player.intent.movement = {500, 200};
intents.push_back(player);
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
checked(seeded->advance_tick(intents), "tick with the player");
closed(*seeded);
}
auto poor = opening(77, true, 1, false);
checked(poor->advance_tick({}), "poor tick");
poor = checked(poor->migration_upgrade_candidate(), "poor boundary");
poor = checked(poor->maturation_upgrade_candidate(), "poor maturation");
poor = checked(poor->inheritance_upgrade_candidate(), "poor inheritance");
poor = checked(poor->photosynthesis_upgrade_candidate({0, 1, {0}}), "poor light");
poor = checked(poor->liquid_upgrade_candidate(liquid()), "poor liquid");
const auto poor_before = poor->snapshot();
require(!poor->revamp_upgrade_candidate(revamp(), 32, 900'000) &&
poor->snapshot() == poor_before,
"insufficient nursery was not atomic");
}
void shown_bud_charge_includes_the_fee() {
auto state = revamp_region();
const auto& life = state->lives().back();
const auto genome = state->archive().find(life.identity.genome);
require(genome.has_value(), "founder genome");
require(state->budding_cost(life.identity.life) ==
biology::bud_cost(*genome, state->ambient_temperature_millikelvin()),
"zero-fee founder charge changed");
require(!state->budding_cost(999'999), "cost for missing life");
auto paid = revamp_region(250, 250'000);
const auto shown = state->budding_cost(life.identity.life);
if (!shown)
throw std::runtime_error("missing shown cost");
auto expected = shown.value();
expected.energy.value += 250'000;
require(paid->budding_cost(life.identity.life) == expected, "shown charge omitted the fee");
}
void upgrade_and_restore() {
const auto state = revamp_region(400);
const auto copy = restore(*state);
require(copy->snapshot() == state->snapshot() && copy->revamp_rules() == revamp(400) &&
copy->liquid_rules() == liquid(),
"format 11 did not restore exactly");
// A tampered rules block is refused rather than read as another share.
auto bytes = state->snapshot();
require(bytes.size() > 8, "empty snapshot");
bytes[8] = 10; // Format field: format 10 bytes with the format 11 magic.
require(!CellularLives::restore(bytes, state->world(), state->region(), state->frame(),
state->tick()),
"a format 11 checkpoint restored as format 10");
}
// Both generations live and pay their way in one region, and restore continues exactly.
void mixed_generations_tick_and_continue() {
auto continuous = revamp_region();
for (int tick = 0; tick < 30; ++tick)
checked(continuous->advance_tick(swim(*continuous, {600, 800})), "continuous tick");
require(continuous->lives().size() == 2, "a life died in thirty ticks");
closed(*continuous);
auto resumed = restore(*continuous);
for (int tick = 0; tick < 30; ++tick) {
checked(continuous->advance_tick(swim(*continuous, {-700, 300})), "continuous tick");
checked(resumed->advance_tick(swim(*resumed, {-700, 300})), "resumed tick");
}
require(continuous->snapshot() == resumed->snapshot(), "restore diverged from a live run");
closed(*continuous);
}
// The spent pool drips back one bubble per non-empty channel on every interval tick, at
// seeded spots, without losing or creating anything; a full habitat keeps it waiting.
void the_spent_pool_drips_back() {
const auto rules = revamp();
biology::CellularHabitatConfig config{7, 9, 11, 48'000, 48'000, {}};
config.format = biology::cellular_habitat_liquid_format;
config.next_deposit = 1;
accounting::Inventory spent{{50'000'000}, {{{2'500'000}, {0}, {300}, {1'000'000}}}};
auto off = config;
auto kept = spent;
require(cellular_drip_spent(off, kept, rules, 1, 2, 19, 5) && off == config && kept == spent,
"the pool dripped between intervals");
auto once = config;
auto left = spent;
require(cellular_drip_spent(once, left, rules, 1, 2, 20, 5), "drip refused");
require(once.patches.size() == 4 && once.next_deposit == 5,
"a drip is one bubble per non-empty channel");
accounting::Inventory dripped{};
for (const auto& bubble : once.patches) {
require(bubble.kind == biology::CellularDepositKind::mote && bubble.merged == 1 &&
bubble.source == 5 && bubble.address.x_um < 48'000 &&
bubble.address.y_um < 48'000,
"a drip bubble is malformed");
dripped.energy.value += bubble.stock.energy.value;
for (std::size_t c = 0; c < 4; ++c)
dripped.matter[c].value += bubble.stock.matter[c].value;
}
require(dripped ==
accounting::Inventory{{20'000'000}, {{{1'000'000}, {0}, {300}, {1'000'000}}}} &&
left == accounting::Inventory{{30'000'000}, {{{1'500'000}, {0}, {0}, {0}}}},
"the drip did not move the capped amounts exactly");
auto again = config;
auto same = spent;
require(cellular_drip_spent(again, same, rules, 1, 2, 20, 5) && again == once,
"the drip is not deterministic");
auto full = config;
for (std::uint32_t i = 0; i < biology::max_cellular_liquid_deposits; ++i) {
biology::CellularPatch filler{{i % 48'000, i / 48'000},
5,
{{1}, {}},
++full.next_deposit,
biology::cellular_mote_radius_um,
biology::CellularDepositKind::mote};
filler.merged = 1;
full.patches.push_back(filler);
}
const auto packed = full;
auto waiting = spent;
require(cellular_drip_spent(full, waiting, rules, 1, 2, 20, 5) && full == packed &&
waiting == spent,
"a full habitat took a drip");
}
// Exclusions belong to owned lives under rules 13 and travel in the trace.
void exclusions_are_checked_and_replayed() {
auto state = revamp_region();
require(state->advance_tick(swim(*state, {300, 0}, 0b0101)).has_value(),
"an owned life's exclusions were refused");
require(!state->advance_tick(swim(*state, {}, 0x10)).has_value(),
"an exclusion outside the four matter channels was accepted");
auto older = opening(7, true, 2, false);
checked(older->advance_tick({}), "genesis tick");
older = checked(older->migration_upgrade_candidate(), "boundary upgrade");
older = checked(older->maturation_upgrade_candidate(), "maturation upgrade");
older = checked(older->inheritance_upgrade_candidate(), "inheritance upgrade");
older = checked(older->photosynthesis_upgrade_candidate({0, 1, {0}}), "light upgrade");
older = checked(older->liquid_upgrade_candidate(liquid()), "liquid upgrade");
older = checked(older->birth_candidate({account(1), 1}, {100, 100, 100, 100, {older->tick()}}),
"founder 5 birth");
require(!older->advance_tick(swim(*older, {}, 0b0001)).has_value(),
"a rules-12 owner accepted exclusions");
}
// A rules-13 region runs long enough for founders to spend their endowment, keeping closure,
// and restores with its rules and spent pool exactly.
void a_long_run_keeps_closure_and_restores() {
auto state = revamp_region();
for (int tick = 0; tick < 700; ++tick) {
const auto x = static_cast<std::int16_t>((tick / 50) % 2 == 0 ? 900 : -900);
checked(state->advance_tick(swim(*state, {x, 400}, 0b0010)), "long-run tick");
}
closed(*state);
const auto copy = restore(*state);
require(copy->snapshot() == state->snapshot() && copy->revamp_rules() == revamp(),
"format 11 did not restore the rules and spent pool exactly");
}
// Rules 13 offers: active play earns them, behaviour moves affinity, and a choice edits the
// plan (never the expressed body), pays and reclaims its cost, or keeps the offer when
// unaffordable; a decline clears it; a pending offer restores exactly.
const CellularOwnedLife& life_of(const CellularLives& state, std::uint64_t id) {
const auto found = std::ranges::find(
state.lives(), id, [](const CellularOwnedLife& l) { return l.identity.life; });
require(found != state.lives().end(), "life missing");
return *found;
}
Owner offering_region(std::uint64_t cost_pj) {
auto rules = revamp();
rules.offer_interval_ticks = 40;
for (auto& m : rules.mutations) {
m.cost.energy.value = cost_pj;
m.cost_scale_percent = 100;
}
auto fresh = opening(7, true, 2, false);
checked(fresh->advance_tick({}), "genesis tick");
fresh = checked(fresh->migration_upgrade_candidate(), "boundary upgrade");
fresh = checked(fresh->maturation_upgrade_candidate(), "maturation upgrade");
fresh = checked(fresh->inheritance_upgrade_candidate(), "inheritance upgrade");
fresh = checked(fresh->photosynthesis_upgrade_candidate({0, 1, {0}}), "light upgrade");
fresh = checked(fresh->liquid_upgrade_candidate(liquid()), "liquid upgrade");
fresh = checked(fresh->birth_candidate({account(1), 1}, {100, 100, 100, 100, {fresh->tick()}}),
"founder 5 birth");
fresh = checked(fresh->revamp_upgrade_candidate(rules), "revamp upgrade");
fresh = checked(fresh->birth_candidate({account(2), 1}, {101, 101, 101, 101, {fresh->tick()}}),
"founder 6 birth");
return fresh;
}
void offers_come_from_active_play() {
auto state = offering_region(0);
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto& founder6 = life_of(*state, 101).revamp;
require(founder6.offer.count == 3 && founder6.offer.event_index == 1 && founder6.events == 1 &&
founder6.active_ticks == 0,
"forty ticks of active play did not earn a founder 6 an offer");
for (std::size_t k = 0; k < 3; ++k)
require(biology::cellular_mutation(founder6.offer.ids.at(k)) != nullptr &&
founder6.offer.chances.at(k) >= 10 && founder6.offer.chances.at(k) <= 700'000,
"an offered mutation is unknown or its chance out of bounds");
// A founder 5 plan (no traits) has no catalog: its life counts but is never offered.
require(life_of(*state, 100).revamp.offer.count == 0, "a founder 5 plan was offered");
// Thrust moved affinity: forty ticks is short of the ten seconds Strong Propulsion counts.
require(founder6.affinity.score.at(0) == 0, "affinity moved too early");
const auto copy = restore(*state);
require(copy->snapshot() == state->snapshot() && life_of(*copy, 101).revamp == founder6,
"a pending offer did not restore exactly");
}
std::vector<CellularMutationSelection> choose(const CellularLives& state, std::uint64_t life_id,
std::uint16_t id, std::uint64_t successor) {
const auto& offer = life_of(state, life_id).revamp.offer;
return {{life_id, offer.event_index, offer.offer_tick, successor, id}};
}
// Rules 13 (reproduction plan section 4): a choice splits the cell. Both plans carry the mutation,
// only the offspring expresses it, body and reserve divide, and the player stays or becomes.
void a_choice_splits_the_cell(bool become) {
auto state = offering_region(1'000);
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto before = life_of(*state, 101);
const auto id = before.revamp.offer.ids.at(0);
const auto deposits = state->habitat().patches().size();
auto choice = choose(*state, 101, id, 9'000);
choice.front().become = become;
const auto execution =
checked(state->advance_tick_with_mutations(swim(*state, {}), choice), "choice tick");
require(execution.mutations.size() == 1 &&
execution.mutations.front().result == CellularMutationResult::split_applied,
"the choice did not split the cell");
const auto identity = cellular_bud_identity(state->region(), 1);
const auto& founder = life_of(*state, 101);
const auto& child = life_of(*state, identity);
require(founder.identity.genome == before.identity.genome &&
founder.offspring_genome == 9'000 && child.identity.genome == 9'000 &&
child.offspring_genome == 9'000 && child.parent_life == 101 &&
founder.revamp.offer.count == 0,
"the split did not give both plans the mutation and only the offspring its body");
require(founder.growth.realized_per_thousand < 1'000 &&
child.growth.realized_per_thousand < 1'000 &&
child.revamp.affinity.score == founder.revamp.affinity.score,
"the split did not halve both cells or pass on the affinity");
require(become ? child.account == account(2) && founder.account == LifeAccount{}
: child.account == LifeAccount{} && founder.account == account(2),
"control did not follow the choice");
require(state->habitat().patches().size() >= deposits + 1, "the paid cost was not reclaimed");
closed(*state);
// A half-grown founder cannot split again, so its next offer waits until it has regrown.
if (!become) {
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto& founder_now = life_of(*state, 101);
require(founder_now.growth.realized_per_thousand < 1'000 &&
founder_now.revamp.offer.count == 0,
"a half-grown founder was offered a split");
closed(*state);
}
// Rules 13 wildlife (the founder after become): its controller's intents are always
// admissible, with matter as energy, fee-aware buds and the revamp engulf test.
if (become) {
for (int tick = 0; tick < 300; ++tick) {
auto intents = checked(wildlife_intents(*state, state->tick() + 1), "wildlife intents");
for (const auto& life : state->lives())
if (life.account != LifeAccount{}) {
CellularLifeIntent owned{life.identity.life, {}};
owned.intent.movement = {600, 300};
intents.push_back(owned);
}
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
checked(state->advance_tick(intents), "wildlife tick");
}
closed(*state);
}
const auto copy = restore(*state);
require(copy->snapshot() == state->snapshot(), "a split region did not restore exactly");
}
void the_region_cap_refuses_splits() {
auto rules = revamp();
rules.offer_interval_ticks = 40;
rules.organism_cap = 2;
auto fresh = opening(7, true, 2, false);
checked(fresh->advance_tick({}), "genesis tick");
fresh = checked(fresh->migration_upgrade_candidate(), "boundary upgrade");
fresh = checked(fresh->maturation_upgrade_candidate(), "maturation upgrade");
fresh = checked(fresh->inheritance_upgrade_candidate(), "inheritance upgrade");
fresh = checked(fresh->photosynthesis_upgrade_candidate({0, 1, {0}}), "light upgrade");
fresh = checked(fresh->liquid_upgrade_candidate(liquid()), "liquid upgrade");
fresh = checked(fresh->birth_candidate({account(1), 1}, {100, 100, 100, 100, {fresh->tick()}}),
"founder 5 birth");
fresh = checked(fresh->revamp_upgrade_candidate(rules), "revamp upgrade");
fresh = checked(fresh->birth_candidate({account(2), 1}, {101, 101, 101, 101, {fresh->tick()}}),
"founder 6 birth");
for (int tick = 0; tick < 40; ++tick)
checked(fresh->advance_tick(swim(*fresh, {1'000, 0})), "swim tick");
const auto offer = life_of(*fresh, 101).revamp.offer;
const auto refused = checked(fresh->advance_tick_with_mutations(
swim(*fresh, {}), choose(*fresh, 101, offer.ids.at(0), 9'020)),
"capped split tick");
require(refused.mutations.front().result == CellularMutationResult::split_refused &&
fresh->lives().size() == 2,
"a full region allowed a split");
}
// Become needs a bud, an owned life and rules 13; litter counts whole and chance offspring.
void become_and_litter() {
auto state = revamp_region();
auto lone = swim(*state, {});
lone.back().intent.become = true;
require(!state->advance_tick(lone), "become without a bud was accepted");
require(cellular_litter_count(0, 0, 900) == 1 && cellular_litter_count(100, 99, 900) == 2 &&
cellular_litter_count(150, 49, 900) == 3 &&
cellular_litter_count(150, 50, 900) == 2 &&
cellular_litter_count(9'900, 0, 900) == 10,
"litter counted the wrong offspring");
}
void unaffordable_choices_wait_and_declines_clear() {
auto state = offering_region(1'000'000'000'000);
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto offer = life_of(*state, 101).revamp.offer;
const auto execution =
checked(state->advance_tick_with_mutations(swim(*state, {}),
choose(*state, 101, offer.ids.at(1), 9'001)),
"unaffordable choice tick");
require(execution.mutations.front().result == CellularMutationResult::insufficient_funding &&
life_of(*state, 101).revamp.offer == offer && !state->archive().find(9'001),
"an unaffordable choice did not leave the offer waiting");
const auto declined =
checked(state->advance_tick_with_mutations(swim(*state, {}), choose(*state, 101, 0, 9'002)),
"decline tick");
require(declined.mutations.front().result == CellularMutationResult::declined &&
life_of(*state, 101).revamp.offer.count == 0 &&
life_of(*state, 101).offspring_genome == life_of(*state, 101).identity.genome,
"a decline did not clear the offer");
// A choice naming something not offered fails the tick.
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto next = life_of(*state, 101).revamp.offer;
std::uint16_t absent = 1;
while (std::ranges::find(next.ids, absent) != next.ids.end())
++absent;
require(
!state->advance_tick_with_mutations(swim(*state, {}), choose(*state, 101, absent, 9'003)),
"a choice outside the offer was accepted");
closed(*state);
}
void thrust_moves_affinity() {
auto state = offering_region(0);
for (int tick = 0; tick < 200; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto& scores = life_of(*state, 101).revamp.affinity.score;
// Ten seconds of thrust: Strong Propulsion up, Light Propulsion down (catalog ids 1 and 7).
require(scores.at(0) == 100 && scores.at(6) == -100,
"ten seconds of thrust did not move propulsion affinity");
}
// Rules 13 (reproduction plan sections 6-7): Adhesion turns the cell into a two-member organism
// that holds its whole body and reserve; the organism expresses later mutations as a whole,
// buds add internal members, and at the threshold it emerges as a recorded export.
Owner adhesion_region(std::uint64_t carbon_fee = 0) {
auto rules = revamp();
rules.bud_fee.matter[0].value = carbon_fee;
rules.bud_fee_scale_percent = carbon_fee == 0 ? 0 : 100;
rules.offer_interval_ticks = 40;
rules.bounds.buds_for_adhesion = 0;
rules.emerge_members = 3;
rules.emerge_mass_fg = 0;
rules.growth_per_tick_centi_mille = 0; // Collected matter stays in the reserve for buds.
for (auto& m : rules.mutations)
m.enabled = false;
// Adhesion and five movement mutations: three options capped at 70% each need five.
rules.mutations.at(48).enabled = true;
rules.mutations.at(48).base_weight = 10'000;
for (std::size_t i = 0; i < 5; ++i)
rules.mutations.at(i).enabled = true;
auto fresh = opening(7, true, 4, false); // A 6 mm region, rich motes at four sites.
checked(fresh->advance_tick({}), "genesis tick");
fresh = checked(fresh->migration_upgrade_candidate(), "boundary upgrade");
fresh = checked(fresh->maturation_upgrade_candidate(), "maturation upgrade");
fresh = checked(fresh->inheritance_upgrade_candidate(), "inheritance upgrade");
fresh = checked(fresh->photosynthesis_upgrade_candidate({0, 1, {0}}), "light upgrade");
fresh = checked(fresh->liquid_upgrade_candidate(liquid(6'000)), "liquid upgrade");
fresh = checked(fresh->revamp_upgrade_candidate(rules), "revamp upgrade");
fresh = checked(fresh->birth_candidate({account(2), 1}, {101, 101, 101, 101, {fresh->tick()}}),
"founder 6 birth");
return fresh;
}
// One tick's intents steering `life_id` toward the richest bubble (the fixture's rich founding
// motes), with matter excluded from burning so the reserve keeps it for growth and buds.
std::vector<CellularLifeIntent> forage(const CellularLives& state, std::uint64_t life_id) {
const auto& life = life_of(state, life_id);
const biology::CellularPatch* best = nullptr;
double nearest{};
// Short of energy, it heads for energy; otherwise for whatever is richest.
const bool hungry = life.reserve.energy.value < 3'000'000;
for (const auto& patch : state.habitat().patches()) {
auto richest = patch.stock.energy.value;
if (!hungry)
for (const auto& channel : patch.stock.matter)
richest = std::max(richest, channel.value);
const auto distance = std::hypot(
static_cast<double>(patch.address.x_um) - static_cast<double>(life.position.x_um),
static_cast<double>(patch.address.y_um) - static_cast<double>(life.position.y_um));
if (richest >= 1'000'000'000 && (best == nullptr || distance < nearest)) {
nearest = distance;
best = &patch;
}
}
require(best != nullptr, "nothing left in the region");
auto input = swim(state, {}, 0x0F);
const auto dx =
static_cast<double>(best->address.x_um) - static_cast<double>(life.position.x_um);
const auto dy =
static_cast<double>(best->address.y_um) - static_cast<double>(life.position.y_um);
// Inside the unit circle: scale by the Euclidean length, rounded toward zero.
const auto span = std::max(1.0, std::hypot(dx, dy));
if (hungry && span < 80)
return input; // On the energy: hold still and feed rather than spend on thrust.
for (auto& entry : input)
if (entry.life_id == life_id)
entry.intent.movement = {static_cast<std::int16_t>(dx * 999.0 / span),
static_cast<std::int16_t>(dy * 999.0 / span)};
return input;
}
// Forages in offer intervals, declining offers, until one names `id`.
std::uint16_t await_offer(Owner& state, std::uint64_t life_id, std::uint16_t id) {
for (std::uint64_t round = 0; round < 40; ++round) {
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(forage(*state, life_id)), "forage tick");
const auto& offer = life_of(*state, life_id).revamp.offer;
const auto end = offer.ids.begin() + offer.count;
if (std::ranges::find(offer.ids.begin(), end, id) != end)
return id;
if (offer.count != 0)
checked(state->advance_tick_with_mutations(swim(*state, {}),
choose(*state, life_id, 0, 8'000 + round)),
"decline tick");
}
require(false, "the expected mutation was never offered");
return 0;
}
// Forages, asking to bud every 50 ticks, until a bud is funded or `ticks` pass; returns the last
// bud result (a single request when `ticks` is 0).
CellularBudExecution bud_until_funded(Owner& state, std::uint64_t life_id, int ticks) {
CellularBudExecution last{};
for (int tick = 0; tick <= ticks; ++tick) {
auto input = forage(*state, life_id);
const bool ask = tick % 50 == 0;
if (ask) {
for (auto& entry : input)
if (entry.life_id == life_id) {
entry.intent = {};
entry.intent.bud = true;
}
}
const auto executed = checked(state->advance_tick_with_mutations(input, {}), "bud tick");
if (ask) {
require(executed.buds.size() == 1, "a bud request went unanswered");
last = executed.buds.front();
if (last.result == CellularBudResult::budded)
break;
}
}
return last;
}
// The bud fee comes on top of the bud. Wildlife that can fund a bud but not the fee as well is
// refused, never charged less than the fee the region reclaims (DEV region 14 stalled on that
// conservation error at its first such bud). Seeded wildlife under the DEV fee, run until buds.
void the_bud_fee_is_paid_in_full_or_refused() {
auto rules = revamp();
rules.bud_fee = {{250'000}, {{{100'000}, {30'000}, {10'000}, {60'000}}}};
rules.bud_fee_scale_percent = 100;
auto source = opening(77, true, 64, false);
checked(source->advance_tick({}), "opening tick");
source = checked(source->migration_upgrade_candidate(), "boundary");
source = checked(source->maturation_upgrade_candidate(), "maturation");
source = checked(source->inheritance_upgrade_candidate(), "inheritance");
source = checked(source->photosynthesis_upgrade_candidate({0, 1, {0}}), "light");
source = checked(source->liquid_upgrade_candidate(liquid()), "liquid");
auto state = checked(source->revamp_upgrade_candidate(rules, 32, 900'000), "wildlife");
int tick = 0;
for (; tick < 12'000 && state->next_bud_sequence() < 2; ++tick) {
const auto intents = checked(wildlife_intents(*state, state->tick() + 1), "intents");
checked(state->advance_tick(intents), "wildlife tick under the bud fee");
}
require(state->next_bud_sequence() >= 2, "no wildlife budded under the fee");
closed(*state);
}
void an_organism_forms_grows_and_emerges() {
auto state = adhesion_region();
const auto adhesion = await_offer(state, 101, 49);
const auto single = life_of(*state, 101);
auto choice = choose(*state, 101, adhesion, 9'000);
const auto formed =
checked(state->advance_tick_with_mutations(swim(*state, {}), choice), "adhesion tick");
require(formed.mutations.front().result == CellularMutationResult::split_applied,
"Adhesion did not form an organism");
const auto identity = cellular_bud_identity(state->region(), 1);
require(state->lives().size() == 1, "Adhesion left the single cell alive");
const auto organism = life_of(*state, identity);
require(organism.revamp.members == 2 && organism.account == account(2) &&
organism.identity.genome == 9'000 && organism.offspring_genome == 9'000 &&
organism.parent_life == 101 &&
organism.revamp.affinity.score == single.revamp.affinity.score,
"the organism did not take the cell's place, plan and account");
const auto merged = std::ranges::find(state->corpses(), std::uint64_t{101},
[](const CellularOwnedCorpse& c) { return c.life_id; });
require(merged != state->corpses().end() &&
merged->cause == biology::CellularDeathCause::merged &&
merged->inventory == accounting::Inventory{},
"the single cell did not end as an empty merged corpse");
closed(*state);
require(restore(*state)->snapshot() == state->snapshot(), "an organism did not restore");
// An organism cannot become its bud; its next mutation is expressed as a whole.
auto become = swim(*state, {});
become.front().intent.bud = true;
become.front().intent.become = true;
require(!state->advance_tick(become), "an organism was allowed to become a bud");
const auto strong = await_offer(state, identity, 1);
const auto whole = checked(state->advance_tick_with_mutations(
swim(*state, {}), choose(*state, identity, strong, 9'001)),
"organism mutation tick");
require(whole.mutations.front().result == CellularMutationResult::applied &&
life_of(*state, identity).identity.genome == 9'001 &&
life_of(*state, identity).offspring_genome == 9'001 && state->lives().size() == 1,
"the organism did not express its mutation as a whole");
closed(*state);
// A bud adds an internal member, not a new life, once the organism has fed enough.
const auto refused = bud_until_funded(state, identity, 0);
require(refused.result == CellularBudResult::insufficient_funding &&
life_of(*state, identity).revamp.members == 2,
"an unfed organism's bud was not refused");
const auto budded = bud_until_funded(state, identity, 10'000);
require(budded.result == CellularBudResult::budded && budded.bud_life == identity &&
life_of(*state, identity).revamp.members == 3 && state->lives().size() == 1,
"an organism's bud did not add an internal member");
closed(*state);
require(cellular_can_emerge(life_of(*state, identity), state->revamp_rules()),
"a three-member organism could not emerge");
const auto summary = checked(summarize_cellular_play(*state), "play summary");
require(summary.organisms == 1 && summary.largest_organism == 3 && summary.merged == 1 &&
summary.offers_earned >= 1,
"the play summary missed the organism");
// Emerge: the whole organism leaves as an export and the life ends as emerged.
const auto outgoing = state->boundary_ledger().outgoing;
const auto leaving = life_of(*state, identity);
auto emerge = swim(*state, {});
emerge.front().intent = {};
emerge.front().intent.emerge = true;
checked(state->advance_tick(emerge), "emerge tick");
require(state->lives().empty(), "the organism did not leave");
const auto emerged = std::ranges::find(state->corpses(), identity,
[](const CellularOwnedCorpse& c) { return c.life_id; });
require(emerged != state->corpses().end() &&
emerged->cause == biology::CellularDeathCause::emerged,
"the organism did not end as emerged");
// The tick's step still moved the reserve first; the body (no growth here) leaves whole,
// and closure accounts for every femtogram exactly.
const auto& exported = state->boundary_ledger().outgoing;
for (std::size_t c = 0; c < exported.matter.size(); ++c)
require(exported.matter[c].value - outgoing.matter[c].value >= leaving.body.matter[c].value,
"the emerged body was not recorded as an export");
require(exported.energy.value > outgoing.energy.value, "the emerged reserve stayed behind");
closed(*state);
require(restore(*state)->snapshot() == state->snapshot(), "an emerged region did not restore");
}
// Emerge needs an owned life at the threshold; a single cell asking is ignored, wildlife refused.
void emerge_needs_the_threshold() {
auto state = adhesion_region();
auto ask = swim(*state, {});
ask.front().intent = {};
ask.front().intent.emerge = true;
checked(state->advance_tick(ask), "single-cell emerge tick");
require(state->lives().size() == 1, "a single cell emerged");
auto mixed = swim(*state, {});
mixed.front().intent.emerge = true;
mixed.front().intent.bud = true;
require(!state->advance_tick(mixed), "emerge with a bud was accepted");
CellularOwnedLife wild = life_of(*state, 101);
wild.revamp.members = 8;
require(cellular_can_emerge(wild, state->revamp_rules()), "an owned organism at the threshold");
wild.account = {};
require(!cellular_can_emerge(wild, state->revamp_rules()), "wildlife could emerge");
}
// A recorded trace replays to the exact live result under rules 13.
void trace_replays() {
auto live = revamp_region();
const auto base = restore(*live);
CellularBatch batch;
batch.format_version = cellular_batch_inheritance_format;
batch.header = {live->world(), live->region(), live->frame(), {}, {}, live->tick(), 0};
batch.header.predecessor.fill(1);
batch.header.predecessor_digest.fill(2);
for (int tick = 0; tick < 24; ++tick) {
auto intents = swim(*live, {static_cast<std::int16_t>(tick < 12 ? 1'000 : -400), 0},
static_cast<std::uint8_t>(tick % 16));
// A single cell asking to emerge is below the threshold and stays.
intents.front().intent.emerge = tick == 5;
checked(live->advance_tick(intents), "recorded tick");
batch.ticks.push_back({intents, {}, {}});
}
batch.header.end_tick = live->tick();
const auto bytes = checked(encode_cellular_batch(batch), "trace encodes");
const auto decoded = checked(decode_cellular_batch(bytes), "trace decodes");
const auto replayed = checked(replay_cellular_batch(*base, decoded), "trace replays");
require(replayed->snapshot() == live->snapshot(), "replay diverged from the live run");
require(decoded.ticks.back().lives.front().intent.exclude == 23 % 16,
"exclusions did not survive the trace");
require(decoded.ticks.at(5).lives.front().intent.emerge &&
!decoded.ticks.at(6).lives.front().intent.emerge,
"Emerge did not survive the trace");
}
} // namespace
int main() try {
starting_wildlife_is_a_funded_opening();
shown_bud_charge_includes_the_fee();
the_bud_fee_is_paid_in_full_or_refused();
upgrade_and_restore();
mixed_generations_tick_and_continue();
the_spent_pool_drips_back();
carried_matter_is_load();
exclusions_are_checked_and_replayed();
a_long_run_keeps_closure_and_restores();
offers_come_from_active_play();
a_choice_splits_the_cell(false);
a_choice_splits_the_cell(true);
the_region_cap_refuses_splits();
become_and_litter();
unaffordable_choices_wait_and_declines_clear();
thrust_moves_affinity();
an_organism_forms_grows_and_emerges();
emerge_needs_the_threshold();
trace_replays();
std::puts("PASS rules 13 owner: upgrade, founder 6, restore and replay");
return 0;
} catch (const std::exception& error) {
std::printf("FAIL rules 13 owner: %s\n", error.what());
return 1;
} catch (...) {
std::puts("FAIL rules 13 owner");
return 1;
}