From 02adc35fa26ecf07026c38d4eb14e17cdb593022 Mon Sep 17 00:00:00 2001 From: dingo Date: Tue, 13 Oct 2026 18:54:03 -0400 Subject: [PATCH] Run the cellular owner on rules 3 with corpse causes ADR-0124's engulf profile starts a region on owner format 4 and rules 3, with the revision-format archive. Ticks pass genome membrane thickness and source to the region step, record each corpse's cause and predator, insert detritus patches and validate rules-3 corpses as empty. Format-4 snapshots carry the cause and predator and refuse an unknown cause, a predator on a starvation corpse or a non-empty corpse. Mutation selection accepts both genome-revision formats (3 and 4). Persistence (version bundle, schema 34), protocol v11 and provisioning follow. Co-Authored-By: Claude Opus 5.5 --- .../region/dev-session-route/listener.yaml | 2 +- docs/engineering/M11_3_DELIVERY_PLAN.md | 8 ++ docs/engineering/VALIDATION.md | 19 ++- include/evo/biology/cellular_region_step.hpp | 3 +- .../evo/server/lifecycle/cellular_lives.hpp | 15 ++- src/server/lifecycle/cellular_batch.cpp | 2 +- src/server/lifecycle/cellular_lives.cpp | 119 +++++++++++++----- src/server/session/cellular_session_batch.cpp | 2 +- tests/cellular_lives_tests.cpp | 84 ++++++++++++- 9 files changed, 217 insertions(+), 37 deletions(-) diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index 9f04225..9f3f572 100644 --- a/deploy/kubernetes/region/dev-session-route/listener.yaml +++ b/deploy/kubernetes/region/dev-session-route/listener.yaml @@ -12,7 +12,7 @@ spec: env: - {name: REGION_SESSION, value: "dev"} - {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"} - - {name: REGION_SESSION_WINDOW, value: "dev-20261013T224748-73224:1791942468"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261013T225403-26545:1791942843"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/engineering/M11_3_DELIVERY_PLAN.md b/docs/engineering/M11_3_DELIVERY_PLAN.md index 267353b..1651684 100644 --- a/docs/engineering/M11_3_DELIVERY_PLAN.md +++ b/docs/engineering/M11_3_DELIVERY_PLAN.md @@ -420,6 +420,14 @@ scoped change before starting the next segment. is unchanged and ignores engulf. Owner, protocol, persistence and recovery wiring remain. +- 11.3f-2 (ADR-0124): `CellularLives` gains the engulf profile (owner format + 4, rules 3, revision archive). Ticks pass genome membrane thickness and source + to the resolver, record each corpse's cause and predator, insert new detritus + patches, and require empty rules-3 corpses. Format-4 snapshots carry the cause + and refuse an unknown cause, a predator on a starvation corpse or a corpse + inventory. Mutation selection accepts formats 3 and 4. Persistence, protocol + and provisioning remain. + ## Exit boundary 11.3 closes only when the documented segments have evidence and the player-facing diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 03fb3da..375fce1 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -7221,4 +7221,21 @@ Executed locally: MSVC Debug full build and `ctest -R cellular` (6/6, with five new region-step cases: capacity split and region-wide conservation, size, membrane and contact refusal, one prey per predator per tick, empty-cell detritus, rules-2 no-op and invalid rules-3 intents); g++-14 `-Werror`, -clang-tidy-19 and clang-format 19.1.5 on the changed files. \ No newline at end of file +clang-tidy-19 and clang-format 19.1.5 on the changed files. +## 2026-10-13 — M11.3f-2 rules-3 cellular owner (CI pending) + +`CellularLives::create(..., CellularLivesProfile::engulf)` starts a region on +owner format 4 / rules 3 with the revision-format archive. Rules-3 ticks feed +membrane thickness and source to the resolver, keep each corpse's cause and +predator, add detritus patches, and validate rules-3 corpses as empty (rules 2 +keeps the body-matter floor). Format 4 snapshots append a cause byte, seven zero +bytes and the predator id to each corpse record; restore refuses an unknown +cause, a predator on a starvation corpse or a non-empty corpse. Mutation +selection now accepts formats 3 and 4. + +Executed locally: MSVC Debug full build and `ctest` (68/68, including a new +owner case: engulf-profile genesis, equal-founder `no_eligible_prey`, refused +engulf-plus-intake tick, starvation detritus into the patch, per-tick +conservation, format-4 round trip and tampered corpse causes); g++-14 +`-Werror`, clang-tidy-19 (the one remaining `cellular_session_batch.cpp:110` +report predates this change) and clang-format 19.1.5. \ No newline at end of file diff --git a/include/evo/biology/cellular_region_step.hpp b/include/evo/biology/cellular_region_step.hpp index 749f63f..5c7fd9c 100644 --- a/include/evo/biology/cellular_region_step.hpp +++ b/include/evo/biology/cellular_region_step.hpp @@ -55,7 +55,8 @@ struct CellularPatchStockUpdate { accounting::Inventory stock; auto operator<=>(const CellularPatchStockUpdate&) const = default; }; -enum class CellularDeathCause : std::uint8_t { starved = 1, engulfed = 2 }; +// Unrecorded: a corpse from a checkpoint format that kept no cause (before format 4). +enum class CellularDeathCause : std::uint8_t { unrecorded = 0, starved = 1, engulfed = 2 }; struct CellularCorpseCandidate { std::uint64_t life_id{}; CellularPosition position; diff --git a/include/evo/server/lifecycle/cellular_lives.hpp b/include/evo/server/lifecycle/cellular_lives.hpp index ade98a7..e1b0eab 100644 --- a/include/evo/server/lifecycle/cellular_lives.hpp +++ b/include/evo/server/lifecycle/cellular_lives.hpp @@ -18,6 +18,10 @@ inline constexpr std::uint32_t cellular_lives_legacy_format = 1; inline constexpr std::uint32_t cellular_lives_format = 2; inline constexpr std::uint32_t cellular_lives_revision_format = 3; inline constexpr std::uint32_t cellular_lives_rules = 2; +// ADR-0124: format 4 adds each corpse's cause and predator; rules 3 add engulfment and +// corpse detritus. They are used together, with the revision-format archive. +inline constexpr std::uint32_t cellular_lives_engulf_format = 4; +inline constexpr std::uint32_t cellular_lives_engulf_rules = 3; inline constexpr std::size_t max_cellular_lives_bytes = std::size_t{16} * 1024 * 1024; inline constexpr std::uint64_t cellular_mutation_surplus_seconds = 60; inline constexpr std::uint16_t cellular_mutation_candidate_count = 3; @@ -50,7 +54,9 @@ struct CellularOwnedCorpse { biology::CellularPosition position{}; biology::GrowthState growth{}; std::uint32_t extent_um{}; - accounting::Inventory inventory{}; + accounting::Inventory inventory{}; // Empty under rules 3: it became detritus. + biology::CellularDeathCause cause{biology::CellularDeathCause::unrecorded}; + std::uint64_t predator_life{}; // Engulfed only. auto operator<=>(const CellularOwnedCorpse&) const = default; }; struct CellularLifeIntent { @@ -79,8 +85,13 @@ struct CellularLifeTickFeedback { accounting::Picojoules maintenance_cost{}, movement_cost{}; biology::CellularMovementStatus movement{biology::CellularMovementStatus::not_requested}; biology::CellularIntakeStatus intake{biology::CellularIntakeStatus::not_requested}; + biology::CellularEngulfStatus engulf{biology::CellularEngulfStatus::not_requested}; + std::uint64_t prey_life{}; auto operator<=>(const CellularLifeTickFeedback&) const = default; }; +// Which owner version a new region starts on. Offers: format 2, rules 2 (the M11.3/11.4 +// trial, upgraded by the no-tick migrations). Engulf: format 4, rules 3 (ADR-0124). +enum class CellularLivesProfile : std::uint8_t { offers, engulf }; struct CellularLivesConfig { biology::CellularArea area{}; std::uint64_t tick{}; @@ -117,7 +128,7 @@ class CellularLives { public: [[nodiscard]] static std::expected, CellularLivesError> create(const PrimitiveLives& opening, std::unique_ptr habitat, - CellularLivesConfig config); + CellularLivesConfig config, CellularLivesProfile profile = CellularLivesProfile::offers); CellularLives(const CellularLives&) = delete; CellularLives& operator=(const CellularLives&) = delete; ~CellularLives(); diff --git a/src/server/lifecycle/cellular_batch.cpp b/src/server/lifecycle/cellular_batch.cpp index 7b59f48..0e4078a 100644 --- a/src/server/lifecycle/cellular_batch.cpp +++ b/src/server/lifecycle/cellular_batch.cpp @@ -543,7 +543,7 @@ match_cellular_mutation_actions_to_trace(const CellularLives& predecessor, const auto life = std::ranges::find(predecessor.lives(), action.account, &CellularOwnedLife::account); if (life == predecessor.lives().end() || - (predecessor.format_version() != cellular_lives_revision_format)) + (predecessor.format_version() < cellular_lives_revision_format)) return std::unexpected{CellularActionBlockError::mismatch}; const auto tick_index = static_cast(action.tick - batch.header.begin_tick - 1); const auto& mutations = batch.ticks[tick_index].mutations; diff --git a/src/server/lifecycle/cellular_lives.cpp b/src/server/lifecycle/cellular_lives.cpp index 81b4c22..df1474a 100644 --- a/src/server/lifecycle/cellular_lives.cpp +++ b/src/server/lifecycle/cellular_lives.cpp @@ -13,11 +13,14 @@ namespace { constexpr std::uint64_t cellular_lives_v1_magic = 0x3130564C43564541ULL; // AEVCLV01 constexpr std::uint64_t cellular_lives_v2_magic = 0x3230564C43564541ULL; // AEVCLV02 constexpr std::uint64_t cellular_lives_v3_magic = 0x3330564C43564541ULL; // AEVCLV03 +constexpr std::uint64_t cellular_lives_v4_magic = 0x3430564C43564541ULL; // AEVCLV04 constexpr std::size_t cellular_lives_header_bytes = 212; constexpr std::size_t cellular_site_bytes = 8; constexpr std::size_t cellular_life_v1_bytes = 168; constexpr std::size_t cellular_life_v2_bytes = 480; constexpr std::size_t cellular_corpse_bytes = 100; +// Format 4: cause (1), 7 zero bytes and the predator's life id (8). +constexpr std::size_t cellular_corpse_v4_bytes = cellular_corpse_bytes + 16; std::uint64_t checksum(std::span bytes) noexcept { std::uint64_t value = 14695981039346656037ULL; @@ -165,7 +168,7 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, const biology::CellularHabitat& habitat, std::span lives, std::span corpses, const biology::LineageArchive& archive, accounting::Inventory nursery, accounting::Inventory heat, - accounting::Inventory opening_total) { + accounting::Inventory opening_total, bool detritus_rules = false) { const auto& map = habitat.config(); if (world == 0 || region == 0 || frame == 0 || nursery_config.world != world || nursery_config.region != region || nursery_config.frame != frame || @@ -263,9 +266,15 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame, corpse.position.x_um > config.area.width_um - corpse.extent_um || corpse.position.y_um > config.area.height_um - corpse.extent_um) return std::unexpected{CellularLivesError::invalid_life}; - for (std::size_t channel = 0; channel < corpse.inventory.matter.size(); ++channel) - if (corpse.inventory.matter[channel].value < budget->body.matter[channel].value) + if (detritus_rules) { + // Rules 3 (ADR-0124): the inventory became detritus or the predator's. + if (corpse.inventory != accounting::Inventory{}) return std::unexpected{CellularLivesError::conservation}; + } else { + for (std::size_t channel = 0; channel < corpse.inventory.matter.size(); ++channel) + if (corpse.inventory.matter[channel].value < budget->body.matter[channel].value) + return std::unexpected{CellularLivesError::conservation}; + } life_ids.push_back(corpse.life_id); } std::ranges::sort(life_ids); @@ -314,8 +323,8 @@ CellularLives::~CellularLives() = default; std::expected, CellularLivesError> CellularLives::create(const PrimitiveLives& opening, - std::unique_ptr habitat, - CellularLivesConfig config) { + std::unique_ptr habitat, CellularLivesConfig config, + CellularLivesProfile profile) { if (!habitat) return std::unexpected{CellularLivesError::invalid_config}; auto nursery_config = opening.config(); @@ -382,10 +391,14 @@ CellularLives::create(const PrimitiveLives& opening, const auto world = nursery_config.world; const auto region = nursery_config.region; const auto frame = nursery_config.frame; - auto state = std::make_unique(world, region, frame, config, std::move(nursery_config), - std::move(habitat), std::move(lives), - std::vector{}, archive, nursery, heat, - opening_total, *current); + const bool engulf = profile == CellularLivesProfile::engulf; + if (engulf) + archive.upgrade_to_revision_format(); // Rules 3 regions carry genome revisions. + auto state = std::make_unique( + world, region, frame, config, std::move(nursery_config), std::move(habitat), + std::move(lives), std::vector{}, archive, nursery, heat, opening_total, + *current, engulf ? cellular_lives_engulf_format : cellular_lives_format, + engulf ? cellular_lives_engulf_rules : cellular_lives_rules); return std::unique_ptr{new CellularLives{std::move(state)}}; } @@ -450,8 +463,10 @@ std::vector CellularLives::snapshot() const { const auto life_bytes = state_->format_version == cellular_lives_legacy_format ? cellular_life_v1_bytes : cellular_life_v2_bytes; + const bool causes = state_->format_version == cellular_lives_engulf_format; + const auto corpse_bytes = causes ? cellular_corpse_v4_bytes : cellular_corpse_bytes; const auto total_bytes = cellular_lives_header_bytes + cellular_site_bytes * site_count + - life_bytes * life_count + cellular_corpse_bytes * corpse_count + + life_bytes * life_count + corpse_bytes * corpse_count + habitat.size() + archive.size() + 8; if (total_bytes > max_cellular_lives_bytes || habitat.size() > biology::max_cellular_habitat_bytes || @@ -466,6 +481,7 @@ std::vector CellularLives::snapshot() const { const auto magic = state_->format_version == cellular_lives_legacy_format ? cellular_lives_v1_magic : state_->format_version == cellular_lives_revision_format ? cellular_lives_v3_magic + : state_->format_version == cellular_lives_engulf_format ? cellular_lives_v4_magic : cellular_lives_v2_magic; out.put(magic); out.put(state_->format_version, 4); @@ -550,6 +566,11 @@ std::vector CellularLives::snapshot() const { out.put(corpse.growth.damage_per_thousand, 4); out.put(corpse.extent_um, 4); out.inventory(corpse.inventory); + if (causes) { + out.put(static_cast(corpse.cause), 1); + out.zeros(7); + out.put(corpse.predator_life); + } } out.raw(habitat); out.raw(archive); @@ -728,9 +749,10 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c state_->region, state_->frame); if (!habitat) return std::unexpected{CellularLivesError::habitat}; - const auto current = validate_state( - state_->world, state_->region, state_->frame, state_->config, nursery_config, **habitat, - lives, state_->corpses, archive, nursery, heat, state_->opening_total); + const auto current = + validate_state(state_->world, state_->region, state_->frame, state_->config, nursery_config, + **habitat, lives, state_->corpses, archive, nursery, heat, + state_->opening_total, state_->rules_version == cellular_lives_engulf_rules); if (!current) return std::unexpected{current.error()}; @@ -760,9 +782,13 @@ CellularLives::restore(std::span bytes, std::uint64_t world, const bool offer_version = magic == cellular_lives_v2_magic && format_version == cellular_lives_format && rules_version == cellular_lives_rules; - const bool revision_version = magic == cellular_lives_v3_magic && - format_version == cellular_lives_revision_format && - rules_version == cellular_lives_rules; + const bool engulf_version = magic == cellular_lives_v4_magic && + format_version == cellular_lives_engulf_format && + rules_version == cellular_lives_engulf_rules; + const bool revision_version = + engulf_version || + (magic == cellular_lives_v3_magic && format_version == cellular_lives_revision_format && + rules_version == cellular_lives_rules); const bool mutation_version = offer_version || revision_version; if (!legacy && !mutation_version) return std::unexpected{CellularLivesError::version}; @@ -796,8 +822,9 @@ CellularLives::restore(std::span bytes, std::uint64_t world, const auto nursery = in.inventory(); const auto heat = in.inventory(); const auto life_bytes = legacy ? cellular_life_v1_bytes : cellular_life_v2_bytes; + const auto corpse_bytes = engulf_version ? cellular_corpse_v4_bytes : cellular_corpse_bytes; const auto expected_size = cellular_lives_header_bytes + cellular_site_bytes * site_count + - life_bytes * life_count + cellular_corpse_bytes * corpse_count + + life_bytes * life_count + corpse_bytes * corpse_count + habitat_size + archive_size + 8; if (source == 0 || expected_size != bytes.size()) return std::unexpected{CellularLivesError::format}; @@ -887,6 +914,20 @@ CellularLives::restore(std::span bytes, std::uint64_t world, corpse.growth.damage_per_thousand = static_cast(in.get(4)); corpse.extent_um = static_cast(in.get(4)); corpse.inventory = in.inventory(); + if (engulf_version) { + // Rules 3: a known cause, a predator exactly when engulfed, and no inventory + // (it became detritus or the predator's). + const auto cause = in.get(1); + const auto padding = in.get(7); + corpse.predator_life = in.get(); + corpse.cause = static_cast(cause); + const bool engulfed = corpse.cause == biology::CellularDeathCause::engulfed; + if (padding != 0 || + (corpse.cause != biology::CellularDeathCause::starved && !engulfed) || + engulfed != (corpse.predator_life != 0) || corpse.predator_life == corpse.life_id || + corpse.inventory != accounting::Inventory{}) + return std::unexpected{CellularLivesError::noncanonical}; + } corpses.push_back(corpse); } const auto habitat_payload = in.raw(static_cast(habitat_size)); @@ -938,7 +979,7 @@ CellularLives::restore(std::span bytes, std::uint64_t world, } const auto current = validate_state(saved_world, saved_region, saved_frame, config, nursery_config, **habitat, - lives, corpses, *archive, nursery, heat, opening_total); + lives, corpses, *archive, nursery, heat, opening_total, engulf_version); if (!current) return std::unexpected{current.error()}; @@ -974,8 +1015,9 @@ CellularLives::advance_tick_with_mutations(std::span i ordered[i].life_id != state_->lives[i].identity.life) return std::unexpected{CellularLivesError::invalid_intents}; - if (!selections.empty() && state_->format_version != cellular_lives_revision_format) + if (!selections.empty() && state_->format_version < cellular_lives_revision_format) return std::unexpected{CellularLivesError::version}; + const bool engulf_rules = state_->rules_version == cellular_lives_engulf_rules; for (std::size_t i = 0; i < selections.size(); ++i) { const auto& selection = selections[i]; if (selection.life_id == 0 || selection.event_index == 0 || selection.offer_tick == 0 || @@ -1013,6 +1055,12 @@ CellularLives::advance_tick_with_mutations(std::span i budget_for(state_->archive, life, state_->config.ambient_temperature_millikelvin); if (!budget) return std::unexpected{budget.error()}; + const auto genome = state_->archive.find(life.identity.genome); + if (!genome) + return std::unexpected{CellularLivesError::archive}; + const auto membrane = genome->parameter(biology::Capability::membrane); + if (!membrane) + return std::unexpected{CellularLivesError::biology}; inputs.push_back({life.identity.life, life.position, budget->phenotype.extent, @@ -1020,10 +1068,12 @@ CellularLives::advance_tick_with_mutations(std::span i life.body, life.reserve, {}, - *budget}); + *budget, + *membrane, + life.source}); } auto proposal = biology::propose_cellular_region_step(state_->config.tick, state_->config.area, - inputs, *state_->habitat); + inputs, *state_->habitat, {engulf_rules}); if (!proposal) return std::unexpected{CellularLivesError::region_step}; @@ -1098,7 +1148,9 @@ CellularLives::advance_tick_with_mutations(std::span i return std::unexpected{corpse_budget.error()}; next_corpses.push_back({found->identity.life, found->identity.organism, found->source, proposal->end_tick, dead.position, found->growth, - corpse_budget->phenotype.extent, dead.inventory}); + corpse_budget->phenotype.extent, dead.inventory, + engulf_rules ? dead.cause : biology::CellularDeathCause::unrecorded, + engulf_rules ? dead.predator_id : 0}); next_lives.erase(found); } std::vector mutation_results; @@ -1155,15 +1207,23 @@ CellularLives::advance_tick_with_mutations(std::span i return std::unexpected{CellularLivesError::habitat}; found->stock = update.stock; } + // Rules 3 detritus at empty cells becomes new patches; create() revalidates the map. + for (const auto& made : proposal->new_patches) { + const auto at = std::ranges::lower_bound(habitat_config.patches, made.address, {}, + [](const auto& patch) { return patch.address; }); + if (at != habitat_config.patches.end() && at->address == made.address) + return std::unexpected{CellularLivesError::habitat}; + habitat_config.patches.insert(at, made); + } auto next_habitat = biology::CellularHabitat::create(std::move(habitat_config)); if (!next_habitat) return std::unexpected{CellularLivesError::habitat}; - const auto total = - validate_state(state_->world, state_->region, state_->frame, - CellularLivesConfig{state_->config.area, proposal->end_tick, - state_->config.ambient_temperature_millikelvin}, - state_->nursery_config, **next_habitat, next_lives, next_corpses, - next_archive, state_->nursery, next_heat, state_->opening_total); + const auto total = validate_state( + state_->world, state_->region, state_->frame, + CellularLivesConfig{state_->config.area, proposal->end_tick, + state_->config.ambient_temperature_millikelvin}, + state_->nursery_config, **next_habitat, next_lives, next_corpses, next_archive, + state_->nursery, next_heat, state_->opening_total, engulf_rules); if (!total) return std::unexpected{total.error()}; @@ -1182,7 +1242,8 @@ CellularLives::advance_tick_with_mutations(std::span i [](const CellularLifeIntent& value) { return value.life_id; }); feedback.push_back({result.life_id, proposal->end_tick, result.candidate.reserve_after, result.candidate.maintenance_cost, result.candidate.movement_cost, - result.candidate.movement_status, result.candidate.intake_status}); + result.candidate.movement_status, result.candidate.intake_status, + result.engulf, result.prey_id}); if (input == ordered.end() || input->life_id != result.life_id) return std::unexpected{CellularLivesError::invalid_intents}; } diff --git a/src/server/session/cellular_session_batch.cpp b/src/server/session/cellular_session_batch.cpp index 513da92..c3d0a24 100644 --- a/src/server/session/cellular_session_batch.cpp +++ b/src/server/session/cellular_session_batch.cpp @@ -85,7 +85,7 @@ prepare_cellular_session_tick(const CellularLives& state, std::uint64_t tick, return left.action_id < right.action_id; }); - if (!mutations.empty() && state.format_version() != cellular_lives_revision_format) + if (!mutations.empty() && state.format_version() < cellular_lives_revision_format) return std::unexpected{CellularSessionBatchError::mutation}; prepared.intents.mutations.reserve(mutations.size()); prepared.mutation_actions.reserve(mutations.size()); diff --git a/tests/cellular_lives_tests.cpp b/tests/cellular_lives_tests.cpp index f798615..1bcedb7 100644 --- a/tests/cellular_lives_tests.cpp +++ b/tests/cellular_lives_tests.cpp @@ -548,6 +548,87 @@ void owner_advances_and_closes_death_atomically() { 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); + + const auto patch_before = owner.habitat().patches()[0].stock; + std::size_t steps{}; + while (!owner.lives().empty() && steps < 2'000) { + std::vector 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(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); +} } // namespace int main() { @@ -556,7 +637,8 @@ int main() { 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"); + rules_three_owner_resolves_engulf_and_detritus(); + std::puts("PASS cellular lives: feeding, tick ownership, terminal closure, rules 3"); } catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1;