Files
aevolution/src/server/lifecycle/cellular_lives.cpp
T
dingoandClaude Opus 5.5 54beceb823 feat(admin): read-only admin portal and API (ADR-0182 step 1, schema 61)
evo-admin-api serves the portal at srs.aeternalisgames.com and read-only JSON
for world 100 behind Keycloak (realm role aevolution-admin, audience
aevolution-admin, client aevolution-admin-portal): accounts with session,
status, lives, deaths, resets and mutation choices; one account's lives; the
world's regions; and a live 2D region view of cells, wildlife, pools and
bubbles. The portal is plain HTML/CSS/JS with PKCE sign-in, a strict CSP and
no third-party code.

- Schema 61: three bounded SECURITY DEFINER read functions, fenced in the
  privilege audit; no table or existing function changes.
- Cellular regions answer GET /admin/view on the ops port (NetworkPolicy:
  Prometheus and the admin portal only); CellularLives::extent_of reads the
  existing phenotype budget. No simulation, checkpoint or wire change.
- TokenVerifier takes an optional realm role and returns the email; the ops
  server's response bound is configurable (16 KiB default unchanged).
- DEV component admin-portal-dev (Deployment, Service, NetworkPolicies); the
  Ingress and the aevolution-admin-pg Secret are created out of band.
- CI scripts pinned to schema 60 now expect 61.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 12:39:28 -04:00

3952 lines
214 KiB
C++

