Files
aevolution/include/evo/biology/cellular_region_step.hpp
T
dingoandClaude Opus 5.5 be69cae652
Foundation / checks (checks) (push) Successful in 47m40s
Foundation / checks (client) (push) Successful in 17m27s
Foundation / checks (deploy) (push) Successful in 4m17s
Foundation / checks (ecs) (push) Successful in 4m31s
Foundation / checks (network) (push) Successful in 22m1s
Foundation / checks (tsan) (push) Successful in 13m10s
Foundation / checks (postgres) (push) Successful in 20m54s
Foundation / image (push) Successful in 4m15s
Foundation / postgres-tools (push) Successful in 5m32s
Foundation / server-image (push) Successful in 7m15s
Cellular rules 8: pools and bubbles fed by contact (ADR-0136 step A)
Square patches invited camping and left the space between them empty. Rules 8 run on a
format-2 habitat of deposits:
- pools and single-nutrient bubbles at free micrometre centres, each with a stable id
  and a contact radius; the cellular-v7 opening scatters bubbles reproducibly from the
  genesis commit (three in ten in loose clumps) and lists pools with --pool;
- every cell drains what it touches, up to its intake rate per tick, with no target; a
  pool gives at most a quarter of that rate; an emptied deposit disappears;
- a dead cell's detritus breaks into one bubble per non-empty channel;
- wildlife swims to the nearest non-empty deposit and feeds by touch.

Bundle v9 (habitat 2) and schema v43 admit it. Session v11 carries the owner's 512
nearest deposits (id, centre, radius, shape, a drained flag and 16-bit amount codes)
instead of patches; every other cellular message is v10's. The client asks for v11,
draws bubbles (nutrient-coloured, pulsing while drained, popping when gone) and pools as
puddles, slows near food and sends no feed target; the HUD summarises food in range.
Earlier rules, regions and v10 clients are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 00:38:21 -04:00

115 lines
5.2 KiB
C++

#pragma once
#include "evo/biology/cellular_step.hpp"
#include <compare>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <span>
#include <vector>
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{};
// ADR-0136 step A (format 2 habitats): every cell drains the deposits it touches, up to
// its intake rate, with no intake target; pools yield at most a quarter of that rate.
// A dead life's detritus becomes one bubble per non-empty channel.
bool contact_feeding{};
auto operator<=>(const CellularRegionRules&) const = default;
};
struct CellularLifeStepInput {
std::uint64_t life_id{}; // Stable world identity; arbitrates same-tick patch contention.
CellularPosition position;
std::uint32_t extent_um{};
CellularStepIntent intent;
accounting::Inventory body; // Structural matter; energy must be zero.
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 (no longer reported).
unsupported, // Rules 2 region: the intent had no effect.
// Why nothing was taken (reporting only; who is engulfed is unchanged):
no_contact, // No other cell touched it.
prey_too_large, // Touching cells were too large even with the thinnest membrane.
membrane_too_thick // A touching cell was small enough, but its membrane defended it.
};
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 {
CellularPatchAddress address;
accounting::Inventory stock;
auto operator<=>(const CellularPatchStockUpdate&) const = default;
};
// 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;
// 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 {
std::uint64_t begin_tick{}, end_tick{};
// Sorted by stable life_id, independent of connection or input order.
std::vector<CellularLifeStepResult> lives;
std::vector<CellularPatchStockUpdate> patches;
// Dead this tick (starved or engulfed), sorted by life_id.
std::vector<CellularCorpseCandidate> starved;
// Rules 3 detritus patches created at empty cells, sorted by address.
std::vector<CellularPatch> new_patches;
accounting::Picojoules heat_released{};
auto operator<=>(const CellularRegionStepCandidate&) const = default;
};
enum class CellularRegionStepError : std::uint8_t {
invalid_tick,
too_many_lives,
invalid_life_id,
duplicate_life_id,
invalid_body,
invalid_heat,
overflow,
life_step,
habitat,
invalid_intent
};
// Detached shared-habitat candidate. Same-tick claims resolve by ascending stable life id;
// the first valid claimant spends from each patch's remaining per-channel stock. Any refused
// 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<CellularRegionStepCandidate, CellularRegionStepError>
propose_cellular_region_step(std::uint64_t begin_tick, CellularArea area,
std::span<const CellularLifeStepInput> lives,
const CellularHabitat& habitat, CellularRegionRules rules = {});
} // namespace evo::biology