Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 4s
Foundation / checks (ecs) (push) Successful in 4s
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 4m29s
Foundation / postgres-tools (push) Successful in 31s
Foundation / server-image (push) Successful in 4m24s
Foundation / image (push) Successful in 5m3s
Phase 2 of the cellular revamp build plan (ADR-0179), server half. - Matter as energy: when an energy cost exceeds the reserve's energy, reserve matter stands in for the rest at each channel's burn rate (pJ per 1,000 fg, scaled by the genome's burn efficiency), largest channel first. Upkeep may burn any channel; thrust only channels the player has not excluded. Burned matter adds no heat; it goes to the region's spent pool. A cell dies only when nothing can pay its upkeep. - Collection: per-channel limits scaled by the genome's collection indices, a shared limit on all matter, a tunable cost per membrane point, and only the genome's kept share (energy conversion) of bubble energy reaching the reserve. - Predation: engulf mass carries a tunable share of reserve matter, the predator's engulf capacity scales its side and the prey's membrane (now in nanometres) its own; kill absorption scales the predator's intake; the kill's remainder is split between bubbles at the prey and the spent pool, and a full habitat sends overflow to the pool. - The spent pool is owner format 11 state, counted in conservation, and drips back as seeded random bubbles every interval tick. - Reserve matter is carried as load: slower thrust and turning, costlier thrust. - Channel exclusions are a 4-bit step intent field, trace byte 14; only owned lives under rules 13 may send them. All values come from the revamp tuning file. Rules up to 12 are unchanged. Tests cover payments and their conservation over 400 seeds, the rules-13 region step (collection, membrane, kept energy, burning, engulfment and kill splits with closure), the drip, load, exclusions, a 700-tick run with closure and exact restore, and trace replay with exclusions. Session v14 and the client follow the server phases (build plan). Refreshes the DEV session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
282 lines
14 KiB
C++
282 lines
14 KiB
C++
#include "evo/server/lifecycle/cellular_batch.hpp"
|
|
#include "fixtures/cellular_ecology.hpp"
|
|
|
|
#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() {
|
|
return {.currents = {5, 48'000, 48'000, 250, 2, 4, 3'000, 6'000, 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) {
|
|
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(revamp(essential)), "revamp upgrade");
|
|
require(state->format_version() == cellular_lives_revamp_format &&
|
|
state->rules_version() == cellular_lives_revamp_rules &&
|
|
state->revamp_rules() == revamp(essential) && 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 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");
|
|
}
|
|
|
|
// 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) {
|
|
const auto intents = swim(*live, {static_cast<std::int16_t>(tick < 12 ? 1'000 : -400), 0},
|
|
static_cast<std::uint8_t>(tick % 16));
|
|
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");
|
|
}
|
|
} // namespace
|
|
|
|
int main() try {
|
|
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();
|
|
trace_replays();
|
|
std::puts("PASS rules 13 owner: upgrade, founder 6, restore and replay");
|
|
return 0;
|
|
} catch (...) {
|
|
std::puts("FAIL rules 13 owner");
|
|
return 1;
|
|
}
|