#include "evo/server/lifecycle/cellular_lives.hpp"
#include "evo/biology/budding.hpp"
#include "evo/biology/founder.hpp"
#include "evo/core/random.hpp"
#include <algorithm>
#include <array>
#include <bit>
#include <limits>
#include <map>
#include <ranges>
#include <set>
#include <stdexcept>
#include <utility>
namespace evo::server {
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::uint64_t cellular_lives_v5_magic = 0x3530564C43564541ULL; // AEVCLV05
constexpr std::uint64_t cellular_lives_v6_magic = 0x3630564C43564541ULL; // AEVCLV06
constexpr std::uint64_t cellular_lives_v7_magic = 0x3730564C43564541ULL; // AEVCLV07
constexpr std::uint64_t cellular_lives_v8_magic = 0x3830564C43564541ULL; // AEVCLV08
constexpr std::uint64_t cellular_lives_v9_magic = 0x3930564C43564541ULL; // AEVCLV09
constexpr std::uint64_t cellular_lives_v10_magic = 0x3031564C43564541ULL; // AEVCLV10
constexpr std::uint64_t cellular_lives_v11_magic = 0x3131564C43564541ULL; // AEVCLV11
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;
// Format 5 (ADR-0125): the header adds the next bud sequence, each life and each corpse
// its parent life (8 bytes each).
constexpr std::size_t cellular_lives_v5_header_bytes = cellular_lives_header_bytes + 8;
constexpr std::size_t cellular_life_v5_bytes = cellular_life_v2_bytes + 8;
constexpr std::size_t cellular_corpse_v5_bytes = cellular_corpse_v4_bytes + 8;
// Format 6 (ADR-0128): each life adds presence (1), 7 zero bytes and its freeze tick (8).
constexpr std::size_t cellular_life_v6_bytes = cellular_life_v5_bytes + 16;
// Format 7: two boundary-flow inventories and nonresident count/reserved.
constexpr std::size_t cellular_lives_v7_header_bytes = cellular_lives_v5_header_bytes + 88;
constexpr std::size_t cellular_lives_v8_header_bytes = cellular_lives_v7_header_bytes + 8;
// Format 9 (ADR-0175): light numerator, denominator, entitlement, moving share and
// reserved (4 each for the last two), and the cumulative captured energy.
constexpr std::size_t cellular_lives_v9_header_bytes = cellular_lives_v8_header_bytes + 40;
// Format 10 (rules 12): the current seed and nine 4-byte current fields (44), five founder
// handling fields (20), five deposit motion fields and reserved (24): 88 bytes. Each life adds
// its motion state (two velocities, heading, reserved, two carries), 20 bytes.
constexpr std::size_t cellular_lives_v10_header_bytes = cellular_lives_v9_header_bytes + 88;
constexpr std::size_t cellular_life_motion_bytes = 20;
// Format 11 (rules 13, ADR-0179): the revamp rules and the spent pool. Essential upkeep share and
// a reserved zero (8), four burn rates (32), membrane collection cost, engulf ratio, engulf
// reserve share and kill bubble share (16), drip interval and a reserved zero (8), drip bubble
// energy and matter (16), and the spent pool (40): 120 bytes. The word after the drip interval
// is the reserve load share. Later build phases extend this
// block before format 11 is deployed.
// Then the growth rate and a reserved zero (8), the offer rules (seven 4-byte fields and a
// reserved zero, 32), the catalog bounds (five 4-byte fields, a reserved zero and the carbon
// gate, 32), the offer interval and a reserved zero (8), and 49 mutation tunables of 80 bytes.
// ADR-0181 uses the growth/offer/bounds reserved words for safety revision,
// growth fuel seconds and split launch speed; historical zeros retain their law.
constexpr std::size_t cellular_revamp_mutation_bytes = 80;
// Then the reproduction tunables: split share, split growth, organism cap, fee scale (16) and
// the bud fee (40).
constexpr std::size_t cellular_lives_v11_header_bytes =
cellular_lives_v10_header_bytes + 120 + 8 + 32 + 32 + 8 +
biology::cellular_catalog_size * cellular_revamp_mutation_bytes + 56 + 24;
// Each format-11 life adds its mutation state: 49 scores and a reserved zero (100), 98 trigger
// states of 24 bytes (2,352), lineage progress and the cadence counter (16), the last brake,
// three zeros and the growth carry (8), the offers made (8), and the pending offer (88).
constexpr std::size_t cellular_trigger_state_bytes = 24;
constexpr std::size_t cellular_life_revamp_bytes =
100 + 2 * biology::cellular_catalog_size * cellular_trigger_state_bytes + 16 + 8 + 8 + 88;
bool valid_motion(const biology::CellularMotionState& m) noexcept {
constexpr std::int64_t carry = biology::cellular_velocity_q10_per_um_s * 1'000'000;
return m.velocity_x_q10 >= -biology::cellular_velocity_limit_q10 &&
m.velocity_x_q10 <= biology::cellular_velocity_limit_q10 &&
m.velocity_y_q10 >= -biology::cellular_velocity_limit_q10 &&
m.velocity_y_q10 <= biology::cellular_velocity_limit_q10 && m.remainder_x >= 0 &&
m.remainder_x < carry && m.remainder_y >= 0 && m.remainder_y < carry;
}
constexpr std::size_t cellular_offspring_revision_bytes = 32;
std::uint64_t checksum(std::span<const std::uint8_t> bytes) noexcept {
std::uint64_t value = 14695981039346656037ULL;
for (const auto byte : bytes)
value = (value ^ byte) * 1099511628211ULL;
return value;
}
std::uint64_t mutation_seed(std::uint64_t world, std::uint64_t region, std::uint64_t life,
std::uint64_t event) noexcept {
auto value = 14695981039346656037ULL;
for (const auto part : {world, region, life, event}) {
for (unsigned index = 0; index < 8; ++index) {
value = (value ^ static_cast<std::uint8_t>(part >> (index * 8U))) * 1099511628211ULL;
}
}
return value == 0 ? 1 : value;
}
class Writer {
public:
explicit Writer(std::vector<std::uint8_t>& bytes) : bytes_{bytes} {}
void put(std::uint64_t value, unsigned width = 8) {
for (unsigned i = 0; i < width; ++i, value >>= 8U)
bytes_.push_back(static_cast<std::uint8_t>(value & 255U));
}
void inventory(const accounting::Inventory& value) {
put(value.energy.value);
for (const auto mass : value.matter)
put(mass.value);
}
void site(SpawnSite value) {
put(std::bit_cast<std::uint32_t>(value.x_um), 4);
put(std::bit_cast<std::uint32_t>(value.y_um), 4);
}
template <std::size_t N> void bytes(const std::array<std::uint8_t, N>& value) {
bytes_.insert(bytes_.end(), value.begin(), value.end());
}
void raw(std::span<const std::uint8_t> value) {
bytes_.insert(bytes_.end(), value.begin(), value.end());
}
void zeros(std::size_t count) {
bytes_.insert(bytes_.end(), count, 0);
}
private:
std::vector<std::uint8_t>& bytes_;
};
class Reader {
public:
explicit Reader(std::span<const std::uint8_t> bytes) : bytes_{bytes} {}
std::uint64_t get(unsigned width = 8) {
std::uint64_t value{};
for (unsigned i = 0; i < width; ++i)
value |= std::uint64_t{bytes_[at_++]} << (8U * i);
return value;
}
accounting::Inventory inventory() {
accounting::Inventory value{};
value.energy.value = get();
for (auto& mass : value.matter)
mass.value = get();
return value;
}
SpawnSite site() {
return {std::bit_cast<std::int32_t>(static_cast<std::uint32_t>(get(4))),
std::bit_cast<std::int32_t>(static_cast<std::uint32_t>(get(4)))};
}
template <std::size_t N> std::array<std::uint8_t, N> bytes() {
std::array<std::uint8_t, N> result{};
std::ranges::copy(bytes_.subspan(at_, N), result.begin());
at_ += N;
return result;
}
std::span<const std::uint8_t> raw(std::size_t size) {
const auto result = bytes_.subspan(at_, size);
at_ += size;
return result;
}
private:
std::span<const std::uint8_t> bytes_;
std::size_t at_{};
};
bool add_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept {
constexpr auto maximum = std::numeric_limits<std::uint64_t>::max();
if (value.energy.value > maximum - total.energy.value)
return false;
for (std::size_t channel = 0; channel < total.matter.size(); ++channel)
if (value.matter[channel].value > maximum - total.matter[channel].value)
return false;
total.energy.value += value.energy.value;
for (std::size_t channel = 0; channel < total.matter.size(); ++channel)
total.matter[channel].value += value.matter[channel].value;
return true;
}
bool subtract_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept {
if (value.energy.value > total.energy.value)
return false;
for (std::size_t channel = 0; channel < total.matter.size(); ++channel)
if (value.matter[channel].value > total.matter[channel].value)
return false;
total.energy.value -= value.energy.value;
for (std::size_t channel = 0; channel < total.matter.size(); ++channel)
total.matter[channel].value -= value.matter[channel].value;
return true;
}
// Format 11: the revamp rules' offer settings and a life's mutation state.
void write_trigger(Writer& out, const biology::CellularTriggerState& s) {
out.put(s.first);
out.put(s.second);
out.put(s.ticks, 4);
out.put(s.heading, 2);
out.put(s.running, 1);
out.put(0, 1);
}
std::optional<biology::CellularTriggerState> read_trigger(Reader& in) {
biology::CellularTriggerState s{};
s.first = in.get();
s.second = in.get();
s.ticks = static_cast<std::uint32_t>(in.get(4));
s.heading = static_cast<std::uint16_t>(in.get(2));
const auto running = in.get(1);
if (running > 1 || in.get(1) != 0)
return std::nullopt;
s.running = static_cast<std::uint8_t>(running);
return s;
}
void write_revamp_offers(Writer& out, const CellularRevampRules& r) {
out.put(r.growth_per_tick_centi_mille, 4);
out.put(r.safety_version, 4);
const auto& o = r.offers;
for (const auto value : {o.options, o.floor_ppm, o.cap_ppm})
out.put(value, 4);
out.put(static_cast<std::uint32_t>(o.score_min), 4);
out.put(static_cast<std::uint32_t>(o.score_max), 4);
out.put(o.max_multiplier_per_mille, 4);
out.put(o.min_multiplier_per_mille, 4);
out.put(r.growth_reserve_seconds, 4);
const auto& b = r.bounds;
for (const auto value :
{b.min_points, b.max_points, b.recipe_min_share, b.max_litter, b.buds_for_adhesion})
out.put(value, 4);
out.put(r.split_launch_um_per_s, 4);
out.put(b.carbon_for_light);
out.put(r.offer_interval_ticks, 4);
out.put(0, 4);
for (const auto& m : r.mutations) {
out.put(m.enabled ? 1 : 0, 1);
out.zeros(3);
out.put(m.base_weight, 4);
out.put(static_cast<std::uint32_t>(m.increase_points), 4);
out.put(static_cast<std::uint32_t>(m.decrease_points), 4);
for (const auto value : {m.primary_step, m.paired_step, m.spread_step, m.increase_ticks,
m.decrease_ticks, m.cost_scale_percent})
out.put(value, 4);
out.inventory(m.cost);
}
for (const auto value :
{r.split_share_per_thousand, r.split_min_growth, r.organism_cap, r.bud_fee_scale_percent})
out.put(value, 4);
out.inventory(r.bud_fee);
out.put(r.organism_load_per_thousand, 4);
out.put(r.emerge_members, 4);
out.put(r.emerge_mass_fg);
out.put(r.emerge_reserve_pj);
}
bool read_revamp_offers(Reader& in, CellularRevampRules& r) {
const auto u32 = [&in] { return static_cast<std::uint32_t>(in.get(4)); };
const auto i32 = [&in] {
return static_cast<std::int32_t>(static_cast<std::uint32_t>(in.get(4)));
};
bool zero = true;
r.growth_per_tick_centi_mille = u32();
r.safety_version = u32();
auto& o = r.offers;
o.options = u32();
o.floor_ppm = u32();
o.cap_ppm = u32();
o.score_min = i32();
o.score_max = i32();
o.max_multiplier_per_mille = u32();
o.min_multiplier_per_mille = u32();
r.growth_reserve_seconds = u32();
auto& b = r.bounds;
b.min_points = u32();
b.max_points = u32();
b.recipe_min_share = u32();
b.max_litter = u32();
b.buds_for_adhesion = u32();
r.split_launch_um_per_s = u32();
b.carbon_for_light = in.get();
r.offer_interval_ticks = u32();
zero = zero && in.get(4) == 0;
for (auto& m : r.mutations) {
const auto enabled = in.get(1);
zero = zero && enabled <= 1 && in.get(3) == 0;
m.enabled = enabled == 1;
m.base_weight = u32();
m.increase_points = i32();
m.decrease_points = i32();
m.primary_step = u32();
m.paired_step = u32();
m.spread_step = u32();
m.increase_ticks = u32();
m.decrease_ticks = u32();
m.cost_scale_percent = u32();
m.cost = in.inventory();
}
r.split_share_per_thousand = u32();
r.split_min_growth = u32();
r.organism_cap = u32();
r.bud_fee_scale_percent = u32();
r.bud_fee = in.inventory();
r.organism_load_per_thousand = u32();
r.emerge_members = u32();
r.emerge_mass_fg = in.get();
r.emerge_reserve_pj = in.get();
return zero;
}
void write_revamp_life(Writer& out, const CellularRevampLife& life) {
for (const auto score : life.affinity.score)
out.put(static_cast<std::uint16_t>(score), 2);
out.put(0, 2);
for (const auto& s : life.affinity.increase)
write_trigger(out, s);
for (const auto& s : life.affinity.decrease)
write_trigger(out, s);
out.put(life.progress.carbon_burned);
out.put(life.progress.buds, 4);
out.put(life.active_ticks, 4);
out.put(life.last_brake, 1);
out.zeros(1);
out.put(life.members, 2);
out.put(life.growth_carry, 4);
out.put(life.events);
const auto& offer = life.offer;
out.put(offer.event_index);
out.put(offer.offer_tick);
out.put(offer.count, 1);
out.zeros(7);
for (const auto id : offer.ids)
out.put(id, 2);
for (const auto chance : offer.chances)
out.put(chance, 4);
out.zeros(4);
}
std::optional<CellularRevampLife> read_revamp_life(Reader& in) {
CellularRevampLife life{};
for (auto& score : life.affinity.score)
score = static_cast<std::int16_t>(static_cast<std::uint16_t>(in.get(2)));
bool zero = in.get(2) == 0;
for (auto& s : life.affinity.increase) {
const auto read = read_trigger(in);
if (!read)
return std::nullopt;
s = *read;
}
for (auto& s : life.affinity.decrease) {
const auto read = read_trigger(in);
if (!read)
return std::nullopt;
s = *read;
}
life.progress.carbon_burned = in.get();
life.progress.buds = static_cast<std::uint32_t>(in.get(4));
life.active_ticks = static_cast<std::uint32_t>(in.get(4));
const auto brake = in.get(1);
zero = zero && brake <= 1 && in.get(1) == 0;
life.last_brake = static_cast<std::uint8_t>(brake);
life.members = static_cast<std::uint16_t>(in.get(2));
zero = zero && life.members >= 1;
life.growth_carry = static_cast<std::uint32_t>(in.get(4));
life.events = in.get();
auto& offer = life.offer;
offer.event_index = in.get();
offer.offer_tick = in.get();
const auto count = in.get(1);
zero = zero && in.get(7) == 0 && count <= max_cellular_offer_options;
offer.count = static_cast<std::uint8_t>(count);
for (auto& id : offer.ids)
id = static_cast<std::uint16_t>(in.get(2));
for (auto& chance : offer.chances)
chance = static_cast<std::uint32_t>(in.get(4));
zero = zero && in.get(4) == 0;
// A pending offer names catalog mutations once each, with chances, and nothing after them;
// no offer leaves every slot zero.
for (std::size_t k = 0; k < max_cellular_offer_options; ++k) {
const bool used = k < offer.count;
if (used != (offer.ids.at(k) != 0) ||
(used &&
(biology::cellular_mutation(offer.ids.at(k)) == nullptr || offer.chances.at(k) == 0 ||
offer.chances.at(k) > biology::cellular_chance_whole)) ||
(!used && offer.chances.at(k) != 0))
return std::nullopt;
for (std::size_t j = 0; j < k && used; ++j)
if (offer.ids.at(j) == offer.ids.at(k))
return std::nullopt;
}
if (!zero || (offer.count == 0 && (offer.event_index != 0 || offer.offer_tick != 0)) ||
(offer.count != 0 && offer.event_index != life.events) || life.growth_carry >= 100)
return std::nullopt;
return life;
}
// Rules 13 (reproduction plan section 6): a multicellular organism develops as its genome with
// the target size times its members, so mass, footprint, upkeep and growth follow from it.
std::expected<biology::Genome, CellularLivesError> organism_genome(const biology::Genome& genome,
std::uint32_t members) {
if (members <= 1)
return genome;
biology::GenomeDraft draft;
draft.schema_version = genome.schema_version();
draft.id = genome.id();
draft.origin_event = genome.origin_event();
draft.development_version = genome.development_version();
draft.parents.assign(genome.parents().begin(), genome.parents().end());
draft.capabilities.assign(genome.capabilities().begin(), genome.capabilities().end());
draft.movement_arrangement = genome.movement_arrangement();
draft.cellular_traits = genome.cellular_traits();
for (auto& record : draft.capabilities)
if (record.kind == biology::Capability::target_size) {
if (record.parameter > std::numeric_limits<std::uint32_t>::max() / members)
return std::unexpected{CellularLivesError::biology};
record.parameter *= members;
}
const auto made = biology::Genome::create(draft);
if (!made)
return std::unexpected{CellularLivesError::biology};
return *made;
}
std::expected<biology::Genome, CellularLivesError>
life_genome(const biology::LineageArchive& archive, const CellularOwnedLife& life) {
const auto genome = archive.find(life.identity.genome);
if (!genome)
return std::unexpected{CellularLivesError::archive};
return organism_genome(*genome, life.revamp.members);
}
// Moves `body` to `target`: added matter from `reserve` per channel with construction energy
// (to `heat`) at `price` pJ per 1,000 fg added, freed matter back to the reserve. Changes nothing
// and returns false when the reserve cannot pay.
bool rebody(accounting::Inventory& body, accounting::Inventory& reserve,
accounting::Inventory& heat, const accounting::Inventory& target, std::uint64_t price) {
auto next_reserve = reserve;
std::uint64_t added{};
for (std::size_t c = 0; c < body.matter.size(); ++c) {
const auto have = body.matter[c].value, want = target.matter[c].value;
if (want > have) {
if (next_reserve.matter[c].value < want - have)
return false;
next_reserve.matter[c].value -= want - have;
added += want - have;
} else {
next_reserve.matter[c].value += have - want;
}
}
const auto energy = added / 1'000 * price + added % 1'000 * price / 1'000;
if (next_reserve.energy.value < energy)
return false;
next_reserve.energy.value -= energy;
reserve = next_reserve;
heat.energy.value += energy;
body = target;
body.energy = {};
return true;
}
std::expected<biology::MetabolicBudget, CellularLivesError>
budget_for(const biology::LineageArchive& archive, const CellularOwnedLife& life,
std::uint32_t temperature,
const biology::BodyTuning& body = biology::default_body_tuning) {
const auto genome = life_genome(archive, life);
if (!genome)
return std::unexpected{genome.error()};
const auto budget =
biology::metabolic_budget(*genome, life.growth, {temperature, {}}, 1000, body);
if (!budget)
return std::unexpected{CellularLivesError::biology};
return *budget;
}
bool separated(std::uint64_t left, std::uint64_t right, std::uint32_t left_extent,
std::uint32_t right_extent) noexcept {
return left < right ? right - left >= left_extent : left - right >= right_extent;
}
// ADR-0125 placement: touching the parent, centres (parent + bud extent) / 2 + 1 apart on
// each moved axis, trying east and then counter-clockwise in 45-degree steps. The first
// spot inside the area and clear of every living cell wins; none is a refusal.
std::expected<std::optional<biology::CellularPosition>, CellularLivesError>
bud_position(const CellularOwnedLife& parent, std::uint32_t parent_extent, std::uint32_t bud_extent,
std::span<const CellularOwnedLife> lives, const biology::LineageArchive& archive,
const CellularLivesConfig& config, std::uint32_t launch_gap = 0) {
constexpr std::array<std::array<std::int64_t, 2>, 8> directions{
{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}}};
if (bud_extent == 0 || bud_extent > config.area.width_um || bud_extent > config.area.height_um)
return std::optional<biology::CellularPosition>{};
std::vector<std::uint32_t> extents;
extents.reserve(lives.size());
for (const auto& living : lives) {
const auto budget = budget_for(archive, living, config.ambient_temperature_millikelvin);
if (!budget)
return std::unexpected{budget.error()};
extents.push_back(launch_gap != 0 && living.identity.life == parent.identity.life
? parent_extent
: budget->phenotype.extent);
}
// Doubled centre coordinates keep half extents exact.
const auto step = std::int64_t{parent_extent} + bud_extent + 2 + 2 * std::int64_t{launch_gap};
// Twice the bud's corner coordinate on one axis; negative is outside the area.
const auto doubled_corner = [&](std::uint64_t parent_corner, std::int64_t direction) {
return 2 * static_cast<std::int64_t>(parent_corner) + parent_extent + direction * step -
std::int64_t{bud_extent};
};
for (const auto& [dx, dy] : directions) {
const auto twice_x = doubled_corner(parent.position.x_um, dx);
const auto twice_y = doubled_corner(parent.position.y_um, dy);
const auto x = twice_x / 2;
const auto y = twice_y / 2;
if (twice_x < 0 || twice_y < 0 ||
static_cast<std::uint64_t>(x) > config.area.width_um - bud_extent ||
static_cast<std::uint64_t>(y) > config.area.height_um - bud_extent)
continue;
const biology::CellularPosition candidate{static_cast<std::uint64_t>(x),
static_cast<std::uint64_t>(y)};
bool clear = true;
for (std::size_t i = 0; i < lives.size() && clear; ++i) {
clear = lives[i].presence == CellularPresence::suspended ||
separated(candidate.x_um, lives[i].position.x_um, bud_extent, extents[i]) ||
separated(candidate.y_um, lives[i].position.y_um, bud_extent, extents[i]);
if (clear && launch_gap != 0 && lives[i].presence != CellularPresence::suspended &&
lives[i].identity.life != parent.identity.life) {
// The short launch corridor must be clear too; no jumping through a cell.
const auto begin_x = static_cast<std::uint64_t>(x - dx * launch_gap);
const auto begin_y = static_cast<std::uint64_t>(y - dy * launch_gap);
clear = separated(std::min(begin_x, candidate.x_um), lives[i].position.x_um,
bud_extent + (dx == 0 ? 0 : launch_gap), extents[i]) ||
separated(std::min(begin_y, candidate.y_um), lives[i].position.y_um,
bud_extent + (dy == 0 ? 0 : launch_gap), extents[i]);
}
}
if (clear)
return std::optional{candidate};
}
return std::optional<biology::CellularPosition>{};
}
// ADR-0128 resume: its own position if clear of every cell in the world, else the first
// clear spot at one, two or three of its extents in the eight fixed directions.
std::expected<std::optional<biology::CellularPosition>, CellularLivesError>
resume_position(const CellularOwnedLife& life, std::uint32_t extent,
std::span<const CellularOwnedLife> lives, const biology::LineageArchive& archive,
const CellularLivesConfig& config) {
constexpr std::array<std::array<std::int64_t, 2>, 8> directions{
{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}}};
if (extent == 0 || extent > config.area.width_um || extent > config.area.height_um)
return std::optional<biology::CellularPosition>{};
std::vector<std::pair<const CellularOwnedLife*, std::uint32_t>> present;
for (const auto& other : lives) {
if (other.presence == CellularPresence::suspended ||
other.identity.life == life.identity.life)
continue;
const auto budget = budget_for(archive, other, config.ambient_temperature_millikelvin);
if (!budget)
return std::unexpected{budget.error()};
present.emplace_back(&other, budget->phenotype.extent);
}
const auto clear = [&](std::int64_t x, std::int64_t y) {
if (x < 0 || y < 0 || static_cast<std::uint64_t>(x) > config.area.width_um - extent ||
static_cast<std::uint64_t>(y) > config.area.height_um - extent)
return false;
return std::ranges::all_of(present, [&](const auto& entry) {
const auto& [other, other_extent] = entry;
return separated(static_cast<std::uint64_t>(x), other->position.x_um, extent,
other_extent) ||
separated(static_cast<std::uint64_t>(y), other->position.y_um, extent,
other_extent);
});
};
const auto x0 = static_cast<std::int64_t>(life.position.x_um);
const auto y0 = static_cast<std::int64_t>(life.position.y_um);
if (clear(x0, y0))
return std::optional{life.position};
for (std::uint32_t ring = 1; ring <= cellular_resume_extents; ++ring)
for (const auto& [dx, dy] : directions) {
const auto step = static_cast<std::int64_t>(ring) * extent;
if (clear(x0 + dx * step, y0 + dy * step))
return std::optional{
biology::CellularPosition{static_cast<std::uint64_t>(x0 + dx * step),
static_cast<std::uint64_t>(y0 + dy * step)}};
}
return std::optional<biology::CellularPosition>{};
}
std::expected<accounting::Inventory, CellularLivesError>
sum_state(accounting::Inventory nursery, accounting::Inventory heat,
const biology::CellularHabitat& habitat, std::span<const CellularOwnedLife> lives,
std::span<const CellularOwnedCorpse> corpses) noexcept {
auto total = nursery;
if (!add_inventory(total, heat))
return std::unexpected{CellularLivesError::overflow};
if (!add_inventory(total, habitat.totals()))
return std::unexpected{CellularLivesError::overflow};
for (const auto& life : lives)
if (!add_inventory(total, life.body) || !add_inventory(total, life.reserve))
return std::unexpected{CellularLivesError::overflow};
for (const auto& corpse : corpses)
if (!add_inventory(total, corpse.inventory))
return std::unexpected{CellularLivesError::overflow};
return total;
}
bool validate_plans(std::span<const CellularOwnedLife> lives,
std::span<const CellularOwnedCorpse> corpses,
const biology::LineageArchive& archive,
std::span<const CellularOffspringRevision> history, std::uint64_t tick,
bool transfers = false) {
if (history.size() > biology::max_archived_genomes)
return false;
struct Plan {
std::uint64_t life, expressed, current, final, editable_after, died;
bool selectable;
};
std::vector<Plan> plans;
std::map<std::uint64_t, std::uint64_t> earliest_birth;
std::map<std::uint64_t, std::uint64_t> last_expression;
for (const auto& revision : archive.revisions())
last_expression[revision.organism] =
std::max(last_expression[revision.organism], revision.at.value);
const auto observe = [&](std::uint64_t genome, std::uint64_t born) {
const auto [position, inserted] = earliest_birth.emplace(genome, born);
if (!inserted)
position->second = std::min(position->second, born);
};
plans.reserve(lives.size() + corpses.size());
for (const auto& life : lives) {
plans.push_back(
{life.identity.life, life.identity.genome, life.identity.genome, life.offspring_genome,
std::max(life.identity.born.value, last_expression[life.identity.organism]), 0,
transfers || life.account != LifeAccount{}});
observe(life.identity.genome, life.identity.born.value);
}
for (const auto& corpse : corpses) {
const auto record = archive.organism(corpse.organism);
const auto expressed = archive.current_genome(corpse.organism);
if (!record || !expressed)
return false;
plans.push_back({corpse.life_id, *expressed, *expressed, corpse.offspring_genome,
std::max(record->born.value, last_expression[corpse.organism]),
corpse.died_tick, transfers || corpse.parent_life == 0});
observe(record->genome, record->born.value);
observe(*expressed, record->born.value);
}
std::ranges::sort(plans, {}, &Plan::life);
std::set<std::uint64_t> successors;
for (std::size_t index = 0; index < history.size(); ++index) {
const auto& revision = history[index];
if (revision.tick == 0 || revision.tick > tick || revision.successor == revision.previous ||
(index != 0 && (history[index - 1].tick > revision.tick ||
(history[index - 1].tick == revision.tick &&
history[index - 1].life >= revision.life))) ||
!successors.insert(revision.successor).second)
return false;
const auto actor = std::ranges::lower_bound(plans, revision.life, {}, &Plan::life);
const auto parent = archive.find(revision.previous);
const auto child = archive.find(revision.successor);
if (actor == plans.end() || actor->life != revision.life || !actor->selectable ||
actor->current != revision.previous || revision.tick <= actor->editable_after ||
(actor->died != 0 && revision.tick >= actor->died) || !parent || !child ||
child->parents().size() != 1 || child->parents().front() != revision.previous ||
child->origin_event() != revision.successor ||
child->schema_version() != parent->schema_version() ||
child->development_version() != parent->development_version())
return false;
actor->current = revision.successor;
// A plan selected here cannot have been expressed at an earlier birth.
const auto born = earliest_birth.find(revision.successor);
if (born != earliest_birth.end() && born->second < revision.tick)
return false;
}
for (const auto& plan : plans) {
const auto expressed = archive.find(plan.expressed);
const auto inherited = archive.find(plan.final);
if (plan.final == 0 || plan.current != plan.final || !expressed || !inherited ||
expressed->schema_version() != inherited->schema_version() ||
expressed->development_version() != inherited->development_version())
return false;
}
return true;
}
std::expected<accounting::Inventory, CellularLivesError>
validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame,
const CellularLivesConfig& config, const NurseryConfig& nursery_config,
const biology::CellularHabitat& habitat, std::span<const CellularOwnedLife> lives,
std::span<const CellularOwnedCorpse> corpses, const biology::LineageArchive& archive,
accounting::Inventory nursery, accounting::Inventory heat,
accounting::Inventory opening_total, bool detritus_rules = false,
bool bud_rules = false, std::uint64_t next_bud_sequence = 1,
bool presence_rules = false, const CellularBoundaryLedger* boundary = nullptr,
const std::vector<CellularOffspringRevision>* plans = nullptr,
const accounting::Inventory& spent = {}, bool transfers = false) {
// A bud's identity lies in this region's namespace below the next sequence; anything
// else is an allocated identity, below the namespace (ADR-0125).
const auto bud_identity = [&](std::uint64_t identity) noexcept {
const auto first = cellular_bud_identity(region, 1);
return bud_rules && first != 0 && next_bud_sequence > 1 && identity >= first &&
identity - first < next_bud_sequence - 1;
};
const auto lineage_valid = [&](std::uint64_t life_id, std::uint64_t parent) noexcept {
if (parent == 0) // Rules 4 keep allocated identities below the bud namespace.
return !bud_rules || life_id < cellular_bud_namespace;
const auto origin = (life_id >> 32U) & cellular_bud_max_region;
const bool imported = boundary && life_id >= cellular_bud_namespace && origin != region &&
origin > 0 && origin <= cellular_bud_max_region &&
(life_id & 0xFFFF'FFFFULL) != 0;
return (bud_identity(life_id) || imported) && parent != life_id;
};
const auto& map = habitat.config();
if (world == 0 || region == 0 || frame == 0 || nursery_config.world != world ||
nursery_config.region != region || nursery_config.frame != frame ||
nursery_config.source == 0 || nursery_config.funding != nursery || map.world != world ||
map.region != region || map.frame != frame || config.area.width_um == 0 ||
config.area.height_um == 0 || map.width_um != config.area.width_um ||
map.height_um != config.area.height_um || config.ambient_temperature_millikelvin == 0 ||
nursery_config.sites.empty() || nursery_config.sites.size() > max_primitive_lives ||
!std::ranges::is_sorted(nursery_config.sites) ||
lives.size() > biology::max_cellular_tick_lives ||
corpses.size() > biology::max_archived_organisms ||
archive.recorded() !=
lives.size() + corpses.size() + (boundary ? boundary->nonresident_organisms.size() : 0))
return std::unexpected{CellularLivesError::invalid_config};
if (std::ranges::any_of(heat.matter, [](const auto& value) { return value.value != 0; }))
return std::unexpected{CellularLivesError::conservation};
const auto founder = biology::primitive_founder(1, 1);
if (!founder)
return std::unexpected{CellularLivesError::biology};
const auto founder_budget = biology::metabolic_budget(
*founder, {1000, 0}, {config.ambient_temperature_millikelvin, {}});
if (!founder_budget)
return std::unexpected{CellularLivesError::biology};
const auto spawn_extent = founder_budget->phenotype.extent;
for (std::size_t i = 0; i < nursery_config.sites.size(); ++i) {
const auto site = nursery_config.sites[i];
if (site.x_um < 0 || site.y_um < 0 || spawn_extent > config.area.width_um ||
spawn_extent > config.area.height_um ||
static_cast<std::uint64_t>(site.x_um) > config.area.width_um - spawn_extent ||
static_cast<std::uint64_t>(site.y_um) > config.area.height_um - spawn_extent)
return std::unexpected{CellularLivesError::invalid_config};
for (std::size_t j = 0; j < i; ++j) {
const auto delta_x = std::int64_t{site.x_um} - nursery_config.sites[j].x_um;
const auto delta_y = std::int64_t{site.y_um} - nursery_config.sites[j].y_um;
const auto dx = static_cast<std::uint64_t>(delta_x < 0 ? -delta_x : delta_x);
const auto dy = static_cast<std::uint64_t>(delta_y < 0 ? -delta_y : delta_y);
if (dx < spawn_extent && dy < spawn_extent)
return std::unexpected{CellularLivesError::invalid_config};
}
}
std::vector<std::uint64_t> live_organisms;
std::vector<std::uint64_t> life_ids;
live_organisms.reserve(lives.size());
life_ids.reserve(lives.size() + corpses.size() +
(boundary ? boundary->nonresident_organisms.size() : 0));
for (std::size_t i = 0; i < lives.size(); ++i) {
const auto& life = lives[i];
if (!plans && life.offspring_genome != 0)
return std::unexpected{CellularLivesError::version};
// Founders are owned; buds are unowned wildlife (rules 4) and never earn offers. Rules 13
// (ADR-0163 succession) moves control between parent and offspring, so ownership is the
// account's alone; bud identities still follow parentage.
const bool wildlife = life.parent_life != 0;
const bool owned = transfers ? life.account != LifeAccount{} : !wildlife;
// ADR-0128: only owned lives leave; a lingering life is within its linger time.
const bool presence_valid =
life.presence == CellularPresence::active
? life.frozen_since == 0
: presence_rules && owned && life.frozen_since != 0 &&
life.frozen_since <= config.tick &&
(life.presence == CellularPresence::suspended ||
(life.presence == CellularPresence::lingering &&
config.tick - life.frozen_since < cellular_linger_ticks));
if (!presence_valid)
return std::unexpected{CellularLivesError::invalid_life};
if ((!transfers && (life.account == LifeAccount{}) != wildlife) ||
life.identity.life == 0 || life.identity.organism == 0 || life.identity.genome == 0 ||
life.identity.event == 0 || life.identity.born.value == 0 ||
life.identity.born.value > config.tick || life.source == 0 ||
(i != 0 && lives[i - 1].identity.life >= life.identity.life) ||
!lineage_valid(life.identity.life, life.parent_life) ||
(wildlife && (life.identity.organism != life.identity.life ||
life.identity.event != life.identity.life ||
life.mutation != CellularMutationProgress{})))
return std::unexpected{CellularLivesError::invalid_life};
for (std::size_t j = 0; j < i; ++j)
if ((owned && lives[j].account == life.account) ||
lives[j].identity.organism == life.identity.organism)
return std::unexpected{CellularLivesError::duplicate_life};
const auto record = archive.organism(life.identity.organism);
const auto current_genome = archive.current_genome(life.identity.organism);
if (!record || !record->alive || !current_genome ||
*current_genome != life.identity.genome || record->born != life.identity.born)
return std::unexpected{CellularLivesError::archive};
const auto budget = budget_for(archive, life, config.ambient_temperature_millikelvin);
if (!budget || budget->body != life.body || life.body.energy.value != 0 ||
budget->phenotype.extent == 0 || budget->phenotype.extent > config.area.width_um ||
budget->phenotype.extent > config.area.height_um ||
life.position.x_um > config.area.width_um - budget->phenotype.extent ||
life.position.y_um > config.area.height_um - budget->phenotype.extent)
return std::unexpected{CellularLivesError::invalid_life};
live_organisms.push_back(life.identity.organism);
life_ids.push_back(life.identity.life);
}
if (boundary) {
if (boundary->nonresident_organisms.size() > biology::max_archived_organisms ||
!std::ranges::is_sorted(boundary->nonresident_organisms) ||
std::ranges::adjacent_find(boundary->nonresident_organisms) !=
boundary->nonresident_organisms.end())
return std::unexpected(CellularLivesError::invalid_life);
for (const auto id : boundary->nonresident_organisms) {
if (id < cellular_bud_namespace || !lineage_valid(id, 1))
return std::unexpected(CellularLivesError::invalid_life);
const auto record = archive.organism(id);
if (!record || record->born.value > config.tick ||
(!record->alive && record->died.value > config.tick))
return std::unexpected(CellularLivesError::archive);
if (record->alive)
live_organisms.push_back(id);
life_ids.push_back(id);
}
}
std::ranges::sort(live_organisms);
if (archive.living_organisms() != live_organisms)
return std::unexpected{CellularLivesError::archive};
for (std::size_t i = 0; i < corpses.size(); ++i) {
const auto& corpse = corpses[i];
if (!plans && corpse.offspring_genome != 0)
return std::unexpected{CellularLivesError::version};
if (corpse.life_id == 0 || corpse.organism == 0 || corpse.source == 0 ||
corpse.died_tick == 0 || corpse.died_tick > config.tick || corpse.extent_um == 0 ||
(i != 0 && corpses[i - 1].organism >= corpse.organism) ||
!lineage_valid(corpse.life_id, corpse.parent_life))
return std::unexpected{CellularLivesError::invalid_life};
const auto record = archive.organism(corpse.organism);
if (!record || record->alive || record->died.value != corpse.died_tick)
return std::unexpected{CellularLivesError::archive};
const auto current_genome = archive.current_genome(corpse.organism);
if (!current_genome)
return std::unexpected{CellularLivesError::archive};
const auto genome = archive.find(*current_genome);
if (!genome)
return std::unexpected{CellularLivesError::archive};
const auto budget = biology::metabolic_budget(*genome, corpse.growth,
{config.ambient_temperature_millikelvin, {}});
if (!budget || budget->phenotype.extent != corpse.extent_um ||
corpse.extent_um > config.area.width_um || corpse.extent_um > config.area.height_um ||
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};
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);
if (std::ranges::adjacent_find(life_ids) != life_ids.end())
return std::unexpected{CellularLivesError::duplicate_life};
if (plans && !validate_plans(lives, corpses, archive, *plans, config.tick, transfers))
return std::unexpected{CellularLivesError::invalid_life};
auto current = sum_state(nursery, heat, habitat, lives, corpses);
if (!current)
return std::unexpected{current.error()};
// Rules 13: the spent pool is region stock until it drips back.
if (!add_inventory(*current, spent))
return std::unexpected{CellularLivesError::overflow};
auto expected = opening_total;
if (boundary) {
accounting::Inventory credit{}, debit{};
const auto difference = [](std::uint64_t in, std::uint64_t out, std::uint64_t& plus,
std::uint64_t& minus) {
if (in >= out)
plus = in - out;
else
minus = out - in;
};
difference(boundary->incoming.energy.value, boundary->outgoing.energy.value,
credit.energy.value, debit.energy.value);
for (std::size_t channel = 0; channel < credit.matter.size(); ++channel)
difference(boundary->incoming.matter[channel].value,
boundary->outgoing.matter[channel].value, credit.matter[channel].value,
debit.matter[channel].value);
if (!add_inventory(expected, credit) || !subtract_inventory(expected, debit))
return std::unexpected(CellularLivesError::conservation);
}
if (*current != expected)
return std::unexpected{CellularLivesError::conservation};
return *current;
}
} // namespace
struct CellularLives::State {
std::uint64_t world{}, region{}, frame{};
std::uint32_t format_version{cellular_lives_format}, rules_version{cellular_lives_rules};
CellularLivesConfig config{};
NurseryConfig nursery_config{};
std::unique_ptr<biology::CellularHabitat> habitat;
std::vector<CellularOwnedLife> lives;
std::vector<CellularOwnedCorpse> corpses;
biology::LineageArchive archive;
accounting::Inventory nursery{};
accounting::Inventory heat{};
accounting::Inventory opening_total{};
accounting::Inventory current_total{};
std::uint64_t next_bud_sequence{1}; // Format 5: the next bud identity's sequence.
CellularBoundaryLedger boundary{};
std::vector<CellularOffspringRevision> offspring_revisions;
CellularLight light{}; // Format 9 (ADR-0175).
accounting::Picojoules captured{}; // Format 9: light credited to reserves so far.
CellularLiquidRules liquid{}; // Format 10 (rules 12).
CellularRevampRules revamp{}; // Format 11 (rules 13).
accounting::Inventory spent{}; // Format 11: matter and energy waiting to drip back.
std::shared_ptr<const biology::CellularFlowField> field; // Generated from `liquid`.
State(std::uint64_t world_id, std::uint64_t region_id, std::uint64_t frame_id,
CellularLivesConfig cfg, NurseryConfig nursery_definition,
std::unique_ptr<biology::CellularHabitat> map, std::vector<CellularOwnedLife> living,
std::vector<CellularOwnedCorpse> dead, const biology::LineageArchive& history,
accounting::Inventory source, accounting::Inventory accumulated_heat,
accounting::Inventory initial, accounting::Inventory current,
std::uint32_t format = cellular_lives_format, std::uint32_t rules = cellular_lives_rules,
CellularBoundaryLedger boundary_ledger = {})
: world{world_id}, region{region_id}, frame{frame_id}, format_version{format},
rules_version{rules}, config{cfg}, nursery_config{std::move(nursery_definition)},
habitat{std::move(map)}, lives{std::move(living)}, corpses{std::move(dead)},
archive{history}, nursery{source}, heat{accumulated_heat}, opening_total{initial},
current_total{current}, boundary{std::move(boundary_ledger)} {}
};
CellularLives::CellularLives(std::unique_ptr<State> state) : state_{std::move(state)} {}
CellularLives::~CellularLives() = default;
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::create(const PrimitiveLives& opening,
std::unique_ptr<biology::CellularHabitat> habitat, CellularLivesConfig config,
CellularLivesProfile profile) {
if (!habitat)
return std::unexpected{CellularLivesError::invalid_config};
auto nursery_config = opening.config();
const auto& map = habitat->config();
if (nursery_config.world == 0 || nursery_config.region == 0 || nursery_config.frame == 0 ||
map.world != nursery_config.world || map.region != nursery_config.region ||
map.frame != nursery_config.frame || config.area.width_um == 0 ||
config.area.height_um == 0 || config.area.width_um != map.width_um ||
config.area.height_um != map.height_um || config.ambient_temperature_millikelvin == 0 ||
opening.lives().size() > biology::max_cellular_tick_lives ||
opening.balances().size() != 2 + 2 * nursery_config.sites.size())
return std::unexpected{CellularLivesError::invalid_config};
std::vector<CellularOwnedLife> lives;
lives.reserve(opening.lives().size());
for (const auto& primitive : opening.lives()) {
if (primitive.identity.born.value == 0 || primitive.identity.born.value > config.tick ||
primitive.identity.life == 0 || primitive.identity.organism == 0 ||
primitive.identity.genome == 0 || primitive.source == 0 || primitive.site.x_um < 0 ||
primitive.site.y_um < 0)
return std::unexpected{CellularLivesError::invalid_life};
if (primitive.body.value == 0 || primitive.reserve.value == 0)
return std::unexpected{CellularLivesError::invalid_life};
const auto body_index = static_cast<std::size_t>(primitive.body.value - 1);
const auto reserve_index = static_cast<std::size_t>(primitive.reserve.value - 1);
if (body_index >= opening.balances().size() || reserve_index >= opening.balances().size())
return std::unexpected{CellularLivesError::invalid_life};
lives.push_back({primitive.request.account,
primitive.identity,
primitive.source,
primitive.growth,
{static_cast<std::uint64_t>(primitive.site.x_um),
static_cast<std::uint64_t>(primitive.site.y_um)},
opening.balances()[body_index],
opening.balances()[reserve_index]});
}
auto archive = opening.archive();
std::ranges::sort(lives, {}, [](const auto& life) { return life.identity.life; });
for (std::size_t i = 0; i < lives.size(); ++i) {
const auto& life = lives[i];
if (i != 0 && lives[i - 1].identity.life == life.identity.life)
return std::unexpected{CellularLivesError::duplicate_life};
const auto budget = budget_for(archive, life, config.ambient_temperature_millikelvin);
if (!budget || budget->phenotype.extent == 0 ||
budget->phenotype.extent > config.area.width_um ||
budget->phenotype.extent > config.area.height_um || life.body.energy.value != 0 ||
budget->body != life.body ||
life.position.x_um > config.area.width_um - budget->phenotype.extent ||
life.position.y_um > config.area.height_um - budget->phenotype.extent)
return std::unexpected{CellularLivesError::invalid_life};
}
auto opening_total = opening.totals();
if (!add_inventory(opening_total, habitat->totals()))
return std::unexpected{CellularLivesError::overflow};
const auto nursery = opening.balances()[0];
nursery_config.funding = nursery;
const auto heat = opening.balances()[1];
const auto current =
validate_state(nursery_config.world, nursery_config.region, nursery_config.frame, config,
nursery_config, *habitat, lives, {}, archive, nursery, heat, opening_total);
if (!current)
return std::unexpected{current.error()};
const auto world = nursery_config.world;
const auto region = nursery_config.region;
const auto frame = nursery_config.frame;
const bool foraging = profile == CellularLivesProfile::foraging; // Rules 8.
// A rules-8 opening needs a deposit habitat, and only it may have one.
if (foraging != (habitat->config().format == biology::cellular_habitat_deposit_format))
return std::unexpected{CellularLivesError::habitat};
const bool reproduction = profile == CellularLivesProfile::reproduction || foraging;
const bool balance = profile == CellularLivesProfile::balance || reproduction; // Rules 6+.
const bool presence = profile == CellularLivesProfile::presence || balance;
const bool budding = profile == CellularLivesProfile::budding || presence;
const bool engulf = profile == CellularLivesProfile::engulf || budding;
if (engulf)
archive.upgrade_to_revision_format(); // Rules 3+ regions carry genome revisions.
auto state = std::make_unique<State>(world, region, frame, config, std::move(nursery_config),
std::move(habitat), std::move(lives),
std::vector<CellularOwnedCorpse>{}, archive, nursery, heat,
opening_total, *current,
presence ? cellular_lives_presence_format
: budding ? cellular_lives_bud_format
: engulf ? cellular_lives_engulf_format
: cellular_lives_format,
foraging ? cellular_lives_foraging_rules
: reproduction ? cellular_lives_reproduction_rules
: balance ? cellular_lives_balance_rules
: presence ? cellular_lives_presence_rules
: budding ? cellular_lives_bud_rules
: engulf ? cellular_lives_engulf_rules
: cellular_lives_rules);
return std::unique_ptr<CellularLives>{new CellularLives{std::move(state)}};
}
std::expected<biology::Genome, CellularLivesError>
cellular_organism_genome(const biology::Genome& genome, std::uint32_t members) {
return organism_genome(genome, members);
}
std::uint64_t cellular_lineage_root(const CellularLives& state, std::uint64_t life_id) {
const auto parent_of = [&](std::uint64_t id) -> std::optional<std::uint64_t> {
for (const auto& life : state.lives())
if (life.identity.life == id)
return life.parent_life;
for (const auto& corpse : state.corpses())
if (corpse.life_id == id)
return corpse.parent_life;
return std::nullopt;
};
auto root = life_id;
auto parent = parent_of(life_id);
for (std::size_t step = 0; parent && *parent != 0 && step < biology::max_archived_organisms;
++step) {
root = *parent;
parent = parent_of(root);
}
return root;
}
bool cellular_can_emerge(const CellularOwnedLife& life, const CellularRevampRules& rules) noexcept {
std::uint64_t mass{};
for (std::size_t c = 0; c < life.body.matter.size(); ++c)
mass += life.body.matter[c].value + life.reserve.matter[c].value;
return life.account != LifeAccount{} && life.revamp.members >= rules.emerge_members &&
mass >= rules.emerge_mass_fg && life.reserve.energy.value >= rules.emerge_reserve_pj;
}
bool cellular_twin_bud(std::uint64_t world, std::uint64_t region, std::uint64_t parent_life,
std::uint64_t tick, std::uint32_t reproduction) noexcept {
// Its own stream: the parent and tick hashed with a twin-only salt ("twin").
constexpr std::uint64_t twin_stream = 0x7477696eULL;
const auto roll = mutation_seed(world, region, parent_life, tick ^ (twin_stream << 32U));
return roll % 1000 < std::min<std::uint32_t>(reproduction, 1000) / 2;
}
std::uint64_t CellularLives::world() const noexcept {
return state_->world;
}
std::uint64_t CellularLives::region() const noexcept {
return state_->region;
}
std::uint64_t CellularLives::frame() const noexcept {
return state_->frame;
}
std::uint64_t CellularLives::tick() const noexcept {
return state_->config.tick;
}
std::uint32_t CellularLives::format_version() const noexcept {
return state_->format_version;
}
std::uint32_t CellularLives::rules_version() const noexcept {
return state_->rules_version;
}
std::uint64_t CellularLives::next_bud_sequence() const noexcept {
return state_->next_bud_sequence;
}
std::uint32_t CellularLives::ambient_temperature_millikelvin() const noexcept {
return state_->config.ambient_temperature_millikelvin;
}
biology::CellularArea CellularLives::area() const noexcept {
return state_->config.area;
}
std::span<const CellularOwnedLife> CellularLives::lives() const noexcept {
return state_->lives;
}
std::span<const CellularOwnedCorpse> CellularLives::corpses() const noexcept {
return state_->corpses;
}
const biology::CellularHabitat& CellularLives::habitat() const noexcept {
return *state_->habitat;
}
const biology::LineageArchive& CellularLives::archive() const noexcept {
return state_->archive;
}
accounting::Inventory CellularLives::nursery() const noexcept {
return state_->nursery;
}
accounting::Inventory CellularLives::heat() const noexcept {
return state_->heat;
}
accounting::Inventory CellularLives::spent() const noexcept {
return state_->spent;
}
std::optional<std::uint32_t> CellularLives::extent_of(const CellularOwnedLife& life) const {
const auto budget = budget_for(
state_->archive, life, state_->config.ambient_temperature_millikelvin, state_->revamp.body);
if (!budget)
return std::nullopt;
return budget->phenotype.extent;
}
accounting::Inventory CellularLives::opening_total() const noexcept {
return state_->opening_total;
}
accounting::Inventory CellularLives::current_total() const noexcept {
return state_->current_total;
}
const CellularBoundaryLedger& CellularLives::boundary_ledger() const noexcept {
return state_->boundary;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::migration_replacement(std::vector<CellularOwnedLife> living,
const biology::LineageArchive& archive,
CellularBoundaryLedger boundary) const {
if ((state_->rules_version != cellular_lives_foraging_rules &&
!(state_->rules_version == cellular_lives_maturation_rules &&
state_->format_version == cellular_lives_migration_format)) ||
(state_->format_version != cellular_lives_presence_format &&
state_->format_version != cellular_lives_migration_format))
return std::unexpected(CellularLivesError::version);
auto habitat = biology::CellularHabitat::restore(state_->habitat->snapshot(), state_->world,
state_->region, state_->frame);
if (!habitat)
return std::unexpected(CellularLivesError::habitat);
const auto total = validate_state(
state_->world, state_->region, state_->frame, state_->config, state_->nursery_config,
**habitat, living, state_->corpses, archive, state_->nursery, state_->heat,
state_->opening_total, true, true, state_->next_bud_sequence, true, &boundary, nullptr,
state_->spent, state_->rules_version >= cellular_lives_revamp_rules);
if (!total)
return std::unexpected(total.error());
auto replacement = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
state_->world, state_->region, state_->frame, state_->config, state_->nursery_config,
std::move(*habitat), std::move(living), state_->corpses, archive, state_->nursery,
state_->heat, state_->opening_total, *total, cellular_lives_migration_format,
state_->rules_version, std::move(boundary))}};
replacement->state_->next_bud_sequence = state_->next_bud_sequence;
try {
[[maybe_unused]] const auto bytes = replacement->snapshot();
} catch (const std::length_error&) {
return std::unexpected(CellularLivesError::overflow);
}
return replacement;
}
std::expected<CellularLives::BoundarySavepoint, CellularLivesError>
CellularLives::exchange_boundary(std::span<const biology::CellularPatch> deposits,
accounting::Picojoules heat_export) {
if (state_->format_version < cellular_lives_migration_format)
return std::unexpected(CellularLivesError::version);
if (heat_export.value > state_->heat.energy.value)
return std::unexpected(CellularLivesError::conservation);
auto boundary = state_->boundary;
auto heat = state_->heat;
heat.energy.value -= heat_export.value;
if (heat_export.value >
std::numeric_limits<std::uint64_t>::max() - boundary.outgoing.energy.value)
return std::unexpected(CellularLivesError::overflow);
boundary.outgoing.energy.value += heat_export.value;
if (deposits.empty()) {
// Heat alone: the total falls by exactly the recorded export, so closure holds.
BoundarySavepoint savepoint{nullptr, state_->heat, state_->current_total, state_->boundary};
state_->heat = heat;
state_->current_total.energy.value -= heat_export.value;
state_->boundary = std::move(boundary);
return savepoint;
}
std::unique_ptr<biology::CellularHabitat> habitat;
{
auto config = state_->habitat->config();
if (config.format != biology::cellular_habitat_deposit_format)
return std::unexpected(CellularLivesError::version);
for (auto deposit : deposits) {
if (config.next_deposit == std::numeric_limits<std::uint32_t>::max() ||
deposit.stock == accounting::Inventory{} ||
!add_inventory(boundary.incoming, deposit.stock))
return std::unexpected(CellularLivesError::overflow);
deposit.id = config.next_deposit++;
const auto at = std::ranges::lower_bound(config.patches, deposit.address, {},
&biology::CellularPatch::address);
if (at != config.patches.end() && at->address == deposit.address)
return std::unexpected(CellularLivesError::habitat);
config.patches.insert(at, deposit);
}
auto created = biology::CellularHabitat::create(std::move(config));
if (!created)
return std::unexpected(CellularLivesError::habitat);
habitat = std::move(*created);
}
const auto rules = state_->rules_version;
const auto total =
validate_state(state_->world, state_->region, state_->frame, state_->config,
state_->nursery_config, *habitat, state_->lives, state_->corpses,
state_->archive, state_->nursery, heat, state_->opening_total,
rules >= cellular_lives_engulf_rules, rules >= cellular_lives_bud_rules,
state_->next_bud_sequence, rules >= cellular_lives_presence_rules, &boundary,
cellular_retained_plans(rules) ? &state_->offspring_revisions : nullptr,
state_->spent, state_->rules_version >= cellular_lives_revamp_rules);
if (!total)
return std::unexpected(total.error());
BoundarySavepoint savepoint{std::move(state_->habitat), state_->heat, state_->current_total,
state_->boundary};
state_->habitat = std::move(habitat);
state_->heat = heat;
state_->current_total = *total;
state_->boundary = std::move(boundary);
return savepoint;
}
void CellularLives::restore_boundary(BoundarySavepoint savepoint) noexcept {
if (savepoint.habitat)
state_->habitat = std::move(savepoint.habitat);
state_->heat = savepoint.heat;
state_->current_total = savepoint.current_total;
state_->boundary = std::move(savepoint.boundary);
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::migration_upgrade_candidate() const {
if (state_->rules_version != cellular_lives_foraging_rules)
return std::unexpected(CellularLivesError::version);
return migration_replacement(state_->lives, state_->archive, state_->boundary);
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::maturation_upgrade_candidate() const {
if (state_->format_version != cellular_lives_migration_format ||
state_->rules_version != cellular_lives_foraging_rules)
return std::unexpected(CellularLivesError::version);
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
if (!candidate)
return std::unexpected(candidate.error());
(*candidate)->state_->rules_version = cellular_lives_maturation_rules;
return candidate;
}
std::span<const CellularLifeTickFeedback> CellularLives::last_tick_feedback() const noexcept {
return last_tick_feedback_;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::photosynthesis_upgrade_candidate(CellularLight light) const {
if (state_->format_version != cellular_lives_inheritance_format ||
state_->rules_version != cellular_lives_inheritance_rules)
return std::unexpected{CellularLivesError::version};
if (!cellular_light_valid(light))
return std::unexpected{CellularLivesError::invalid_config};
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
if (!candidate)
return std::unexpected(candidate.error());
(*candidate)->state_->format_version = cellular_lives_light_format;
(*candidate)->state_->rules_version = cellular_lives_photosynthesis_rules;
(*candidate)->state_->light = light;
return candidate;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::liquid_upgrade_candidate(const CellularLiquidRules& rules) const {
if (state_->format_version != cellular_lives_light_format ||
state_->rules_version != cellular_lives_photosynthesis_rules)
return std::unexpected{CellularLivesError::version};
if (!cellular_liquid_valid(rules, state_->config.area))
return std::unexpected{CellularLivesError::invalid_config};
auto field = biology::CellularFlowField::shared(rules.currents);
if (!field)
return std::unexpected{CellularLivesError::invalid_config};
auto config = state_->habitat->config();
if (config.format != biology::cellular_habitat_deposit_format ||
config.patches.size() > biology::max_cellular_liquid_deposits)
return std::unexpected{CellularLivesError::habitat};
config.format = biology::cellular_habitat_liquid_format;
for (auto& patch : config.patches)
patch.merged = 1;
auto habitat = biology::CellularHabitat::create(std::move(config));
if (!habitat)
return std::unexpected{CellularLivesError::habitat};
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
if (!candidate)
return std::unexpected(candidate.error());
auto& next = *(*candidate)->state_;
next.habitat = std::move(*habitat);
next.format_version = cellular_lives_liquid_format;
next.rules_version = cellular_lives_liquid_rules;
next.liquid = rules;
next.field = std::move(*field);
for (auto& life : next.lives)
life.motion = {};
return candidate;
}
const CellularLiquidRules& CellularLives::liquid_rules() const noexcept {
return state_->liquid;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::revamp_upgrade_candidate(const CellularRevampRules& rules, std::uint32_t count,
std::uint64_t first) const {
if (state_->format_version != cellular_lives_liquid_format ||
state_->rules_version != cellular_lives_liquid_rules)
return std::unexpected{CellularLivesError::version};
if (!cellular_revamp_valid(rules))
return std::unexpected{CellularLivesError::invalid_config};
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
if (!candidate)
return std::unexpected(candidate.error());
auto& next = *(*candidate)->state_;
next.format_version = cellular_lives_revamp_format;
next.rules_version = cellular_lives_revamp_rules;
next.revamp = rules;
if (count == 0)
return first == 0 ? std::move(candidate) : std::unexpected{CellularLivesError::identity};
// ADR-0180: only an explicit, empty opening may contain fixture roots.
if (tick() != 1 || !next.lives.empty() || !next.corpses.empty() ||
next.archive.archived() != 0 || count >= rules.organism_cap || count > 255 || first == 0 ||
first > cellular_bud_namespace - count)
return std::unexpected{CellularLivesError::invalid_config};
for (std::uint32_t index = 0; index < count; ++index) {
const auto id = first + index;
const auto founder = biology::primitive_founder(id, id, biology::primitive_founder_v6);
if (!founder)
return std::unexpected{CellularLivesError::biology};
biology::GenomeDraft draft{
.id = id,
.origin_event = id,
.development_version = 7,
.parents = {},
.capabilities = {founder->capabilities().begin(), founder->capabilities().end()},
.schema_version = biology::genome_schema_v7,
.movement_arrangement = biology::founder_movement_arrangement,
.cellular_traits = biology::founder_cellular_traits};
Random random{mutation_seed(world(), region(), id, 0x57494C44U)};
const auto points = [&] { return static_cast<std::uint16_t>(75 + random.next() % 51); };
auto& traits = *draft.cellular_traits;
traits.density = points();
traits.upkeep_efficiency = points();
traits.growth_speed = points();
for (auto& channel : traits.collection)
channel = points();
for (auto& channel : traits.burn)
channel = points();
traits.engulf_capacity = points();
traits.kill_absorption = points();
auto& movement = *draft.movement_arrangement;
movement.output = points();
movement.efficiency = points();
movement.steering = points();
movement.streamlining = points();
movement.braking = points();
movement.coasting = points();
const auto genome = biology::Genome::create(draft);
const auto budget =
genome ? biology::metabolic_budget(*genome, {1000, 0},
{next.config.ambient_temperature_millikelvin, {}},
1000, rules.body)
: std::unexpected{biology::DevelopmentError::overflow};
if (!budget)
return std::unexpected{CellularLivesError::biology};
// A normal founder's starting provision, evaluated for its randomized genome.
const accounting::Inventory reserve{
{budget->demand.value * biology::founder_reserve_seconds}, {}};
auto empty_body = accounting::Inventory{};
auto nursery = next.nursery;
auto heat = next.heat;
const auto development = biology::rules_for(genome->development_version());
if (!development || !subtract_inventory(nursery, reserve) ||
!rebody(empty_body, nursery, heat, budget->body,
development->construction_per_kilogram))
return std::unexpected{CellularLivesError::insufficient_funding};
const auto extent = budget->phenotype.extent;
if (next.config.area.width_um <= extent + 2000 ||
next.config.area.height_um <= extent + 2000)
return std::unexpected{CellularLivesError::no_placement};
std::optional<biology::CellularPosition> position;
for (int attempt = 0; attempt < 1024 && !position; ++attempt) {
const biology::CellularPosition spot{
1000 + random.next() % (next.config.area.width_um - extent - 2000),
1000 + random.next() % (next.config.area.height_um - extent - 2000)};
bool occupied = false;
for (const auto& other : next.lives) {
const auto body = budget_for(
next.archive, other, next.config.ambient_temperature_millikelvin, rules.body);
if (!body)
return std::unexpected{CellularLivesError::biology};
const auto side = body->phenotype.extent;
occupied = occupied || (spot.x_um < other.position.x_um + side &&
other.position.x_um < spot.x_um + extent &&
spot.y_um < other.position.y_um + side &&
other.position.y_um < spot.y_um + extent);
}
if (!occupied)
position = spot;
}
if (!position)
return std::unexpected{CellularLivesError::no_placement};
if (!next.archive.admit(*genome) || !next.archive.record_birth(id, id, {tick()}))
return std::unexpected{CellularLivesError::archive};
CellularOwnedLife life{};
life.identity = {id, id, id, id, {tick()}};
life.source = next.nursery_config.source;
life.growth = {1000, 0};
life.position = *position;
life.body = budget->body;
life.reserve = reserve;
life.offspring_genome = id;
next.lives.push_back(life);
next.nursery = nursery;
next.nursery_config.funding = nursery;
next.heat = heat;
}
// Restore validates bodies, identities, history and channel-by-channel closure.
return restore((*candidate)->snapshot(), world(), region(), frame(), tick());
}
std::optional<accounting::Inventory> CellularLives::budding_cost(std::uint64_t id) const {
const auto life =
std::ranges::find(state_->lives, id, [](const auto& value) { return value.identity.life; });
if (life == state_->lives.end())
return std::nullopt;
const auto parent = state_->archive.find(life->identity.genome);
const auto child = state_->archive.find(cellular_offspring_genome(*life));
if (!parent || !child)
return std::nullopt;
if (state_->rules_version < cellular_lives_revamp_rules)
return biology::offspring_cost(*parent, *child, ambient_temperature_millikelvin());
auto cost =
cellular_mutation_cost({.cost = state_->revamp.bud_fee,
.cost_scale_percent = state_->revamp.bud_fee_scale_percent});
if (life->revamp.members == 1) {
const auto investment =
biology::offspring_cost(*parent, *child, ambient_temperature_millikelvin());
if (!investment || !add_inventory(cost, *investment))
return std::nullopt;
} else {
const auto traits = parent->cellular_traits().value_or(biology::founder_cellular_traits);
const auto added = std::min<std::uint32_t>(1 + (traits.litter + 99U) / 100U,
1 + state_->revamp.bounds.max_litter / 100U);
const auto grown = organism_genome(*parent, life->revamp.members + added);
const auto target = grown
? biology::metabolic_budget(*grown, life->growth,
{ambient_temperature_millikelvin(), {}},
1000, state_->revamp.body)
: std::unexpected{biology::DevelopmentError::overflow};
const auto development = biology::rules_for(parent->development_version());
if (!target || !development)
return std::nullopt;
std::uint64_t mass{};
for (std::size_t c = 0; c < cost.matter.size(); ++c) {
const auto difference = target->body.matter[c].value > life->body.matter[c].value
? target->body.matter[c].value - life->body.matter[c].value
: 0;
cost.matter[c].value += difference;
mass += difference;
}
const auto price = development->construction_per_kilogram;
cost.energy.value += mass / 1000 * price + mass % 1000 * price / 1000;
}
return cost;
}
const CellularRevampRules& CellularLives::revamp_rules() const noexcept {
return state_->revamp;
}
const biology::CellularFlowField* CellularLives::flow_field() const noexcept {
return state_->field.get();
}
const CellularLight& CellularLives::light() const noexcept {
return state_->light;
}
accounting::Picojoules CellularLives::captured_light() const noexcept {
return state_->captured;
}
std::span<const CellularOffspringRevision> CellularLives::offspring_revisions() const noexcept {
return state_->offspring_revisions;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::inheritance_upgrade_candidate() const {
if (state_->format_version != cellular_lives_migration_format ||
state_->rules_version != cellular_lives_maturation_rules)
return std::unexpected{CellularLivesError::version};
auto candidate = restore(snapshot(), world(), region(), frame(), tick());
if (!candidate)
return std::unexpected(candidate.error());
auto& next = *(*candidate)->state_;
next.format_version = cellular_lives_inheritance_format;
next.rules_version = cellular_lives_inheritance_rules;
for (auto& life : next.lives)
life.offspring_genome = life.identity.genome;
for (auto& corpse : next.corpses) {
const auto genome = next.archive.current_genome(corpse.organism);
if (!genome)
return std::unexpected{CellularLivesError::archive};
corpse.offspring_genome = *genome;
}
return restore((*candidate)->snapshot(), world(), region(), frame(), tick());
}
std::vector<std::uint8_t> CellularLives::snapshot() const {
const auto habitat = state_->habitat->snapshot();
const auto archive = state_->archive.encode();
const auto site_count = state_->nursery_config.sites.size();
const auto life_count = state_->lives.size();
const auto corpse_count = state_->corpses.size();
const bool parents = state_->format_version >= cellular_lives_bud_format;
const bool presence = state_->format_version >= cellular_lives_presence_format;
const bool inheritance = state_->format_version >= cellular_lives_inheritance_format;
const bool lit = state_->format_version >= cellular_lives_light_format;
// Format 11 is format 10 with the revamp rules.
const bool revamp = state_->format_version == cellular_lives_revamp_format;
const bool liquid = revamp || state_->format_version == cellular_lives_liquid_format;
const auto life_bytes =
revamp
? cellular_life_v6_bytes + 8 + cellular_life_motion_bytes + cellular_life_revamp_bytes
: liquid ? cellular_life_v6_bytes + 8 + cellular_life_motion_bytes
: inheritance ? cellular_life_v6_bytes + 8
: state_->format_version == cellular_lives_legacy_format ? cellular_life_v1_bytes
: presence ? cellular_life_v6_bytes
: parents ? cellular_life_v5_bytes
: cellular_life_v2_bytes;
const bool causes = state_->format_version >= cellular_lives_engulf_format;
const auto corpse_bytes = inheritance ? cellular_corpse_v5_bytes + 8
: parents ? cellular_corpse_v5_bytes
: causes ? cellular_corpse_v4_bytes
: cellular_corpse_bytes;
const bool migration = state_->format_version >= cellular_lives_migration_format;
const auto header_bytes = revamp ? cellular_lives_v11_header_bytes
: liquid ? cellular_lives_v10_header_bytes
: lit ? cellular_lives_v9_header_bytes
: inheritance ? cellular_lives_v8_header_bytes
: migration ? cellular_lives_v7_header_bytes
: parents ? cellular_lives_v5_header_bytes
: cellular_lives_header_bytes;
const auto external_count = migration ? state_->boundary.nonresident_organisms.size() : 0;
const auto total_bytes =
header_bytes + cellular_site_bytes * site_count + life_bytes * life_count +
corpse_bytes * corpse_count + habitat.size() + archive.size() + external_count * 8 +
state_->offspring_revisions.size() * cellular_offspring_revision_bytes + 8;
if (total_bytes > max_cellular_lives_bytes ||
habitat.size() > biology::max_cellular_habitat_bytes ||
archive.size() > biology::max_archive_bytes || site_count > max_primitive_lives ||
life_count > biology::max_cellular_tick_lives ||
corpse_count > biology::max_archived_organisms ||
external_count > biology::max_archived_organisms ||
state_->offspring_revisions.size() > biology::max_archived_genomes ||
(!inheritance && !state_->offspring_revisions.empty()))
throw std::length_error{"cellular lives checkpoint exceeds its format bounds"};
std::vector<std::uint8_t> bytes;
bytes.reserve(total_bytes);
Writer out{bytes};
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
: state_->format_version == cellular_lives_bud_format ? cellular_lives_v5_magic
: state_->format_version == cellular_lives_presence_format ? cellular_lives_v6_magic
: revamp ? cellular_lives_v11_magic
: liquid ? cellular_lives_v10_magic
: lit ? cellular_lives_v9_magic
: inheritance ? cellular_lives_v8_magic
: migration ? cellular_lives_v7_magic
: cellular_lives_v2_magic;
out.put(magic);
out.put(state_->format_version, 4);
out.put(state_->rules_version, 4);
out.put(state_->world);
out.put(state_->region);
out.put(state_->frame);
out.put(state_->config.tick);
out.put(state_->config.area.width_um, 4);
out.put(state_->config.area.height_um, 4);
out.put(state_->config.ambient_temperature_millikelvin, 4);
out.put(site_count, 4);
out.put(life_count, 4);
out.put(corpse_count, 4);
out.put(habitat.size(), 4);
out.put(archive.size(), 4);
out.put(0, 4);
out.put(state_->nursery_config.source);
out.inventory(state_->opening_total);
out.inventory(state_->nursery);
out.inventory(state_->heat);
if (parents)
out.put(state_->next_bud_sequence);
if (migration) {
out.inventory(state_->boundary.incoming);
out.inventory(state_->boundary.outgoing);
out.put(external_count, 4);
out.put(0, 4);
}
if (inheritance) {
out.put(state_->offspring_revisions.size(), 4);
out.put(0, 4);
}
if (lit) {
out.put(state_->light.numerator);
out.put(state_->light.denominator);
out.put(state_->light.entitlement.value);
out.put(state_->light.moving_per_thousand, 4);
out.put(0, 4);
out.put(state_->captured.value);
}
if (liquid) {
const auto& c = state_->liquid.currents;
const auto& f = state_->liquid.founder;
const auto& d = state_->liquid.deposits;
out.put(c.seed);
for (const auto value :
{c.width_um, c.height_um, c.pitch_um, c.min_count, c.max_count, c.min_route_width_um,
c.max_route_width_um, c.min_speed_um_per_s, c.max_speed_um_per_s})
out.put(value, 4);
for (const auto value : {f.thrust_q10, f.reverse_thrust_q10, f.forward_drag_ppm,
f.lateral_drag_ppm, static_cast<std::uint32_t>(f.turn)})
out.put(value, 4);
out.put(d.drift_radius_um, 4);
out.put(static_cast<std::uint32_t>(d.max_drift_q10), 4);
out.put(d.drift_decay_ppm, 4);
out.put(d.merged_cap, 4);
out.put(d.bubble_radius_um, 4);
// Thrust cost share; zero stands for the original 1,000 per mille.
const auto cost = state_->liquid.thrust_cost_per_mille;
out.put(cost == 1'000 ? 0 : cost, 4);
}
if (revamp) {
const auto& r = state_->revamp;
out.put(r.body.essential_upkeep_per_thousand, 4);
// Formerly reserved: collection per cent (0 for the original 100) and the even split
// in bit 16. Regions opened before these keys hold zero and keep their meaning.
out.put((r.step.collection_percent == 100 ? 0U : r.step.collection_percent) |
(r.step.split_evenly ? 0x10000U : 0U),
4);
for (const auto rate : r.burn_pj_per_kfg)
out.put(rate);
out.put(r.step.membrane_collection_per_mille_per_point, 4);
out.put(r.step.engulf_ratio_milli, 4);
out.put(r.step.engulf_reserve_percent, 4);
out.put(r.step.kill_bubble_per_thousand, 4);
out.put(r.drip_interval_ticks, 4);
out.put(r.reserve_load_per_thousand, 4);
out.put(r.drip_bubble_pj);
out.put(r.drip_bubble_fg);
out.inventory(state_->spent);
write_revamp_offers(out, r);
}
for (const auto site : state_->nursery_config.sites)
out.site(site);
for (const auto& life : state_->lives) {
out.bytes(life.account);
out.put(life.identity.life);
out.put(life.identity.organism);
out.put(life.identity.genome);
out.put(life.identity.event);
out.put(life.identity.born.value);
out.put(life.source);
out.put(life.growth.realized_per_thousand, 4);
out.put(life.growth.damage_per_thousand, 4);
out.put(life.position.x_um);
out.put(life.position.y_um);
out.inventory(life.body);
out.inventory(life.reserve);
if (state_->format_version >= cellular_lives_format) {
const auto& mutation = life.mutation;
out.put(mutation.fed_energy_credit_pj);
out.put(mutation.event_index);
out.put(mutation.offer_tick);
out.put(mutation.offer ? mutation.offer->parent : 0);
out.put(mutation.offer ? mutation.offer->parent_digest : 0);
out.put(mutation.offer ? mutation.offer->context.seed : 0);
out.put(mutation.offer ? mutation.offer->context.stream : 0, 4);
out.put(mutation.offer ? mutation.offer->context.event_index : 0);
out.put(mutation.offer ? mutation.offer->context.candidate_count : 0, 2);
out.put(0, 2);
out.put(mutation.offer ? mutation.offer->context.growth.realized_per_thousand : 0, 4);
out.put(mutation.offer ? mutation.offer->context.growth.damage_per_thousand : 0, 4);
out.put(mutation.offer ? mutation.offer->context.environment.temperature_millikelvin
: 0,
4);
out.put(0, 4);
out.inventory(mutation.offer ? mutation.offer->context.environment.available
: accounting::Inventory{});
for (std::size_t index = 0; index < biology::max_candidates; ++index) {
if (mutation.offer && index < mutation.offer->candidates.size()) {
const auto& candidates = mutation.offer.value().candidates;
const auto& candidate = candidates[index];
out.put(candidate.operator_id, 2);
out.put(static_cast<std::uint8_t>(candidate.target), 1);
out.put(static_cast<std::uint8_t>(candidate.effect), 1);
out.put(candidate.parameter, 4);
out.put(candidate.maintenance);
out.put(candidate.total_mass);
} else {
out.zeros(24);
}
}
}
if (parents)
out.put(life.parent_life);
if (presence) {
out.put(static_cast<std::uint8_t>(life.presence), 1);
out.zeros(7);
out.put(life.frozen_since);
}
if (inheritance)
out.put(life.offspring_genome);
if (liquid) {
out.put(static_cast<std::uint32_t>(life.motion.velocity_x_q10), 4);
out.put(static_cast<std::uint32_t>(life.motion.velocity_y_q10), 4);
out.put(life.motion.heading, 2);
out.put(0, 2);
out.put(static_cast<std::uint64_t>(life.motion.remainder_x), 4);
out.put(static_cast<std::uint64_t>(life.motion.remainder_y), 4);
}
if (revamp)
write_revamp_life(out, life.revamp);
}
for (const auto& corpse : state_->corpses) {
out.put(corpse.life_id);
out.put(corpse.organism);
out.put(corpse.source);
out.put(corpse.died_tick);
out.put(corpse.position.x_um);
out.put(corpse.position.y_um);
out.put(corpse.growth.realized_per_thousand, 4);
out.put(corpse.growth.damage_per_thousand, 4);
out.put(corpse.extent_um, 4);
out.inventory(corpse.inventory);
if (causes) {
out.put(static_cast<std::uint8_t>(corpse.cause), 1);
out.zeros(7);
out.put(corpse.predator_life);
}
if (parents)
out.put(corpse.parent_life);
if (inheritance)
out.put(corpse.offspring_genome);
}
out.raw(habitat);
out.raw(archive);
if (migration)
for (const auto id : state_->boundary.nonresident_organisms)
out.put(id);
if (inheritance)
for (const auto& revision : state_->offspring_revisions) {
out.put(revision.life);
out.put(revision.previous);
out.put(revision.successor);
out.put(revision.tick);
}
if (bytes.size() + 8 != total_bytes)
throw std::logic_error{"cellular lives checkpoint size calculation mismatch"};
out.put(checksum(bytes));
return bytes;
}
std::expected<std::vector<biology::CellularPatchPerception>, CellularLivesError>
CellularLives::perceive(std::uint64_t life_id) const {
const auto life = std::ranges::find(state_->lives, life_id,
[](const auto& owned) { return owned.identity.life; });
if (life == state_->lives.end())
return std::unexpected{CellularLivesError::invalid_life};
const auto budget =
budget_for(state_->archive, *life, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!budget)
return std::unexpected{budget.error()};
auto view = state_->habitat->perceive(life->position, budget->phenotype.extent);
if (!view)
return std::unexpected{CellularLivesError::habitat};
return std::move(*view);
}
std::expected<std::optional<biology::MutationOffer>, CellularLivesError>
CellularLives::mutation_offer(std::uint64_t life_id) const {
const auto life = std::ranges::find(state_->lives, life_id,
[](const auto& owned) { return owned.identity.life; });
if (life == state_->lives.end())
return std::unexpected{CellularLivesError::invalid_life};
return life->mutation.offer;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::migrate_to_v2() const {
if (state_->format_version != cellular_lives_legacy_format || state_->rules_version != 1)
return std::unexpected{CellularLivesError::version};
auto lives = state_->lives;
for (auto& life : lives)
life.mutation = {};
auto habitat = biology::CellularHabitat::restore(state_->habitat->snapshot(), state_->world,
state_->region, state_->frame);
if (!habitat)
return std::unexpected{CellularLivesError::habitat};
auto candidate = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
state_->world, state_->region, state_->frame, state_->config, state_->nursery_config,
std::move(*habitat), std::move(lives), state_->corpses, state_->archive, state_->nursery,
state_->heat, state_->opening_total, state_->current_total, cellular_lives_format,
cellular_lives_rules)}};
return candidate;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::migrate_to_v3() const {
if (state_->format_version != cellular_lives_format ||
state_->rules_version != cellular_lives_rules ||
state_->archive.format_version() != biology::lineage_archive_format)
return std::unexpected{CellularLivesError::version};
auto archive = state_->archive;
archive.upgrade_to_revision_format();
auto habitat = biology::CellularHabitat::restore(state_->habitat->snapshot(), state_->world,
state_->region, state_->frame);
if (!habitat)
return std::unexpected{CellularLivesError::habitat};
const auto current =
validate_state(state_->world, state_->region, state_->frame, state_->config,
state_->nursery_config, **habitat, state_->lives, state_->corpses, archive,
state_->nursery, state_->heat, state_->opening_total);
if (!current || *current != state_->current_total)
return std::unexpected{current ? CellularLivesError::conservation : current.error()};
auto candidate = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
state_->world, state_->region, state_->frame, state_->config, state_->nursery_config,
std::move(*habitat), state_->lives, state_->corpses, archive, state_->nursery, state_->heat,
state_->opening_total, state_->current_total, cellular_lives_revision_format,
cellular_lives_rules)}};
return candidate;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) const {
if (request.action == 0 ||
std::ranges::all_of(request.account, [](std::uint8_t value) { return value == 0; }))
return std::unexpected{CellularLivesError::invalid_life};
if (allocation.life == 0 || allocation.life != allocation.organism ||
allocation.life != allocation.genome || allocation.life != allocation.event)
return std::unexpected{CellularLivesError::identity};
if (allocation.born.value == 0 || allocation.born.value != state_->config.tick)
return std::unexpected{CellularLivesError::invalid_tick};
if (state_->lives.size() >= biology::max_cellular_tick_lives)
return std::unexpected{CellularLivesError::no_placement};
if (std::ranges::any_of(state_->lives, [&](const CellularOwnedLife& life) {
return life.account == request.account;
}))
return std::unexpected{CellularLivesError::life_exists};
if (std::ranges::any_of(state_->lives,
[&](const CellularOwnedLife& life) {
return life.identity.life == allocation.life ||
life.identity.organism == allocation.organism ||
life.identity.genome == allocation.genome ||
life.identity.event == allocation.event;
}) ||
std::ranges::any_of(state_->corpses,
[&](const CellularOwnedCorpse& corpse) {
return corpse.life_id == allocation.life ||
corpse.organism == allocation.organism;
}) ||
state_->archive.find(allocation.genome) || state_->archive.organism(allocation.organism))
return std::unexpected{CellularLivesError::duplicate_life};
// Rules 6 found version-2 founders: lower construction energy, finer mutations.
const auto founder_version = cellular_founder_version(state_->rules_version);
const auto endowed = biology::primitive_endowment(founder_version);
const auto genome =
biology::primitive_founder(allocation.genome, allocation.event, founder_version);
if (!endowed || !genome)
return std::unexpected{CellularLivesError::biology};
const auto budget = biology::metabolic_budget(
*genome, endowed->growth, {state_->config.ambient_temperature_millikelvin, {}});
if (!budget || budget->body != endowed->body)
return std::unexpected{CellularLivesError::biology};
// Rules 12: a new founder starts at a seeded random spot anywhere in the region (1 mm
// clear of its edges), so starts spread out; the provisioned sites remain the fallback.
// Seeded by world, region and the life's identity, so replay places it identically.
std::vector<biology::CellularPosition> candidates;
if (state_->rules_version >= cellular_lives_liquid_rules) {
constexpr std::uint64_t margin = 1'000;
const auto& area = state_->config.area;
if (area.width_um > 2 * margin + budget->phenotype.extent &&
area.height_um > 2 * margin + budget->phenotype.extent) {
Random random{
mutation_seed(state_->world, state_->region, allocation.life, 0x5350574EU)};
const auto span_x = area.width_um - 2 * margin - budget->phenotype.extent;
const auto span_y = area.height_um - 2 * margin - budget->phenotype.extent;
for (int attempt = 0; attempt < 16; ++attempt)
candidates.push_back(
{margin + random.next() % span_x, margin + random.next() % span_y});
}
}
for (const auto site : state_->nursery_config.sites) {
if (site.x_um < 0 || site.y_um < 0)
return std::unexpected{CellularLivesError::invalid_config};
candidates.push_back(
{static_cast<std::uint64_t>(site.x_um), static_cast<std::uint64_t>(site.y_um)});
}
std::optional<biology::CellularPosition> position;
for (const auto candidate : candidates) {
bool occupied = false;
for (const auto& living : state_->lives) {
if (living.presence == CellularPresence::suspended)
continue; // Out of the world (ADR-0128).
const auto living_budget =
budget_for(state_->archive, living, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!living_budget)
return std::unexpected{living_budget.error()};
const auto separated = [](std::uint64_t left, std::uint64_t right,
std::uint32_t left_extent,
std::uint32_t right_extent) noexcept {
return left < right ? right - left >= left_extent : left - right >= right_extent;
};
if (!separated(candidate.x_um, living.position.x_um, budget->phenotype.extent,
living_budget->phenotype.extent) &&
!separated(candidate.y_um, living.position.y_um, budget->phenotype.extent,
living_budget->phenotype.extent)) {
occupied = true;
break;
}
}
if (!occupied) {
position = candidate;
break;
}
}
if (!position)
return std::unexpected{CellularLivesError::no_placement};
auto nursery = state_->nursery;
if (!subtract_inventory(nursery, endowed->body) ||
!subtract_inventory(nursery, endowed->reserve) ||
endowed->construction.value > nursery.energy.value)
return std::unexpected{CellularLivesError::insufficient_funding};
nursery.energy.value -= endowed->construction.value;
auto heat = state_->heat;
if (endowed->construction.value > std::numeric_limits<std::uint64_t>::max() - heat.energy.value)
return std::unexpected{CellularLivesError::overflow};
heat.energy.value += endowed->construction.value;
auto archive = state_->archive;
if (!archive.admit(*genome) ||
!archive.record_birth(allocation.organism, allocation.genome, allocation.born))
return std::unexpected{CellularLivesError::archive};
auto lives = state_->lives;
lives.push_back({request.account, allocation, state_->nursery_config.source, endowed->growth,
*position, endowed->body, endowed->reserve});
if (state_->format_version >= cellular_lives_inheritance_format)
lives.back().offspring_genome = allocation.genome;
std::ranges::sort(lives, {}, [](const CellularOwnedLife& life) { return life.identity.life; });
auto nursery_config = state_->nursery_config;
nursery_config.funding = nursery;
auto habitat = biology::CellularHabitat::restore(state_->habitat->snapshot(), state_->world,
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,
state_->rules_version >= cellular_lives_engulf_rules,
state_->rules_version >= cellular_lives_bud_rules, state_->next_bud_sequence,
state_->rules_version >= cellular_lives_presence_rules,
state_->format_version >= cellular_lives_migration_format ? &state_->boundary : nullptr,
state_->format_version >= cellular_lives_inheritance_format ? &state_->offspring_revisions
: nullptr,
state_->spent, state_->rules_version >= cellular_lives_revamp_rules);
if (!current)
return std::unexpected{current.error()};
auto candidate = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
state_->world, state_->region, state_->frame, state_->config, std::move(nursery_config),
std::move(*habitat), std::move(lives), state_->corpses, archive, nursery, heat,
state_->opening_total, *current, state_->format_version, state_->rules_version,
state_->boundary)}};
candidate->last_tick_feedback_ = last_tick_feedback_;
candidate->state_->next_bud_sequence = state_->next_bud_sequence;
candidate->state_->offspring_revisions = state_->offspring_revisions;
candidate->state_->light = state_->light;
candidate->state_->captured = state_->captured;
candidate->state_->liquid = state_->liquid;
candidate->state_->field = state_->field;
candidate->state_->revamp = state_->revamp;
candidate->state_->spent = state_->spent;
return candidate;
}
std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
std::uint64_t region, std::uint64_t frame, std::uint64_t tick) {
if (bytes.size() < cellular_lives_header_bytes + 8 || bytes.size() > max_cellular_lives_bytes)
return std::unexpected{CellularLivesError::format};
Reader tail{bytes.last(8)};
if (checksum(bytes.first(bytes.size() - 8)) != tail.get())
return std::unexpected{CellularLivesError::checksum};
Reader in{bytes};
const auto magic = in.get();
const auto format_version = static_cast<std::uint32_t>(in.get(4));
const auto rules_version = static_cast<std::uint32_t>(in.get(4));
const bool legacy = magic == cellular_lives_v1_magic &&
format_version == cellular_lives_legacy_format && rules_version == 1;
const bool offer_version = magic == cellular_lives_v2_magic &&
format_version == cellular_lives_format &&
rules_version == cellular_lives_rules;
// Format 6 carries rules 5, 6 (founder 2) or 7 (founder 3, ADR-0137); no new state.
// Format 9 is exactly rules 11; format 8 exactly rules 10.
// Format 10 is exactly rules 12.
// Format 11 is exactly rules 13, and carries everything format 10 does.
const bool revamp_version = magic == cellular_lives_v11_magic &&
format_version == cellular_lives_revamp_format &&
rules_version == cellular_lives_revamp_rules;
const bool liquid_version = revamp_version || (magic == cellular_lives_v10_magic &&
format_version == cellular_lives_liquid_format &&
rules_version == cellular_lives_liquid_rules);
const bool light_version =
liquid_version ||
(magic == cellular_lives_v9_magic && format_version == cellular_lives_light_format &&
rules_version == cellular_lives_photosynthesis_rules);
const bool inheritance_version =
light_version ||
(magic == cellular_lives_v8_magic && format_version == cellular_lives_inheritance_format &&
rules_version == cellular_lives_inheritance_rules);
const bool migration_version =
inheritance_version ||
(magic == cellular_lives_v7_magic && format_version == cellular_lives_migration_format &&
(rules_version == cellular_lives_foraging_rules ||
rules_version == cellular_lives_maturation_rules));
const bool presence_version =
migration_version ||
(magic == cellular_lives_v6_magic && format_version == cellular_lives_presence_format &&
(rules_version == cellular_lives_presence_rules ||
rules_version == cellular_lives_balance_rules ||
rules_version == cellular_lives_reproduction_rules ||
rules_version == cellular_lives_foraging_rules));
// Formats 5 and 6 carry the bud sequence and parent lives (rules 4 and 5).
const bool bud_version = presence_version || (magic == cellular_lives_v5_magic &&
format_version == cellular_lives_bud_format &&
rules_version == cellular_lives_bud_rules);
// Formats 4 and 5 record death causes and leave detritus (rules 3 and 4).
const bool engulf_version = bud_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};
if (migration_version && bytes.size() < cellular_lives_v7_header_bytes + 8)
return std::unexpected(CellularLivesError::format);
if (inheritance_version && bytes.size() < cellular_lives_v8_header_bytes + 8)
return std::unexpected(CellularLivesError::format);
if (light_version && bytes.size() < cellular_lives_v9_header_bytes + 8)
return std::unexpected(CellularLivesError::format);
if (liquid_version && bytes.size() < cellular_lives_v10_header_bytes + 8)
return std::unexpected(CellularLivesError::format);
if (revamp_version && bytes.size() < cellular_lives_v11_header_bytes + 8)
return std::unexpected(CellularLivesError::format);
const auto saved_world = in.get();
const auto saved_region = in.get();
const auto saved_frame = in.get();
const auto saved_tick = in.get();
if (saved_world != world || saved_region != region || saved_frame != frame)
return std::unexpected{CellularLivesError::identity};
if (saved_tick != tick)
return std::unexpected{CellularLivesError::invalid_tick};
CellularLivesConfig config;
config.area.width_um = static_cast<std::uint32_t>(in.get(4));
config.area.height_um = static_cast<std::uint32_t>(in.get(4));
config.tick = saved_tick;
config.ambient_temperature_millikelvin = static_cast<std::uint32_t>(in.get(4));
const auto site_count = in.get(4);
const auto life_count = in.get(4);
const auto corpse_count = in.get(4);
const auto habitat_size = in.get(4);
const auto archive_size = in.get(4);
if (in.get(4) != 0 || site_count == 0 || site_count > max_primitive_lives ||
life_count > biology::max_cellular_tick_lives ||
corpse_count > biology::max_archived_organisms ||
habitat_size > biology::max_cellular_habitat_bytes ||
archive_size > biology::max_archive_bytes)
return std::unexpected{CellularLivesError::format};
const auto source = in.get();
const auto opening_total = in.inventory();
const auto nursery = in.inventory();
const auto heat = in.inventory();
const auto next_bud_sequence = bud_version ? in.get() : std::uint64_t{1};
CellularBoundaryLedger boundary;
std::uint64_t nonresident_count = 0;
if (migration_version) {
boundary.incoming = in.inventory();
boundary.outgoing = in.inventory();
nonresident_count = in.get(4);
if (in.get(4) != 0 || nonresident_count > biology::max_archived_organisms)
return std::unexpected(CellularLivesError::format);
}
std::uint64_t plan_count = 0;
if (inheritance_version) {
plan_count = in.get(4);
if (in.get(4) != 0 || plan_count > biology::max_archived_genomes)
return std::unexpected{CellularLivesError::format};
}
CellularLight light{};
accounting::Picojoules captured{};
if (light_version) {
light.numerator = in.get();
light.denominator = in.get();
light.entitlement.value = in.get();
light.moving_per_thousand = static_cast<std::uint32_t>(in.get(4));
const auto reserved = in.get(4);
captured.value = in.get();
if (reserved != 0 || !cellular_light_valid(light) ||
captured.value > light.entitlement.value)
return std::unexpected{CellularLivesError::format};
}
CellularLiquidRules liquid{};
std::shared_ptr<const biology::CellularFlowField> field;
if (liquid_version) {
auto& c = liquid.currents;
auto& f = liquid.founder;
auto& d = liquid.deposits;
const auto u32 = [&in] { return static_cast<std::uint32_t>(in.get(4)); };
c.seed = in.get();
c.width_um = u32();
c.height_um = u32();
c.pitch_um = u32();
c.min_count = u32();
c.max_count = u32();
c.min_route_width_um = u32();
c.max_route_width_um = u32();
c.min_speed_um_per_s = u32();
c.max_speed_um_per_s = u32();
f.thrust_q10 = u32();
f.reverse_thrust_q10 = u32();
f.forward_drag_ppm = u32();
f.lateral_drag_ppm = u32();
const auto turn = u32();
f.turn = static_cast<std::uint16_t>(turn);
d.drift_radius_um = u32();
d.max_drift_q10 = static_cast<std::int32_t>(u32());
d.drift_decay_ppm = u32();
const auto cap = u32();
d.merged_cap = static_cast<std::uint16_t>(cap);
d.bubble_radius_um = u32();
const auto cost = u32();
liquid.thrust_cost_per_mille = cost == 0 ? 1'000 : cost;
if (cost == 1'000 || turn > 0xFFFFU || cap > 0xFFFFU ||
!cellular_liquid_valid(liquid, config.area))
return std::unexpected{CellularLivesError::format};
auto generated = biology::CellularFlowField::shared(liquid.currents);
if (!generated)
return std::unexpected{CellularLivesError::format};
field = std::move(*generated);
}
CellularRevampRules revamp{};
accounting::Inventory spent{};
if (revamp_version) {
const auto u32 = [&in] { return static_cast<std::uint32_t>(in.get(4)); };
revamp.body.essential_upkeep_per_thousand = u32();
const auto feeding = in.get(4);
revamp.step.collection_percent =
(feeding & 0xFFFFU) == 0 ? 100U : static_cast<std::uint32_t>(feeding & 0xFFFFU);
revamp.step.split_evenly = (feeding & 0x10000U) != 0;
for (auto& rate : revamp.burn_pj_per_kfg)
rate = in.get();
revamp.step.membrane_collection_per_mille_per_point = u32();
revamp.step.engulf_ratio_milli = u32();
revamp.step.engulf_reserve_percent = u32();
revamp.step.kill_bubble_per_thousand = u32();
revamp.drip_interval_ticks = u32();
revamp.reserve_load_per_thousand = u32();
revamp.drip_bubble_pj = in.get();
revamp.drip_bubble_fg = in.get();
spent = in.inventory();
if (!read_revamp_offers(in, revamp) || (feeding & ~0x1FFFFULL) != 0 ||
(feeding & 0xFFFFU) == 100 || !cellular_revamp_valid(revamp))
return std::unexpected{CellularLivesError::format};
}
const auto life_bytes =
revamp_version
? cellular_life_v6_bytes + 8 + cellular_life_motion_bytes + cellular_life_revamp_bytes
: liquid_version ? cellular_life_v6_bytes + 8 + cellular_life_motion_bytes
: inheritance_version ? cellular_life_v6_bytes + 8
: legacy ? cellular_life_v1_bytes
: presence_version ? cellular_life_v6_bytes
: bud_version ? cellular_life_v5_bytes
: cellular_life_v2_bytes;
const auto corpse_bytes = inheritance_version ? cellular_corpse_v5_bytes + 8
: bud_version ? cellular_corpse_v5_bytes
: engulf_version ? cellular_corpse_v4_bytes
: cellular_corpse_bytes;
const auto expected_size = (revamp_version ? cellular_lives_v11_header_bytes
: liquid_version ? cellular_lives_v10_header_bytes
: light_version ? cellular_lives_v9_header_bytes
: inheritance_version ? cellular_lives_v8_header_bytes
: migration_version ? cellular_lives_v7_header_bytes
: bud_version ? cellular_lives_v5_header_bytes
: cellular_lives_header_bytes) +
cellular_site_bytes * site_count + life_bytes * life_count +
corpse_bytes * corpse_count + habitat_size + archive_size +
nonresident_count * 8 +
plan_count * cellular_offspring_revision_bytes + 8;
if (source == 0 || next_bud_sequence == 0 || expected_size != bytes.size())
return std::unexpected{CellularLivesError::format};
NurseryConfig nursery_config{saved_world, saved_region, saved_frame, source, nursery, {}};
nursery_config.sites.reserve(static_cast<std::size_t>(site_count));
for (std::uint64_t i = 0; i < site_count; ++i)
nursery_config.sites.push_back(in.site());
std::vector<CellularOwnedLife> lives;
lives.reserve(static_cast<std::size_t>(life_count));
for (std::uint64_t i = 0; i < life_count; ++i) {
CellularOwnedLife life{};
life.account = in.bytes<16>();
life.identity.life = in.get();
life.identity.organism = in.get();
life.identity.genome = in.get();
life.identity.event = in.get();
life.identity.born.value = in.get();
life.source = in.get();
life.growth.realized_per_thousand = static_cast<std::uint32_t>(in.get(4));
life.growth.damage_per_thousand = static_cast<std::uint32_t>(in.get(4));
life.position = {in.get(), in.get()};
life.body = in.inventory();
life.reserve = in.inventory();
if (mutation_version) {
auto& mutation = life.mutation;
mutation.fed_energy_credit_pj = in.get();
mutation.event_index = in.get();
mutation.offer_tick = in.get();
biology::MutationOffer offer{};
offer.parent = in.get();
offer.parent_digest = in.get();
offer.context.seed = in.get();
offer.context.stream = static_cast<std::uint32_t>(in.get(4));
offer.context.event_index = in.get();
const auto offered_count = static_cast<std::uint16_t>(in.get(2));
if (offered_count != 0)
offer.context.candidate_count = cellular_mutation_candidate_count;
const auto reserved16 = in.get(2);
offer.context.growth.realized_per_thousand = static_cast<std::uint32_t>(in.get(4));
offer.context.growth.damage_per_thousand = static_cast<std::uint32_t>(in.get(4));
offer.context.environment.temperature_millikelvin =
static_cast<std::uint32_t>(in.get(4));
const auto reserved32 = in.get(4);
offer.context.environment.available = in.inventory();
for (std::size_t slot = 0; slot < biology::max_candidates; ++slot) {
biology::MutationCandidate candidate{};
candidate.operator_id = static_cast<std::uint16_t>(in.get(2));
candidate.target = static_cast<biology::Capability>(in.get(1));
candidate.effect = static_cast<biology::MutationEffect>(in.get(1));
candidate.parameter = static_cast<std::uint32_t>(in.get(4));
candidate.maintenance = in.get();
candidate.total_mass = in.get();
if (slot < offered_count)
offer.candidates.push_back(candidate);
else if (candidate != biology::MutationCandidate{})
return std::unexpected{CellularLivesError::noncanonical};
}
const bool has_offer = mutation.offer_tick != 0;
if (reserved16 != 0 || reserved32 != 0 ||
(has_offer &&
(offer.parent == 0 || offer.parent_digest == 0 || offer.context.seed == 0 ||
offer.context.stream == 0 || offer.context.event_index != mutation.event_index ||
offered_count == 0 || offered_count > cellular_mutation_candidate_count ||
offer.candidates.size() != offered_count)) ||
(!has_offer && (offer.parent != 0 || offer.parent_digest != 0 ||
offer.context != biology::MutationContext{})))
return std::unexpected{CellularLivesError::noncanonical};
if (has_offer) {
mutation.offer = std::move(offer);
}
}
if (bud_version)
life.parent_life = in.get();
if (presence_version) {
const auto presence = in.get(1);
const auto padding = in.get(7);
life.frozen_since = in.get();
if (presence > static_cast<std::uint8_t>(CellularPresence::suspended) || padding != 0)
return std::unexpected{CellularLivesError::noncanonical};
life.presence = static_cast<CellularPresence>(presence);
}
if (inheritance_version)
life.offspring_genome = in.get();
if (liquid_version) {
life.motion.velocity_x_q10 =
static_cast<std::int32_t>(static_cast<std::uint32_t>(in.get(4)));
life.motion.velocity_y_q10 =
static_cast<std::int32_t>(static_cast<std::uint32_t>(in.get(4)));
life.motion.heading = static_cast<std::uint16_t>(in.get(2));
const auto padding = in.get(2);
life.motion.remainder_x = static_cast<std::int64_t>(in.get(4));
life.motion.remainder_y = static_cast<std::int64_t>(in.get(4));
if (padding != 0 || !valid_motion(life.motion))
return std::unexpected{CellularLivesError::noncanonical};
}
if (revamp_version) {
const auto state = read_revamp_life(in);
if (!state)
return std::unexpected{CellularLivesError::noncanonical};
life.revamp = *state;
}
lives.push_back(life);
}
std::vector<CellularOwnedCorpse> corpses;
corpses.reserve(static_cast<std::size_t>(corpse_count));
for (std::uint64_t i = 0; i < corpse_count; ++i) {
CellularOwnedCorpse corpse{};
corpse.life_id = in.get();
corpse.organism = in.get();
corpse.source = in.get();
corpse.died_tick = in.get();
corpse.position = {in.get(), in.get()};
corpse.growth.realized_per_thousand = static_cast<std::uint32_t>(in.get(4));
corpse.growth.damage_per_thousand = static_cast<std::uint32_t>(in.get(4));
corpse.extent_um = static_cast<std::uint32_t>(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<biology::CellularDeathCause>(cause);
const bool engulfed = corpse.cause == biology::CellularDeathCause::engulfed;
const bool revamp_cause =
revamp_version && (corpse.cause == biology::CellularDeathCause::merged ||
corpse.cause == biology::CellularDeathCause::emerged);
if (padding != 0 ||
(corpse.cause != biology::CellularDeathCause::starved && !engulfed &&
!revamp_cause) ||
engulfed != (corpse.predator_life != 0) || corpse.predator_life == corpse.life_id ||
corpse.inventory != accounting::Inventory{})
return std::unexpected{CellularLivesError::noncanonical};
}
if (bud_version)
corpse.parent_life = in.get();
if (inheritance_version)
corpse.offspring_genome = in.get();
corpses.push_back(corpse);
}
const auto habitat_payload = in.raw(static_cast<std::size_t>(habitat_size));
const auto archive_payload = in.raw(static_cast<std::size_t>(archive_size));
auto habitat =
biology::CellularHabitat::restore(habitat_payload, saved_world, saved_region, saved_frame);
if (!habitat) {
if (habitat.error() == biology::CellularHabitatError::version)
return std::unexpected{CellularLivesError::version};
if (habitat.error() == biology::CellularHabitatError::checksum)
return std::unexpected{CellularLivesError::checksum};
return std::unexpected{CellularLivesError::habitat};
}
// Rules 8 to 11 run on a deposit habitat, rules 12 on a liquid one (ADR-0136, rules 12).
const auto habitat_format = (*habitat)->config().format;
if ((rules_version >= cellular_lives_liquid_rules)
? habitat_format != biology::cellular_habitat_liquid_format
: (rules_version >= cellular_lives_foraging_rules) !=
(habitat_format == biology::cellular_habitat_deposit_format))
return std::unexpected{CellularLivesError::habitat};
auto archive = biology::LineageArchive::decode(archive_payload);
if (!archive) {
if (archive.error() == biology::ArchiveCodecError::version)
return std::unexpected{CellularLivesError::version};
if (archive.error() == biology::ArchiveCodecError::checksum)
return std::unexpected{CellularLivesError::checksum};
if (archive.error() == biology::ArchiveCodecError::noncanonical)
return std::unexpected{CellularLivesError::noncanonical};
return std::unexpected{CellularLivesError::archive};
}
if (migration_version) {
boundary.nonresident_organisms.reserve(static_cast<std::size_t>(nonresident_count));
for (std::uint64_t index = 0; index < nonresident_count; ++index)
boundary.nonresident_organisms.push_back(in.get());
}
std::vector<CellularOffspringRevision> plan_history;
plan_history.reserve(static_cast<std::size_t>(plan_count));
for (std::uint64_t index = 0; index < plan_count; ++index)
plan_history.push_back({in.get(), in.get(), in.get(), in.get()});
if (archive->format_version() != (revision_version ? biology::lineage_archive_revision_format
: biology::lineage_archive_format))
return std::unexpected{CellularLivesError::version};
if (mutation_version) {
for (const auto& life : lives) {
if (!life.mutation.offer)
continue;
const auto genome = archive->find(cellular_offspring_genome(life));
if (!genome)
return std::unexpected{CellularLivesError::archive};
const auto& offer = *life.mutation.offer;
if (life.mutation.event_index == 0 || life.mutation.offer_tick == 0 ||
life.mutation.offer_tick > saved_tick ||
offer.parent != cellular_offspring_genome(life) ||
offer.context.seed != mutation_seed(saved_world, saved_region, life.identity.life,
life.mutation.event_index) ||
offer.context.stream != cellular_mutation_stream ||
offer.context.event_index != life.mutation.event_index ||
offer.context.environment.temperature_millikelvin !=
config.ambient_temperature_millikelvin)
return std::unexpected{CellularLivesError::noncanonical};
const auto generated = biology::mutation_candidates(*genome, offer.context);
if (!generated || *generated != offer)
return std::unexpected{CellularLivesError::noncanonical};
}
}
const auto current = validate_state(
saved_world, saved_region, saved_frame, config, nursery_config, **habitat, lives, corpses,
*archive, nursery, heat, opening_total, engulf_version, bud_version, next_bud_sequence,
presence_version, migration_version ? &boundary : nullptr,
inheritance_version ? &plan_history : nullptr, spent, revamp_version);
if (!current)
return std::unexpected{current.error()};
auto restored = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
saved_world, saved_region, saved_frame, config, std::move(nursery_config),
std::move(*habitat), std::move(lives), std::move(corpses), *archive, nursery, heat,
opening_total, *current, format_version, rules_version, std::move(boundary))}};
restored->state_->next_bud_sequence = next_bud_sequence;
restored->state_->offspring_revisions = std::move(plan_history);
restored->state_->light = light;
restored->state_->captured = captured;
restored->state_->liquid = liquid;
restored->state_->field = std::move(field);
restored->state_->revamp = revamp;
restored->state_->spent = spent;
if (!std::ranges::equal(bytes, restored->snapshot()))
return std::unexpected{CellularLivesError::noncanonical};
return restored;
}
std::expected<biology::CellularRegionStepCandidate, CellularLivesError>
CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
auto execution =
advance_tick_with_mutations(intents, std::span<const CellularMutationSelection>{});
if (!execution)
return std::unexpected{execution.error()};
return std::move(execution->step);
}
std::expected<CellularTickExecution, CellularLivesError>
CellularLives::advance_tick_with_mutations(std::span<const CellularLifeIntent> intents,
std::span<const CellularMutationSelection> selections) {
if (state_->config.tick == std::numeric_limits<std::uint64_t>::max())
return std::unexpected{CellularLivesError::invalid_tick};
if (intents.size() != state_->lives.size())
return std::unexpected{CellularLivesError::invalid_intents};
std::vector<CellularLifeIntent> ordered{intents.begin(), intents.end()};
std::ranges::sort(ordered, {}, &CellularLifeIntent::life_id);
for (std::size_t i = 0; i < ordered.size(); ++i)
if ((i != 0 && ordered[i - 1].life_id == ordered[i].life_id) ||
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)
return std::unexpected{CellularLivesError::version};
// Rules 4 keep rules 3 (engulfment, detritus) and add budding (ADR-0125).
const bool engulf_rules = state_->rules_version >= cellular_lives_engulf_rules;
const bool contact_rules = state_->rules_version >= cellular_lives_foraging_rules;
const bool bud_rules = state_->rules_version >= cellular_lives_bud_rules;
const bool presence_rules = state_->rules_version >= cellular_lives_presence_rules;
const bool inheritance_rules = cellular_retained_plans(state_->rules_version);
const bool liquid_rules = state_->rules_version >= cellular_lives_liquid_rules;
const bool revamp_rules = state_->rules_version >= cellular_lives_revamp_rules;
if (liquid_rules && !state_->field)
return std::unexpected{CellularLivesError::invalid_config};
for (std::size_t i = 0; i < ordered.size(); ++i) {
const auto& intent = ordered[i].intent;
// Below rules 4 a bud is ignored, as engulfment is below rules 3 (ADR-0124/0125).
if (intent.bud && (intent.intake_target || intent.engulf))
return std::unexpected{CellularLivesError::invalid_intents};
// ADR-0128: only an owned life of a rules-5 region freezes, and a frozen intent
// carries nothing else.
if (intent.frozen && (!presence_rules || state_->lives[i].account == LifeAccount{} ||
intent.movement != biology::CellularIntent{} ||
intent.intake_target || intent.engulf || intent.bud || intent.brake))
return std::unexpected{CellularLivesError::invalid_intents};
if (intent.brake && !liquid_rules)
return std::unexpected{CellularLivesError::invalid_intents};
if (intent.become &&
(!revamp_rules || !intent.bud || state_->lives[i].account == LifeAccount{} ||
state_->lives[i].revamp.members > 1))
return std::unexpected{CellularLivesError::invalid_intents};
if (intent.emerge && (!revamp_rules || state_->lives[i].account == LifeAccount{} ||
intent.frozen || intent.bud || intent.engulf || intent.intake_target))
return std::unexpected{CellularLivesError::invalid_intents};
// Rules 13: exclusions are an owned life's setting, never wildlife's or a frozen cell's.
if (intent.exclude != 0 && (!revamp_rules || intent.exclude > 0x0F || intent.frozen ||
state_->lives[i].account == LifeAccount{}))
return std::unexpected{CellularLivesError::invalid_intents};
}
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 ||
selection.successor_id == 0 || // Operator 0 declines (ADR-0120 amendment).
(selection.become && !revamp_rules) || // Rules 13 only (ADR-0179).
(i != 0 && selections[i - 1].life_id >= selection.life_id))
return std::unexpected{CellularLivesError::invalid_intents};
const auto life = std::ranges::lower_bound(
state_->lives, selection.life_id, {},
[](const CellularOwnedLife& value) { return value.identity.life; });
// ADR-0121 amendment (schema 59): a queued choice can outlive its life; it binds
// with the life_died result and changes nothing.
if (life == state_->lives.end() || life->identity.life != selection.life_id) {
if (state_->archive.find(selection.successor_id))
return std::unexpected{CellularLivesError::mutation};
continue;
}
if (revamp_rules) {
// Rules 13: a choice names the life's own pending offer and one of its mutations.
const auto& pending = life->revamp.offer;
const auto ids = std::span{pending.ids}.first(pending.count);
if (pending.count == 0 || pending.event_index != selection.event_index ||
pending.offer_tick != selection.offer_tick ||
(selection.operator_id != 0 &&
std::ranges::find(ids, selection.operator_id) == ids.end()) ||
state_->archive.find(selection.successor_id))
return std::unexpected{CellularLivesError::mutation};
for (std::size_t j = 0; j < i; ++j)
if (selections[j].successor_id == selection.successor_id)
return std::unexpected{CellularLivesError::identity};
continue;
}
if (life->mutation.event_index != selection.event_index ||
life->mutation.offer_tick != selection.offer_tick)
return std::unexpected{CellularLivesError::mutation};
if (!life->mutation.offer.has_value())
return std::unexpected{CellularLivesError::mutation};
const auto offer = life->mutation.offer.value_or(biology::MutationOffer{});
if (offer.parent != cellular_offspring_genome(*life) ||
offer.context.event_index != selection.event_index ||
(selection.operator_id != 0 && !std::ranges::any_of(offer.candidates,
[&](const auto& candidate) {
return candidate.operator_id ==
selection.operator_id;
})) ||
state_->archive.find(selection.successor_id))
return std::unexpected{CellularLivesError::mutation};
for (std::size_t j = 0; j < i; ++j)
if (selections[j].successor_id == selection.successor_id)
return std::unexpected{CellularLivesError::identity};
}
std::vector<biology::CellularLifeStepInput> inputs;
inputs.reserve(state_->lives.size());
for (std::size_t i = 0; i < state_->lives.size(); ++i) {
const auto& life = state_->lives[i];
if (life.presence == CellularPresence::suspended)
continue; // Out of the world: no step, no contact (ADR-0128).
const auto budget =
budget_for(state_->archive, life, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
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,
ordered[i].intent,
life.body,
life.reserve,
{},
*budget,
*membrane,
life.source});
if (liquid_rules) {
auto handling = cellular_liquid_handling(*genome, *budget, state_->liquid);
if (!handling)
return std::unexpected{CellularLivesError::biology};
if (revamp_rules) {
// Rules 13: reserve matter is carried as load.
std::uint64_t carried{};
for (const auto& channel : life.reserve.matter)
carried += channel.value;
const auto members = std::uint64_t{life.revamp.members};
const auto extra = budget->phenotype.total_mass / members * (members - 1) / 1'000 *
state_->revamp.organism_load_per_thousand;
*handling = cellular_loaded_handling(*handling, budget->phenotype.total_mass,
carried, state_->revamp, extra);
}
inputs.back().liquid = biology::CellularLiquidInput{
life.motion, *handling,
state_->field->at_footprint(life.position, budget->phenotype.extent),
ordered[i].intent.brake};
}
if (revamp_rules) {
// Rules 13: the genome's traits; a life from before the upgrade (no traits, the
// membrane in micrometres) feeds and burns as a founder and keeps all bubble energy.
biology::CellularRevampLifeInput revamp{};
const auto& traits = genome->cellular_traits();
const auto kept = genome->parameter(biology::Capability::energy_conversion);
if (traits) {
revamp.burn = biology::cellular_burn(state_->revamp.burn_pj_per_kfg, traits->burn,
ordered[i].intent.exclude);
revamp.collection = traits->collection;
revamp.energy_kept_per_thousand = kept ? *kept : 1'000;
revamp.membrane_nm = *membrane;
revamp.engulf_capacity = traits->engulf_capacity;
revamp.kill_absorption = traits->kill_absorption;
} else {
revamp.burn =
biology::cellular_burn(state_->revamp.burn_pj_per_kfg, {100, 100, 100, 100},
ordered[i].intent.exclude);
revamp.membrane_nm = *membrane * 1'000;
}
inputs.back().revamp = revamp;
}
}
biology::CellularRegionRules region_rules{engulf_rules, contact_rules};
if (revamp_rules)
region_rules.revamp = state_->revamp.step;
auto proposal = biology::propose_cellular_region_step(state_->config.tick, state_->config.area,
inputs, *state_->habitat, region_rules);
if (!proposal)
return std::unexpected{CellularLivesError::region_step};
auto next_lives = state_->lives;
auto next_corpses = state_->corpses;
auto next_archive = state_->archive;
auto next_offspring_revisions = state_->offspring_revisions;
auto next_heat = state_->heat;
auto next_spent = state_->spent;
if (!add_inventory(next_spent, proposal->spent))
return std::unexpected{CellularLivesError::overflow};
auto habitat_config = state_->habitat->config();
// Rules 13: each owned life's activity this tick, gathered from every phase below and
// applied to its affinity at the end. Paid mutation costs wait to be reclaimed.
std::vector<std::pair<std::uint64_t, biology::CellularActivity>> activity;
const auto activity_of = [&activity](std::uint64_t life_id) -> biology::CellularActivity& {
const auto found = std::ranges::find(
activity, life_id, &std::pair<std::uint64_t, biology::CellularActivity>::first);
if (found != activity.end())
return found->second;
return activity.emplace_back(life_id, biology::CellularActivity{}).second;
};
std::vector<std::pair<accounting::Inventory, biology::CellularPosition>> reclaims;
for (const auto& result : proposal->lives) {
const auto found = std::ranges::lower_bound(
next_lives, result.life_id, {}, [](const auto& life) { return life.identity.life; });
if (found == next_lives.end() || found->identity.life != result.life_id)
return std::unexpected{CellularLivesError::invalid_life};
found->position = result.candidate.position;
found->reserve = result.candidate.reserve_after;
if (liquid_rules)
found->motion = result.candidate.motion;
if (!add_inventory(next_heat, result.candidate.heat_after))
return std::unexpected{CellularLivesError::overflow};
if (revamp_rules && found->account != LifeAccount{}) {
using S = biology::CellularSignal;
const auto& c = result.candidate;
auto& a = activity_of(result.life_id);
const bool thrust = c.movement_status == biology::CellularMovementStatus::moved ||
c.movement_status == biology::CellularMovementStatus::blocked;
a[S::thrust] = thrust ? 1 : 0;
a[S::drifting] = thrust ? 0 : 1;
const auto request =
std::ranges::lower_bound(ordered, result.life_id, {}, &CellularLifeIntent::life_id);
const bool brake = request != ordered.end() && request->life_id == result.life_id &&
request->intent.brake;
a[S::brake_press] = brake && found->revamp.last_brake == 0 ? 1 : 0;
found->revamp.last_brake = brake ? 1 : 0;
const auto acquired = c.intake ? c.intake->transfer.acquired : accounting::Inventory{};
std::uint64_t collected{}, burned{};
for (const auto& channel : acquired.matter)
collected += channel.value;
for (const auto& channel : c.spent.matter)
burned += channel.value;
a[S::fed] = collected != 0 || acquired.energy.value != 0 ? 1 : 0;
a[S::intake_limited] = c.matter_limited ? 1 : 0;
a[S::energy_limited] = c.energy_limited ? 1 : 0;
a[S::energy_collected] = acquired.energy.value;
a[S::collected_carbon] = acquired.matter[0].value;
a[S::collected_nitrogen] = acquired.matter[1].value;
a[S::collected_phosphorus] = acquired.matter[2].value;
a[S::collected_other] = acquired.matter[3].value;
a[S::collected_matter] = collected;
a[S::burned_carbon] = c.spent.matter[0].value;
a[S::burned_nitrogen] = c.spent.matter[1].value;
a[S::burned_phosphorus] = c.spent.matter[2].value;
a[S::burned_other] = c.spent.matter[3].value;
a[S::burned_matter] = burned;
a[S::burned_not_carbon] = burned - c.spent.matter[0].value;
a[S::energy_upkeep] = c.maintenance_cost.value;
a[S::energy_movement] = c.movement_cost.value;
a[S::energy_spent] = c.maintenance_cost.value + c.movement_cost.value;
const bool asked = request != ordered.end() && request->life_id == result.life_id &&
request->intent.engulf;
a[S::engulf_attempt] = asked ? 1 : 0;
a[S::engulf_success] = result.engulf == biology::CellularEngulfStatus::engulfed ? 1 : 0;
const bool too_large = result.engulf == biology::CellularEngulfStatus::prey_too_large;
a[S::engulf_too_large] = too_large ? 1 : 0;
a[S::engulf_too_large_or_membrane] =
too_large || result.engulf == biology::CellularEngulfStatus::membrane_too_thick ? 1
: 0;
a.heading = c.motion.heading;
found->revamp.progress.carbon_burned += c.spent.matter[0].value;
// Touching a cell over 1.5 times its own mass.
const auto own = std::ranges::lower_bound(inputs, result.life_id, {},
&biology::CellularLifeStepInput::life_id);
if (own != inputs.end() && own->life_id == result.life_id)
for (const auto& other : proposal->lives) {
if (other.life_id == result.life_id)
continue;
const auto input = std::ranges::lower_bound(
inputs, other.life_id, {}, &biology::CellularLifeStepInput::life_id);
if (input == inputs.end() || input->life_id != other.life_id ||
input->budget.phenotype.total_mass * 2 <=
own->budget.phenotype.total_mass * 3)
continue;
if (biology::cellular_footprints_contact(c.position, own->extent_um,
other.candidate.position,
input->extent_um)) {
a[S::larger_contact] = 1;
break;
}
}
}
// Only owned lives earn mutation offers; wildlife never mutates in M11 (ADR-0098).
// Rules 13 earn them from active play instead (below).
if (state_->format_version >= cellular_lives_format && result.candidate.intake &&
found->account != LifeAccount{} && !revamp_rules) {
const auto acquired = result.candidate.intake->transfer.acquired.energy.value;
if (acquired >
std::numeric_limits<std::uint64_t>::max() - found->mutation.fed_energy_credit_pj)
return std::unexpected{CellularLivesError::overflow};
found->mutation.fed_energy_credit_pj += acquired;
if (!found->mutation.offer) {
const auto budget =
budget_for(next_archive, *found, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!budget ||
budget->maintenance.value > std::numeric_limits<std::uint64_t>::max() /
cellular_mutation_surplus_seconds)
return std::unexpected{CellularLivesError::mutation};
const auto threshold =
budget->maintenance.value * cellular_mutation_surplus_seconds;
if (threshold == 0)
return std::unexpected{CellularLivesError::mutation};
if (found->mutation.fed_energy_credit_pj >= threshold) {
if (found->mutation.event_index == std::numeric_limits<std::uint64_t>::max())
return std::unexpected{CellularLivesError::overflow};
const auto genome = next_archive.find(cellular_offspring_genome(*found));
if (!genome)
return std::unexpected{CellularLivesError::archive};
const auto next_event = found->mutation.event_index + 1;
biology::MutationContext context{
mutation_seed(state_->world, state_->region, result.life_id, next_event),
cellular_mutation_stream,
next_event,
cellular_mutation_candidate_count,
found->growth,
{state_->config.ambient_temperature_millikelvin,
result.candidate.intake->transfer.patch_after}};
const auto offer = biology::mutation_candidates(*genome, context);
if (offer) {
found->mutation.fed_energy_credit_pj -= threshold;
found->mutation.event_index = next_event;
found->mutation.offer_tick = proposal->end_tick;
found->mutation.offer = *offer;
} else if (offer.error() != biology::MutationError::no_candidates) {
return std::unexpected{CellularLivesError::mutation};
}
}
}
}
}
for (const auto& dead : proposal->starved) {
const auto found = std::ranges::lower_bound(
next_lives, dead.life_id, {}, [](const auto& life) { return life.identity.life; });
if (found == next_lives.end() || found->identity.life != dead.life_id ||
!next_archive.record_death(found->identity.organism, {proposal->end_tick}))
return std::unexpected{CellularLivesError::archive};
auto single = *found;
single.revamp.members = 1; // A corpse records the single-cell extent.
const auto corpse_budget =
budget_for(next_archive, single, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!corpse_budget)
return std::unexpected{corpse_budget.error()};
if (revamp_rules && dead.cause == biology::CellularDeathCause::engulfed &&
found->parent_life != 0 &&
proposal->end_tick - found->identity.born.value <= cellular_bud_early_ticks)
activity_of(found->parent_life)[biology::CellularSignal::bud_lost_early] += 1;
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,
engulf_rules ? dead.cause : biology::CellularDeathCause::unrecorded,
engulf_rules ? dead.predator_id : 0, found->parent_life, found->offspring_genome});
next_lives.erase(found);
}
std::vector<CellularMutationExecution> mutation_results;
// Bud identities: rules-13 splits draw from the same sequence as buds.
auto next_bud_sequence = state_->next_bud_sequence;
mutation_results.reserve(selections.size());
for (const auto& selection : selections) {
const auto found = std::ranges::lower_bound(
next_lives, selection.life_id, {},
[](const CellularOwnedLife& value) { return value.identity.life; });
if (found == next_lives.end() || found->identity.life != selection.life_id) {
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::life_died});
continue;
}
if (revamp_rules) {
auto& pending = found->revamp.offer;
const auto plan = next_archive.find(cellular_offspring_genome(*found));
const auto expressed = next_archive.find(found->identity.genome);
if (pending.count == 0 || !plan || !expressed)
return std::unexpected{CellularLivesError::mutation};
const auto* spec = biology::cellular_mutation(selection.operator_id);
const auto draft = spec == nullptr
? std::nullopt
: biology::apply_cellular_mutation(
*plan, *spec, state_->revamp.mutations.at(spec->id - 1u),
state_->revamp.bounds, found->revamp.progress,
selection.successor_id, selection.successor_id);
if (selection.operator_id == 0 || !draft) {
// A decline, or a mutation no longer available, consumes the offer.
pending = {};
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::declined});
continue;
}
// The cost comes from the reserve: matter channels directly, energy with matter
// standing in (except excluded channels). Unaffordable: the offer stays.
const auto cost = cellular_mutation_cost(state_->revamp.mutations.at(spec->id - 1u));
auto reserve = found->reserve;
bool affordable = true;
for (std::size_t c = 0; c < reserve.matter.size(); ++c) {
if (reserve.matter[c].value < cost.matter[c].value)
affordable = false;
else
reserve.matter[c].value -= cost.matter[c].value;
}
const auto request = std::ranges::lower_bound(ordered, selection.life_id, {},
&CellularLifeIntent::life_id);
const auto exclude = request != ordered.end() && request->life_id == selection.life_id
? request->intent.exclude
: std::uint8_t{0};
const auto& traits = expressed->cellular_traits();
const auto burn = biology::cellular_burn(
state_->revamp.burn_pj_per_kfg,
traits ? traits->burn : std::array<std::uint16_t, 4>{100, 100, 100, 100}, exclude);
const auto payment =
affordable ? biology::cellular_pay(reserve, cost.energy.value, burn, false)
: std::nullopt;
if (!payment) {
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::insufficient_funding});
continue;
}
const auto successor = biology::Genome::create(*draft);
if (!successor)
return std::unexpected{CellularLivesError::mutation};
const auto price = [&]() -> std::uint64_t {
const auto rules = biology::rules_for(successor->development_version());
return rules ? rules->construction_per_kilogram : 0;
}();
if (found->revamp.members > 1) {
// A multicellular organism expresses the mutation as a whole (ADR-0179), its
// changed tissue funded from the shared reserve; "not now" when it cannot be.
const auto scaled = organism_genome(*successor, found->revamp.members);
const auto target = scaled
? biology::metabolic_budget(
*scaled, found->growth,
{state_->config.ambient_temperature_millikelvin, {}},
1000, state_->revamp.body)
: std::unexpected{biology::DevelopmentError::overflow};
auto body = found->body;
auto heat = accounting::Inventory{};
if (!target)
return std::unexpected{CellularLivesError::biology};
if (!rebody(body, reserve, heat, target->body, price)) {
// The offer stays, as for any unaffordable cost.
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::insufficient_funding});
continue;
}
if (!next_archive.record_mutation(found->identity.organism, *successor,
{proposal->end_tick}) ||
!add_inventory(next_heat, heat) || !add_inventory(next_spent, payment->spent))
return std::unexpected{CellularLivesError::archive};
auto returned = cost;
returned.energy.value = payment->energy;
reclaims.emplace_back(returned, found->position);
found->identity.genome = successor->id();
found->offspring_genome = successor->id();
found->body = body;
found->reserve = reserve;
pending = {};
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::applied});
continue;
}
if (spec->effect == biology::CellularEffect::acquire_adhesion) {
// Adhesion: the split's offspring attaches at once, so the cell becomes a
// two-member organism holding its whole body and reserve under the new plan. The
// single cell's life ends as merged; the player continues as the organism.
const auto temperature = state_->config.ambient_temperature_millikelvin;
const auto organism = organism_genome(*successor, 2);
if (!organism)
return std::unexpected{organism.error()};
const auto fit = biology::largest_growth_within(*organism, found->body, temperature,
state_->revamp.body);
if (!fit)
return std::unexpected{CellularLivesError::biology};
const auto identity = cellular_bud_identity(state_->region, next_bud_sequence);
const auto& formed = *fit;
if (!formed || identity == 0 || next_archive.organism(identity)) {
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::split_refused});
continue;
}
const auto grown = biology::metabolic_budget(
*organism, formed->first, {temperature, {}}, 1000, state_->revamp.body);
if (!grown)
return std::unexpected{CellularLivesError::biology};
const auto single_budget =
budget_for(next_archive, *found, temperature, state_->revamp.body);
if (!single_budget)
return std::unexpected{single_budget.error()};
if (!next_archive.admit(*successor) ||
!next_archive.record_birth(identity, successor->id(), {proposal->end_tick}) ||
!next_archive.record_death(found->identity.organism, {proposal->end_tick}))
return std::unexpected{CellularLivesError::archive};
if (!add_inventory(next_spent, payment->spent))
return std::unexpected{CellularLivesError::overflow};
auto returned = cost;
returned.energy.value = payment->energy;
reclaims.emplace_back(returned, found->position);
CellularOwnedLife whole{};
whole.account = found->account;
whole.identity = {
identity, identity, successor->id(), identity, {proposal->end_tick}};
whole.source = found->source;
whole.growth = formed->first;
whole.body = formed->second;
whole.reserve = reserve;
for (std::size_t c = 0; c < whole.body.matter.size(); ++c)
whole.reserve.matter[c].value +=
found->body.matter[c].value - formed->second.matter[c].value;
// Keep the larger body inside the region.
const auto extent = grown->phenotype.extent;
whole.position = found->position;
whole.position.x_um = std::min<std::uint64_t>(
whole.position.x_um, state_->config.area.width_um - extent);
whole.position.y_um = std::min<std::uint64_t>(
whole.position.y_um, state_->config.area.height_um - extent);
whole.motion = found->motion;
whole.parent_life = found->identity.life;
whole.offspring_genome = successor->id();
whole.revamp.affinity.score = found->revamp.affinity.score;
whole.revamp.progress = found->revamp.progress;
whole.revamp.members = 2;
next_corpses.push_back({found->identity.life,
found->identity.organism,
found->source,
proposal->end_tick,
found->position,
found->growth,
single_budget->phenotype.extent,
{},
biology::CellularDeathCause::merged,
0,
found->parent_life,
found->offspring_genome});
next_lives.erase(found);
++next_bud_sequence;
next_lives.insert(std::ranges::lower_bound(next_lives, identity, {},
[](const CellularOwnedLife& life) {
return life.identity.life;
}),
whole);
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::split_applied});
continue;
}
// The split (Cellular_reproduction_plan.md section 4): body and reserve divide, the
// offspring expresses the mutation, both plans carry it. Refused, spending nothing,
// when the cell is too small, has no room beside it, or the region is full.
const auto temperature = state_->config.ambient_temperature_millikelvin;
const auto child_share = state_->revamp.safety_version == 1 && !selection.become
? 1'000 - state_->revamp.split_share_per_thousand
: state_->revamp.split_share_per_thousand;
const auto split = biology::split_cell(
*expressed, *successor, found->growth, found->body, reserve, temperature,
child_share, state_->revamp.split_min_growth, state_->revamp.body);
if (!split && split.error() == biology::BuddingError::development)
return std::unexpected{CellularLivesError::biology};
const auto identity = cellular_bud_identity(state_->region, next_bud_sequence);
std::optional<biology::CellularPosition> spot;
std::uint16_t launch_heading{};
if (split) {
const auto shrunk = biology::metabolic_budget(
*expressed, split->parent_growth, {temperature, {}}, 1000, state_->revamp.body);
const auto born = biology::metabolic_budget(
*successor, split->child_growth, {temperature, {}}, 1000, state_->revamp.body);
if (!shrunk || !born)
return std::unexpected{CellularLivesError::biology};
const auto position = bud_position(
*found, shrunk->phenotype.extent, born->phenotype.extent, next_lives,
next_archive, state_->config, state_->revamp.split_launch_um_per_s / 20);
if (!position)
return std::unexpected{position.error()};
spot = *position;
if (spot && state_->revamp.safety_version == 1) {
const auto dx = 2 * (static_cast<std::int64_t>(spot->x_um) -
static_cast<std::int64_t>(found->position.x_um)) +
std::int64_t{born->phenotype.extent} - shrunk->phenotype.extent;
const auto dy = 2 * (static_cast<std::int64_t>(spot->y_um) -
static_cast<std::int64_t>(found->position.y_um)) +
std::int64_t{born->phenotype.extent} - shrunk->phenotype.extent;
launch_heading = biology::cellular_heading_of(dx, dy);
}
}
if (!split || !spot || identity == 0 ||
next_lives.size() >= state_->revamp.organism_cap ||
next_archive.organism(identity)) {
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::split_refused});
continue;
}
if (next_offspring_revisions.size() >= biology::max_archived_genomes ||
!next_archive.admit(*successor) ||
!next_archive.record_birth(identity, successor->id(), {proposal->end_tick}))
return std::unexpected{CellularLivesError::archive};
next_offspring_revisions.push_back({selection.life_id, found->offspring_genome,
selection.successor_id, proposal->end_tick});
if (!add_inventory(next_spent, payment->spent))
return std::unexpected{CellularLivesError::overflow};
auto returned = cost;
returned.energy.value = payment->energy;
reclaims.emplace_back(returned, found->position);
CellularOwnedLife child{};
child.identity = {identity, identity, successor->id(), identity, {proposal->end_tick}};
child.source = found->source;
child.growth = split->child_growth;
child.position = *spot;
child.body = split->child_body;
child.reserve = split->child_reserve;
if (state_->revamp.safety_version == 1) {
// A liquid-relative launch, inherited by either control choice and persisted
// as ordinary motion. Drag, braking and currents apply on the next tick.
child.motion = found->motion;
child.motion.heading = launch_heading;
const auto impulse = std::int64_t{state_->revamp.split_launch_um_per_s} *
biology::cellular_velocity_q10_per_um_s;
const auto launched = [&](std::int32_t velocity, std::int32_t direction) {
return static_cast<std::int32_t>(
std::clamp(velocity + impulse * direction / biology::cellular_trig_one,
-std::int64_t{biology::cellular_velocity_limit_q10},
std::int64_t{biology::cellular_velocity_limit_q10}));
};
child.motion.velocity_x_q10 = launched(
child.motion.velocity_x_q10, biology::cellular_cos_q14(child.motion.heading));
child.motion.velocity_y_q10 = launched(
child.motion.velocity_y_q10, biology::cellular_sin_q14(child.motion.heading));
}
child.parent_life = found->identity.life;
child.offspring_genome = successor->id();
child.revamp.affinity.score = found->revamp.affinity.score;
child.revamp.progress = found->revamp.progress;
found->growth = split->parent_growth;
found->body = split->parent_body;
found->reserve = split->parent_reserve;
found->offspring_genome = successor->id();
pending = {};
if (selection.become) {
// One-way: the player continues as the offspring; the founder is wildlife.
child.account = found->account;
found->account = {};
found->revamp.active_ticks = 0;
}
++next_bud_sequence;
next_lives.insert(std::ranges::lower_bound(
next_lives, identity, {},
[](const CellularOwnedLife& life) { return life.identity.life; }),
child);
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::split_applied});
continue;
}
const auto parent = next_archive.find(cellular_offspring_genome(*found));
if (!parent || !found->mutation.offer.has_value())
return std::unexpected{CellularLivesError::mutation};
if (selection.operator_id == 0) {
// ADR-0120 amendment: a decline consumes the offer and changes nothing else; its
// reserved successor identity stays unused. Banked credit may earn the next offer.
found->mutation.offer.reset();
found->mutation.offer_tick = 0;
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::declined});
continue;
}
const auto offer = found->mutation.offer.value_or(biology::MutationOffer{});
if (inheritance_rules) {
const auto selected =
biology::select_mutation(*parent, offer.context, offer, selection.operator_id,
selection.successor_id, selection.successor_id);
if (!selected)
return std::unexpected{CellularLivesError::mutation};
if (next_offspring_revisions.size() >= biology::max_archived_genomes ||
!next_archive.admit(*selected))
return std::unexpected{CellularLivesError::archive};
next_offspring_revisions.push_back({selection.life_id, found->offspring_genome,
selection.successor_id, proposal->end_tick});
found->offspring_genome = selection.successor_id;
found->mutation.offer.reset();
found->mutation.offer_tick = 0;
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::offspring_plan_applied});
continue;
}
auto transition = biology::fund_mutation_at_growth(
*parent, offer.context, offer, selection.operator_id, selection.successor_id,
selection.successor_id, found->reserve,
state_->rules_version >= cellular_lives_maturation_rules ? found->growth
: offer.context.growth);
if (!transition) {
if (transition.error() == biology::MutationError::insufficient_funding) {
mutation_results.push_back({selection.life_id, selection.successor_id,
CellularMutationResult::insufficient_funding});
continue;
}
return std::unexpected{CellularLivesError::mutation};
}
if (!next_archive.record_mutation(found->identity.organism, transition->successor,
{proposal->end_tick}))
return std::unexpected{CellularLivesError::archive};
if (transition->intake.energy.value >
std::numeric_limits<std::uint64_t>::max() - next_heat.energy.value)
return std::unexpected{CellularLivesError::overflow};
next_heat.energy.value += transition->intake.energy.value;
found->identity.genome = selection.successor_id;
found->body = transition->body;
found->reserve = transition->reserve;
found->mutation.offer.reset();
found->mutation.offer_tick = 0;
mutation_results.push_back(
{selection.life_id, selection.successor_id, CellularMutationResult::applied});
}
// Rules 4 budding (ADR-0125), after mutations and in parent life order: a parent that
// died this tick cannot bud, and a bud born this tick asked for nothing.
std::vector<CellularBudExecution> bud_results;
for (const auto& request : ordered) {
if (!bud_rules || !request.intent.bud)
continue;
auto parent = std::ranges::lower_bound(
next_lives, request.life_id, {},
[](const CellularOwnedLife& value) { return value.identity.life; });
if (parent == next_lives.end() || parent->identity.life != request.life_id) {
bud_results.push_back({request.life_id, 0, CellularBudResult::life_died});
continue;
}
if (parent->presence == CellularPresence::suspended) {
bud_results.push_back({request.life_id, 0, CellularBudResult::not_able});
continue; // Out of the world (ADR-0128).
}
if (revamp_rules && parent->revamp.members > 1) {
// An organism's bud is an internal cell (reproduction plan section 6): litter adds
// members, funded from the shared reserve. Wildlife organisms stop one short of
// the emergence threshold.
const auto expressed_genome = next_archive.find(parent->identity.genome);
if (!expressed_genome)
return std::unexpected{CellularLivesError::archive};
const auto& traits = expressed_genome->cellular_traits();
Random roll{state_->world * 0x9e3779b97f4a7c15ULL ^ request.life_id ^
proposal->end_tick * 0xbf58476d1ce4e5b9ULL};
const auto added = cellular_litter_count(traits ? traits->litter : 0U, roll.next(),
state_->revamp.bounds.max_litter);
auto members = std::uint32_t{parent->revamp.members} + added;
if (parent->account == LifeAccount{})
members = std::min(members, state_->revamp.emerge_members - 1);
const auto grown = members > parent->revamp.members
? organism_genome(*expressed_genome, members)
: std::unexpected{CellularLivesError::biology};
const auto target = grown ? biology::metabolic_budget(
*grown, parent->growth,
{state_->config.ambient_temperature_millikelvin, {}},
1000, state_->revamp.body)
: std::unexpected{biology::DevelopmentError::overflow};
const auto rules = biology::rules_for(expressed_genome->development_version());
// The same fee per bud action as a single cell's, then the new tissue.
const auto fee = cellular_mutation_cost(
{.cost = state_->revamp.bud_fee,
.cost_scale_percent = state_->revamp.bud_fee_scale_percent});
auto body = parent->body;
auto reserve = parent->reserve;
bool funded = reserve.energy.value >= fee.energy.value;
for (std::size_t c = 0; c < fee.matter.size(); ++c)
funded = funded && reserve.matter[c].value >= fee.matter[c].value;
if (funded) {
reserve.energy.value -= fee.energy.value;
for (std::size_t c = 0; c < fee.matter.size(); ++c)
reserve.matter[c].value -= fee.matter[c].value;
}
auto heat = accounting::Inventory{};
if (!target || !rules || !funded ||
!rebody(body, reserve, heat, target->body, rules->construction_per_kilogram)) {
bud_results.push_back({request.life_id, 0,
target ? CellularBudResult::insufficient_funding
: CellularBudResult::not_able});
if (target && parent->account != LifeAccount{})
activity_of(request.life_id)[biology::CellularSignal::bud_refused] += 1;
continue;
}
if (!add_inventory(next_heat, heat))
return std::unexpected{CellularLivesError::overflow};
reclaims.emplace_back(fee, parent->position);
parent->body = body;
parent->reserve = reserve;
parent->revamp.members = static_cast<std::uint16_t>(members);
if (parent->account != LifeAccount{}) {
activity_of(request.life_id)[biology::CellularSignal::bud_done] += 1;
parent->revamp.progress.buds += 1;
}
// The bud is internal: the organism reports itself as the bud.
bud_results.push_back({request.life_id, request.life_id, CellularBudResult::budded});
continue;
}
// ADR-0137 (rules 7): on a twin roll the bud investment is split between two buds
// (each a quarter of the parent's body). The parent's reported result is the
// first bud's; a twin that finds no room is simply not made.
// Rules 13 (mutation plan section 9): litter gives extra offspring sharing one investment,
// whole hundreds guaranteed and the rest a chance, up to the declared maximum.
std::uint32_t litter_count = 1;
accounting::Inventory fee{};
if (revamp_rules) {
const auto expressed_genome = next_archive.find(parent->identity.genome);
const auto& traits =
expressed_genome ? expressed_genome->cellular_traits() : std::nullopt;
const auto litter = traits ? std::uint32_t{traits->litter} : 0U;
Random roll{state_->world * 0x9e3779b97f4a7c15ULL ^ request.life_id ^
proposal->end_tick * 0xbf58476d1ce4e5b9ULL};
litter_count =
cellular_litter_count(litter, roll.next(), state_->revamp.bounds.max_litter);
fee = cellular_mutation_cost(
{.cost = state_->revamp.bud_fee,
.cost_scale_percent = state_->revamp.bud_fee_scale_percent});
bool affordable = parent->reserve.energy.value >= fee.energy.value;
for (std::size_t c = 0; c < fee.matter.size(); ++c)
affordable = affordable && parent->reserve.matter[c].value >= fee.matter[c].value;
if (!affordable) {
bud_results.push_back(
{request.life_id, 0, CellularBudResult::insufficient_funding});
if (parent->account != LifeAccount{})
activity_of(request.life_id)[biology::CellularSignal::bud_refused] += 1;
continue;
}
}
const bool twins = [&] {
if (state_->rules_version < cellular_lives_reproduction_rules || revamp_rules)
return false;
const auto parent_genome = next_archive.find(parent->identity.genome);
const auto offspring_genome = next_archive.find(cellular_offspring_genome(*parent));
if (!parent_genome || !offspring_genome)
return false;
const auto skill = parent_genome->parameter(biology::Capability::reproduction);
// Twins split one whole bud: the parent must afford that whole bud first.
return skill &&
cellular_twin_bud(state_->world, state_->region, request.life_id,
proposal->end_tick, *skill) &&
biology::fund_offspring(*parent_genome, *offspring_genome, parent->growth,
parent->reserve,
state_->config.ambient_temperature_millikelvin)
.has_value();
}();
const auto copies = revamp_rules ? litter_count : (twins ? 2U : 1U);
for (std::uint32_t copy = 0; copy < copies; ++copy) {
if (copy != 0)
// Inserting the first bud may have moved the parent; find it again.
parent = std::ranges::lower_bound(
next_lives, request.life_id, {},
[](const CellularOwnedLife& value) { return value.identity.life; });
const bool twin =
revamp_rules && state_->revamp.safety_version == 1 ? copy != 0 : copy == 1;
const auto temperature = state_->config.ambient_temperature_millikelvin;
const auto genome = next_archive.find(cellular_offspring_genome(*parent));
const auto expressed = next_archive.find(parent->identity.genome);
const auto parent_budget =
budget_for(next_archive, *parent, temperature, state_->revamp.body);
if (!genome || !expressed || !parent_budget)
return std::unexpected{CellularLivesError::archive};
// Rules 13: a bud made with the reserve covering twice its cost.
bool surplus = false;
if (revamp_rules && !twin) {
const auto cost = biology::offspring_cost(*expressed, *genome, temperature);
surplus =
cost.has_value() && parent->reserve.energy.value / 2 >= cost->energy.value;
for (std::size_t c = 0; surplus && c < cost->matter.size(); ++c)
surplus = parent->reserve.matter[c].value / 2 >= cost->matter[c].value;
}
auto transition = biology::fund_offspring(*expressed, *genome, parent->growth,
parent->reserve, temperature, copies);
// Rules 13: the fee comes on top of the bud, so what the reserve keeps after funding
// it must still pay the fee; otherwise the bud is refused like any unaffordable one.
if (transition && revamp_rules && !twin) {
bool covered = transition->parent_reserve.energy.value >= fee.energy.value;
for (std::size_t c = 0; c < fee.matter.size(); ++c)
covered = covered &&
transition->parent_reserve.matter[c].value >= fee.matter[c].value;
if (!covered)
transition = std::unexpected{biology::BuddingError::insufficient_funding};
}
if (revamp_rules && !twin && parent->account != LifeAccount{}) {
using S = biology::CellularSignal;
auto& a = activity_of(request.life_id);
if (transition) {
a[S::bud_done] += 1;
a[S::bud_with_surplus] += surplus ? 1 : 0;
parent->revamp.progress.buds += 1;
} else if (transition.error() == biology::BuddingError::insufficient_funding) {
a[S::bud_refused] += 1;
}
}
if (!transition) {
if (transition.error() == biology::BuddingError::development)
return std::unexpected{CellularLivesError::biology};
if (!twin)
bud_results.push_back(
{request.life_id, 0,
transition.error() == biology::BuddingError::insufficient_funding
? CellularBudResult::insufficient_funding
: CellularBudResult::not_able});
break;
}
const auto bud_budget =
biology::metabolic_budget(*genome, transition->growth, {temperature, {}});
if (!bud_budget || bud_budget->body.matter != transition->body.matter)
return std::unexpected{CellularLivesError::biology};
const auto identity = cellular_bud_identity(state_->region, next_bud_sequence);
const auto position =
bud_position(*parent, parent_budget->phenotype.extent, bud_budget->phenotype.extent,
next_lives, next_archive, state_->config);
if (!position)
return std::unexpected{position.error()};
if (identity == 0 || !*position ||
next_lives.size() >= biology::max_cellular_tick_lives ||
(revamp_rules && next_lives.size() >= state_->revamp.organism_cap) ||
next_archive.organism(identity)) {
if (!twin)
bud_results.push_back({request.life_id, 0, CellularBudResult::no_placement});
break;
}
if (!add_inventory(next_heat, accounting::Inventory{transition->heat, {}}) ||
!next_archive.record_birth(identity, genome->id(), {proposal->end_tick}))
return std::unexpected{CellularLivesError::archive};
parent->reserve = transition->parent_reserve;
if (revamp_rules && !twin) {
// The fee, once per bud action, returns to the region; then control, if asked.
// Funding checked that the reserve still covers it.
if (!subtract_inventory(parent->reserve, fee))
return std::unexpected{CellularLivesError::conservation};
const auto asked = std::ranges::lower_bound(ordered, request.life_id, {},
&CellularLifeIntent::life_id);
if (state_->revamp.safety_version == 1 && parent->account != LifeAccount{}) {
// The provision was funded in full above, then returned exactly once to
// the selected cell. Construction and the ordinary bud provision remain.
auto& recipient = asked != ordered.end() && asked->life_id == request.life_id &&
asked->intent.become
? transition->reserve
: parent->reserve;
if (!add_inventory(recipient, fee))
return std::unexpected{CellularLivesError::overflow};
} else {
reclaims.emplace_back(fee, parent->position);
}
}
CellularOwnedLife bud{};
bud.identity = {identity, identity, genome->id(), identity, {proposal->end_tick}};
bud.source = parent->source;
bud.growth = transition->growth;
bud.position = **position;
bud.body = transition->body;
bud.reserve = transition->reserve;
bud.parent_life = parent->identity.life;
if (inheritance_rules)
bud.offspring_genome = genome->id();
if (revamp_rules) {
// Offspring start with the parent's scores and lineage progress.
bud.revamp.affinity.score = parent->revamp.affinity.score;
bud.revamp.progress = parent->revamp.progress;
const auto asked = std::ranges::lower_bound(ordered, request.life_id, {},
&CellularLifeIntent::life_id);
if (!twin && asked != ordered.end() && asked->life_id == request.life_id &&
asked->intent.become) {
// One-way: the player continues as the first bud; the parent is wildlife.
bud.account = parent->account;
parent->account = {};
parent->revamp.offer = {};
parent->revamp.active_ticks = 0;
}
}
// Foreign residents can have a higher origin-region namespace. Keep
// the sequence sorted even before the next parent's lookup/twin.
const auto slot = std::ranges::lower_bound(
next_lives, identity, {},
[](const CellularOwnedLife& life) { return life.identity.life; });
next_lives.insert(slot, bud);
++next_bud_sequence;
if (!twin)
bud_results.push_back({request.life_id, identity, CellularBudResult::budded});
}
}
std::ranges::sort(next_lives, {},
[](const CellularOwnedLife& life) { return life.identity.life; });
// Rules 13 (reproduction plan section 7): an owned organism at the emergence threshold that
// asks leaves for the world. Its matter is a recorded export; its life ends as emerged.
auto next_boundary = state_->boundary;
if (revamp_rules) {
for (const auto& request : ordered) {
if (!request.intent.emerge)
continue;
const auto life = std::ranges::lower_bound(
next_lives, request.life_id, {},
[](const CellularOwnedLife& value) { return value.identity.life; });
if (life == next_lives.end() || life->identity.life != request.life_id ||
!cellular_can_emerge(*life, state_->revamp))
continue;
auto single = *life;
single.revamp.members = 1;
const auto budget =
budget_for(next_archive, single, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!budget ||
!next_archive.record_death(life->identity.organism, {proposal->end_tick}) ||
!add_inventory(next_boundary.outgoing, life->body) ||
!add_inventory(next_boundary.outgoing, life->reserve))
return std::unexpected{CellularLivesError::archive};
next_corpses.push_back({life->identity.life,
life->identity.organism,
life->source,
proposal->end_tick,
life->position,
life->growth,
budget->phenotype.extent,
{},
biology::CellularDeathCause::emerged,
0,
life->parent_life,
life->offspring_genome});
next_lives.erase(life);
}
}
// Rules 5 presence (ADR-0128), after deaths, mutations and buds: a death in this tick
// is final before any presence change.
std::vector<std::uint64_t> resume_blocked;
if (presence_rules) {
for (auto& life : next_lives) {
const auto request = std::ranges::lower_bound(ordered, life.identity.life, {},
&CellularLifeIntent::life_id);
if (request == ordered.end() || request->life_id != life.identity.life)
continue; // Born this tick: active.
const bool frozen = request->intent.frozen;
if (life.presence == CellularPresence::active && frozen) {
life.presence = CellularPresence::lingering;
life.frozen_since = proposal->end_tick;
} else if (life.presence == CellularPresence::lingering && !frozen) {
life.presence = CellularPresence::active;
life.frozen_since = 0;
} else if (life.presence == CellularPresence::lingering &&
proposal->end_tick - life.frozen_since >= cellular_linger_ticks) {
life.presence = CellularPresence::suspended;
} else if (life.presence == CellularPresence::suspended && !frozen) {
const auto budget =
budget_for(next_archive, life, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!budget)
return std::unexpected{budget.error()};
const auto spot = resume_position(life, budget->phenotype.extent, next_lives,
next_archive, state_->config);
if (!spot)
return std::unexpected{spot.error()};
if (*spot) {
life.position = **spot;
life.presence = CellularPresence::active;
life.frozen_since = 0;
} else {
resume_blocked.push_back(life.identity.life);
}
}
}
}
// ADR-0157: old-size actions finish first. A newborn, frozen life or a life
// resuming from suspension did not take an active step and cannot grow here.
// Expansion holds the existing lower corner fixed; earlier IDs claim space first.
std::vector<CellularGrowthExecution> growth_results;
// Rules 13: what held each owned life's growth step back this tick (feedback only).
std::vector<std::pair<std::uint64_t, std::uint8_t>> growth_limits;
if (state_->rules_version >= cellular_lives_maturation_rules) {
for (auto& life : next_lives) {
const auto input = std::ranges::lower_bound(ordered, life.identity.life, {},
&CellularLifeIntent::life_id);
const auto previous =
std::ranges::lower_bound(state_->lives, life.identity.life, {},
[](const auto& old) { return old.identity.life; });
if (input == ordered.end() || input->life_id != life.identity.life ||
input->intent.frozen || life.presence != CellularPresence::active ||
previous == state_->lives.end() || previous->identity.life != life.identity.life ||
previous->presence == CellularPresence::suspended ||
life.growth.realized_per_thousand == 1000)
continue;
const auto genome = life_genome(next_archive, life);
if (!genome)
return std::unexpected(genome.error());
// Rules 13: growth speed scales the per-tick step; the fraction carries over.
auto step = cellular_growth_per_tick;
const auto& traits = genome->cellular_traits();
if (revamp_rules && traits) {
const auto centi =
life.revamp.growth_carry +
state_->revamp.growth_per_tick_centi_mille * traits->growth_speed / 100;
step = centi / 100;
life.revamp.growth_carry = centi % 100;
if (step == 0)
continue;
}
auto budget = biology::metabolic_budget(
*genome, life.growth,
{state_->config.ambient_temperature_millikelvin, life.reserve}, step,
state_->revamp.body);
if (!budget || budget->body != life.body)
return std::unexpected(CellularLivesError::biology);
if (revamp_rules && state_->revamp.safety_version == 1) {
const auto burn = biology::cellular_burn(
state_->revamp.burn_pj_per_kfg,
traits ? traits->burn : std::array<std::uint16_t, 4>{100, 100, 100, 100},
input->intent.exclude);
// Narrow to the largest construction step that leaves the NEW body's
// full-demand fuel buffer. This is an affordability check, never a payment
// or resource grant. Matter consumed by construction no longer counts as fuel.
bool protected_fuel = false;
while (budget->construction.after.realized_per_thousand >
life.growth.realized_per_thousand) {
auto remaining = life.reserve;
const auto& construction = budget->construction;
if (!subtract_inventory(remaining, construction.intake) ||
!add_inventory(remaining, construction.release))
return std::unexpected{CellularLivesError::conservation};
const auto target = biology::metabolic_budget(
*genome, construction.after,
{state_->config.ambient_temperature_millikelvin, {}}, 1000,
state_->revamp.body);
if (!target || target->rate_microseconds == 0)
return std::unexpected{CellularLivesError::biology};
const auto periods = std::uint64_t{state_->revamp.growth_reserve_seconds} *
1'000'000 / target->rate_microseconds;
const bool bounded =
periods == 0 ||
target->demand.value <= std::numeric_limits<std::uint64_t>::max() / periods;
if (bounded && biology::cellular_payable_energy(remaining, burn, false) >=
target->demand.value * periods)
break;
protected_fuel = true;
const auto smaller = construction.after.realized_per_thousand -
life.growth.realized_per_thousand - 1;
budget = biology::metabolic_budget(
*genome, life.growth,
{state_->config.ambient_temperature_millikelvin, life.reserve}, smaller,
state_->revamp.body);
if (!budget)
return std::unexpected{CellularLivesError::biology};
}
if (protected_fuel && life.account != LifeAccount{})
growth_limits.emplace_back(life.identity.life, std::uint8_t{1});
}
const auto& move = budget->construction;
// Rules 13: an owned life learns which nutrient (or energy) narrowed its step: the
// one its reserve covers least of what an ample reserve's step needs.
std::optional<biology::MetabolicBudget> full;
if (revamp_rules && life.account != LifeAccount{}) {
accounting::Inventory ample{{1ULL << 50U}, {}};
for (auto& channel : ample.matter)
channel.value = 1ULL << 50U;
if (auto made = biology::metabolic_budget(
*genome, life.growth,
{state_->config.ambient_temperature_millikelvin, ample}, step,
state_->revamp.body))
full = *made;
if (full && move.after.realized_per_thousand <
full->construction.after.realized_per_thousand) {
const auto& need = full->construction.intake;
std::uint8_t limit = 0;
double least = 2.0;
for (std::size_t c = 0; c < 5; ++c) {
const auto wanted =
c == 0 ? need.energy.value : need.matter.at(c - 1).value;
const auto have = c == 0 ? life.reserve.energy.value
: life.reserve.matter.at(c - 1).value;
if (wanted == 0)
continue;
const auto share = static_cast<double>(have) / static_cast<double>(wanted);
if (share < least) {
least = share;
limit = static_cast<std::uint8_t>(c + 1);
}
}
growth_limits.emplace_back(life.identity.life, limit);
}
}
if (move.after == life.growth) {
if (revamp_rules && life.account != LifeAccount{}) {
// Which channels held the step back: what an ample reserve's step needs.
if (full) {
using S = biology::CellularSignal;
constexpr std::array blocked{S::blocked_carbon, S::blocked_nitrogen,
S::blocked_phosphorus, S::blocked_other};
auto& a = activity_of(life.identity.life);
for (std::size_t c = 0; c < blocked.size(); ++c)
if (full->construction.intake.matter[c].value >
life.reserve.matter[c].value)
a[blocked.at(c)] = 1;
}
}
continue;
}
const auto grown = biology::metabolic_budget(
*genome, move.after, {state_->config.ambient_temperature_millikelvin, {}});
if (!grown)
return std::unexpected(CellularLivesError::biology);
const auto extent = grown->phenotype.extent;
bool clear = extent <= state_->config.area.width_um &&
extent <= state_->config.area.height_um &&
life.position.x_um <= state_->config.area.width_um - extent &&
life.position.y_um <= state_->config.area.height_um - extent;
for (const auto& other : next_lives) {
if (!clear || other.identity.life == life.identity.life ||
other.presence == CellularPresence::suspended)
continue;
const auto obstacle =
budget_for(next_archive, other, state_->config.ambient_temperature_millikelvin,
state_->revamp.body);
if (!obstacle)
return std::unexpected(obstacle.error());
clear = separated(life.position.x_um, other.position.x_um, extent,
obstacle->phenotype.extent) ||
separated(life.position.y_um, other.position.y_um, extent,
obstacle->phenotype.extent);
}
if (!clear) {
if (revamp_rules && life.account != LifeAccount{})
growth_limits.emplace_back(life.identity.life, std::uint8_t{6}); // No room.
continue; // No partial spatial retry, relocation or spending.
}
if (!subtract_inventory(life.reserve, move.intake) ||
!add_inventory(life.reserve, move.release) ||
!add_inventory(next_heat, accounting::Inventory{move.intake.energy, {}}))
return std::unexpected(CellularLivesError::overflow);
growth_results.push_back(
{life.identity.life, life.growth, move.after, move.intake, move.release});
life.growth = move.after;
life.body = grown->body;
}
}
// Rules 13: each owned, active life's activity moves its affinity; active play earns offers.
if (revamp_rules) {
using S = biology::CellularSignal;
for (auto& life : next_lives) {
const auto request = std::ranges::lower_bound(ordered, life.identity.life, {},
&CellularLifeIntent::life_id);
if (life.account == LifeAccount{} || request == ordered.end() ||
request->life_id != life.identity.life || request->intent.frozen ||
life.presence != CellularPresence::active)
continue; // Wildlife, newborns, and frozen or absent cells.
auto a = activity_of(life.identity.life);
std::uint64_t reserve{}, body{};
for (std::size_t c = 0; c < life.body.matter.size(); ++c) {
reserve += life.reserve.matter[c].value;
body += life.body.matter[c].value;
}
a[S::reserve_over_body] = reserve > body ? 1 : 0;
a[S::regrowing] = life.growth.realized_per_thousand < 1000 ? 1 : 0;
a[S::fully_grown] = life.growth.realized_per_thousand == 1000 ? 1 : 0;
biology::cellular_affinity_tick(
life.revamp.affinity, a, state_->revamp.mutations,
{state_->revamp.offers.score_min, state_->revamp.offers.score_max});
if (life.revamp.offer.count != 0)
continue;
if (life.revamp.active_ticks < state_->revamp.offer_interval_ticks)
++life.revamp.active_ticks;
// A single cell's choice splits it, so an earned offer waits (keeping its count)
// until the cell has grown enough to split.
if (life.revamp.active_ticks < state_->revamp.offer_interval_ticks ||
(life.revamp.members == 1 &&
life.growth.realized_per_thousand < state_->revamp.split_min_growth))
continue;
life.revamp.active_ticks = 0;
const auto plan = next_archive.find(cellular_offspring_genome(life));
if (!plan)
return std::unexpected{CellularLivesError::archive};
const auto offer =
cellular_draw_offer(*plan, life.revamp, state_->revamp, state_->world,
state_->region, life.identity.life, proposal->end_tick);
if (offer) {
life.revamp.offer = *offer;
life.revamp.events = offer->event_index;
}
}
}
std::ranges::sort(next_corpses, {}, &CellularOwnedCorpse::organism);
if (proposal->heat_released.value >
std::numeric_limits<std::uint64_t>::max() - next_heat.energy.value)
return std::unexpected{CellularLivesError::overflow};
next_heat.energy.value += proposal->heat_released.value;
for (const auto& update : proposal->patches) {
const auto found =
std::ranges::lower_bound(habitat_config.patches, update.address, {},
[](const auto& patch) { return patch.address; });
if (found == habitat_config.patches.end() || found->address != update.address)
return std::unexpected{CellularLivesError::habitat};
found->stock = update.stock;
}
// Rules 3 detritus at empty cells becomes new patches; create() revalidates the map.
// Format 2 (ADR-0136): new bubbles take the next deposit ids, and a deposit emptied this
// tick is gone.
const bool deposits = habitat_config.format == biology::cellular_habitat_deposit_format ||
habitat_config.format == biology::cellular_habitat_liquid_format;
for (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};
if (deposits) {
if (habitat_config.next_deposit == std::numeric_limits<std::uint32_t>::max())
return std::unexpected{CellularLivesError::overflow};
made.id = habitat_config.next_deposit++;
}
habitat_config.patches.insert(at, made);
}
// Rules 13: the spent pool drips back as bubbles at seeded random spots.
if (revamp_rules &&
!cellular_drip_spent(habitat_config, next_spent, state_->revamp, state_->world,
state_->region, proposal->end_tick, state_->nursery_config.source))
return std::unexpected{CellularLivesError::overflow};
// Rules 13: paid mutation costs return as bubbles at seeded random spots.
for (std::size_t k = 0; k < reclaims.size(); ++k)
if (!cellular_reclaim(habitat_config, reclaims[k].first,
state_->world * 0x9e3779b97f4a7c15ULL ^
proposal->end_tick * 0x94d049bbULL ^ k,
reclaims[k].second, state_->nursery_config.source))
return std::unexpected{CellularLivesError::overflow};
if (deposits)
std::erase_if(habitat_config.patches, [](const biology::CellularPatch& patch) {
return patch.stock == accounting::Inventory{};
});
// Rules 12: after every life fed where the food was, bubbles move with the current and
// the drift that this tick's moving cells induce, then touching bubbles merge.
if (liquid_rules) {
std::vector<biology::CellularWake> wakes;
wakes.reserve(proposal->lives.size());
for (const auto& result : proposal->lives) {
const auto input = std::ranges::lower_bound(
inputs, result.life_id, {},
[](const biology::CellularLifeStepInput& value) { return value.life_id; });
if (input == inputs.end() || input->life_id != result.life_id || input->intent.frozen)
continue;
const auto flow =
state_->field->at_footprint(result.candidate.position, input->extent_um);
wakes.push_back({result.candidate.position, input->extent_um,
result.candidate.motion.velocity_x_q10 + flow.x_q10,
result.candidate.motion.velocity_y_q10 + flow.y_q10});
}
auto moved = biology::advect_cellular_deposits(habitat_config, *state_->field, wakes,
state_->liquid.deposits);
if (!moved)
return std::unexpected{CellularLivesError::habitat};
habitat_config = std::move(moved->config);
}
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, engulf_rules, bud_rules,
next_bud_sequence, presence_rules,
state_->format_version >= cellular_lives_migration_format ? &next_boundary : nullptr,
inheritance_rules ? &next_offspring_revisions : nullptr, next_spent, revamp_rules);
if (!total)
return std::unexpected{total.error()};
auto next = std::make_unique<State>(
state_->world, state_->region, state_->frame,
CellularLivesConfig{state_->config.area, proposal->end_tick,
state_->config.ambient_temperature_millikelvin},
state_->nursery_config, std::move(*next_habitat), std::move(next_lives),
std::move(next_corpses), next_archive, state_->nursery, next_heat, state_->opening_total,
*total, state_->format_version, state_->rules_version, next_boundary);
next->next_bud_sequence = next_bud_sequence;
next->offspring_revisions = std::move(next_offspring_revisions);
next->light = state_->light;
next->captured = state_->captured;
next->liquid = state_->liquid;
next->field = state_->field;
next->revamp = state_->revamp;
next->spent = next_spent;
// ADR-0175: light, from this tick's own intentions, credited to every active,
// unfrozen photosynthetic survivor's reserve and to the boundary inflow together.
std::vector<std::pair<std::uint64_t, std::uint64_t>> lit_lives;
if (next->light.numerator != 0) {
for (auto& life : next->lives) {
const auto left = next->light.entitlement.value - next->captured.value;
if (left == 0)
break;
if (life.presence != CellularPresence::active)
continue;
const auto genome = next->archive.find(life.identity.genome);
if (!genome)
return std::unexpected{CellularLivesError::archive};
if (!genome->carries(biology::Capability::photosynthesis))
continue;
const auto input = std::ranges::lower_bound(
ordered, life.identity.life, {},
[](const CellularLifeIntent& value) { return value.life_id; });
// Newborn buds had no intention this tick and capture from the next one.
if (input == ordered.end() || input->life_id != life.identity.life ||
input->intent.frozen)
continue;
const auto budget =
budget_for(next->archive, life, next->config.ambient_temperature_millikelvin,
next->revamp.body);
if (!budget)
return std::unexpected{CellularLivesError::biology};
const auto energy =
cellular_light_capture(*genome, budget->phenotype.extent, next->light,
input->intent.movement != biology::CellularIntent{});
if (!energy)
return std::unexpected{CellularLivesError::overflow};
const auto granted = std::min(*energy, left);
constexpr auto most = std::numeric_limits<std::uint64_t>::max();
if (granted > most - life.reserve.energy.value ||
granted > most - next->boundary.incoming.energy.value ||
granted > most - next->current_total.energy.value)
return std::unexpected{CellularLivesError::overflow};
life.reserve.energy.value += granted;
next->boundary.incoming.energy.value += granted;
next->current_total.energy.value += granted;
next->captured.value += granted;
if (granted != 0)
lit_lives.emplace_back(life.identity.life, granted);
}
}
std::vector<CellularLifeTickFeedback> feedback;
feedback.reserve(proposal->lives.size());
for (const auto& result : proposal->lives) {
const auto input =
std::ranges::lower_bound(ordered, result.life_id, {},
[](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.engulf, result.prey_id, std::nullopt, 0,
CellularPresence::active, false});
if (const auto bud =
std::ranges::find(bud_results, result.life_id, &CellularBudExecution::parent_life);
bud != bud_results.end()) {
feedback.back().bud = bud->result;
feedback.back().bud_life = bud->bud_life;
}
if (input == ordered.end() || input->life_id != result.life_id)
return std::unexpected{CellularLivesError::invalid_intents};
feedback.back().exclude = input->intent.exclude;
if (revamp_rules) {
auto& entry = feedback.back();
if (result.candidate.intake)
entry.collected = result.candidate.intake->transfer.acquired;
entry.burned = result.candidate.spent;
if (const auto grew = std::ranges::find(growth_results, result.life_id,
&CellularGrowthExecution::life_id);
grew != growth_results.end())
entry.into_growth = grew->intake;
if (const auto held = std::ranges::find(growth_limits, result.life_id,
&std::pair<std::uint64_t, std::uint8_t>::first);
held != growth_limits.end())
entry.growth_limit = held->second;
}
}
// ADR-0128: each surviving life reports its presence after the tick; a suspended life,
// which took no step, reports its unchanged reserve and any blocked resume.
for (const auto& life : next->lives) {
auto entry =
std::ranges::find(feedback, life.identity.life, &CellularLifeTickFeedback::life_id);
if (entry == feedback.end()) {
feedback.push_back({life.identity.life,
proposal->end_tick,
life.reserve,
{},
{},
biology::CellularMovementStatus::not_requested,
biology::CellularIntakeStatus::not_requested,
biology::CellularEngulfStatus::not_requested,
0,
std::nullopt,
0,
life.presence,
false});
entry = std::prev(feedback.end());
}
entry->presence = life.presence;
if (state_->rules_version >= cellular_lives_maturation_rules)
entry->reserve = life.reserve; // Includes funded growth/mutation/budding.
entry->resume_blocked =
std::ranges::find(resume_blocked, life.identity.life) != resume_blocked.end();
}
for (const auto& [life, energy] : lit_lives) {
const auto entry = std::ranges::find(feedback, life, &CellularLifeTickFeedback::life_id);
if (entry != feedback.end())
entry->light = {energy};
}
std::ranges::sort(feedback, {}, &CellularLifeTickFeedback::life_id);
state_.swap(next);
last_tick_feedback_ = std::move(feedback);
return CellularTickExecution{std::move(*proposal), std::move(mutation_results),
std::move(bud_results), std::move(growth_results)};
}
} // namespace evo::server