From 0fb67c32574a135d59b2ea3c172f64e1f95f5605 Mon Sep 17 00:00:00 2001 From: dingo Date: Tue, 13 Oct 2026 18:47:48 -0400 Subject: [PATCH] Resolve cellular engulfment and detritus in the region step ADR-0124 implements ADR-0098's predation and corpse rules for the cellular trial. Under rules 3 the pure region step adds an engulf phase after every life's step: in ascending life id, a predator takes the lowest-id contacted survivor whose total mass, times 1.5 per micrometre of its membrane, is at most the predator's. The prey's whole inventory moves once; the predator keeps what its remaining per-tick intake allows and the rest, like every starvation corpse, becomes detritus in the patch at the dead cell's 1 mm cell. Corpse candidates report their cause. Rules 2 is unchanged and ignores engulf intents. Owner, protocol v11, persistence and recovery wiring follow in the next 11.3f steps. Co-Authored-By: Claude Opus 5.5 --- .../region/dev-session-route/listener.yaml | 2 +- .../0124-cellular-engulfment-and-detritus.md | 104 ++++++++++ docs/adr/README.md | 1 + docs/engineering/M11_3_DELIVERY_PLAN.md | 12 ++ docs/engineering/VALIDATION.md | 17 +- include/evo/biology/cellular_region_step.hpp | 39 +++- include/evo/biology/cellular_step.hpp | 3 + src/biology/cellular_region_step.cpp | 193 +++++++++++++++++- tests/cellular_region_step_tests.cpp | 140 ++++++++++++- 9 files changed, 502 insertions(+), 9 deletions(-) create mode 100644 docs/adr/0124-cellular-engulfment-and-detritus.md diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index e1b4ce0..9f04225 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-20261013T224028-49591:1791942028"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261013T224748-73224:1791942468"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/adr/0124-cellular-engulfment-and-detritus.md b/docs/adr/0124-cellular-engulfment-and-detritus.md new file mode 100644 index 0000000..752733b --- /dev/null +++ b/docs/adr/0124-cellular-engulfment-and-detritus.md @@ -0,0 +1,104 @@ +# ADR-0124: Cellular engulfment and detritus + +## Status + +Accepted M11.3 engineering contract (2026-10-13), under the maintainer's standing +direction to proceed through M11 with recommendations. It implements the +predation and corpse rules already ratified in +[ADR-0098](0098-m11-first-cellular-loop-decisions.md) §6. Values marked +**tunable** are versioned trial inputs for the 11.9 playtests, not final rules. + +## Context + +The cellular trial resolves movement, maintenance, patch intake and starvation +(ADR-0101 to ADR-0107). ADR-0098 also requires engulfment of a sufficiently +smaller contacted cell, contested by the prey's membrane, with the prey's whole +inventory moving to the predator once and any excess left as detritus, and it +requires that a corpse can be absorbed by any cell. ADR-0107 kept starvation +corpses as inert records, and nothing can engulf yet. + +The 2026-10-13 probe showed that a player's only feedback is patch intake and +reserve, and that founders are identical in size. Engulfment therefore becomes +possible only once mutation or later growth changes relative size; until then it +must still be resolved correctly. + +## Decision + +### Intent + +- A cellular action names one target **kind**, replacing the intake flag in + byte 12 of the 24-byte canonical input: 0 none, 1 patch intake at the given + patch address, 2 engulf. An engulf intent carries zero coordinates; the server + chooses the prey. Clients still send only intentions. +- Kind 2 is accepted only on session protocol v11, which otherwise equals v10. + Earlier sessions keep refusing it, and their bytes are unchanged. + +### Tick order (rules 3) + +Each tick keeps the ADR-0104 single-life order and ADR-0106 patch arbitration, +then adds two phases, all in ascending stable life id: + +1. **Step:** movement, maintenance and patch intake exactly as under rules 2. + A life that cannot pay maintenance starves (ADR-0107). +2. **Engulf:** each life that survived step 1 and holds an engulf intent takes at + most one prey: the lowest-id surviving life in contact (ADR-0102 footprint + contact) for which + `predator_total_mass × 1000 ≥ required × prey_total_mass`, where + `required = 1500 × prey_membrane_um` (**tunable**; 1.5 for the 1 µm founder + membrane, per ADR-0098). Total mass is the phenotype's structural plus + membrane mass. A life engulfed earlier in the phase can neither act nor be + taken twice. A predator cannot engulf itself. +3. **Death and detritus:** every life that died this tick (starved or engulfed) + becomes a corpse record. Its accumulated heat goes to the world heat owner. + +### Transfer + +- The prey's body and reserve, every channel, move out exactly once. +- The predator's reserve receives at most its per-tick intake limit in each + channel (the same capacity that bounds absorption). The remainder is detritus. +- Detritus, and the whole inventory of a starved cell, is deposited into the + habitat at the 1 mm patch cell containing the corpse's position: + - If a patch exists there, the inventory is added to its stock. The patch keeps + its provenance; the corpse record and lineage archive keep the dead organism's. + - Otherwise a new patch is created there with the dead life's source as + provenance. + - If the habitat is at its 4,096-patch bound, the nearest existing patch + (lowest address on a tie) receives it. +- Corpse records keep identity, position, growth, extent, death tick and a new + **cause** (starved or engulfed). Their inventory is zero under rules 3. +- Any cell absorbs detritus with ordinary patch intake. Nothing decays or + replenishes; every channel is conserved region-wide. + +### Versions and persistence + +- Cellular rules 3 and owner envelope 4 (the corpse cause) form a new version + bundle `{rules 3, envelope 4, habitat 1, coordinate 1, genome 1, development 2, + founder 1, archive 2, mutation_state 1}`. +- New regions are provisioned on it. Existing v2 and v3 regions keep rules 2 and + replay byte-for-byte; no in-place migration is provided in this step. +- Schema migration 34 admits the new bundle and canonical input kind 2 with + zero coordinates. Batch traces record the kind with each intent. +- Client presentation of an engulf control and of corpse causes belongs to + 11.8 (maintainer-owned client UI). + +## Alternatives + +- **Explicit prey id in the action:** rejected for this step. It needs a new + message layout and lets a client name an unseen cell; contact already bounds + the choice, and the server picks deterministically. +- **Engulf without a capacity bound:** rejected. ADR-0098 bounds the transfer by + the predator's capacity, and per-tick intake is the only capacity cells have. +- **Keep corpses as separate food objects:** rejected for now. A second food + type needs its own perception, contact and client view; depositing into the + patch grid reuses all three. +- **Migrate existing regions in place:** deferred. Only DEV regions exist, and a + fresh region is cheaper to qualify than a no-tick rules migration. + +## Consequences + +- Biology gains a pure engulf/detritus resolution; the cellular owner, snapshot, + manifest bundle, SQL admission, protocol v11, batch trace and recovery change. +- Founders are equal in size, so live engulfment needs mutation (11.4) or + later growth before it is observable in play. +- Size may dominate predation (ADR-0098 risk); 11.9 watches for it, and the + required ratio stays tunable. diff --git a/docs/adr/README.md b/docs/adr/README.md index 4ec5eac..c9e07e3 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -24,6 +24,7 @@ - [ADR-0121: Durable cellular mutation selection](0121-durable-cellular-mutation-selection.md) - specifies a distinct reliable action, allocator identity, tick-bound replay and atomic publication for M11.4c. - [ADR-0122: Append-only cellular genome revisions](0122-append-only-cellular-genome-revisions.md) - preserves immutable birth-genome links while adding a versioned revision chain and no-tick cellular-v3 migration. - [ADR-0123: Dev cellular region and life-allocator provisioning](0123-dev-cellular-region-and-life-allocator-provisioning.md) - moves DEV to cellular region 100/2 at schema v33 and has the owner provisioner create a world's life allocator once at an audited start. +- [ADR-0124: Cellular engulfment and detritus](0124-cellular-engulfment-and-detritus.md) - resolves engulfment of a sufficiently smaller contacted cell and deposits every corpse's inventory into the patch grid as absorbable detritus, under cellular rules 3. - [ADR-0058: Region durability contract](0058-region-durability-contract.md) - accepted M7.1 full checkpoint batches and explicit state closure; storage implementation follows. diff --git a/docs/engineering/M11_3_DELIVERY_PLAN.md b/docs/engineering/M11_3_DELIVERY_PLAN.md index 23c155e..267353b 100644 --- a/docs/engineering/M11_3_DELIVERY_PLAN.md +++ b/docs/engineering/M11_3_DELIVERY_PLAN.md @@ -408,6 +408,18 @@ scoped change before starting the next segment. evidence is green for the pushed M11.3 implementation. Only the live human probe remains before 11.3 closes and 11.4 can begin. +- 11.3e probe (2026-10-13): the exploratory playtest ran in DEV region 100/3; + steering and feeding work end to end. Notes: + [probe notes](../playtests/M11_3_PROBE_NOTES_2026-10-13.md); session and + deployment fixes are recorded in ADR-0123. +- 11.3f-1 (ADR-0124): the pure region step gains rules 3. An engulf intent + takes the lowest-id contacted survivor at least 1.5x lighter per micrometre + of prey membrane; the prey's whole inventory moves once, bounded by the + predator's remaining per-tick intake, and the rest, like every starvation + corpse, is deposited as patch detritus (a new patch at an empty cell). Rules 2 + is unchanged and ignores engulf. Owner, protocol, persistence and recovery + wiring 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 bd3b3eb..03fb3da 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -7206,4 +7206,19 @@ an identity only with `born`. The session layer now clears identity and commit on every other result. `quic_sessions` adds an `existing_life` refusal that must arrive valid while the session stays established. Locally (MSVC, client preset) the case failed with the same 33-byte decode error before the fix and -passed after it. \ No newline at end of file +passed after it. +## 2026-10-13 — M11.3f-1 cellular engulfment and detritus resolver (CI pending) + +ADR-0124. `propose_cellular_region_step` takes `CellularRegionRules`; rules 3 +adds an engulf phase after every life's step (ascending life id, one prey per +predator, contact plus `predator_mass × 1000 ≥ 1500 × prey_membrane_um × +prey_mass`), bounds the predator's gain by its remaining per-tick intake, and +deposits detritus and starvation corpses into the patch at the dead cell's +1 mm cell (a new patch at an empty cell, the nearest patch when full). Corpse +candidates report a cause and predator. Rules 2 results are unchanged. + +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 diff --git a/include/evo/biology/cellular_region_step.hpp b/include/evo/biology/cellular_region_step.hpp index 79b1288..749f63f 100644 --- a/include/evo/biology/cellular_region_step.hpp +++ b/include/evo/biology/cellular_region_step.hpp @@ -12,6 +12,18 @@ namespace evo::biology { inline constexpr std::size_t max_cellular_tick_lives = 256; +// ADR-0124 (rules 3): a predator needs total mass >= ratio x prey total mass, with the +// ratio in thousandths per micrometre of prey membrane (tunable; 1.5 for 1 um). +inline constexpr std::uint64_t cellular_engulf_ratio_milli_per_membrane_um = 1'500; + +struct CellularRegionRules { + // Rules 3: engulfment, and every corpse's inventory deposited as patch detritus. + // Rules 2 (false) is the original trial: engulf intents are ignored and starvation + // corpses keep their inventory. + bool engulf_and_detritus{}; + auto operator<=>(const CellularRegionRules&) const = default; +}; + struct CellularLifeStepInput { std::uint64_t life_id{}; // Stable world identity; arbitrates same-tick patch contention. CellularPosition position; @@ -21,11 +33,21 @@ struct CellularLifeStepInput { accounting::Inventory reserve; accounting::Inventory heat; // Energy-only owner; matter channels must be zero. MetabolicBudget budget; + std::uint32_t membrane_um{}; // Genome membrane thickness; contests engulfment (rules 3). + std::uint64_t source{}; // Provenance for a detritus patch this life creates (rules 3). auto operator<=>(const CellularLifeStepInput&) const = default; }; +enum class CellularEngulfStatus : std::uint8_t { + not_requested, + engulfed, // Took the reported prey. + no_eligible_prey, // Nothing in contact was small enough. + unsupported // Rules 2 region: the intent had no effect. +}; struct CellularLifeStepResult { std::uint64_t life_id{}; CellularStepCandidate candidate; + CellularEngulfStatus engulf{CellularEngulfStatus::not_requested}; + std::uint64_t prey_id{}; auto operator<=>(const CellularLifeStepResult&) const = default; }; struct CellularPatchStockUpdate { @@ -33,10 +55,15 @@ struct CellularPatchStockUpdate { accounting::Inventory stock; auto operator<=>(const CellularPatchStockUpdate&) const = default; }; +enum class CellularDeathCause : std::uint8_t { starved = 1, engulfed = 2 }; struct CellularCorpseCandidate { std::uint64_t life_id{}; CellularPosition position; - accounting::Inventory inventory; // Body and reserve; accumulated heat is transferred out. + // Rules 2: body and reserve. Rules 3: empty, because the inventory moved to the + // predator and detritus. Accumulated heat is transferred out in both. + accounting::Inventory inventory; + CellularDeathCause cause{CellularDeathCause::starved}; + std::uint64_t predator_id{}; // Engulfed only. auto operator<=>(const CellularCorpseCandidate&) const = default; }; struct CellularRegionStepCandidate { @@ -44,7 +71,10 @@ struct CellularRegionStepCandidate { // Sorted by stable life_id, independent of connection or input order. std::vector lives; std::vector patches; + // Dead this tick (starved or engulfed), sorted by life_id. std::vector starved; + // Rules 3 detritus patches created at empty cells, sorted by address. + std::vector new_patches; accounting::Picojoules heat_released{}; auto operator<=>(const CellularRegionStepCandidate&) const = default; }; @@ -57,7 +87,8 @@ enum class CellularRegionStepError : std::uint8_t { invalid_heat, overflow, life_step, - habitat + habitat, + invalid_intent }; // Detached shared-habitat candidate. Same-tick claims resolve by ascending stable life id; @@ -65,8 +96,10 @@ enum class CellularRegionStepError : std::uint8_t { // life step rejects the complete candidate; the caller publishes nothing. If maintenance // cannot be paid, the life dies in this tick: body and reserve move to one corpse candidate, // and its accumulated heat is reported separately for transfer to the world heat owner. +// Under rules 3 (ADR-0124) an engulf phase follows, and every dead life's inventory is +// deposited into the patch at its cell (a new patch when the cell is empty). [[nodiscard]] std::expected propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, std::span lives, - const CellularHabitat& habitat); + const CellularHabitat& habitat, CellularRegionRules rules = {}); } // namespace evo::biology diff --git a/include/evo/biology/cellular_step.hpp b/include/evo/biology/cellular_step.hpp index 8c92c70..70e4b70 100644 --- a/include/evo/biology/cellular_step.hpp +++ b/include/evo/biology/cellular_step.hpp @@ -9,6 +9,9 @@ namespace evo::biology { struct CellularStepIntent { CellularIntent movement{}; std::optional intake_target; + // ADR-0124: take one smaller contacted cell after every life's step (rules 3 only). + // Exclusive with an intake target; the server chooses the prey. + bool engulf{}; auto operator<=>(const CellularStepIntent&) const = default; }; diff --git a/src/biology/cellular_region_step.cpp b/src/biology/cellular_region_step.cpp index 1dd7ea9..5f96b2b 100644 --- a/src/biology/cellular_region_step.cpp +++ b/src/biology/cellular_region_step.cpp @@ -1,14 +1,59 @@ #include "evo/biology/cellular_region_step.hpp" +#include "evo/accounting/rates.hpp" + #include #include #include namespace evo::biology { +namespace { +constexpr auto u64_max = std::numeric_limits::max(); + +bool add(std::uint64_t& to, std::uint64_t amount) noexcept { + if (amount > u64_max - to) + return false; + to += amount; + return true; +} +bool add(accounting::Inventory& to, const accounting::Inventory& from) noexcept { + if (!add(to.energy.value, from.energy.value)) + return false; + for (std::size_t channel = 0; channel < to.matter.size(); ++channel) + if (!add(to.matter[channel].value, from.matter[channel].value)) + return false; + return true; +} +// a * ka >= b * kb without overflow: compares the exact 128-bit products. +bool product_at_least(std::uint64_t a, std::uint64_t ka, std::uint64_t b, std::uint64_t kb) { + const auto wide = [](std::uint64_t x, std::uint64_t y) { + const std::uint64_t x0 = x & 0xFFFFFFFFU, x1 = x >> 32U; + const std::uint64_t y0 = y & 0xFFFFFFFFU, y1 = y >> 32U; + const std::uint64_t p00 = x0 * y0, p01 = x0 * y1, p10 = x1 * y0, p11 = x1 * y1; + const std::uint64_t middle = (p00 >> 32U) + (p01 & 0xFFFFFFFFU) + (p10 & 0xFFFFFFFFU); + const std::uint64_t high = p11 + (p01 >> 32U) + (p10 >> 32U) + (middle >> 32U); + const std::uint64_t low = (middle << 32U) | (p00 & 0xFFFFFFFFU); + return std::pair{high, low}; + }; + return wide(a, ka) >= wide(b, kb); +} +CellularPatchAddress cell_of(CellularPosition position) noexcept { + return {static_cast(position.x_um / cellular_patch_pitch_um * + cellular_patch_pitch_um), + static_cast(position.y_um / cellular_patch_pitch_um * + cellular_patch_pitch_um)}; +} +struct Deposit { + std::uint64_t life_id{}, source{}; + CellularPosition position; + accounting::Inventory inventory; +}; +} // namespace + std::expected propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, std::span lives, - const CellularHabitat& habitat) { + const CellularHabitat& habitat, CellularRegionRules rules) { if (begin_tick == std::numeric_limits::max()) return std::unexpected{CellularRegionStepError::invalid_tick}; if (lives.size() > max_cellular_tick_lives) @@ -19,6 +64,9 @@ propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, for (const auto& life : lives) { if (life.life_id == 0) return std::unexpected{CellularRegionStepError::invalid_life_id}; + if (rules.engulf_and_detritus && (life.membrane_um == 0 || life.source == 0 || + (life.intent.engulf && life.intent.intake_target))) + return std::unexpected{CellularRegionStepError::invalid_intent}; ordered.push_back(&life); } std::ranges::sort(ordered, {}, [](const auto* life) { return life->life_id; }); @@ -26,13 +74,17 @@ propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, if (ordered[i - 1]->life_id == ordered[i]->life_id) return std::unexpected{CellularRegionStepError::duplicate_life_id}; - CellularRegionStepCandidate candidate{begin_tick, begin_tick + 1, {}, {}, {}, {}}; + CellularRegionStepCandidate candidate{begin_tick, begin_tick + 1, {}, {}, {}, {}, {}}; candidate.lives.reserve(ordered.size()); candidate.starved.reserve(ordered.size()); std::vector patch_stock; patch_stock.reserve(habitat.patches().size()); for (const auto& patch : habitat.patches()) patch_stock.push_back(patch.stock); + // Inputs of the lives still in candidate.lives, in the same order. + std::vector survivors; + survivors.reserve(ordered.size()); + std::vector deposits; for (const auto* life : ordered) { if (life->body.energy.value != 0) @@ -43,6 +95,7 @@ propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, auto intent = life->intent; const auto target = intent.intake_target; intent.intake_target.reset(); + intent.engulf = false; const auto step = propose_cellular_step(begin_tick, area, life->position, life->extent_um, intent, life->reserve, life->heat, life->budget, habitat); @@ -59,6 +112,10 @@ propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, std::numeric_limits::max() - candidate.heat_released.value) return std::unexpected{CellularRegionStepError::overflow}; candidate.heat_released.value += life->heat.energy.value; + if (rules.engulf_and_detritus) { + deposits.push_back({life->life_id, life->source, life->position, corpse.inventory}); + corpse.inventory = {}; + } candidate.starved.push_back(corpse); continue; } @@ -87,7 +144,137 @@ propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area, } } } - candidate.lives.push_back({life->life_id, result}); + CellularLifeStepResult life_result{life->life_id, result}; + if (life->intent.engulf) + life_result.engulf = rules.engulf_and_detritus ? CellularEngulfStatus::no_eligible_prey + : CellularEngulfStatus::unsupported; + candidate.lives.push_back(life_result); + survivors.push_back(life); + } + + if (rules.engulf_and_detritus) { + // Engulf phase (ADR-0124): ascending predator id; each takes at most the lowest-id + // eligible survivor in contact. A taken life neither acts nor is taken again. + std::vector taken(candidate.lives.size(), false); + for (std::size_t p = 0; p < candidate.lives.size(); ++p) { + if (taken[p] || !survivors[p]->intent.engulf) + continue; + auto& predator = candidate.lives[p]; + const auto* hunter = survivors[p]; + for (std::size_t q = 0; q < candidate.lives.size(); ++q) { + if (q == p || taken[q]) + continue; + const auto* prey = survivors[q]; + const auto& prey_step = candidate.lives[q].candidate; + if (!cellular_footprints_contact(predator.candidate.position, hunter->extent_um, + prey_step.position, prey->extent_um) || + !product_at_least(hunter->budget.phenotype.total_mass, 1'000, + prey->budget.phenotype.total_mass, + cellular_engulf_ratio_milli_per_membrane_um * + prey->membrane_um)) + continue; + // The prey's whole inventory moves once: body matter and its post-step reserve. + accounting::Inventory whole = prey_step.reserve_after; + if (!add(whole, prey->body)) + return std::unexpected{CellularRegionStepError::overflow}; + if (!add(candidate.heat_released.value, prey_step.heat_after.energy.value)) + return std::unexpected{CellularRegionStepError::overflow}; + // Capacity: what is left of the predator's per-tick intake limit this tick. + const auto remaining = [&](std::uint64_t per_second, + std::uint64_t already) -> std::optional { + const auto limit = accounting::per_tick( + per_second, cellular_motion_tick_microseconds, accounting::Rounding::down); + if (!limit) + return std::nullopt; + return *limit > already ? *limit - already : 0; + }; + const auto acquired = predator.candidate.intake + ? predator.candidate.intake->transfer.acquired + : accounting::Inventory{}; + accounting::Inventory taken_in{}; + const auto energy_room = + remaining(hunter->budget.intake_limit.energy.value, acquired.energy.value); + if (!energy_room) + return std::unexpected{CellularRegionStepError::overflow}; + taken_in.energy.value = std::min(whole.energy.value, *energy_room); + for (std::size_t channel = 0; channel < whole.matter.size(); ++channel) { + const auto room = remaining(hunter->budget.intake_limit.matter[channel].value, + acquired.matter[channel].value); + if (!room) + return std::unexpected{CellularRegionStepError::overflow}; + taken_in.matter[channel].value = std::min(whole.matter[channel].value, *room); + } + if (!add(predator.candidate.reserve_after, taken_in)) + return std::unexpected{CellularRegionStepError::overflow}; + accounting::Inventory detritus = whole; + detritus.energy.value -= taken_in.energy.value; + for (std::size_t channel = 0; channel < detritus.matter.size(); ++channel) + detritus.matter[channel].value -= taken_in.matter[channel].value; + deposits.push_back({prey->life_id, prey->source, prey_step.position, detritus}); + CellularCorpseCandidate corpse{prey->life_id, prey_step.position, {}}; + corpse.cause = CellularDeathCause::engulfed; + corpse.predator_id = hunter->life_id; + candidate.starved.push_back(corpse); + predator.engulf = CellularEngulfStatus::engulfed; + predator.prey_id = prey->life_id; + taken[q] = true; + break; + } + } + std::vector remaining_lives; + remaining_lives.reserve(candidate.lives.size()); + for (std::size_t i = 0; i < candidate.lives.size(); ++i) + if (!taken[i]) + remaining_lives.push_back(candidate.lives[i]); + candidate.lives = std::move(remaining_lives); + std::ranges::sort(candidate.starved, {}, &CellularCorpseCandidate::life_id); + + // Detritus: each dead life's inventory goes to the patch at its cell, a new patch at + // an empty cell, or the nearest patch once the habitat is full. + std::ranges::sort(deposits, {}, &Deposit::life_id); + for (const auto& deposit : deposits) { + const auto address = cell_of(deposit.position); + if (const auto index = habitat.find(address)) { + if (!add(patch_stock[*index], deposit.inventory)) + return std::unexpected{CellularRegionStepError::overflow}; + continue; + } + const auto made = std::ranges::lower_bound(candidate.new_patches, address, {}, + &CellularPatch::address); + if (made != candidate.new_patches.end() && made->address == address) { + if (!add(made->stock, deposit.inventory)) + return std::unexpected{CellularRegionStepError::overflow}; + continue; + } + if (habitat.patches().size() + candidate.new_patches.size() < max_cellular_patches) { + candidate.new_patches.insert(made, {address, deposit.source, deposit.inventory}); + continue; + } + // Full habitat: nearest existing patch, lowest address on a tie. + const auto distance = [&](CellularPatchAddress other) { + const auto dx = static_cast(other.x_um) - address.x_um; + const auto dy = static_cast(other.y_um) - address.y_um; + return static_cast(dx * dx) + static_cast(dy * dy); + }; + std::optional> best; + for (const auto& patch : habitat.patches()) + if (!best || std::pair{distance(patch.address), patch.address} < *best) + best = std::pair{distance(patch.address), patch.address}; + for (const auto& patch : candidate.new_patches) + if (!best || std::pair{distance(patch.address), patch.address} < *best) + best = std::pair{distance(patch.address), patch.address}; + if (!best) + return std::unexpected{CellularRegionStepError::habitat}; + if (const auto index = habitat.find(best->second)) { + if (!add(patch_stock[*index], deposit.inventory)) + return std::unexpected{CellularRegionStepError::overflow}; + } else { + const auto nearest = std::ranges::lower_bound(candidate.new_patches, best->second, + {}, &CellularPatch::address); + if (!add(nearest->stock, deposit.inventory)) + return std::unexpected{CellularRegionStepError::overflow}; + } + } } for (std::size_t i = 0; i < patch_stock.size(); ++i) diff --git a/tests/cellular_region_step_tests.cpp b/tests/cellular_region_step_tests.cpp index 75ab3cc..3c1c433 100644 --- a/tests/cellular_region_step_tests.cpp +++ b/tests/cellular_region_step_tests.cpp @@ -95,13 +95,151 @@ void refusal_never_returns_partial_tick_state() { CHECK(result->patches.empty()); CHECK(map->patches()[0].stock == Inventory{{5}, {{{2}, {2}, {2}, {2}}}}); } + +// ADR-0124 (rules 3) helpers: a cell of the given total mass, membrane and engulf intent. +CellularLifeStepInput cell(std::uint64_t id, CellularPosition at, std::uint64_t mass, + std::uint32_t membrane, bool engulf) { + CellularLifeStepInput life{id, at, 20, {}, {{0}, {{{10}, {10}, {10}, {10}}}}, + {{100}, {}}, {}, budget()}; + life.budget.phenotype.total_mass = mass; + life.intent.engulf = engulf; + life.membrane_um = membrane; + life.source = 900 + id; + return life; +} +constexpr CellularRegionRules rules3{true}; + +Inventory total(const CellularRegionStepCandidate& c, const CellularHabitat& map) { + Inventory sum{}; + const auto add = [&](const Inventory& v) { + sum.energy.value += v.energy.value; + for (std::size_t i = 0; i < v.matter.size(); ++i) + sum.matter[i].value += v.matter[i].value; + }; + std::vector updated(map.patches().size(), false); + for (const auto& patch : c.patches) { + add(patch.stock); + const auto index = map.find(patch.address); + CHECK(index.has_value()); + if (index) + updated[*index] = true; + } + for (std::size_t i = 0; i < updated.size(); ++i) + if (!updated[i]) + add(map.patches()[i].stock); + for (const auto& patch : c.new_patches) + add(patch.stock); + for (const auto& corpse : c.starved) + add(corpse.inventory); + sum.energy.value += c.heat_released.value; + return sum; +} + +void engulfment_moves_the_prey_once_bounded_by_capacity() { + const auto map = habitat(); + // Predator 3x the prey's mass, prey with a 1 um membrane: 3 >= 1.5. + const std::array input{cell(2, {0, 0}, 1'000, 1, false), cell(1, {10, 0}, 3'000, 1, true)}; + const auto result = propose_cellular_region_step(4, {3'000, 2'000}, input, *map, rules3); + CHECK(result); + CHECK(result->lives.size() == 1 && result->lives[0].life_id == 1); + CHECK(result->lives[0].engulf == CellularEngulfStatus::engulfed && + result->lives[0].prey_id == 2); + CHECK(result->starved.size() == 1 && result->starved[0].life_id == 2 && + result->starved[0].cause == CellularDeathCause::engulfed && + result->starved[0].predator_id == 1 && result->starved[0].inventory == Inventory{}); + // Capacity is the per-tick intake limit: 1,000 per second is 50 per 50 ms tick. + // The prey holds 100 pJ and 10 fg per channel; the predator takes 50 pJ and all matter. + const auto& predator = result->lives[0].candidate.reserve_after; + CHECK(predator.energy.value == 100 + 50); + CHECK(predator.matter[0].value == 10); + // The other 50 pJ is detritus in the patch at the prey's cell. + CHECK(result->patches.size() == 1 && + result->patches[0] == CellularPatchStockUpdate{{0, 0}, {{55}, {{{2}, {2}, {2}, {2}}}}}); + CHECK(result->new_patches.empty()); + + // Region-wide conservation: lives + patches + corpses + released heat. + auto after = total(*result, *map); + after.energy.value += predator.energy.value; + for (std::size_t i = 0; i < after.matter.size(); ++i) + after.matter[i].value += predator.matter[i].value + 10; // The predator's body. + CHECK(after == Inventory{{5 + 100 + 100}, {{{2 + 20}, {2 + 20}, {2 + 20}, {2 + 20}}}}); +} + +void size_and_membrane_contest_engulfment() { + const auto map = habitat(); + const std::array equal{cell(1, {0, 0}, 1'000, 1, true), cell(2, {0, 0}, 1'000, 1, false)}; + const auto same = propose_cellular_region_step(4, {3'000, 2'000}, equal, *map, rules3); + CHECK(same && same->lives.size() == 2 && same->starved.empty()); + CHECK(same->lives[0].engulf == CellularEngulfStatus::no_eligible_prey); + + // A 3 um membrane raises the required ratio to 4.5; a 3x predator fails. + const std::array armored{cell(1, {0, 0}, 3'000, 1, true), cell(2, {0, 0}, 1'000, 3, false)}; + const auto defended = propose_cellular_region_step(4, {3'000, 2'000}, armored, *map, rules3); + CHECK(defended && defended->lives.size() == 2 && defended->starved.empty()); + // Out of contact: no prey, whatever the size. + const std::array apart{cell(1, {0, 0}, 9'000, 1, true), cell(2, {2'000, 0}, 1'000, 1, false)}; + const auto distant = propose_cellular_region_step(4, {3'000, 2'000}, apart, *map, rules3); + CHECK(distant && distant->lives.size() == 2 && + distant->lives[0].engulf == CellularEngulfStatus::no_eligible_prey); +} + +void a_taken_cell_neither_acts_nor_is_taken_twice() { + const auto map = habitat(); + // 1 takes 2 first (ascending id), so 2's own engulf of 3 never happens and 4 cannot + // take 2 again; 4 takes 3 instead. + const std::array input{cell(1, {0, 0}, 9'000, 1, true), cell(2, {0, 0}, 3'000, 1, true), + cell(3, {0, 0}, 1'000, 1, false), cell(4, {0, 0}, 9'000, 1, true)}; + const auto result = propose_cellular_region_step(4, {3'000, 2'000}, input, *map, rules3); + CHECK(result && result->lives.size() == 2); + CHECK(result->lives[0].life_id == 1 && result->lives[0].prey_id == 2); + CHECK(result->lives[1].life_id == 4 && result->lives[1].prey_id == 3); + CHECK(result->starved.size() == 2 && result->starved[0].predator_id == 1 && + result->starved[1].predator_id == 4); +} + +void starvation_detritus_creates_a_patch_at_an_empty_cell() { + const auto map = habitat(); + auto starving = cell(5, {1'500, 1'500}, 1'000, 1, false); + starving.budget.maintenance = {1'000'000}; + const std::array input{starving}; + const auto result = propose_cellular_region_step(4, {3'000, 2'000}, input, *map, rules3); + CHECK(result && result->lives.empty() && result->starved.size() == 1); + CHECK(result->starved[0].cause == CellularDeathCause::starved && + result->starved[0].inventory == Inventory{}); + CHECK(result->new_patches.size() == 1); + CHECK(result->new_patches[0] == + CellularPatch{{1'000, 1'000}, 905, {{100}, {{{10}, {10}, {10}, {10}}}}}); + CHECK(result->patches.empty()); +} + +void rules_two_ignores_engulf_and_rules_three_refuses_bad_intents() { + const auto map = habitat(); + const std::array input{cell(1, {0, 0}, 9'000, 1, true), cell(2, {0, 0}, 1'000, 1, false)}; + const auto legacy = propose_cellular_region_step(4, {3'000, 2'000}, input, *map); + CHECK(legacy && legacy->lives.size() == 2 && legacy->starved.empty() && + legacy->lives[0].engulf == CellularEngulfStatus::unsupported); + + auto both = cell(1, {0, 0}, 9'000, 1, true); + both.intent.intake_target = CellularPatchAddress{0, 0}; + const std::array conflicting{both}; + const auto refused = propose_cellular_region_step(4, {3'000, 2'000}, conflicting, *map, rules3); + CHECK(!refused && refused.error() == CellularRegionStepError::invalid_intent); + const std::array bare{cell(1, {0, 0}, 9'000, 0, false)}; + const auto unmembraned = propose_cellular_region_step(4, {3'000, 2'000}, bare, *map, rules3); + CHECK(!unmembraned && unmembraned.error() == CellularRegionStepError::invalid_intent); +} } // namespace int main() { try { shared_patch_claims_are_identity_ordered_and_conserved(); refusal_never_returns_partial_tick_state(); - std::puts("PASS cellular region step: shared claims and starvation closure"); + engulfment_moves_the_prey_once_bounded_by_capacity(); + size_and_membrane_contest_engulfment(); + a_taken_cell_neither_acts_nor_is_taken_twice(); + starvation_detritus_creates_a_patch_at_an_empty_cell(); + rules_two_ignores_engulf_and_rules_three_refuses_bad_intents(); + std::puts("PASS cellular region step: shared claims, starvation, engulfment, detritus"); } catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1;