Foundation / checks (deploy) (push) Successful in 3m32s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m56s
Foundation / checks (network) (push) Successful in 13m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / checks (checks) (push) Successful in 33m36s
Foundation / checks (postgres) (push) Successful in 45m30s
Foundation / postgres-tools (push) Successful in 20s
Foundation / server-image (push) Successful in 25s
Foundation / image (push) Successful in 2m36s
Movement and ingestion are stored per second in schema 2 (ranges x20). Schema 1 records stay valid, are never rewritten, and read as exactly x20 via Genome::per_second; drafts default to schema 1 so existing literals keep their meaning. Development version 1 converts genome rates at its own 50 ms quantum (round down), so phenotypes are unchanged. Mutation keeps the parent's schema and step; the lineage archive header names exactly the highest schema held (all-schema-1 archives keep their bytes); the development-v1 opening names schema 1. No golden changed; two tests that used 2 as an unknown schema now use the next one. Refresh the dev session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
77 lines
4.0 KiB
C++
77 lines
4.0 KiB
C++
#pragma once
|
|
|
|
#include "evo/accounting/ledger.hpp"
|
|
#include "evo/biology/genome.hpp"
|
|
|
|
namespace evo::biology {
|
|
// What an organism has actually built and lost. Runtime state, never written
|
|
// back into the genome: heredity must not carry acquired condition.
|
|
struct GrowthState {
|
|
std::uint32_t realized_per_thousand{};
|
|
std::uint32_t damage_per_thousand{};
|
|
auto operator<=>(const GrowthState&) const = default;
|
|
};
|
|
struct EnvironmentState {
|
|
std::uint32_t temperature_millikelvin{};
|
|
// What is there to build from, per ledger channel. A single pool could not
|
|
// say that carbon is plentiful while nitrogen is not, which is the whole
|
|
// question once a body has a composition. Nothing here is spent or reserved.
|
|
accounting::Inventory available{};
|
|
auto operator<=>(const EnvironmentState&) const = default;
|
|
};
|
|
// Development version 1 is defined in ticks of this quantum: its per-tick constants and
|
|
// outputs, and the genome rates it reads (converted from per second, ADR-0099).
|
|
inline constexpr std::uint64_t development_v1_tick_microseconds = 50'000;
|
|
// Chosen constants, reviewable as a unit and selected by the genome's
|
|
// development version. Declared model parameters, not balance.
|
|
struct DevelopmentRules {
|
|
std::uint64_t structure_density; // femtograms per cubic micrometre
|
|
std::uint64_t membrane_density; // femtograms per cubic micrometre
|
|
std::uint64_t maintenance_per_kilogram; // picojoules per tick per 1000 fg
|
|
std::uint64_t membrane_upkeep_per_kilo; // picojoules per tick per 1000 fg
|
|
std::uint64_t construction_per_kilogram; // picojoules per 1000 fg built
|
|
std::uint64_t reference_surface; // square micrometres
|
|
std::uint32_t reference_temperature; // millikelvin
|
|
std::uint32_t growth_step_per_thousand; // most one plan may advance
|
|
};
|
|
// Dimensioned parameters derived from a genome and its runtime state. A derived
|
|
// phenotype is not a viability claim and holds no fitness score.
|
|
struct Phenotype {
|
|
std::uint64_t structural_mass{}; // femtograms
|
|
std::uint64_t membrane_mass{}; // femtograms
|
|
std::uint64_t total_mass{}; // femtograms
|
|
std::uint32_t extent{}; // micrometres, the cube-model side length
|
|
std::uint64_t surface{}; // square micrometres
|
|
std::uint64_t maintenance{}; // picojoules per tick
|
|
std::uint32_t movement_speed{}; // micrometres per tick; zero without the capability
|
|
std::uint64_t ingestion_rate{}; // femtograms per tick; zero without the capability
|
|
std::uint32_t conversion_per_thousand{};
|
|
// Millikelvin beyond the genome's tolerance. A reported quantity, not a rule.
|
|
std::uint32_t thermal_shortfall{};
|
|
auto operator<=>(const Phenotype&) const = default;
|
|
};
|
|
// A proposal. It reserves nothing, pays for nothing and commits nothing; the
|
|
// matching transfer does not exist until M3.3.
|
|
struct DevelopmentPlan {
|
|
GrowthState after{};
|
|
std::uint64_t material_required{};
|
|
std::uint64_t energy_required{};
|
|
auto operator<=>(const DevelopmentPlan&) const = default;
|
|
};
|
|
enum class DevelopmentError : std::uint8_t { unsupported_rules, invalid_growth, overflow };
|
|
|
|
[[nodiscard]] std::expected<DevelopmentRules, DevelopmentError>
|
|
rules_for(std::uint32_t development_version);
|
|
// Pure: a phenotype is recomputed from retained inputs rather than cached, so a
|
|
// cached copy can always be checked against a recomputation.
|
|
[[nodiscard]] std::expected<Phenotype, DevelopmentError>
|
|
derive_phenotype(const Genome& genome, GrowthState growth, EnvironmentState environment);
|
|
// Advances realized growth toward the target by at most the rule step, reduced to
|
|
// the largest step the available mass and energy admit. This bounds by total mass
|
|
// only: it cannot see which elements a step consumes, so it is a proposal and not
|
|
// an affordability authority. `metabolic_budget` decides that, per channel, and
|
|
// can only narrow this further. Never repairs damage.
|
|
[[nodiscard]] std::expected<DevelopmentPlan, DevelopmentError>
|
|
plan_development(const Genome& genome, GrowthState growth, EnvironmentState environment);
|
|
} // namespace evo::biology
|