#include "evo/server/lifecycle/cellular_lives.hpp" #include "evo/biology/budding.hpp" #include "evo/biology/founder.hpp" #include "evo/core/random.hpp" #include #include #include #include #include #include #include #include #include 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 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(part >> (index * 8U))) * 1099511628211ULL; } } return value == 0 ? 1 : value; } class Writer { public: explicit Writer(std::vector& 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(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(value.x_um), 4); put(std::bit_cast(value.y_um), 4); } template void bytes(const std::array& value) { bytes_.insert(bytes_.end(), value.begin(), value.end()); } void raw(std::span value) { bytes_.insert(bytes_.end(), value.begin(), value.end()); } void zeros(std::size_t count) { bytes_.insert(bytes_.end(), count, 0); } private: std::vector& bytes_; }; class Reader { public: explicit Reader(std::span 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(static_cast(get(4))), std::bit_cast(static_cast(get(4)))}; } template std::array bytes() { std::array result{}; std::ranges::copy(bytes_.subspan(at_, N), result.begin()); at_ += N; return result; } std::span raw(std::size_t size) { const auto result = bytes_.subspan(at_, size); at_ += size; return result; } private: std::span bytes_; std::size_t at_{}; }; bool add_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept { constexpr auto maximum = std::numeric_limits::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 read_trigger(Reader& in) { biology::CellularTriggerState s{}; s.first = in.get(); s.second = in.get(); s.ticks = static_cast(in.get(4)); s.heading = static_cast(in.get(2)); const auto running = in.get(1); if (running > 1 || in.get(1) != 0) return std::nullopt; s.running = static_cast(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(o.score_min), 4); out.put(static_cast(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(m.increase_points), 4); out.put(static_cast(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(in.get(4)); }; const auto i32 = [&in] { return static_cast(static_cast(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(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 read_revamp_life(Reader& in) { CellularRevampLife life{}; for (auto& score : life.affinity.score) score = static_cast(static_cast(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(in.get(4)); life.active_ticks = static_cast(in.get(4)); const auto brake = in.get(1); zero = zero && brake <= 1 && in.get(1) == 0; life.last_brake = static_cast(brake); life.members = static_cast(in.get(2)); zero = zero && life.members >= 1; life.growth_carry = static_cast(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(count); for (auto& id : offer.ids) id = static_cast(in.get(2)); for (auto& chance : offer.chances) chance = static_cast(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 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::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 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 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, CellularLivesError> bud_position(const CellularOwnedLife& parent, std::uint32_t parent_extent, std::uint32_t bud_extent, std::span lives, const biology::LineageArchive& archive, const CellularLivesConfig& config, std::uint32_t launch_gap = 0) { constexpr std::array, 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{}; std::vector 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(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(x) > config.area.width_um - bud_extent || static_cast(y) > config.area.height_um - bud_extent) continue; const biology::CellularPosition candidate{static_cast(x), static_cast(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(x - dx * launch_gap); const auto begin_y = static_cast(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{}; } // 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, CellularLivesError> resume_position(const CellularOwnedLife& life, std::uint32_t extent, std::span lives, const biology::LineageArchive& archive, const CellularLivesConfig& config) { constexpr std::array, 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{}; std::vector> 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(x) > config.area.width_um - extent || static_cast(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(x), other->position.x_um, extent, other_extent) || separated(static_cast(y), other->position.y_um, extent, other_extent); }); }; const auto x0 = static_cast(life.position.x_um); const auto y0 = static_cast(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(ring) * extent; if (clear(x0 + dx * step, y0 + dy * step)) return std::optional{ biology::CellularPosition{static_cast(x0 + dx * step), static_cast(y0 + dy * step)}}; } return std::optional{}; } std::expected sum_state(accounting::Inventory nursery, accounting::Inventory heat, const biology::CellularHabitat& habitat, std::span lives, std::span 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 lives, std::span corpses, const biology::LineageArchive& archive, std::span 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 plans; std::map earliest_birth; std::map 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 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 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 lives, std::span 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* 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(site.x_um) > config.area.width_um - spawn_extent || static_cast(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(delta_x < 0 ? -delta_x : delta_x); const auto dy = static_cast(delta_y < 0 ? -delta_y : delta_y); if (dx < spawn_extent && dy < spawn_extent) return std::unexpected{CellularLivesError::invalid_config}; } } std::vector live_organisms; std::vector 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 habitat; std::vector lives; std::vector 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 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 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 map, std::vector living, std::vector 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_{std::move(state)} {} CellularLives::~CellularLives() = default; std::expected, CellularLivesError> CellularLives::create(const PrimitiveLives& opening, std::unique_ptr 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 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(primitive.body.value - 1); const auto reserve_index = static_cast(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(primitive.site.x_um), static_cast(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(world, region, frame, config, std::move(nursery_config), std::move(habitat), std::move(lives), std::vector{}, 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{new CellularLives{std::move(state)}}; } std::expected 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 { 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(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 CellularLives::lives() const noexcept { return state_->lives; } std::span 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 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, CellularLivesError> CellularLives::migration_replacement(std::vector 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{new CellularLives{std::make_unique( 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::exchange_boundary(std::span 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::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 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::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, 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, 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 CellularLives::last_tick_feedback() const noexcept { return last_tick_feedback_; } std::expected, 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, 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, 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(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 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 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(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 CellularLives::offspring_revisions() const noexcept { return state_->offspring_revisions; } std::expected, 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 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 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(f.turn)}) out.put(value, 4); out.put(d.drift_radius_um, 4); out.put(static_cast(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(candidate.target), 1); out.put(static_cast(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(life.presence), 1); out.zeros(7); out.put(life.frozen_since); } if (inheritance) out.put(life.offspring_genome); if (liquid) { out.put(static_cast(life.motion.velocity_x_q10), 4); out.put(static_cast(life.motion.velocity_y_q10), 4); out.put(life.motion.heading, 2); out.put(0, 2); out.put(static_cast(life.motion.remainder_x), 4); out.put(static_cast(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(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, 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, 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, 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{new CellularLives{std::make_unique( 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, 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{new CellularLives{std::make_unique( 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, 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 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(site.x_um), static_cast(site.y_um)}); } std::optional 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::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{new CellularLives{std::make_unique( 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, CellularLivesError> CellularLives::restore(std::span 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(in.get(4)); const auto rules_version = static_cast(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(in.get(4)); config.area.height_um = static_cast(in.get(4)); config.tick = saved_tick; config.ambient_temperature_millikelvin = static_cast(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(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 field; if (liquid_version) { auto& c = liquid.currents; auto& f = liquid.founder; auto& d = liquid.deposits; const auto u32 = [&in] { return static_cast(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(turn); d.drift_radius_um = u32(); d.max_drift_q10 = static_cast(u32()); d.drift_decay_ppm = u32(); const auto cap = u32(); d.merged_cap = static_cast(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(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(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(site_count)); for (std::uint64_t i = 0; i < site_count; ++i) nursery_config.sites.push_back(in.site()); std::vector lives; lives.reserve(static_cast(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(in.get(4)); life.growth.damage_per_thousand = static_cast(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(in.get(4)); offer.context.event_index = in.get(); const auto offered_count = static_cast(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(in.get(4)); offer.context.growth.damage_per_thousand = static_cast(in.get(4)); offer.context.environment.temperature_millikelvin = static_cast(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(in.get(2)); candidate.target = static_cast(in.get(1)); candidate.effect = static_cast(in.get(1)); candidate.parameter = static_cast(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(CellularPresence::suspended) || padding != 0) return std::unexpected{CellularLivesError::noncanonical}; life.presence = static_cast(presence); } if (inheritance_version) life.offspring_genome = in.get(); if (liquid_version) { life.motion.velocity_x_q10 = static_cast(static_cast(in.get(4))); life.motion.velocity_y_q10 = static_cast(static_cast(in.get(4))); life.motion.heading = static_cast(in.get(2)); const auto padding = in.get(2); life.motion.remainder_x = static_cast(in.get(4)); life.motion.remainder_y = static_cast(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 corpses; corpses.reserve(static_cast(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(in.get(4)); corpse.growth.damage_per_thousand = static_cast(in.get(4)); corpse.extent_um = static_cast(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(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(habitat_size)); const auto archive_payload = in.raw(static_cast(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(nonresident_count)); for (std::uint64_t index = 0; index < nonresident_count; ++index) boundary.nonresident_organisms.push_back(in.get()); } std::vector plan_history; plan_history.reserve(static_cast(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{new CellularLives{std::make_unique( 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 CellularLives::advance_tick(std::span intents) { auto execution = advance_tick_with_mutations(intents, std::span{}); if (!execution) return std::unexpected{execution.error()}; return std::move(execution->step); } std::expected CellularLives::advance_tick_with_mutations(std::span intents, std::span selections) { if (state_->config.tick == std::numeric_limits::max()) return std::unexpected{CellularLivesError::invalid_tick}; if (intents.size() != state_->lives.size()) return std::unexpected{CellularLivesError::invalid_intents}; std::vector 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 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> activity; const auto activity_of = [&activity](std::uint64_t life_id) -> biology::CellularActivity& { const auto found = std::ranges::find( activity, life_id, &std::pair::first); if (found != activity.end()) return found->second; return activity.emplace_back(life_id, biology::CellularActivity{}).second; }; std::vector> 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::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::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::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 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{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( whole.position.x_um, state_->config.area.width_um - extent); whole.position.y_um = std::min( 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 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(spot->x_um) - static_cast(found->position.x_um)) + std::int64_t{born->phenotype.extent} - shrunk->phenotype.extent; const auto dy = 2 * (static_cast(spot->y_um) - static_cast(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::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::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 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(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 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 growth_results; // Rules 13: what held each owned life's growth step back this tick (feedback only). std::vector> 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{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::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 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(have) / static_cast(wanted); if (share < least) { least = share; limit = static_cast(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::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::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 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_->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> 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::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 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::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