Resolve cellular engulfment and detritus in the region step
Foundation / checks (ecs) (push) Successful in 2m17s
Foundation / checks (deploy) (push) Successful in 3m57s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 6m13s
Foundation / checks (checks) (push) Canceled after 6m19s
Foundation / checks (tsan) (push) Canceled after 3m58s
Foundation / checks (client) (push) Canceled after 6m17s
Foundation / checks (network) (push) Canceled after 6m18s
Foundation / checks (ecs) (push) Successful in 2m17s
Foundation / checks (deploy) (push) Successful in 3m57s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 6m13s
Foundation / checks (checks) (push) Canceled after 6m19s
Foundation / checks (tsan) (push) Canceled after 3m58s
Foundation / checks (client) (push) Canceled after 6m17s
Foundation / checks (network) (push) Canceled after 6m18s
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 <noreply@anthropic.com>
This commit is contained in:
@@ -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<bool> 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;
|
||||
|
||||
Reference in New Issue
Block a user