Foundation / checks (client) (push) Successful in 5s
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m32s
Foundation / postgres-tools (push) Successful in 21s
Foundation / server-image (push) Successful in 4m12s
Foundation / image (push) Successful in 4m52s
Adhesion turns a cell into a two-member organism: one life with a member count, one genome and one reserve, developed as its genome with the target size times its members. The single cell ends as an empty merged corpse. An organism expresses accepted mutations as a whole, paid from its reserve; its buds add internal members (wildlife stops one short of the threshold); the extra members' mass loads its thrust. At the emergence threshold the Emerge intent exports the body and reserve through the boundary ledger and ends the life as emerged. Records the maintainer's 2026-10-23 decisions in ADR-0179 and the project vision (whole-organism mutations; the playtest form of Emerge). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
131 lines
7.3 KiB
C++
131 lines
7.3 KiB
C++
#pragma once
|
|
|
|
#include "evo/biology/cellular_catalog.hpp"
|
|
#include "evo/biology/cellular_habitat.hpp"
|
|
#include "evo/biology/cellular_motion.hpp"
|
|
#include "evo/biology/cellular_offers.hpp"
|
|
#include "evo/biology/cellular_region_step.hpp"
|
|
#include "evo/biology/cellular_revamp_tuning.hpp"
|
|
#include "evo/biology/cellular_triggers.hpp"
|
|
#include "evo/biology/development.hpp"
|
|
|
|
#include <array>
|
|
#include <compare>
|
|
#include <cstdint>
|
|
#include <optional>
|
|
|
|
// Rules 13 (ADR-0179, Cellular_Revamp_Build_Plan.md): what a cellular owner declares when it
|
|
// upgrades to owner format 11. Taken from the Git tuning file when the region opens and
|
|
// persisted with the owner, so replay and restore never read the file. Later build phases add
|
|
// the feeding, mutation and reproduction tunables here.
|
|
namespace evo::server {
|
|
struct CellularRevampRules {
|
|
biology::BodyTuning body{};
|
|
// Picojoules 1,000 fg of C, N, P and other matter stand in for at burn efficiency 100.
|
|
std::array<std::uint64_t, 4> burn_pj_per_kfg{};
|
|
biology::CellularRevampStepRules step{};
|
|
// The spent pool drips back as bubbles every `drip_interval_ticks` ticks (0: never), one
|
|
// bubble per non-empty channel of at most these amounts, at seeded random spots.
|
|
std::uint32_t drip_interval_ticks{};
|
|
std::uint64_t drip_bubble_pj{}, drip_bubble_fg{};
|
|
// Share of reserve matter carried as load, per mille: it slows thrust and turning and makes
|
|
// thrust costlier, in proportion to the body's mass. Upkeep stays on the body.
|
|
std::uint32_t reserve_load_per_thousand{};
|
|
// Growth per tick in hundredths of a per mille at growth speed 100 (trial 500: 5 per mille).
|
|
std::uint32_t growth_per_tick_centi_mille{500};
|
|
// Mutation offers: the draw, the catalog's bounds and gates, the cadence in active ticks,
|
|
// and every catalog mutation's tunables in catalog order.
|
|
biology::CellularOfferRules offers{};
|
|
biology::CellularCatalogBounds bounds{};
|
|
std::uint32_t offer_interval_ticks{500};
|
|
std::array<biology::CellularMutationTuning, biology::cellular_catalog_size> mutations{};
|
|
// Reproduction: the offspring's share of a split and the growth a cell needs to split; the
|
|
// on-demand bud's fee (amounts times scale, reclaimed); the region's organism cap.
|
|
std::uint32_t split_share_per_thousand{500}, split_min_growth{1'000};
|
|
accounting::Inventory bud_fee{};
|
|
std::uint32_t bud_fee_scale_percent{};
|
|
std::uint32_t organism_cap{256};
|
|
// Multicellular organisms (reproduction plan section 6): the share of the extra members'
|
|
// mass carried as load on one cell's thrust, and the emergence threshold.
|
|
std::uint32_t organism_load_per_thousand{500};
|
|
std::uint32_t emerge_members{8};
|
|
std::uint64_t emerge_mass_fg{}, emerge_reserve_pj{};
|
|
auto operator<=>(const CellularRevampRules&) const = default;
|
|
};
|
|
|
|
// A rules-13 offer: the drawn mutations (catalog ids) and their chances, in catalog order.
|
|
inline constexpr std::size_t max_cellular_offer_options = 10;
|
|
struct CellularRevampOffer {
|
|
std::uint64_t event_index{}, offer_tick{};
|
|
std::uint8_t count{};
|
|
std::array<std::uint16_t, max_cellular_offer_options> ids{};
|
|
std::array<std::uint32_t, max_cellular_offer_options> chances{};
|
|
auto operator<=>(const CellularRevampOffer&) const = default;
|
|
};
|
|
// A rules-13 life's mutation state: affinity, lineage progress, the cadence counter, the pending
|
|
// offer (count 0: none), the previous tick's brake (for presses) and the growth carry.
|
|
struct CellularRevampLife {
|
|
biology::CellularAffinity affinity{};
|
|
biology::CellularLineageProgress progress{};
|
|
std::uint32_t active_ticks{};
|
|
std::uint8_t last_brake{};
|
|
std::uint16_t members{1}; // Cells in the organism: 1 for a single cell.
|
|
std::uint32_t growth_carry{};
|
|
std::uint64_t events{}; // Offers made so far; the next offer's event index is events + 1.
|
|
CellularRevampOffer offer{};
|
|
auto operator<=>(const CellularRevampLife&) const = default;
|
|
};
|
|
|
|
// The rules' offer settings as the catalog and offer code take them.
|
|
[[nodiscard]] bool cellular_revamp_offer_rules_valid(const CellularRevampRules& rules) noexcept;
|
|
|
|
// Draws an offer from `plan`'s eligible mutations at its affinity, or nothing when fewer
|
|
// mutations are eligible than the cap can fill. Seeded by world, region, life and event, so a
|
|
// retry draws the same offer.
|
|
[[nodiscard]] std::optional<CellularRevampOffer>
|
|
cellular_draw_offer(const biology::Genome& plan, const CellularRevampLife& life,
|
|
const CellularRevampRules& rules, std::uint64_t world, std::uint64_t region,
|
|
std::uint64_t life_id, std::uint64_t tick);
|
|
|
|
// How many offspring one bud makes from `litter` (hundredths of an extra offspring) and a roll:
|
|
// one, plus every whole hundred, plus one more when roll % 100 falls below the remainder; at most
|
|
// max_litter / 100 + 1.
|
|
[[nodiscard]] constexpr std::uint32_t
|
|
cellular_litter_count(std::uint32_t litter, std::uint64_t roll, std::uint32_t max_litter) noexcept {
|
|
const auto count = 1 + litter / 100 + (roll % 100 < litter % 100 ? 1U : 0U);
|
|
return count < max_litter / 100 + 1 ? count : max_litter / 100 + 1;
|
|
}
|
|
// What choosing a mutation costs: its amounts times its scale.
|
|
[[nodiscard]] accounting::Inventory
|
|
cellular_mutation_cost(const biology::CellularMutationTuning& tuning) noexcept;
|
|
|
|
// Returns `amount` to the region as bubbles at seeded random spots, one per non-empty channel;
|
|
// a habitat at its deposit limit merges each into the existing deposit farthest from `from`.
|
|
// False only on identity overflow.
|
|
[[nodiscard]] bool cellular_reclaim(biology::CellularHabitatConfig& config,
|
|
const accounting::Inventory& amount, std::uint64_t seed,
|
|
biology::CellularPosition from, std::uint64_t source);
|
|
|
|
[[nodiscard]] bool cellular_revamp_valid(const CellularRevampRules& rules) noexcept;
|
|
// The spent pool's drip for the tick ending at `tick`: on every `drip_interval_ticks`-th tick,
|
|
// one bubble per non-empty channel of at most the declared size, taken from `spent`, at a
|
|
// seeded random spot (nudged east past taken addresses) with the next deposit id and `source`.
|
|
// A habitat at its deposit limit keeps the rest waiting. False only on identity overflow, with
|
|
// `config` and `spent` then unusable.
|
|
[[nodiscard]] bool cellular_drip_spent(biology::CellularHabitatConfig& config,
|
|
accounting::Inventory& spent,
|
|
const CellularRevampRules& rules, std::uint64_t world,
|
|
std::uint64_t region, std::uint64_t tick,
|
|
std::uint64_t source);
|
|
// A body's handling carrying reserve matter: thrust, reverse thrust and turning scale by
|
|
// body / (body + load), full-output costs by (body + load) / body, where load is the declared
|
|
// share of `carried` matter. Drag is unchanged. No load leaves the handling as it is.
|
|
[[nodiscard]] biology::CellularHandling
|
|
cellular_loaded_handling(const biology::CellularHandling& handling, std::uint64_t body_mass,
|
|
std::uint64_t carried, const CellularRevampRules& rules,
|
|
std::uint64_t extra_load = 0) noexcept;
|
|
// Rules from the revamp tuning file.
|
|
[[nodiscard]] CellularRevampRules
|
|
cellular_revamp_rules(const biology::CellularRevampTuning& tuning);
|
|
} // namespace evo::server
|