#include "evo/server/lifecycle/cellular_batch.hpp" #include "evo/server/lifecycle/cellular_lives.hpp" #include #include #include #include #include #include #include #include #include #include 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(__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 bytes) { std::uint64_t value = 14695981039346656037ULL; for (const auto byte : bytes) value = (value ^ byte) * 1099511628211ULL; return value; } void refresh_checksum(std::vector& 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(value >> (i * 8U)); } std::unique_ptr empty_cellular_owner(Inventory funding, std::vector 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 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.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(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->ticks[0].births.empty()); 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(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); } 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::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(); 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); CHECK(earned && *earned && (*earned)->candidates.size() <= cellular_mutation_candidate_count && !(*earned)->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); 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); } 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(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(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{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 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)); } } // 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(); std::puts("PASS cellular lives: feeding, tick ownership and terminal closure"); } catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1; } }