Files
aevolution/tests/cellular_liquid_owner_tests.cpp
T
dingoandClaude Opus 5.5 3f82795c18
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
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 5s
Foundation / checks (deploy) (push) Successful in 4m23s
Foundation / postgres-tools (push) Successful in 29s
Foundation / server-image (push) Successful in 4m10s
Foundation / image (push) Successful in 4m31s
feat(lifecycle): rules 12 liquid owner on format 10 with brake traces
The cellular owner gains rules 12 on owner format 10: an explicit no-tick
format-9/rules-11 upgrade declares the region's liquid rules (current
configuration, founder handling and deposit motion, from the tuning file and a
seed when the region opens), converts the habitat to format 3 and starts lives at
rest. Founders born afterwards are founder 5 (genome schema 6).

Each tick derives every life's handling from its genome and the declared founder
handling, samples the current at its footprint and steps the shared liquid
motion; afterwards bubbles move with the current and the drift moving cells
induce, and touching bubbles merge. Format 10 persists the rules and each life's
motion state; restore regenerates the identical current field.

Brake is a new step intent, valid only under rules 12, carried in trace 4 as flag
bit 1 (SQL never parses that byte; player action records keep it zero). Tests
cover the upgrade, exact restore, swimming and braking, moving food with fixed
pools, restore continuing a live run, and brake traces replaying exactly. Genomes
from before schema 6 handle as founders. Refreshes the DEV session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 17:28:58 -04:00

190 lines
8.7 KiB
C++

#include "evo/server/lifecycle/cellular_batch.hpp"
#include "fixtures/cellular_ecology.hpp"
#include <algorithm>
#include <cstdio>
#include <vector>
// Rules 12 owner (Cellular_Region_Movement_Plan.md phase 2): the format 9 -> 10 upgrade, liquid
// motion inside the owner's tick, moving food and exact restore.
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::fixture;
constexpr biology::CellularArea area{48'000, 48'000};
CellularLiquidRules rules(std::uint64_t seed = 5) {
return {.currents = {seed, area.width_um, area.height_um, 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}};
}
// A rules-12 region whose founder is born after the upgrade (founder 5, schema 6).
Owner liquid_region() {
auto state = opening(7, true, 1, false);
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->liquid_upgrade_candidate(CellularLiquidRules{}), "empty rules accepted");
auto wrong = rules();
wrong.currents.width_um = 30'000;
require(!state->liquid_upgrade_candidate(wrong), "rules for another area accepted");
state = checked(state->liquid_upgrade_candidate(rules()), "liquid upgrade");
require(state->format_version() == cellular_lives_liquid_format &&
state->rules_version() == cellular_lives_liquid_rules &&
state->liquid_rules() == rules() && state->flow_field() != nullptr &&
state->habitat().config().format == biology::cellular_habitat_liquid_format &&
!state->liquid_upgrade_candidate(rules()),
"liquid upgrade repeated, wrong versions or lost rules");
for (const auto& patch : state->habitat().patches())
require(patch.merged == 1, "upgraded deposit without a merged count");
LifeAccount account{};
account.back() = 1;
state = checked(state->birth_candidate({account, 1}, {100, 100, 100, 100, {state->tick()}}),
"founder 5 birth");
const auto genome = state->archive().find(100);
require(genome && genome->schema_version() == biology::genome_schema_v6 &&
genome->movement_arrangement() == biology::founder_movement_arrangement,
"founder 5 is not schema 6 with the founder arrangement");
return state;
}
std::vector<CellularLifeIntent> swim(const CellularLives& state, biology::CellularIntent movement,
bool brake = false) {
std::vector<CellularLifeIntent> result;
for (const auto& life : state.lives()) {
CellularLifeIntent input{life.identity.life, {}};
input.intent.movement = movement;
input.intent.brake = brake;
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, "liquid region broke closure");
}
void upgrade_and_restore() {
auto state = liquid_region();
const auto copy = restore(*state);
require(copy->snapshot() == state->snapshot() && copy->liquid_rules() == rules() &&
copy->flow_field()->digest() == state->flow_field()->digest(),
"format 10 did not restore exactly");
}
void swimming_moves_and_pays() {
auto state = liquid_region();
const auto start = state->lives().front();
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {1'000, 0})), "swim tick");
const auto& life = state->lives().front();
require(life.motion.velocity_x_q10 > 150 * 1'024, "the founder did not reach swimming speed");
require(life.position.x_um > start.position.x_um + 100, "the founder did not move east");
closed(*state);
// Braking brings the relative velocity to rest.
for (int tick = 0; tick < 40; ++tick)
checked(state->advance_tick(swim(*state, {}, true)), "brake tick");
require(state->lives().front().motion.velocity_x_q10 == 0 &&
state->lives().front().motion.velocity_y_q10 == 0,
"braking did not stop the founder relative to the liquid");
closed(*state);
}
void food_moves_and_merges_without_loss() {
auto state = liquid_region();
const auto before = state->habitat().config().patches;
for (int tick = 0; tick < 400; ++tick)
checked(state->advance_tick(swim(*state, {})), "drift tick");
const auto after = state->habitat().config().patches;
const auto moved = std::ranges::count_if(after, [&before](const biology::CellularPatch& p) {
const auto old = std::ranges::find(before, p.id, &biology::CellularPatch::id);
return old != before.end() && old->address != p.address;
});
require(moved > 0, "no bubble moved with the current");
for (const auto& patch : after)
if (patch.kind == biology::CellularDepositKind::pool)
require(std::ranges::any_of(before,
[&patch](const biology::CellularPatch& old) {
return old.id == patch.id &&
old.address == patch.address;
}),
"a pool moved");
closed(*state);
}
void restore_continues_exactly() {
auto continuous = liquid_region();
for (int tick = 0; tick < 30; ++tick)
checked(continuous->advance_tick(swim(*continuous, {600, 800})), "continuous tick");
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");
}
// A trace of swimming and braking replays to the exact live result (brake is flag bit 1).
void trace_replays_brakes() {
auto live = liquid_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); // Any bound commit; this test replays portably.
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 : 0), 0}, tick >= 12);
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), "brake trace encodes");
const auto decoded = checked(decode_cellular_batch(bytes), "brake trace decodes");
require(decoded == batch && decoded.ticks.back().lives.front().intent.brake,
"the brake did not survive the trace");
const auto replayed = checked(replay_cellular_batch(*base, decoded), "brake trace replays");
require(replayed->snapshot() == live->snapshot(), "replay diverged from the live run");
}
void older_rules_refuse_brake() {
auto state = opening(7, true, 1);
require(!state->advance_tick(swim(*state, {}, true)), "rules 8 accepted a brake");
}
} // namespace
int main() {
try {
upgrade_and_restore();
swimming_moves_and_pays();
food_moves_and_merges_without_loss();
restore_continues_exactly();
trace_replays_brakes();
older_rules_refuse_brake();
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
std::puts("cellular liquid owner contracts passed");
return 0;
}