#pragma once #include "evo/world/transfers.hpp" #include namespace evo::processes { // Explicit fixture parameters; units and array order in environmental-community.md. // Rules 1 and 2 state rates per tick of `tick_microseconds`. Rules 3 (ADR-0099) is rules // 2 with every rate per second: irradiance and growth as rationals per second (converted // exactly), and intake and decay caps per second (rounded down at the tick). struct EnvironmentalConfig { std::uint64_t rules{1}, world{}, frame{}, producer{}, consumer{}, source{}, tick_microseconds{}, area_um2{}, irradiance_numerator{}, irradiance_denominator{1}, efficiency{}, growth_numerator{}, growth_denominator{1}, growth_cost{}; std::array recipe{}, intake{}; std::uint64_t assimilation{}, producer_min_mK{}, producer_max_mK{}, consumer_min_mK{}, consumer_max_mK{}; std::array decay{}; // Rules 2+: shared source-channel caps per tick // (rules 3: per second). auto operator<=>(const EnvironmentalConfig&) const = default; }; struct EnvironmentalInput { std::uint64_t temperature_mK{}, source_enabled{}; std::array bite{}; std::array terminal{}; // Rules 2: trusted host facts, actor order. auto operator<=>(const EnvironmentalInput&) const = default; }; struct EnvironmentalProgress { std::uint64_t tick{}, source_remainder{}, last_funded{}, efficiency_remainder{}, growth_remainder{}, producer_terminal{}; std::uint64_t consumer_terminal{}; auto operator<=>(const EnvironmentalProgress&) const = default; }; struct EnvironmentalReport { std::uint64_t tick{}, captured{}, retained{}, capture_heat{}, grown{}, unmet{}, source_status{}; std::array assimilated{}, waste{}; std::uint64_t terminal_transition{}; std::uint64_t consumer_transition{}; std::array decomposed{}; auto operator<=>(const EnvironmentalReport&) const = default; }; enum class CommunityError : std::uint8_t { config, input, tick, conflict, stale, capacity, insufficient, overflow, budget, format, version, checksum, resources }; class EnvironmentalCommunity { public: static constexpr std::size_t history_limit = 64, scratch_bytes = 65536, max_snapshot_bytes = std::size_t{1024} * 1024; [[nodiscard]] static std::expected, CommunityError> create(EnvironmentalConfig config, std::unique_ptr resources, std::size_t budget); [[nodiscard]] std::expected advance(std::uint64_t tick, const EnvironmentalInput& input); [[nodiscard]] std::expected snapshot() const; [[nodiscard]] static std::expected, CommunityError> restore(std::span bytes, world::WorldIdentity identity, std::size_t budget); [[nodiscard]] const world::EnvironmentalTransfers& resources() const noexcept { return *resources_; } [[nodiscard]] EnvironmentalProgress progress() const noexcept { return progress_; } [[nodiscard]] std::uint64_t tick_microseconds() const noexcept { return config_.tick_microseconds; } [[nodiscard]] std::uint64_t world() const noexcept { return config_.world; } // Clone support (ADR-0067): records the region under another nonzero world ID, // keeping its frame. Rules, content and trajectory do not depend on the world ID // (ADR-0044), so rebinding back yields byte-identical snapshots. False for 0. [[nodiscard]] bool rebind_world(std::uint64_t world) noexcept; private: struct State { std::array environment{}, producer{}, consumer{}; EnvironmentalProgress progress{}; auto operator<=>(const State&) const = default; }; struct History { EnvironmentalInput input{}; EnvironmentalReport report{}; }; EnvironmentalCommunity() = default; [[nodiscard]] State state() const noexcept; [[nodiscard]] bool valid(const State& s) const noexcept; // Validates a configuration and returns its per-tick form (itself for rules 1 and 2; // rules 3's rates converted at its tick), or nothing when invalid. [[nodiscard]] static std::optional configuration(const EnvironmentalConfig& c, const world::EnvironmentalTransfers& r) noexcept; [[nodiscard]] std::expected step(State& candidate, std::uint64_t tick, const EnvironmentalInput& input) const noexcept; EnvironmentalConfig config_{}; // As configured and persisted. EnvironmentalConfig step_{}; // Its per-tick form, which every step uses. std::unique_ptr resources_; EnvironmentalProgress progress_{}; State anchor_{}; std::array history_{}; std::size_t count_{}, next_{}, budget_{}; }; } // namespace evo::processes