#pragma once #include "evo/biology/cellular_region_step.hpp" #include "evo/biology/mutation.hpp" #include "evo/server/lifecycle/primitive_lives.hpp" #include #include #include #include #include #include #include #include namespace evo::server { inline constexpr std::uint32_t cellular_lives_legacy_format = 1; inline constexpr std::uint32_t cellular_lives_format = 2; inline constexpr std::uint32_t cellular_lives_revision_format = 3; inline constexpr std::uint32_t cellular_lives_rules = 2; inline constexpr std::size_t max_cellular_lives_bytes = std::size_t{16} * 1024 * 1024; inline constexpr std::uint64_t cellular_mutation_surplus_seconds = 60; inline constexpr std::uint16_t cellular_mutation_candidate_count = 3; inline constexpr std::uint32_t cellular_mutation_stream = 0x4D555431U; // "MUT1" struct CellularMutationProgress { std::uint64_t fed_energy_credit_pj{}; std::uint64_t event_index{}; std::uint64_t offer_tick{}; std::optional offer; auto operator<=>(const CellularMutationProgress&) const = default; }; struct CellularOwnedLife { LifeAccount account{}; LifeAllocation identity{}; std::uint64_t source{}; biology::GrowthState growth{}; biology::CellularPosition position{}; accounting::Inventory body{}; accounting::Inventory reserve{}; CellularMutationProgress mutation{}; auto operator<=>(const CellularOwnedLife&) const = default; }; struct CellularOwnedCorpse { std::uint64_t life_id{}; std::uint64_t organism{}; std::uint64_t source{}; std::uint64_t died_tick{}; biology::CellularPosition position{}; biology::GrowthState growth{}; std::uint32_t extent_um{}; accounting::Inventory inventory{}; auto operator<=>(const CellularOwnedCorpse&) const = default; }; struct CellularLifeIntent { std::uint64_t life_id{}; biology::CellularStepIntent intent{}; auto operator<=>(const CellularLifeIntent&) const = default; }; struct CellularMutationSelection { std::uint64_t life_id{}, event_index{}, offer_tick{}, successor_id{}; std::uint16_t operator_id{}; auto operator<=>(const CellularMutationSelection&) const = default; }; enum class CellularMutationResult : std::uint8_t { applied, life_died, insufficient_funding }; struct CellularMutationExecution { std::uint64_t life_id{}, successor_id{}; CellularMutationResult result{}; auto operator<=>(const CellularMutationExecution&) const = default; }; struct CellularTickExecution { biology::CellularRegionStepCandidate step; std::vector mutations; }; struct CellularLifeTickFeedback { std::uint64_t life_id{}, tick{}; accounting::Inventory reserve; accounting::Picojoules maintenance_cost{}, movement_cost{}; biology::CellularMovementStatus movement{biology::CellularMovementStatus::not_requested}; biology::CellularIntakeStatus intake{biology::CellularIntakeStatus::not_requested}; auto operator<=>(const CellularLifeTickFeedback&) const = default; }; struct CellularLivesConfig { biology::CellularArea area{}; std::uint64_t tick{}; std::uint32_t ambient_temperature_millikelvin{}; }; enum class CellularLivesError : std::uint8_t { identity, invalid_config, invalid_life, life_exists, no_placement, insufficient_funding, duplicate_life, invalid_tick, invalid_intents, biology, region_step, mutation, archive, habitat, overflow, conservation, format, version, checksum, noncanonical }; // In-memory authoritative cellular owner. It consumes funded profile-3 opening // state but never mutates or reinterprets that checkpoint. Each tick is applied // to a detached candidate and swapped only after life, corpse, heat, habitat and // archive closure all validate. Durable profile-4 publication remains external. class CellularLives { public: [[nodiscard]] static std::expected, CellularLivesError> create(const PrimitiveLives& opening, std::unique_ptr habitat, CellularLivesConfig config); CellularLives(const CellularLives&) = delete; CellularLives& operator=(const CellularLives&) = delete; ~CellularLives(); [[nodiscard]] std::uint64_t world() const noexcept; [[nodiscard]] std::uint64_t region() const noexcept; [[nodiscard]] std::uint64_t frame() const noexcept; [[nodiscard]] std::uint64_t tick() const noexcept; [[nodiscard]] std::uint32_t format_version() const noexcept; [[nodiscard]] std::uint32_t rules_version() const noexcept; [[nodiscard]] std::uint32_t ambient_temperature_millikelvin() const noexcept; [[nodiscard]] biology::CellularArea area() const noexcept; [[nodiscard]] std::span lives() const noexcept; [[nodiscard]] std::span corpses() const noexcept; [[nodiscard]] const biology::CellularHabitat& habitat() const noexcept; [[nodiscard]] const biology::LineageArchive& archive() const noexcept; [[nodiscard]] accounting::Inventory nursery() const noexcept; [[nodiscard]] accounting::Inventory heat() const noexcept; [[nodiscard]] accounting::Inventory opening_total() const noexcept; [[nodiscard]] accounting::Inventory current_total() const noexcept; // Latest successful in-memory step report; omitted from snapshots and empty after restore. [[nodiscard]] std::span last_tick_feedback() const noexcept; [[nodiscard]] std::vector snapshot() const; // Exact stock view for one live cell, filtered by its authoritative footprint and the // M11.3 perception radius. Patch provenance and out-of-range stock are never returned. [[nodiscard]] std::expected, CellularLivesError> perceive(std::uint64_t life_id) const; // Stable unranked offer for the owning life; an absent offer is legitimate. [[nodiscard]] std::expected, CellularLivesError> mutation_offer(std::uint64_t life_id) const; // Detached no-tick representation upgrade. Only a fully restored v1 owner can migrate. [[nodiscard]] std::expected, CellularLivesError> migrate_to_v2() const; // Detached no-tick v2-to-v3 profile upgrade enabling genome revisions. [[nodiscard]] std::expected, CellularLivesError> migrate_to_v3() const; // Returns a detached post-birth candidate for an allocator-reserved request. // The caller supplies the durable identity; the owner derives founder biology, // funding, source and the first unoccupied provisioned site. Birth must occur // at the current checkpoint tick, after that tick's existing-life step. [[nodiscard]] std::expected, CellularLivesError> birth_candidate(LifeRequest request, LifeAllocation allocation) const; [[nodiscard]] static std::expected, CellularLivesError> restore(std::span bytes, std::uint64_t world, std::uint64_t region, std::uint64_t frame, std::uint64_t tick); // Advances every living cell exactly one 50 ms tick. Intentions are keyed by // stable life ID and must cover the living set exactly. Any refusal leaves // this owner byte-for-byte unchanged. [[nodiscard]] std::expected advance_tick(std::span intents); // Mutation selections are validated against the predecessor offer, then applied // after the normal life step and before births on the same advancing tick. [[nodiscard]] std::expected advance_tick_with_mutations(std::span intents, std::span selections); private: struct State; explicit CellularLives(std::unique_ptr state); std::unique_ptr state_; std::vector last_tick_feedback_; }; } // namespace evo::server