#include "evo/server/lifecycle/cellular_lives.hpp" #include "evo/server/lifecycle/cellular_batch.hpp" #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)); } 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 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.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(!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)->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 { 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; } }