Files
aevolution/tests/cellular_lives_tests.cpp
T
dingoandClaude Opus 5.5 e74bdf286b
Foundation / checks (ecs) (push) Successful in 2m15s
Foundation / checks (deploy) (push) Successful in 3m53s
Foundation / checks (tsan) (push) Successful in 9m46s
Foundation / checks (client) (push) Failing after 13m47s
Foundation / checks (network) (push) Successful in 19m5s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 19m34s
Foundation / checks (postgres) (push) Canceled after 19m28s
Freeze offline cells, linger, suspend and resume them
M11.7 (ADR-0128): a frozen step intent, set by the server for every owned life
whose account holds no session, leaves the cell unchanged but engulfable. Owner
format 6 / rules 5 track presence: lingering for 200 ticks, then suspended out of
the world without aging; an unfrozen intent resumes it in place or at the nearest
clear spot within three extents. Bundle v6, schema v38 and the cellular-v4
opening carry it. The server refuses an offline account's carried actions, ticks
while anyone lingers, and skips suspended cells in replication and perception.

Also fixes the TSan failure of CI run 374: the rules-4 owner test read the bud
through a reference into a replaced state.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 07:50:45 -04:00

873 lines
47 KiB
C++

#include "evo/server/lifecycle/cellular_batch.hpp"
#include "evo/server/lifecycle/cellular_lives.hpp"
#include "evo/server/lifecycle/wildlife_controller.hpp"
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstdio>
#include <limits>
#include <source_location>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
using namespace evo::server;
using evo::accounting::Inventory;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("cellular lives line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
Inventory founder_price(std::uint64_t count) {
const auto endowment = evo::biology::primitive_endowment();
CHECK(endowment);
auto funding = endowment->body;
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
funding.energy.value *= count;
for (auto& channel : funding.matter)
channel.value *= count;
return funding;
}
std::uint64_t checksum(std::span<const std::uint8_t> bytes) {
std::uint64_t value = 14695981039346656037ULL;
for (const auto byte : bytes)
value = (value ^ byte) * 1099511628211ULL;
return value;
}
void refresh_checksum(std::vector<std::uint8_t>& bytes) {
const auto value = checksum(std::span{bytes}.first(bytes.size() - 8));
for (unsigned i = 0; i < 8; ++i)
bytes[bytes.size() - 8 + i] = static_cast<std::uint8_t>(value >> (i * 8U));
}
std::unique_ptr<CellularLives> empty_cellular_owner(Inventory funding,
std::vector<SpawnSite> sites) {
auto primitive = PrimitiveLives::create({91, 1, 1, 17, funding, std::move(sites)});
CHECK(primitive);
auto habitat = evo::biology::CellularHabitat::create({91, 1, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto owner =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(owner);
CHECK((*owner)->ambient_temperature_millikelvin() == 293'150);
return std::move(*owner);
}
void reserved_birth_is_funded_and_detached() {
auto opening = empty_cellular_owner(founder_price(1), {{0, 0}, {20, 0}});
const std::span<const CellularLifeIntent> no_lives{};
CHECK(opening->advance_tick(no_lives));
const auto predecessor = opening->snapshot();
LifeRequest request{};
request.account.back() = 9;
request.action = 17;
const LifeAllocation allocation{501, 501, 501, 501, {1}};
auto born = opening->birth_candidate(request, allocation);
CHECK(born && opening->tick() == 1 && opening->lives().empty());
CHECK((*born)->tick() == opening->tick() && (*born)->lives().size() == 1 &&
(*born)->lives()[0].account == request.account &&
(*born)->lives()[0].identity == allocation && (*born)->lives()[0].source == 17 &&
(*born)->lives()[0].position == (evo::biology::CellularPosition{0, 0}));
const auto endowment = evo::biology::primitive_endowment();
CHECK(endowment);
CHECK((*born)->nursery().energy.value == opening->nursery().energy.value -
endowment->reserve.energy.value -
endowment->construction.value);
CHECK((*born)->heat().energy.value == endowment->construction.value &&
(*born)->current_total() == (*born)->opening_total() &&
(*born)->archive().recorded() == 1);
CHECK(opening->snapshot() == predecessor);
const auto recovered = CellularLives::restore((*born)->snapshot(), 91, 1, 1, 1);
CHECK(recovered && (*recovered)->snapshot() == (*born)->snapshot());
auto retry_account = request;
retry_account.action++;
CHECK((*born)->birth_candidate(retry_account, {502, 502, 502, 502, {1}}).error() ==
CellularLivesError::life_exists);
CHECK(opening->birth_candidate(request, {502, 503, 502, 502, {1}}).error() ==
CellularLivesError::identity);
CHECK(opening->birth_candidate(request, {502, 502, 502, 502, {2}}).error() ==
CellularLivesError::invalid_tick);
const std::array next_tick{CellularLifeIntent{allocation.life, {}}};
CHECK((*born)->advance_tick(next_tick) && (*born)->tick() == 2 && (*born)->lives().size() == 1);
auto trace_base = empty_cellular_owner(founder_price(1), {{0, 0}});
CellularBatch birth_batch;
birth_batch.format_version = cellular_batch_v2_format;
birth_batch.header = {trace_base->world(), trace_base->region(), trace_base->frame(), {}, {},
trace_base->tick(), trace_base->tick() + 1};
birth_batch.header.predecessor.fill(3);
birth_batch.header.predecessor_digest.fill(4);
CellularTickIntents birth_tick;
birth_tick.births.push_back({request.account, request.action, 1, 801});
birth_batch.ticks.push_back(birth_tick);
const auto birth_bytes = encode_cellular_batch(birth_batch);
CHECK(birth_bytes);
const auto decoded_births = decode_cellular_batch(*birth_bytes);
CHECK(decoded_births && *decoded_births == birth_batch);
const auto replayed_birth = replay_cellular_batch(*trace_base, *decoded_births);
CHECK(replayed_birth && (*replayed_birth)->tick() == 1 &&
(*replayed_birth)->lives().size() == 1 &&
(*replayed_birth)->lives()[0].identity.life == 801 &&
(*replayed_birth)->lives()[0].account == request.account &&
(*replayed_birth)->archive().recorded() == 1 &&
(*replayed_birth)->current_total() == (*replayed_birth)->opening_total());
auto legacy_batch = birth_batch;
legacy_batch.ticks[0].births.clear();
auto legacy_bytes = encode_cellular_batch(legacy_batch);
CHECK(legacy_bytes);
(*legacy_bytes)[8] = static_cast<std::uint8_t>(cellular_batch_legacy_format);
legacy_bytes->erase(legacy_bytes->begin() + 116, legacy_bytes->begin() + 120);
const auto decoded_legacy = decode_cellular_batch(*legacy_bytes);
CHECK(decoded_legacy && decoded_legacy->format_version == cellular_batch_legacy_format &&
decoded_legacy->ticks[0].births.empty());
auto v2_bytes = encode_cellular_batch(legacy_batch);
CHECK(v2_bytes);
const auto decoded_v2 = decode_cellular_batch(*v2_bytes);
CHECK(decoded_v2 && decoded_v2->format_version == cellular_batch_v2_format &&
decoded_v2->ticks[0].births.empty() &&
decoded_v2->ticks[0].lives == legacy_batch.ticks[0].lives);
auto invalid_birth_batch = birth_batch;
invalid_birth_batch.ticks[0].births[0].generation = 0;
CHECK(encode_cellular_batch(invalid_birth_batch).error() == CellularBatchError::format);
auto unfunded = empty_cellular_owner({}, {{0, 0}});
CHECK(unfunded->advance_tick(no_lives));
const auto unfunded_snapshot = unfunded->snapshot();
CHECK(unfunded->birth_candidate(request, {601, 601, 601, 601, {1}}).error() ==
CellularLivesError::insufficient_funding);
CHECK(unfunded->snapshot() == unfunded_snapshot && unfunded->lives().empty());
auto occupied_primitive = PrimitiveLives::create({92, 1, 1, 17, founder_price(2), {{0, 0}}});
CHECK(occupied_primitive);
LifeRequest existing{};
existing.account.back() = 11;
existing.action = 1;
CHECK((*occupied_primitive)->spawn(existing, {701, 701, 701, 701, {1}}));
auto occupied_habitat = evo::biology::CellularHabitat::create({92, 1, 1, 1'000, 1'000, {}});
CHECK(occupied_habitat);
auto occupied = CellularLives::create(**occupied_primitive, std::move(*occupied_habitat),
{{1'000, 1'000}, 1, 293'150});
CHECK(occupied);
LifeRequest arriving{};
arriving.account.back() = 12;
arriving.action = 2;
CHECK((*occupied)->birth_candidate(arriving, {702, 702, 702, 702, {1}}).error() ==
CellularLivesError::no_placement);
}
void cellular_profile_migration_is_explicit_and_no_tick() {
auto primitive = PrimitiveLives::create({91, 1, 1, 17, founder_price(1), {{0, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 5;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
auto habitat = evo::biology::CellularHabitat::create({91, 1, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 1, 293'150});
CHECK(created && (*created)->lives().size() == 1);
auto current = std::move(*created);
auto legacy_bytes = current->snapshot();
legacy_bytes.erase(legacy_bytes.begin() + 220 + 168, legacy_bytes.begin() + 220 + 480);
constexpr std::uint64_t legacy_magic = 0x3130564C43564541ULL;
for (unsigned index = 0; index < 8; ++index)
legacy_bytes[index] = static_cast<std::uint8_t>(legacy_magic >> (index * 8U));
legacy_bytes[8] = 1;
legacy_bytes[9] = legacy_bytes[10] = legacy_bytes[11] = 0;
legacy_bytes[12] = 1;
legacy_bytes[13] = legacy_bytes[14] = legacy_bytes[15] = 0;
refresh_checksum(legacy_bytes);
const auto legacy = CellularLives::restore(legacy_bytes, current->world(), current->region(),
current->frame(), current->tick());
CHECK(legacy && (*legacy)->format_version() == cellular_lives_legacy_format &&
(*legacy)->rules_version() == 1 && (*legacy)->snapshot() == legacy_bytes &&
(*legacy)->lives().size() == 1);
const auto legacy_life_id = (*legacy)->lives()[0].identity.life;
const std::array legacy_idle{CellularLifeIntent{legacy_life_id, {}}};
CHECK((*legacy)->advance_tick(legacy_idle) &&
(*legacy)->format_version() == cellular_lives_legacy_format &&
(*legacy)->rules_version() == 1 && (*legacy)->tick() == 2);
const auto before = (*legacy)->snapshot();
const auto biological_state = (*legacy)->lives()[0];
const auto migrated = (*legacy)->migrate_to_v2();
CHECK(migrated && (*migrated)->format_version() == cellular_lives_format &&
(*migrated)->rules_version() == cellular_lives_rules &&
(*migrated)->tick() == (*legacy)->tick() &&
(*migrated)->current_total() == (*legacy)->current_total() &&
(*migrated)->lives().size() == 1 &&
(*migrated)->lives()[0].account == biological_state.account &&
(*migrated)->lives()[0].identity == biological_state.identity &&
(*migrated)->lives()[0].source == biological_state.source &&
(*migrated)->lives()[0].growth == biological_state.growth &&
(*migrated)->lives()[0].position == biological_state.position &&
(*migrated)->lives()[0].body == biological_state.body &&
(*migrated)->lives()[0].reserve == biological_state.reserve &&
(*migrated)->lives()[0].mutation == CellularMutationProgress{} &&
(*legacy)->snapshot() == before && (*migrated)->snapshot() != before);
const auto restored =
CellularLives::restore((*migrated)->snapshot(), current->world(), current->region(),
current->frame(), (*migrated)->tick());
CHECK(restored && (*restored)->snapshot() == (*migrated)->snapshot());
const auto migrated_life_id = (*migrated)->lives()[0].identity.life;
const std::array migrated_idle{CellularLifeIntent{migrated_life_id, {}}};
CHECK((*migrated)->advance_tick(migrated_idle) &&
(*migrated)->format_version() == cellular_lives_format &&
(*migrated)->rules_version() == cellular_lives_rules && (*migrated)->tick() == 3);
const auto v2_before = (*migrated)->snapshot();
const auto revision_profile = (*migrated)->migrate_to_v3();
CHECK(revision_profile &&
(*revision_profile)->format_version() == cellular_lives_revision_format &&
(*revision_profile)->rules_version() == cellular_lives_rules &&
(*revision_profile)->tick() == (*migrated)->tick() &&
(*revision_profile)->current_total() == (*migrated)->current_total() &&
std::ranges::equal((*revision_profile)->lives(), (*migrated)->lives()) &&
(*revision_profile)->archive().format_version() ==
evo::biology::lineage_archive_revision_format &&
(*revision_profile)->archive().revisions().empty() &&
(*migrated)->snapshot() == v2_before);
const auto v3_bytes = (*revision_profile)->snapshot();
const auto v3_restored =
CellularLives::restore(v3_bytes, 91, 1, 1, (*revision_profile)->tick());
CHECK(v3_restored && (*v3_restored)->snapshot() == v3_bytes &&
(*v3_restored)->format_version() == cellular_lives_revision_format);
}
void retained_feeding_earns_a_persistent_mutation_offer() {
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 3;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
Inventory patch_stock{{1'000'000'000'000ULL},
{{{1'000'000'000'000ULL},
{1'000'000'000'000ULL},
{1'000'000'000'000ULL},
{1'000'000'000'000ULL}}}};
auto habitat = evo::biology::CellularHabitat::create(
{93, 1, 1, 1'000, 1'000, {{{0, 0}, 29, patch_stock}}});
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 1, 293'150});
CHECK(created && (*created)->lives().size() == 1 &&
(*created)->lives()[0].mutation.fed_energy_credit_pj == 0);
auto& owner = **created;
const auto life_id = owner.lives()[0].identity.life;
CHECK(owner.mutation_offer(life_id) && !*owner.mutation_offer(life_id));
const auto founder = owner.archive().find(owner.lives()[0].identity.genome);
CHECK(founder);
const auto founder_budget = evo::biology::metabolic_budget(
*founder, owner.lives()[0].growth, {owner.ambient_temperature_millikelvin(), {}});
CHECK(founder_budget &&
founder_budget->maintenance.value <=
std::numeric_limits<std::uint64_t>::max() / cellular_mutation_surplus_seconds);
const auto threshold = founder_budget->maintenance.value * cellular_mutation_surplus_seconds;
std::uint64_t total_acquired{};
bool offered = false;
for (std::size_t step = 0; step < 10'000 && !offered; ++step) {
const std::array intent{CellularLifeIntent{life_id, {{0, 0}, {{0, 0}}}}};
const auto advanced = owner.advance_tick(intent);
CHECK(advanced && advanced->lives.size() == 1 && advanced->lives[0].candidate.intake);
const auto intake = advanced->lives[0].candidate.intake.value_or(
evo::biology::CellularPatchUptakeProposal{});
total_acquired += intake.transfer.acquired.energy.value;
const auto offer = owner.mutation_offer(life_id);
CHECK(offer);
offered = offer->has_value();
}
CHECK(offered);
const auto earned = owner.mutation_offer(life_id);
const auto earned_data = earned.value_or(std::nullopt).value_or(evo::biology::MutationOffer{});
CHECK(earned && earned_data.candidates.size() <= cellular_mutation_candidate_count &&
!earned_data.candidates.empty() && owner.lives()[0].mutation.event_index == 1 &&
owner.lives()[0].mutation.offer_tick == owner.tick() &&
total_acquired == threshold + owner.lives()[0].mutation.fed_energy_credit_pj);
const auto saved = owner.snapshot();
const auto recovered = CellularLives::restore(saved, 93, 1, 1, owner.tick());
CHECK(recovered && (*recovered)->snapshot() == saved);
auto changed_seed = saved;
constexpr std::size_t v2_header_and_single_site = 220;
constexpr std::size_t v1_life_bytes = 168;
constexpr std::size_t mutation_seed_offset = 40;
changed_seed[v2_header_and_single_site + v1_life_bytes + mutation_seed_offset] ^= 1U;
refresh_checksum(changed_seed);
const auto noncanonical = CellularLives::restore(changed_seed, 93, 1, 1, owner.tick());
CHECK(!noncanonical && noncanonical.error() == CellularLivesError::noncanonical);
const auto replayed_offer = (*recovered)->mutation_offer(life_id);
CHECK(replayed_offer && replayed_offer == earned);
const std::array idle{CellularLifeIntent{life_id, {}}};
CHECK(owner.advance_tick(idle));
const auto after_tick = owner.mutation_offer(life_id);
CHECK(after_tick && after_tick == earned);
auto revision_owner = owner.migrate_to_v3();
CHECK(revision_owner && (*revision_owner)->format_version() == cellular_lives_revision_format);
const auto current_offer = (*revision_owner)->mutation_offer(life_id);
const auto current_offer_data =
current_offer.value_or(std::nullopt).value_or(evo::biology::MutationOffer{});
CHECK(current_offer && !current_offer_data.candidates.empty());
const CellularMutationSelection selection{life_id,
(*revision_owner)->lives()[0].mutation.event_index,
(*revision_owner)->lives()[0].mutation.offer_tick,
999, current_offer_data.candidates[0].operator_id};
CellularBatch mutation_batch;
mutation_batch.header = {(*revision_owner)->world(),
(*revision_owner)->region(),
(*revision_owner)->frame(),
{},
{},
(*revision_owner)->tick(),
(*revision_owner)->tick() + 1};
mutation_batch.header.predecessor.fill(0x31);
mutation_batch.header.predecessor_digest.fill(0x41);
CellularTickIntents mutation_tick;
mutation_tick.lives.push_back({life_id, {}});
mutation_tick.mutations.push_back(selection);
mutation_batch.ticks.push_back(mutation_tick);
const auto mutation_bytes = encode_cellular_batch(mutation_batch);
CHECK(mutation_bytes);
const auto decoded_mutation = decode_cellular_batch(*mutation_bytes);
CHECK(decoded_mutation && *decoded_mutation == mutation_batch);
const std::array mutation_actions{CellularMutationActionRecord{
(*revision_owner)->lives()[0].account,
44,
mutation_batch.header.end_tick,
{life_id, selection.event_index, selection.offer_tick, selection.operator_id}}};
const auto action_block = encode_cellular_mutation_action_block(
mutation_actions, mutation_batch.header.begin_tick, mutation_batch.header.end_tick);
CHECK(action_block);
const auto decoded_action_block = decode_cellular_mutation_action_block(
*action_block, mutation_batch.header.begin_tick, mutation_batch.header.end_tick);
CHECK(decoded_action_block &&
*decoded_action_block ==
std::vector<CellularMutationActionRecord>{mutation_actions.front()} &&
match_cellular_mutation_actions_to_trace(**revision_owner, *decoded_mutation,
*decoded_action_block));
const auto replayed_mutation = replay_cellular_batch(**revision_owner, *decoded_mutation);
CHECK(replayed_mutation && (*replayed_mutation)->tick() == mutation_batch.header.end_tick);
const std::array idle_next{CellularLifeIntent{life_id, {}}};
const std::array selections{selection};
const auto direct_mutation =
(*revision_owner)->advance_tick_with_mutations(idle_next, selections);
CHECK(direct_mutation && direct_mutation->mutations.size() == 1 &&
(*replayed_mutation)->snapshot() == (*revision_owner)->snapshot() &&
(*revision_owner)->current_total() == (*revision_owner)->opening_total());
if (direct_mutation->mutations[0].result == CellularMutationResult::applied) {
CHECK(direct_mutation->mutations[0].successor_id == selection.successor_id &&
(*revision_owner)->lives()[0].identity.genome == selection.successor_id &&
(*revision_owner)
->archive()
.current_genome((*revision_owner)->lives()[0].identity.organism) ==
selection.successor_id &&
(*revision_owner)->archive().revisions().size() == 1 &&
!(*revision_owner)->lives()[0].mutation.offer);
} else if (direct_mutation->mutations[0].result ==
CellularMutationResult::insufficient_funding) {
CHECK(direct_mutation->mutations[0].result ==
CellularMutationResult::insufficient_funding &&
(*revision_owner)->lives()[0].identity.genome ==
(*revision_owner)
->archive()
.organism((*revision_owner)->lives()[0].identity.organism)
->genome &&
(*revision_owner)->archive().revisions().empty() &&
(*revision_owner)->lives()[0].mutation.offer.has_value());
} else {
CHECK(direct_mutation->mutations[0].result == CellularMutationResult::life_died &&
(*revision_owner)->lives().empty() && (*revision_owner)->corpses().size() == 1 &&
(*revision_owner)->archive().revisions().empty());
}
}
void owner_advances_and_closes_death_atomically() {
auto primitive = PrimitiveLives::create({90, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 1;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
request.account.back() = 2;
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
evo::biology::CellularHabitatConfig habitat_config{
90, 1, 7, 3'000, 2'000, {{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
auto habitat = evo::biology::CellularHabitat::create(std::move(habitat_config));
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150});
CHECK(created);
auto& owner = **created;
CHECK(owner.world() == 90 && owner.region() == 1 && owner.frame() == 7);
CHECK(owner.lives().size() == 2 && owner.tick() == 1);
CHECK(owner.current_total() == owner.opening_total());
const std::array invalid{CellularLifeIntent{1, {}}, CellularLifeIntent{1, {}}};
const auto refused = owner.advance_tick(invalid);
CHECK(!refused && owner.tick() == 1 && owner.lives().size() == 2);
const auto first_life_id = owner.lives()[0].identity.life;
const auto second_life_id = owner.lives()[1].identity.life;
const auto visible_patches = owner.perceive(first_life_id);
CHECK(visible_patches && visible_patches->size() == 1 &&
visible_patches->front().address == (evo::biology::CellularPatchAddress{0, 0}) &&
visible_patches->front().available == owner.habitat().patches()[0].stock);
CHECK(owner.perceive(0).error() == CellularLivesError::invalid_life);
const std::array invalid_motion{CellularLifeIntent{first_life_id, {}},
CellularLifeIntent{second_life_id, {{1'001, 0}, std::nullopt}}};
const auto partial = owner.advance_tick(invalid_motion);
CHECK(!partial && partial.error() == CellularLivesError::region_step && owner.tick() == 1 &&
owner.lives().size() == 2);
const std::array feed{CellularLifeIntent{first_life_id, {{0, 0}, {{0, 0}}}},
CellularLifeIntent{second_life_id, {{0, 0}, {{0, 0}}}}};
const auto fed = owner.advance_tick(feed);
CHECK(fed && owner.tick() == 2 && owner.lives().size() == 2);
CHECK(fed->lives.size() == 2 &&
fed->lives[0].candidate.intake_status == evo::biology::CellularIntakeStatus::acquired);
CHECK(owner.format_version() == cellular_lives_format &&
owner.lives()[0].mutation.fed_energy_credit_pj > 0 &&
owner.mutation_offer(first_life_id) && !*owner.mutation_offer(first_life_id));
CHECK(owner.last_tick_feedback().size() == 2 &&
owner.last_tick_feedback()[0].tick == owner.tick() &&
owner.last_tick_feedback()[0].life_id == owner.lives()[0].identity.life &&
owner.last_tick_feedback()[0].reserve == fed->lives[0].candidate.reserve_after &&
owner.last_tick_feedback()[0].maintenance_cost ==
fed->lives[0].candidate.maintenance_cost &&
owner.last_tick_feedback()[0].movement ==
evo::biology::CellularMovementStatus::not_requested &&
owner.last_tick_feedback()[0].intake == evo::biology::CellularIntakeStatus::acquired);
CHECK(owner.habitat().patches()[0].stock == (Inventory{{0}, {}}));
CHECK(owner.current_total() == owner.opening_total());
const auto saved = owner.snapshot();
CHECK(saved.size() <= max_cellular_lives_bytes);
auto recovered = CellularLives::restore(saved, 90, 1, 7, owner.tick());
CHECK(recovered && (*recovered)->snapshot() == saved);
CHECK((*recovered)->last_tick_feedback().empty()); // Transient presentation is not restored.
CHECK(!CellularLives::restore(saved, 91, 1, 7, owner.tick()));
CHECK(!CellularLives::restore(saved, 90, 1, 7, owner.tick() + 1));
auto damaged = saved;
damaged[100] ^= 1;
const auto damaged_result = CellularLives::restore(damaged, 90, 1, 7, owner.tick());
CHECK(!damaged_result && damaged_result.error() == CellularLivesError::checksum);
auto unsupported = saved;
unsupported[8] = static_cast<std::uint8_t>(cellular_lives_format + 1);
refresh_checksum(unsupported);
const auto unsupported_result = CellularLives::restore(unsupported, 90, 1, 7, owner.tick());
CHECK(!unsupported_result && unsupported_result.error() == CellularLivesError::version);
auto outside = saved;
std::fill(outside.begin() + 300, outside.begin() + 308, uint8_t{0xff});
refresh_checksum(outside);
CHECK(!CellularLives::restore(outside, 90, 1, 7, owner.tick()));
CellularBatch replay_batch;
replay_batch.header = {owner.world(), owner.region(), owner.frame(), {}, {},
owner.tick(), owner.tick() + 2};
replay_batch.header.predecessor.fill(0x31);
replay_batch.header.predecessor_digest.fill(0x41);
for (int i = 0; i < 2; ++i) {
CellularTickIntents tick;
for (const auto& life : owner.lives())
tick.lives.push_back({life.identity.life, {}});
replay_batch.ticks.push_back(std::move(tick));
}
const auto batch_bytes = encode_cellular_batch(replay_batch);
CHECK(batch_bytes && batch_bytes->size() <= max_cellular_batch_bytes);
const auto decoded_batch = decode_cellular_batch(*batch_bytes);
CHECK(decoded_batch && *decoded_batch == replay_batch);
CellularActionRecord action;
action.account = owner.lives()[0].account;
action.action_id = 17;
action.input[0] = static_cast<std::uint8_t>(owner.tick() + 1);
const std::array actions{action};
const auto action_bytes = encode_cellular_action_block(actions, owner.tick(), owner.tick() + 2);
CHECK(action_bytes && action_bytes->size() == cellular_action_record_bytes);
const auto decoded_actions =
decode_cellular_action_block(*action_bytes, owner.tick(), owner.tick() + 2);
CHECK(decoded_actions && *decoded_actions == std::vector<CellularActionRecord>{action});
CHECK(match_cellular_actions_to_trace(owner, *decoded_batch, *decoded_actions));
auto changed_action = action;
changed_action.input[8] = 1;
const std::array changed_actions{changed_action};
CHECK(match_cellular_actions_to_trace(owner, *decoded_batch, changed_actions).error() ==
CellularActionBlockError::mismatch);
const auto replayed_batch = replay_cellular_batch(owner, *decoded_batch);
CHECK(replayed_batch && (*replayed_batch)->tick() == owner.tick() + 2);
CHECK((*replayed_batch)->last_tick_feedback().size() == owner.lives().size() &&
(*replayed_batch)->last_tick_feedback()[0].tick == (*replayed_batch)->tick());
CHECK((*replayed_batch)->current_total() == owner.opening_total());
auto short_batch = *batch_bytes;
short_batch.pop_back();
CHECK(!decode_cellular_batch(short_batch));
auto noncanonical_batch = *batch_bytes;
noncanonical_batch[noncanonical_batch.size() - 1] = 1;
CHECK(!decode_cellular_batch(noncanonical_batch));
auto wrong_scope = replay_batch;
wrong_scope.header.region++;
CHECK(replay_cellular_batch(owner, wrong_scope).error() == CellularBatchError::scope);
std::size_t steps{};
while (!owner.lives().empty() && steps < 2'000) {
std::vector<CellularLifeIntent> idle;
idle.reserve(owner.lives().size());
for (const auto& life : owner.lives())
idle.push_back({life.identity.life, {}});
const auto advanced = owner.advance_tick(idle);
const auto replayed = (*recovered)->advance_tick(idle);
CHECK(advanced && replayed && *advanced == *replayed);
CHECK(owner.snapshot() == (*recovered)->snapshot());
CHECK(owner.current_total() == owner.opening_total());
++steps;
}
CHECK(owner.lives().empty() && owner.corpses().size() == 2 && steps < 2'000);
CHECK(owner.corpses()[0].organism == 101 && owner.corpses()[0].died_tick <= owner.tick());
CHECK(owner.corpses()[1].organism == 102 && owner.corpses()[1].died_tick <= owner.tick());
CHECK(owner.corpses()[0].life_id == 1 && owner.corpses()[0].source == 17 &&
owner.corpses()[0].growth == (evo::biology::GrowthState{1000, 0}) &&
owner.corpses()[0].extent_um == 20);
const auto lineage = owner.archive().organism(101);
CHECK(lineage && !lineage->alive && lineage->died.value == owner.corpses()[0].died_tick);
const auto second_lineage = owner.archive().organism(102);
CHECK(second_lineage && !second_lineage->alive &&
second_lineage->died.value == owner.corpses()[1].died_tick);
CHECK(owner.heat().energy.value != 0);
CHECK(owner.current_total() == owner.opening_total());
const auto terminal_snapshot = owner.snapshot();
auto terminal_recovery = CellularLives::restore(terminal_snapshot, 90, 1, 7, owner.tick());
CHECK(terminal_recovery && (*terminal_recovery)->snapshot() == terminal_snapshot);
CHECK((*terminal_recovery)->lives().empty() &&
std::ranges::equal((*terminal_recovery)->corpses(), owner.corpses()));
CHECK((*terminal_recovery)->heat() == owner.heat());
CHECK((*terminal_recovery)->archive().organism(101) == owner.archive().organism(101));
}
// ADR-0124 rules 3: engulf intents resolve, starvation leaves detritus, corpses keep a cause.
void rules_three_owner_resolves_engulf_and_detritus() {
auto primitive = PrimitiveLives::create({92, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 1;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
request.account.back() = 2;
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
evo::biology::CellularHabitatConfig habitat_config{
92, 1, 7, 3'000, 2'000, {{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
auto habitat = evo::biology::CellularHabitat::create(std::move(habitat_config));
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150},
CellularLivesProfile::engulf);
CHECK(created);
auto& owner = **created;
CHECK(owner.format_version() == cellular_lives_engulf_format &&
owner.rules_version() == cellular_lives_engulf_rules &&
owner.archive().format_version() == evo::biology::lineage_archive_revision_format);
// Equal founders touching at an edge: neither is 1.5x the other.
evo::biology::CellularStepIntent engulf{};
engulf.engulf = true;
const std::array hunt{CellularLifeIntent{1, engulf}, CellularLifeIntent{2, {}}};
const auto hunted = owner.advance_tick(hunt);
CHECK(hunted && owner.lives().size() == 2);
CHECK(owner.last_tick_feedback()[0].engulf ==
evo::biology::CellularEngulfStatus::no_eligible_prey &&
owner.last_tick_feedback()[1].engulf ==
evo::biology::CellularEngulfStatus::not_requested);
// An engulf intent with an intake target is refused as a whole tick.
auto both = engulf;
both.intake_target = evo::biology::CellularPatchAddress{0, 0};
const std::array conflicting{CellularLifeIntent{1, both}, CellularLifeIntent{2, {}}};
CHECK(!owner.advance_tick(conflicting) && owner.tick() == 2);
// Below rules 4 a bud intent is ignored: the tick advances and nothing buds.
evo::biology::CellularStepIntent bud{};
bud.bud = true;
CHECK(owner.advance_tick(std::array{CellularLifeIntent{1, bud}, CellularLifeIntent{2, {}}}));
CHECK(owner.lives().size() == 2 && !owner.last_tick_feedback()[0].bud &&
owner.current_total() == owner.opening_total());
const auto patch_before = owner.habitat().patches()[0].stock;
std::size_t steps{};
while (!owner.lives().empty() && steps < 2'000) {
std::vector<CellularLifeIntent> idle;
for (const auto& life : owner.lives())
idle.push_back({life.identity.life, {}});
const auto advanced = owner.advance_tick(idle);
if (!advanced)
std::fprintf(stderr, "rules 3 idle tick %zu refused: %d\n", steps,
static_cast<int>(advanced.error()));
CHECK(advanced);
CHECK(owner.current_total() == owner.opening_total());
++steps;
}
CHECK(owner.lives().empty() && owner.corpses().size() == 2);
for (const auto& corpse : owner.corpses())
CHECK(corpse.cause == evo::biology::CellularDeathCause::starved &&
corpse.predator_life == 0 && corpse.inventory == Inventory{});
// Both founders died inside the (0, 0) cell, so their whole inventories joined that patch.
CHECK(owner.habitat().patches().size() == 1);
CHECK(owner.habitat().patches()[0].stock.matter[0].value >
patch_before.matter[0].value + 2 * founder_price(1).matter[0].value / 2);
const auto saved = owner.snapshot();
auto recovered = CellularLives::restore(saved, 92, 1, 7, owner.tick());
CHECK(recovered && (*recovered)->snapshot() == saved &&
std::ranges::equal((*recovered)->corpses(), owner.corpses()));
// A corpse cause outside the closed set, or a predator on a starvation corpse, is refused.
const auto corpse_at = saved.size() - 8 - owner.habitat().snapshot().size() -
owner.archive().encode().size() - std::size_t{2} * 116;
auto bad_cause = saved;
bad_cause[corpse_at + 100] = 7;
refresh_checksum(bad_cause);
CHECK(CellularLives::restore(bad_cause, 92, 1, 7, owner.tick()).error() ==
CellularLivesError::noncanonical);
auto bad_predator = saved;
bad_predator[corpse_at + 108] = 1;
refresh_checksum(bad_predator);
CHECK(CellularLives::restore(bad_predator, 92, 1, 7, owner.tick()).error() ==
CellularLivesError::noncanonical);
}
// ADR-0125: a fed founder buds an unowned wildlife cell carrying its genome. The bud's
// identity is in the region namespace, funding is conserved, and restore is exact.
void rules_four_owner_buds_wildlife() {
auto primitive = PrimitiveLives::create({93, 1, 7, 17, founder_price(1), {{0, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 3;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
constexpr std::uint64_t rich = 10'000'000'000;
evo::biology::CellularHabitatConfig habitat_config{
93, 1, 7, 3'000, 2'000, {{{0, 0}, 29, {{rich}, {{{rich}, {rich}, {rich}, {rich}}}}}}};
auto habitat = evo::biology::CellularHabitat::create(std::move(habitat_config));
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150},
CellularLivesProfile::budding);
CHECK(created);
auto& owner = **created;
CHECK(owner.format_version() == cellular_lives_bud_format &&
owner.rules_version() == cellular_lives_bud_rules && owner.next_bud_sequence() == 1);
evo::biology::CellularStepIntent feed{};
feed.intake_target = evo::biology::CellularPatchAddress{0, 0};
evo::biology::CellularStepIntent bud{};
bud.bud = true;
// A bud is exclusive with feeding; below rules 4 it is ignored (the rules 3 test).
auto feeding_bud = feed;
feeding_bud.bud = true;
CHECK(owner.advance_tick(std::array{CellularLifeIntent{1, feeding_bud}}).error() ==
CellularLivesError::invalid_intents);
// Freezing is rules 5 (ADR-0128).
evo::biology::CellularStepIntent frozen{};
frozen.frozen = true;
CHECK(owner.advance_tick(std::array{CellularLifeIntent{1, frozen}}).error() ==
CellularLivesError::invalid_intents);
const auto parent_genome = owner.lives().front().identity.genome;
std::optional<CellularTickExecution> budded;
std::size_t refused{};
for (std::size_t round = 0; round < 400 && !budded; ++round) {
for (int tick = 0; tick < 19; ++tick)
CHECK(owner.advance_tick(std::array{CellularLifeIntent{1, feed}}));
const auto before = owner.lives().front().reserve;
auto attempt = owner.advance_tick_with_mutations(
std::array{CellularLifeIntent{1, bud}}, std::span<const CellularMutationSelection>{});
CHECK(attempt && attempt->buds.size() == 1 && attempt->buds.front().parent_life == 1);
CHECK(owner.current_total() == owner.opening_total());
if (attempt->buds.front().result == CellularBudResult::budded) {
budded = std::move(*attempt);
} else {
// A refusal spends nothing beyond the ordinary tick.
CHECK(attempt->buds.front().result == CellularBudResult::insufficient_funding);
CHECK(owner.lives().size() == 1 &&
owner.lives().front().reserve.matter == before.matter);
++refused;
}
}
CHECK(budded.has_value() && refused > 0);
const auto budding = budded.value_or(CellularTickExecution{});
CHECK(budding.buds.size() == 1);
const auto identity = cellular_bud_identity(1, 1);
CHECK(budding.buds.front().bud_life == identity && owner.next_bud_sequence() == 2);
CHECK(owner.lives().size() == 2);
const auto& parent = owner.lives()[0];
const auto& child = owner.lives()[1];
CHECK(parent.identity.life == 1 && child.identity.life == identity);
CHECK(child.account == LifeAccount{} && child.parent_life == 1 &&
child.identity.genome == parent_genome && child.identity.organism == identity &&
child.identity.born.value == owner.tick() &&
child.mutation == CellularMutationProgress{});
CHECK(child.growth.realized_per_thousand < 1000 && child.reserve.energy.value > 0);
CHECK(owner.archive().living_carriers(parent_genome).value_or(0) == 2);
CHECK(owner.last_tick_feedback().front().bud == CellularBudResult::budded &&
owner.last_tick_feedback().front().bud_life == identity);
CHECK(owner.current_total() == owner.opening_total());
// The wildlife controller drives only the unowned bud: deterministically, and here by
// feeding from the stocked patch it already touches (no movement needed).
const auto controlled = wildlife_intents(owner, owner.tick() + 1);
CHECK(controlled && controlled->size() == 1 && controlled->front().life_id == identity);
CHECK(wildlife_intents(owner, owner.tick() + 1) == controlled);
const auto& wild = controlled->front().intent;
CHECK(!wild.engulf &&
(wild.bud || (wild.intake_target == evo::biology::CellularPatchAddress{0, 0} &&
wild.movement == evo::biology::CellularIntent{})));
CHECK(owner.advance_tick(std::array{CellularLifeIntent{1, feed}, controlled->front()}));
// Wildlife feeds like any cell but never earns a mutation offer.
// Read the bud from the current state: the tick above replaced the one `child` named.
const auto& wildlife = owner.lives()[1];
const auto child_x = wildlife.position.x_um / 1000 * 1000;
const auto child_y = wildlife.position.y_um / 1000 * 1000;
evo::biology::CellularStepIntent child_feed{};
child_feed.intake_target = evo::biology::CellularPatchAddress{
static_cast<std::uint32_t>(child_x), static_cast<std::uint32_t>(child_y)};
for (int tick = 0; tick < 40; ++tick)
CHECK(owner.advance_tick(
std::array{CellularLifeIntent{1, feed}, CellularLifeIntent{identity, child_feed}}));
CHECK(owner.lives().size() == 2 && owner.lives()[1].mutation == CellularMutationProgress{});
const auto saved = owner.snapshot();
auto recovered = CellularLives::restore(saved, 93, 1, 7, owner.tick());
CHECK(recovered && (*recovered)->snapshot() == saved &&
(*recovered)->next_bud_sequence() == 2 &&
std::ranges::equal((*recovered)->lives(), owner.lives()));
// A bud identity at or beyond the recorded sequence is refused on restore.
auto rewound = saved;
const auto sequence_at = std::size_t{212};
rewound[sequence_at] = 1;
refresh_checksum(rewound);
CHECK(!CellularLives::restore(rewound, 93, 1, 7, owner.tick()));
}
// ADR-0128: an offline owned life freezes, lingers 200 ticks, is suspended without aging,
// survives restore, and resumes; a newborn on its spot makes it resume nearby.
void rules_five_owner_freezes_lingers_suspends_and_resumes() {
auto primitive = PrimitiveLives::create({94, 1, 7, 17, founder_price(3), {{0, 0}, {1'500, 0}}});
CHECK(primitive);
LifeRequest request{};
request.account.back() = 1;
request.action = 1;
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
request.account.back() = 2;
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
auto habitat = evo::biology::CellularHabitat::create({94, 1, 7, 3'000, 2'000, {}});
CHECK(habitat);
auto created =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150},
CellularLivesProfile::presence);
CHECK(created);
auto owner = std::move(*created);
CHECK(owner->format_version() == cellular_lives_presence_format &&
owner->rules_version() == cellular_lives_presence_rules);
evo::biology::CellularStepIntent frozen{};
frozen.frozen = true;
// The trace keeps the flag (intent byte 13) and refuses it with anything else.
CellularBatch frozen_batch;
frozen_batch.header = {94, 1, 7, {}, {}, owner->tick(), owner->tick() + 1};
frozen_batch.header.predecessor.fill(1);
frozen_batch.header.predecessor_digest.fill(2);
frozen_batch.ticks.push_back({{{1, frozen}, {2, {}}}, {}, {}});
const auto frozen_bytes = encode_cellular_batch(frozen_batch);
CHECK(frozen_bytes);
CHECK(decode_cellular_batch(*frozen_bytes) == frozen_batch);
auto flag_two = *frozen_bytes;
flag_two[cellular_batch_header_bytes + cellular_batch_tick_header_bytes + 13] = 2;
CHECK(!decode_cellular_batch(flag_two));
// A frozen intent carries nothing else.
auto moving = frozen;
moving.movement = {100, 0};
CHECK(owner->advance_tick(std::array{CellularLifeIntent{1, moving}, CellularLifeIntent{2, {}}})
.error() == CellularLivesError::invalid_intents);
const auto before = owner->lives()[0];
CHECK(
owner->advance_tick(std::array{CellularLifeIntent{1, frozen}, CellularLifeIntent{2, {}}}));
const auto first_frozen = owner->tick();
CHECK(owner->lives()[0].presence == CellularPresence::lingering &&
owner->lives()[0].frozen_since == first_frozen &&
owner->lives()[0].reserve == before.reserve &&
owner->lives()[0].position == before.position &&
owner->lives()[1].reserve.energy.value < before.reserve.energy.value);
// Back within the linger: active again in place.
CHECK(owner->advance_tick(std::array{CellularLifeIntent{1, {}}, CellularLifeIntent{2, {}}}));
CHECK(owner->lives()[0].presence == CellularPresence::active &&
owner->lives()[0].frozen_since == 0);
// Frozen through the whole linger: suspended after 200 ticks, without aging.
CHECK(
owner->advance_tick(std::array{CellularLifeIntent{1, frozen}, CellularLifeIntent{2, {}}}));
const auto parked = owner->lives()[0];
for (std::uint64_t tick = 1; tick <= cellular_linger_ticks; ++tick) {
CHECK(owner->lives()[0].presence == CellularPresence::lingering);
CHECK(owner->advance_tick(
std::array{CellularLifeIntent{1, frozen}, CellularLifeIntent{2, {}}}));
CHECK(owner->current_total() == owner->opening_total());
}
CHECK(owner->lives()[0].presence == CellularPresence::suspended &&
owner->lives()[0].reserve == parked.reserve &&
owner->lives()[0].position == parked.position &&
owner->last_tick_feedback()[0].presence == CellularPresence::suspended);
// Suspended lives stay out of the step while frozen.
for (int tick = 0; tick < 5; ++tick)
CHECK(owner->advance_tick(
std::array{CellularLifeIntent{1, frozen}, CellularLifeIntent{2, {}}}));
CHECK(owner->lives()[0].reserve == parked.reserve);
const auto saved = owner->snapshot();
auto recovered = CellularLives::restore(saved, 94, 1, 7, owner->tick());
CHECK(recovered && (*recovered)->snapshot() == saved &&
std::ranges::equal((*recovered)->lives(), owner->lives()));
// A lingering presence older than the linger is refused on restore.
auto stale = saved;
const auto presence_at = std::size_t{220} + std::size_t{2} * 8 + 480 + 8;
stale[presence_at] = static_cast<std::uint8_t>(CellularPresence::lingering);
refresh_checksum(stale);
CHECK(!CellularLives::restore(stale, 94, 1, 7, owner->tick()));
// A newborn takes the suspended cell's spot (placement ignores suspended cells)...
LifeRequest third{};
third.account.back() = 3;
third.action = 1;
auto born = owner->birth_candidate(third, {50, 50, 50, 50, {owner->tick()}});
CHECK(born);
owner = std::move(*born);
CHECK(owner->lives().size() == 3 && owner->lives()[2].position == parked.position);
// ...so the resume relocates within three extents, clear of everyone.
CHECK(owner->advance_tick(std::array{CellularLifeIntent{1, {}}, CellularLifeIntent{2, {}},
CellularLifeIntent{50, {}}}));
const auto& resumed = owner->lives()[0];
CHECK(resumed.presence == CellularPresence::active && resumed.frozen_since == 0 &&
resumed.position != parked.position && !owner->last_tick_feedback()[0].resume_blocked);
CHECK(owner->current_total() == owner->opening_total());
}
} // namespace
int main() {
try {
reserved_birth_is_funded_and_detached();
cellular_profile_migration_is_explicit_and_no_tick();
retained_feeding_earns_a_persistent_mutation_offer();
owner_advances_and_closes_death_atomically();
rules_three_owner_resolves_engulf_and_detritus();
rules_four_owner_buds_wildlife();
rules_five_owner_freezes_lingers_suspends_and_resumes();
std::puts(
"PASS cellular lives: feeding, tick ownership, terminal closure, rules 3, budding");
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
}