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
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>
115 lines
5.2 KiB
C++
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
|