feat(biology): evolve photosynthetic producers that capture light
Foundation / checks (ecs) (push) Successful in 2m25s
Foundation / checks (deploy) (push) Successful in 5m15s
Foundation / checks (network) (push) Successful in 21m56s
Foundation / checks (client) (push) Successful in 22m54s
Foundation / checks (tsan) (push) Successful in 47m4s
Foundation / checks (postgres) (push) Successful in 1h15m49s
Foundation / checks (checks) (push) Failing after 1h30m4s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped

ADR-0175 implements ADR-0136 step C with trial costs to be balanced after
playtesting. Genome schema 5 adds a photosynthesis efficiency (empty in
schemas 1-4, so earlier offers and draws are unchanged; mutation operators
29-32 are appended). Development version 5 builds the organelles as
internal membrane (p/4 of structure, upkept twice) and slows movement by
p/2 per thousand. Founder 4 and cellular rules 11 let lineages earn the
capability as an offspring plan that children express.

Owner format 9 declares the region's light. Inside each tick's detached
candidate, active unfrozen producers capture cross-section x irradiance x
efficiency (a quarter while moving), credited to the reserve and boundary
inflow together and replayed from recorded intentions. Well-lit wildlife
producers hold still. The joint owner keeps infall, water and radiation and
nests a rules-11 owner unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-19 18:06:02 -04:00
co-authored by Claude Opus 5.5
parent 51991ac7ff
commit 108f29eda5
34 changed files with 856 additions and 128 deletions
+6 -1
View File
@@ -95,7 +95,8 @@ add_library(evo_lifecycle STATIC src/server/lifecycle/primitive_lives.cpp
src/server/lifecycle/cellular_play_summary.cpp src/server/lifecycle/cellular_population.cpp
src/server/lifecycle/cellular_population_codec.cpp src/server/lifecycle/cellular_population_policy.cpp
src/server/lifecycle/cellular_schedule.cpp src/server/lifecycle/cellular_population_batch.cpp
src/server/lifecycle/cellular_environment.cpp src/server/lifecycle/cellular_environment_batch.cpp)
src/server/lifecycle/cellular_environment.cpp src/server/lifecycle/cellular_environment_batch.cpp
src/server/lifecycle/cellular_light.cpp)
add_library(evo::lifecycle ALIAS evo_lifecycle)
target_link_libraries(evo_lifecycle PUBLIC evo::biology evo::world)
evo_owned_target(evo_lifecycle)
@@ -707,6 +708,10 @@ if(BUILD_TESTING)
-P "${CMAKE_CURRENT_SOURCE_DIR}/tests/cellular_population_restart.cmake")
set_tests_properties(cellular-retained-plan-population cellular-retained-plan-population-restart
PROPERTIES TIMEOUT ${evo_cohort_timeout})
add_executable(evo-photosynthesis-tests tests/photosynthesis_tests.cpp)
target_link_libraries(evo-photosynthesis-tests PRIVATE evo::lifecycle)
evo_owned_target(evo-photosynthesis-tests)
add_test(NAME photosynthesis-contracts COMMAND evo-photosynthesis-tests)
add_executable(evo-cellular-environment-tests tests/cellular_environment_tests.cpp)
target_link_libraries(evo-cellular-environment-tests PRIVATE evo::lifecycle)
evo_owned_target(evo-cellular-environment-tests)
@@ -12,7 +12,7 @@ spec:
env:
- {name: REGION_SESSION, value: "dev"}
- {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"}
- {name: REGION_SESSION_WINDOW, value: "dev-20261019T210956-a2cdedf2:1792458596"}
- {name: REGION_SESSION_WINDOW, value: "dev-20261019T215818-e009abce:1792461498"}
- {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"}
ports:
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
+12
View File
@@ -1,5 +1,17 @@
# Project status and next steps
## Photosynthesis producers (ADR-0136 step C) - 2026-10-19
[ADR-0175](adr/0175-photosynthesis-producers.md) adds genome schema 5's photosynthesis
capability with trial costs (organelle membrane mass and slower movement), founder 4
and cellular rules 11. A region declares light in owner format 9; each tick a still,
active producer captures cross-section x irradiance x efficiency (a quarter while
moving), booked as boundary inflow inside the same atomic tick. A founder earns the
capability as its offspring plan; its children express it and capture light. Every
earlier genome, offer, owner and environment byte keeps its meaning. Durable bundle,
session wire, client look and a DEV opening follow next. Numbers are trial values to
balance after playtesting.
## Cellular environment ownership (M12.5a-b) - 2026-10-19
The maintainer accepted one owner per patch of space for cells and their local
+64
View File
@@ -0,0 +1,64 @@
# ADR-0175: Photosynthesis producers
## Status and scope
Accepted 2026-10-19, implementing ADR-0136 step C. The maintainer authorized choosing
trial costs, to be balanced after playtesting; every number below is **tunable**. This
segment is portable biology and owner state; the session wire/client and durable/host
admission are separate segments. No default/live opening changes.
## Decision
**Capability.** Genome schema 5 adds `photosynthesis`, an efficiency per thousand
(1..1000) that requires a membrane. Schemas 1-4 carry an empty range for it, so no
earlier record, offer or draw changes. Mutation operators 29-32 (adjust up/down,
acquire, shed) are appended; earlier operator IDs are unchanged. Schema 5 keeps schema
4's percentage steps; an acquired photosynthesis starts at **100** (10 %).
**Costs (development version 5).** Version 4's rules, plus photosynthetic organelles
built as internal membrane: at efficiency p they add p/4 of the structural mass as
membrane mass (so they cost construction and are upkept twice, like membrane) and slow
movement by p/2 per thousand. Extent is unchanged. Light gives energy only; a producer
still needs C/N/P by contact to grow and bud.
**Founders and rules.** Founder 4 (schema 5, development 5) is founder 3 with that
schema: identical phenotype, body and endowment, and no photosynthesis. Cellular rules
11 are rules 10 (offspring plans) with founder 4. Under rules 10+, a selected mutation
edits the offspring plan, so photosynthesis is expressed by children (ADR-0163).
**Light is booked by the cell owner (owner format 9).** Incident light is not a stock and
has no other owner, so the region's cellular owner declares it: irradiance (pJ per square
micrometre of cross-section per tick, a rational; trial **40**), a cumulative entitlement
and the share a moving cell keeps (trial **250** per thousand), plus the energy captured
so far. An explicit no-tick format-8/rules-10 -> format-9/rules-11 upgrade declares the
light; existing lineages keep their schemas, and only founders born afterwards, and their
descendants, can evolve photosynthesis. Inside each tick's detached candidate, after the
step, every active, unfrozen photosynthetic survivor that had an intention captures
`extent^2 x irradiance x p / 1000`, a quarter of that if its intention moved, rounded down
and bounded by the remaining entitlement. Capture is credited to its reserve, the boundary
inflow and the current total together, so the tick commits or refuses as one unit. Light
nobody captures never enters the books. Capture depends only on recorded intentions and
state, so the existing raw trace replays it. A dark declaration captures nothing.
The ADR-0172 joint owner keeps infall, water and radiation and may nest a rules-11 owner;
its own environmental imports stay separate from the nested owner's captured light.
Putting light in the cell owner keeps producers on the existing live path (profile-4
publication, sessions and player actions) instead of requiring a second live trace.
**Wildlife.** Under rules 11 with declared light, a photosynthetic wildlife cell that
would capture at least its maintenance by holding still holds still (it still feeds from
what it touches); otherwise it forages as before.
Measured trial consequences (founder size, irradiance 40): at 10 % a still producer
captures 1,600 pJ/tick against 7,850 pJ/tick maintenance and moves 5 % slower; around
55 % it breaks even; at 100 % it captures 16,000 pJ/tick at half speed against
10,100 pJ/tick maintenance.
## Consequences
Plant-like lineages become possible without infinite energy: capture is bounded by
cross-section, efficiency, stillness and entitlement, and producers still compete for
matter. All earlier genome, mutation, development, cellular and environment bytes and
goldens keep their meaning. Durable admission of rules 11 (a new cellular bundle), the
session wire (capability 7 in offers, producer look) and a DEV opening remain before
playtesting.
+2
View File
@@ -1,5 +1,7 @@
# Architecture decision records
- [ADR-0175: Photosynthesis producers](0175-photosynthesis-producers.md) - genome schema 5 photosynthesis with trial organelle costs, founder 4/rules 11, light booked by the cell owner (format 9) from recorded intentions, light-aware wildlife; earlier bytes unchanged.
- [ADR-0174: Durable cellular environment profile](0174-durable-cellular-environment-profile.md) - schema 56 checkpoint profile 6 nesting population envelope 2; explicit one-way 5 -> 6 entry, fenced joint publication with owned intervals and SQL flow totals, exact replayed recovery.
- [ADR-0173: Cellular environment joint batch](0173-cellular-environment-batch.md) - portable `AEVOEBT1` wraps the unchanged population batch with per-tick recorded environmental flows; unattended recording runs the controller after each exchange and replay re-derives every flow exactly.
+1 -1
View File
@@ -66,7 +66,7 @@ or authorize production enablement.
| 12.2 | Exact cellular model and paired matrix; local samples through 256 lives; bounded four-generation rules-9 predation/twin matrix | Deployment-host tail costs including publication; larger wildlife cohorts and fuller contention coverage; useful compression remains unimplemented. |
| 12.3 | Dedicated population profile/trace/store/owning host; exact recovery and private PostgreSQL fault tests | Population-specific executable/network fault drills and target-host publication/capacity qualification. |
| 12.4 | Owned intervals; exact transfer/accounting; durable atomic pair/recovery; independent loopback TLS path loss and owner expiry/replacement/heal; local object sync/read-failure matrix | Multi-host/kernel-network, storage-host and orchestrator drills, linked-boundary contracts and integrated ownership/stock audits at scale. |
| 12.5 | ADR-0172 portable joint owner: one budget for cells and local environment, effective depth, tagged water/dissolved compartments, refused atmosphere, finite infall entitlements, radiative export; closed/source-off/open/exhaustion and raw/cohort comparisons; ADR-0173 joint batch with exact unattended replay; ADR-0174/schema 56 durable profile 6 with owned intervals and exact recovery | Producer process and coefficients (ADR-0136 step C), executable/network joint fault drills, worker/census/migration integration and escrowed cross-worker sources (12.5d), target-host qualification (12.5e). |
| 12.5 | ADR-0175 photosynthesis producers (portable rules 11/format 9); ADR-0172 portable joint owner: one budget for cells and local environment, effective depth, tagged water/dissolved compartments, refused atmosphere, finite infall entitlements, radiative export; closed/source-off/open/exhaustion and raw/cohort comparisons; ADR-0173 joint batch with exact unattended replay; ADR-0174/schema 56 durable profile 6 with owned intervals and exact recovery | Durable rules-11 bundle, producer session wire/client and DEV opening; joint fault drills (deferred by the maintainer), worker/census/migration integration and escrowed cross-worker sources (12.5d), target-host qualification (12.5e). |
| 12.6 | Retained archive, regional census/lineage queries, replayed history, scoped multi-region queries and consistent database head snapshots (12.6a-d); registered coverage/history domains follow in 12.7a-b | Cross-domain clone provenance, retained historical coverage/other viable stores, target-host query/index qualification and client permission/presentation; no account power or invented precise statistical ancestry. |
| 12.7 | Viability/unknown policy; consistent cuts, registered coverage, history domains/restore forks and verified pending handoff evidence (12.7a-c/schema 52) | Cross-domain clone provenance, other viable-store coverage and durable accepted global evidence records/freshness. Missing/stale/unsupported owners must prevent terminal extinction. |
| 12.8 | Deterministic seed/regime drivers, separate-process exact continuation and bounded unscripted generations | Reproducible integrated worlds running for actual days, real restarts/clone comparisons and retained accounting/diversity/cost audits. Accelerated tests cannot supply elapsed days. |
+36
View File
@@ -1,5 +1,41 @@
# Validation report
## 2026-10-19 - Photosynthesis producers (ADR-0175)
[ADR-0175](../adr/0175-photosynthesis-producers.md) adds genome schema 5, development 5,
founder 4, cellular rules 11 and owner format 9 with declared light.
Executed locally:
- GCC 14.2 Release full CTest **96/96** and MSVC 19.44 Release full CTest **96/96,
7.35 s**, with NDEBUG and no MSVC warnings.
- Clang 19.1 ASan/UBSan biology and cellular subset (36 tests): one failure, a
heap-use-after-free in the new producer test, which compared an iterator into a
mutation offer after the tick had replaced the state holding it. The test now decides
before the tick; the environment and photosynthesis tests then pass **3/3, 88.86 s**
with no sanitizer reports. No product code changed for it.
- clang-tidy 19 and clang-format 19 on every new and changed source and test.
- Private PostgreSQL population (35 s) and joint-environment suites still pass on the
changed biology.
Evidence: earlier genome schemas reject photosynthesis at any value and their offers
never include it (catalog grows from 28 to 32 with IDs 29-32 appended); all existing
goldens and cellular suites are unchanged. Founder 4 has founder 3's phenotype, body,
maintenance, reproduction investment and endowment exactly. Organelle mass, maintenance
and speed match the declared rule at 100, 500 and 1000 (maintenance 7,850 / 8,850 /
10,100 pJ/tick vs the founder's 7,600; still capture 1,600 / 8,000 / 16,000; moving a
quarter). A founder in a rules-11 region took the offered photosynthesis plan at tick
159; its budded child captured 387,200 pJ over 400 ticks with exact closure (captured
light equals the boundary energy inflow). Format 9 restores and continues byte-identically;
a nested joint owner keeps its infall separate from the owner's light. Twenty times the
irradiance gives exactly twenty times the capture on the same history; a dark declaration
captures nothing. In this rich fixture producers always touch food, so the light-driven
hold-still branch of the wildlife controller is not exercised by these tests.
The ADR-0175 design first placed light in the joint owner; it was moved into the cell
owner before commit so producers can use the existing live publication path. No durable
bundle, SQL schema, session wire, client, DEV opening or live upgrade changes here.
## 2026-10-19 - Durable cellular environment profile (M12.5c)
[ADR-0174](../adr/0174-durable-cellular-environment-profile.md)/schema 56 adds
+8 -2
View File
@@ -32,8 +32,8 @@ inline constexpr std::uint64_t development_v2_rate_microseconds = 1'000'000;
[[nodiscard]] constexpr std::uint64_t
development_rate_microseconds(std::uint32_t development_version) noexcept {
return development_version == 1 ? development_v1_tick_microseconds
: development_version >= 2 && development_version <= 4
? development_v2_rate_microseconds // Versions 3 and 4 keep version 2's rates.
: development_version >= 2 && development_version <= 5
? development_v2_rate_microseconds // Versions 3-5 keep version 2's rates.
: 0;
}
// Chosen constants, reviewable as a unit and selected by the genome's
@@ -64,6 +64,12 @@ struct Phenotype {
std::uint32_t thermal_shortfall{};
auto operator<=>(const Phenotype&) const = default;
};
// Development version 5 (ADR-0175; trial values): photosynthetic organelles are membrane
// built inside the cell. At efficiency p per thousand they add p/4 of the structural mass
// as membrane mass (so they are upkept twice, like membrane) and slow movement by p/2 per
// thousand. Light itself is captured by the region's environment owner, never here.
inline constexpr std::uint32_t photosynthesis_organelle_quarter = 4;
inline constexpr std::uint32_t photosynthesis_speed_halving = 2;
// A proposal. It reserves nothing, pays for nothing and commits nothing; the
// matching transfer does not exist until M3.3.
struct DevelopmentPlan {
+3
View File
@@ -34,6 +34,9 @@ inline constexpr FounderVersion primitive_founder_v1{genome_schema_v2, 2};
inline constexpr FounderVersion primitive_founder_v2{genome_schema_v3, 3};
// Founder 3 serves rules 7 (ADR-0137): percentage mutation steps and skilled reproduction.
inline constexpr FounderVersion primitive_founder_v3{genome_schema_v4, 4};
// Founder 4 serves rules 11 (ADR-0175): founder 3 that can evolve photosynthesis. Founders
// start without it; the capability is only ever earned through mutation.
inline constexpr FounderVersion primitive_founder_v4{genome_schema_v5, 5};
inline constexpr std::uint32_t primitive_founder_development_version =
primitive_founder_v1.development_version;
// The founder genome under a world-scoped identity and its origin event. Fails only on
+28 -7
View File
@@ -17,9 +17,10 @@ enum class Capability : std::uint8_t {
ingestion,
reproduction,
target_size,
thermal_tolerance
thermal_tolerance,
photosynthesis // Schema 5 (ADR-0175); unrepresentable in earlier schemas.
};
inline constexpr std::size_t capability_count = 7;
inline constexpr std::size_t capability_count = 8;
// The unit is a schema fact per kind and is never encoded, so no record can
// contradict its own units.
enum class Unit : std::uint8_t {
@@ -55,7 +56,9 @@ inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
capability_bit(Capability::energy_conversion)},
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0},
// An empty range: no schema-1 record can carry photosynthesis.
CapabilitySpec{Unit::per_thousand, 1, 0, false, 0}};
// Schema 2 (ADR-0099): the same capabilities with rates per second. Each rate range is
// schema 1's times 20, so every schema 1 value has an exact schema 2 equivalent.
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v2{
@@ -68,7 +71,22 @@ inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
capability_bit(Capability::energy_conversion)},
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0},
CapabilitySpec{Unit::per_thousand, 1, 0, false, 0}}; // Not in schemas 2-4.
// Schema 5 (ADR-0175): schema 2 plus photosynthesis, an efficiency per thousand that
// needs a membrane to hold its organelles.
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v5{
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
CapabilitySpec{Unit::micrometres_per_second, 0, 2'000'000, false,
capability_bit(Capability::membrane)},
CapabilitySpec{Unit::femtograms_per_second, 0, 20'000'000, false,
capability_bit(Capability::membrane)},
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
capability_bit(Capability::energy_conversion)},
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0},
CapabilitySpec{Unit::per_thousand, 1, 1000, false, capability_bit(Capability::membrane)}};
// The current schema's table.
inline constexpr const auto& capability_schema = capability_schema_v2;
// Schema 1 rates are per tick of this quantum.
@@ -114,15 +132,18 @@ inline constexpr std::uint32_t genome_schema_v3 = 3;
// Schema 4 (rules 7, ADR-0137): schema 2's table and units; a mutation step is a tenth of
// the current value (at least 1), and an acquired capability starts at the founder's value.
inline constexpr std::uint32_t genome_schema_v4 = 4;
// Schema 5 (rules 11, ADR-0175): schema 4's steps with the photosynthesis capability.
inline constexpr std::uint32_t genome_schema_v5 = 5;
// The newest schema. Older records stay valid and are never rewritten (ADR-0099).
inline constexpr std::uint32_t genome_schema_version = genome_schema_v4;
// The capability table of a supported schema (1 to 4); nullptr otherwise.
inline constexpr std::uint32_t genome_schema_version = genome_schema_v5;
// The capability table of a supported schema (1 to 5); nullptr otherwise.
[[nodiscard]] constexpr const std::array<CapabilitySpec, capability_count>*
capability_schema_for(std::uint32_t schema) noexcept {
return schema == genome_schema_v1 ? &capability_schema_v1
: schema == genome_schema_v2 || schema == genome_schema_v3 || schema == genome_schema_v4
? &capability_schema_v2
: nullptr;
: schema == genome_schema_v5 ? &capability_schema_v5
: nullptr;
}
inline constexpr std::size_t max_parents = 2;
inline constexpr std::size_t max_genome_bytes = 256;
+2
View File
@@ -68,6 +68,8 @@ enum class MutationError : std::uint8_t {
development
};
inline constexpr std::size_t max_candidates = 8;
// ADR-0175 trial value: an acquired photosynthesis starts at 10 % efficiency.
inline constexpr std::uint32_t photosynthesis_acquired_start = 100;
[[nodiscard]] std::span<const MutationOperator> mutation_catalog() noexcept;
// Identical inputs always yield identical candidates, sorted by operator ID.
@@ -69,7 +69,7 @@ struct CellularEnvironmentConfig {
};
struct CellularEnvironmentTickReport {
std::uint64_t tick{};
accounting::Inventory imported{};
accounting::Inventory imported{}; // Infall only; a rules-11 owner books its own light.
accounting::Picojoules exported{};
std::uint64_t events{}, credited_bubbles{}, skipped_bubbles{};
CellularTickExecution biology;
@@ -114,7 +114,7 @@ class CellularEnvironment {
[[nodiscard]] std::span<const CellularInfallSource> sources() const noexcept;
[[nodiscard]] std::span<const CellularInfallProgress> infall() const noexcept;
[[nodiscard]] accounting::Picojoules radiation_cap() const noexcept;
[[nodiscard]] accounting::Inventory imported() const noexcept; // All sources, cumulative.
[[nodiscard]] accounting::Inventory imported() const noexcept; // Infall, cumulative.
[[nodiscard]] accounting::Picojoules exported() const noexcept;
[[nodiscard]] std::uint64_t tick() const noexcept;
@@ -139,6 +139,13 @@ class CellularEnvironment {
friend std::expected<std::unique_ptr<CellularEnvironment>, CellularEnvironmentError>
execute_environment_batch(const CellularEnvironment&, CellularEnvironmentBatch&, bool record);
struct Exchange;
struct Step {
CellularEnvironmentTickReport report;
};
enum class StepMode : std::uint8_t { live, record, replay };
[[nodiscard]] std::expected<Step, CellularEnvironmentError>
joint_step(std::vector<CellularLifeIntent>& intents,
std::span<const CellularMutationSelection> selections, StepMode mode);
CellularEnvironment(std::unique_ptr<CellularPopulation> population,
CellularEnvironmentConfig config);
[[nodiscard]] std::expected<Exchange, CellularEnvironmentError>
@@ -0,0 +1,34 @@
#pragma once
#include "evo/accounting/ledger.hpp"
#include "evo/biology/genome.hpp"
#include <compare>
#include <cstdint>
#include <optional>
namespace evo::server {
// ADR-0175 trial values: light on a region's habitat, as picojoules per square micrometre
// of a cell's cross-section per 50 ms tick (a rational), and the share a moving cell keeps.
inline constexpr std::uint64_t cellular_light_trial_irradiance = 40;
inline constexpr std::uint32_t cellular_light_trial_moving_per_thousand = 250;
// Declared light on one habitat. The entitlement bounds cumulative capture; light nobody
// captures is not modelled and never enters the books.
struct CellularLight {
std::uint64_t numerator{}, denominator{1};
accounting::Picojoules entitlement{};
std::uint32_t moving_per_thousand{cellular_light_trial_moving_per_thousand};
auto operator<=>(const CellularLight&) const = default;
};
[[nodiscard]] constexpr bool cellular_light_valid(const CellularLight& light) noexcept {
return light.denominator != 0 && light.moving_per_thousand <= 1000 &&
(light.numerator == 0) == (light.entitlement.value == 0);
}
// Energy one cell captures in a tick: cross-section (extent squared) x irradiance x its
// photosynthesis efficiency, reduced while moving, rounded down. Nothing for a genome
// without the capability. Nothing on overflow (refused, never wrapped).
[[nodiscard]] std::optional<std::uint64_t> cellular_light_capture(const biology::Genome& genome,
std::uint32_t extent_um,
const CellularLight& light,
bool moving) noexcept;
} // namespace evo::server
@@ -2,6 +2,7 @@
#include "evo/biology/cellular_region_step.hpp"
#include "evo/biology/mutation.hpp"
#include "evo/server/lifecycle/cellular_light.hpp"
#include "evo/server/lifecycle/primitive_lives.hpp"
#include <compare>
@@ -50,13 +51,23 @@ inline constexpr std::uint32_t cellular_lives_maturation_rules = 9;
// ADR-0165: explicit offspring-plan editing mode; expressed bodies retain their genomes.
inline constexpr std::uint32_t cellular_lives_inheritance_format = 8;
inline constexpr std::uint32_t cellular_lives_inheritance_rules = 10;
// ADR-0175: rules 10 with founder 4 (genome schema 5), which can evolve photosynthesis.
// Format 9 is format 8 with the region's declared light and cumulative capture.
inline constexpr std::uint32_t cellular_lives_light_format = 9;
inline constexpr std::uint32_t cellular_lives_photosynthesis_rules = 11;
// Rules that retain offspring plans (formats 8 and 9): 10 and 11.
[[nodiscard]] constexpr bool cellular_retained_plans(std::uint32_t rules) noexcept {
return rules == cellular_lives_inheritance_rules ||
rules == cellular_lives_photosynthesis_rules;
}
inline constexpr std::uint32_t cellular_growth_per_tick = 5; // Per 50 ms; trial rate.
// The founder a region of these rules creates.
[[nodiscard]] constexpr biology::FounderVersion
cellular_founder_version(std::uint32_t rules) noexcept {
return rules >= cellular_lives_reproduction_rules ? biology::primitive_founder_v3
: rules >= cellular_lives_balance_rules ? biology::primitive_founder_v2
: biology::primitive_founder_v1;
return rules >= cellular_lives_photosynthesis_rules ? biology::primitive_founder_v4
: rules >= cellular_lives_reproduction_rules ? biology::primitive_founder_v3
: rules >= cellular_lives_balance_rules ? biology::primitive_founder_v2
: biology::primitive_founder_v1;
}
// ADR-0137: a bud action also yields a twin with probability reproduction / 2 per thousand
// (founders: 25 %), when the reserve funds it and there is room. Seeded per parent and tick.
@@ -283,6 +294,14 @@ class CellularLives {
// ADR-0165: explicit no-tick format-7/rules-9 -> format-8/rules-10 upgrade.
[[nodiscard]] std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
inheritance_upgrade_candidate() const;
// ADR-0175: explicit no-tick format-8/rules-10 -> format-9/rules-11 upgrade declaring
// the region's light. Existing lineages keep their genome schemas; only founders born
// afterwards can evolve photosynthesis.
[[nodiscard]] std::expected<std::unique_ptr<CellularLives>, CellularLivesError>
photosynthesis_upgrade_candidate(CellularLight light) const;
// Format 9: declared light and the energy captured from it, cumulatively.
[[nodiscard]] const CellularLight& light() const noexcept;
[[nodiscard]] accounting::Picojoules captured_light() const noexcept;
[[nodiscard]] std::span<const CellularOffspringRevision> offspring_revisions() const noexcept;
// Latest successful in-memory step report; omitted from snapshots and empty after restore.
[[nodiscard]] std::span<const CellularLifeTickFeedback> last_tick_feedback() const noexcept;
@@ -23,7 +23,9 @@ inline constexpr std::int16_t wildlife_full_speed = 1'000;
// One intention per wildlife life (zero account), sorted by life id: bud when the reserve
// funds one, else steer to and feed from the nearest perceived patch holding energy,
// else wander. Owned lives are left to their players.
// else wander. Owned lives are left to their players. ADR-0175: under rules 11 with
// the region's declared light, a photosynthetic cell that would capture at least its
// maintenance by holding still stays still (it still feeds from whatever it touches).
[[nodiscard]] std::expected<std::vector<CellularLifeIntent>, CellularLivesError>
wildlife_intents(const CellularLives& state, std::uint64_t tick);
} // namespace evo::server
+25
View File
@@ -0,0 +1,25 @@
# Cellular owner format 9: declared light
Authority: [ADR-0175](../docs/adr/0175-photosynthesis-producers.md). Format 9 is exactly
rules 11. It is [format 8](cellular-lives-v8.md) with magic `AEVCLV09` and a 40-byte
light block after the offspring-plan count; every other record, length rule and
validation is format 8's. Format 8 is exactly rules 10. Earlier formats are unchanged.
| Offset | Bytes | Field |
|---:|---:|---|
| 316 | 8 | Irradiance numerator, pJ per square micrometre of cross-section per tick |
| 324 | 8 | Irradiance denominator, nonzero |
| 332 | 8 | Light entitlement, pJ; zero exactly when the numerator is zero (dark) |
| 340 | 4 | Share a moving cell keeps, per thousand, at most 1000 |
| 344 | 4 | Reserved zero |
| 348 | 8 | Cumulative captured energy, at most the entitlement |
| 356 | 8 each | Sorted spawn sites, then lives, corpses and the rest as in format 8 |
The exact length is format 8's plus 40. Captured light is part of the boundary inflow
(`incoming.energy`) and therefore of the closure `current = opening + incoming -
outgoing`; no other balance holds it. Replay re-derives every capture from recorded
intentions and the stored state; the raw trace format is unchanged (trace 4).
Format 9 arises only from the explicit no-tick format-8/rules-10 upgrade, which keeps
every existing lineage, body and plan. No SQL schema, checkpoint bundle, population
profile or migration adapter admits it yet.
+15 -2
View File
@@ -69,7 +69,8 @@ std::expected<DevelopmentRules, DevelopmentError> rules_for(std::uint32_t develo
// heat, so this changes no matter balance.
// Version 4 (rules 7, ADR-0137) keeps version 3's rules; only what reproduction
// means changes (metabolism.cpp).
if (development_version == 3 || development_version == 4) {
// Version 5 (ADR-0175) keeps them too; it adds photosynthetic organelles below.
if (development_version >= 3 && development_version <= 5) {
return DevelopmentRules{1000, 1200, 10, 15, 13, 60'000, 293'150, 50};
}
return std::unexpected{DevelopmentError::unsupported_rules};
@@ -101,6 +102,16 @@ derive_phenotype(const Genome& genome, GrowthState growth, EnvironmentState envi
!multiply(phenotype.membrane_mass, shell, rules->membrane_density)) {
return std::unexpected{DevelopmentError::overflow};
}
const auto photosynthesis =
genome.development_version() >= 5 && genome.carries(Capability::photosynthesis)
? *genome.parameter(Capability::photosynthesis)
: 0U;
if (photosynthesis != 0 &&
!add(
phenotype.membrane_mass, phenotype.membrane_mass,
scaled(phenotype.structural_mass / photosynthesis_organelle_quarter, photosynthesis))) {
return std::unexpected{DevelopmentError::overflow};
}
if (!add(phenotype.total_mass, phenotype.structural_mass, phenotype.membrane_mass)) {
return std::unexpected{DevelopmentError::overflow};
}
@@ -124,7 +135,9 @@ derive_phenotype(const Genome& genome, GrowthState growth, EnvironmentState envi
if (!speed || *speed > std::numeric_limits<std::uint32_t>::max()) {
return std::unexpected{DevelopmentError::overflow};
}
phenotype.movement_speed = static_cast<std::uint32_t>(*speed);
// Organelles slow the cell: p/2 per thousand off its speed (version 5).
const auto kept = thousand - photosynthesis / photosynthesis_speed_halving;
phenotype.movement_speed = static_cast<std::uint32_t>(scaled(*speed, kept));
}
if (genome.carries(Capability::ingestion)) {
const auto intake = rate_per_tick(*genome.per_second(Capability::ingestion));
+3 -3
View File
@@ -109,8 +109,8 @@ metabolic_rules_for(std::uint32_t development_version) {
return MetabolicRules{structure_shares, membrane_shares, 20, 50'000};
}
// Version 2: per second; movement at 1000 um/s costs 50 pJ/s per 1000 fg (tunable).
// Versions 3 and 4: the same metabolism.
if (development_version >= 2 && development_version <= 4) {
// Versions 3, 4 and 5: the same metabolism.
if (development_version >= 2 && development_version <= 5) {
return MetabolicRules{structure_shares, membrane_shares, 50, 50'000};
}
return std::unexpected{DevelopmentError::unsupported_rules};
@@ -209,7 +209,7 @@ metabolic_budget(const Genome& genome, GrowthState growth, EnvironmentState envi
// Version 4 (ADR-0137): a bud is always half the body, and reproduction is skill:
// it takes up to half off the bud's construction energy (value / 2000). Matter is
// never discounted (ADR-0118). Earlier versions invest `value` per thousand.
const bool skill = genome.development_version() == 4;
const bool skill = genome.development_version() >= 4; // Versions 4 and 5.
const auto fraction = skill ? bud_body_per_thousand_v4 : value;
// A parent divides the body it has, so the investment keeps its composition.
budget.reproduction_investment = fraction_of(budget.body, fraction);
+11 -8
View File
@@ -10,7 +10,8 @@
namespace evo::biology {
namespace {
// Four effects over seven capabilities. IDs are stable and carry no ranking;
// Four effects over eight capabilities. IDs are stable and carry no ranking;
// photosynthesis (ADR-0175) appends IDs 29-32, so every earlier ID is unchanged;
// they exist to order candidates canonically and to name one across calls.
constexpr std::array<MutationOperator, 4 * capability_count> catalog = [] {
std::array<MutationOperator, 4 * capability_count> entries{};
@@ -38,7 +39,7 @@ constexpr std::array<MutationOperator, 4 * capability_count> catalog = [] {
constexpr std::uint32_t adjustment_step(const std::array<CapabilitySpec, capability_count>& table,
Capability kind, std::uint32_t schema,
std::uint32_t current) noexcept {
if (schema == genome_schema_v4)
if (schema == genome_schema_v4 || schema == genome_schema_v5)
return current / 10 == 0 ? 1 : current / 10;
const auto& limits = table[static_cast<std::size_t>(kind)];
const auto span = limits.maximum - limits.minimum;
@@ -48,10 +49,11 @@ constexpr std::uint32_t adjustment_step(const std::array<CapabilitySpec, capabil
std::uint32_t acquired_start(Capability kind, const CapabilitySpec& limits) noexcept {
const auto& p = primitive_founder_parameters;
const auto value = kind == Capability::movement ? p.movement
: kind == Capability::ingestion ? p.ingestion
: kind == Capability::reproduction ? p.reproduction
: limits.minimum;
const auto value = kind == Capability::movement ? p.movement
: kind == Capability::ingestion ? p.ingestion
: kind == Capability::reproduction ? p.reproduction
: kind == Capability::photosynthesis ? photosynthesis_acquired_start
: limits.minimum;
return std::clamp(value, limits.minimum, limits.maximum);
}
@@ -134,13 +136,14 @@ std::optional<GenomeDraft> apply(const Genome& genome, const MutationOperator& e
break;
}
case MutationEffect::acquire:
if (present) {
// An empty range (photosynthesis before schema 5) is not acquirable at all.
if (present || limits.maximum < limits.minimum) {
return std::nullopt;
}
// Schema 4 starts an acquired capability at the founder's value (a percentage of
// the minimum, zero speed for instance, would never grow); otherwise the minimum.
draft.capabilities.push_back({entry.target,
genome.schema_version() == genome_schema_v4
genome.schema_version() >= genome_schema_v4
? acquired_start(entry.target, limits)
: limits.minimum,
0});
+2 -2
View File
@@ -40,8 +40,8 @@ bool owner_version_matches(const CellularLives& owner, const CellularBatch& batc
if (!known_format(batch.format_version))
return false;
if (batch.format_version == cellular_batch_inheritance_format)
return owner.format_version() == cellular_lives_inheritance_format &&
owner.rules_version() == cellular_lives_inheritance_rules;
return owner.format_version() >= cellular_lives_inheritance_format &&
cellular_retained_plans(owner.rules_version());
return owner.format_version() < cellular_lives_inheritance_format;
}
bool payload_version_matches(const CellularBatch& batch) {
+2 -2
View File
@@ -57,8 +57,8 @@ CellularCensus::observe(const CellularLives& state, std::span<const CellularCoho
state.format_version() == cellular_lives_migration_format &&
(population == 0 || population == 2);
const bool inherited =
state.rules_version() == cellular_lives_inheritance_rules &&
state.format_version() == cellular_lives_inheritance_format &&
cellular_retained_plans(state.rules_version()) &&
state.format_version() >= cellular_lives_inheritance_format &&
(population == 0 || population == cellular_population_inheritance_format);
if (!inherited && ((!maturing && state.rules_version() != cellular_lives_foraging_rules) ||
(state.format_version() != cellular_lives_presence_format &&
+79 -49
View File
@@ -97,8 +97,8 @@ bool supported(const CellularLives& state) noexcept {
return (state.format_version() == cellular_lives_migration_format &&
(state.rules_version() == cellular_lives_foraging_rules ||
state.rules_version() == cellular_lives_maturation_rules)) ||
(state.format_version() == cellular_lives_inheritance_format &&
state.rules_version() == cellular_lives_inheritance_rules);
(state.format_version() >= cellular_lives_inheritance_format &&
cellular_retained_plans(state.rules_version()));
}
std::expected<world::HabitatMeasure, CellularEnvironmentError>
validate(const CellularLives& state, const CellularEnvironmentConfig& config) {
@@ -285,11 +285,20 @@ CellularEnvironment::plan_exchange(std::uint64_t tick) const {
return exchange;
}
std::expected<CellularEnvironmentTickReport, CellularEnvironmentError>
CellularEnvironment::advance_tick(std::span<const CellularLifeIntent> controlled,
std::span<const CellularMutationSelection> selections) {
// One joint tick, shared by live play, unattended recording and replay: the infall and
// heat exchange; the full intentions (live: the shared controller on the exchanged state
// plus the players'; record: the controller plus frozen players; replay: as recorded);
// then the unchanged biological step, which books a rules-11 owner's own light. Any
// refusal swaps the exchange back, so the owner is unchanged.
std::expected<CellularEnvironment::Step, CellularEnvironmentError>
CellularEnvironment::joint_step(std::vector<CellularLifeIntent>& intents,
std::span<const CellularMutationSelection> selections,
StepMode mode) {
if (tick() == std::numeric_limits<std::uint64_t>::max())
return std::unexpected(CellularEnvironmentError::overflow);
if (population_->policy_.automatic &&
population_->conversion_sequence_ == std::numeric_limits<std::uint64_t>::max())
return std::unexpected(CellularEnvironmentError::overflow);
auto exchange = plan_exchange(tick() + 1);
if (!exchange)
return std::unexpected(exchange.error());
@@ -299,53 +308,57 @@ CellularEnvironment::advance_tick(std::span<const CellularLifeIntent> controlled
return std::unexpected(savepoint.error() == CellularLivesError::habitat
? CellularEnvironmentError::habitat
: CellularEnvironmentError::conservation);
auto executed = population_->advance_tick(controlled, selections);
if (!executed) {
const auto refuse = [&](CellularEnvironmentError error) {
lives.restore_boundary(std::move(*savepoint));
return std::unexpected(CellularEnvironmentError::biology);
}
progress_ = std::move(exchange->progress);
exported_.value += exchange->heat_export.value;
exchange->report.biology = std::move(*executed);
return std::move(exchange->report);
}
std::expected<CellularEnvironmentFlow, CellularEnvironmentError>
CellularEnvironment::advance_unattended(std::vector<CellularLifeIntent>& intents, bool record) {
if (tick() == std::numeric_limits<std::uint64_t>::max())
return std::unexpected(CellularEnvironmentError::overflow);
auto exchange = plan_exchange(tick() + 1);
if (!exchange)
return std::unexpected(exchange.error());
auto& lives = *population_->state_;
auto savepoint = lives.exchange_boundary(exchange->deposits, exchange->heat_export);
if (!savepoint)
return std::unexpected(savepoint.error() == CellularLivesError::habitat
? CellularEnvironmentError::habitat
: CellularEnvironmentError::conservation);
return std::unexpected(error);
};
biology::CellularStepIntent frozen;
frozen.frozen = true;
if (record) {
if (mode != StepMode::replay) {
auto chosen = wildlife_intents(lives, lives.tick() + 1);
if (!chosen)
return std::unexpected(CellularEnvironmentError::biology);
for (const auto& life : lives.lives())
if (life.account != LifeAccount{})
return refuse(CellularEnvironmentError::biology);
std::size_t player = 0;
for (const auto& life : lives.lives()) {
if (life.account == LifeAccount{})
continue;
if (mode == StepMode::record) {
chosen->push_back({life.identity.life, frozen});
} else {
if (player == intents.size() || intents[player].life_id != life.identity.life)
return refuse(CellularEnvironmentError::biology);
chosen->push_back(intents[player++]);
}
}
if (mode == StepMode::live && player != intents.size())
return refuse(CellularEnvironmentError::biology);
std::ranges::sort(*chosen, {}, &CellularLifeIntent::life_id);
intents = std::move(*chosen);
}
for (const auto& life : lives.lives()) {
if (life.account == LifeAccount{})
continue;
const auto found =
std::ranges::find(intents, life.identity.life, &CellularLifeIntent::life_id);
if (life.presence != CellularPresence::suspended || found == intents.end() ||
found->intent != frozen)
return std::unexpected(CellularEnvironmentError::unsupported);
if (mode == StepMode::live) {
for (const auto& selection : selections) {
const auto life =
std::ranges::find(lives.lives(), selection.life_id,
[](const auto& owned) { return owned.identity.life; });
if (life == lives.lives().end() || life->account == LifeAccount{})
return refuse(CellularEnvironmentError::biology);
}
} else {
if (!selections.empty())
return refuse(CellularEnvironmentError::unsupported);
for (const auto& life : lives.lives()) {
if (life.account == LifeAccount{})
continue;
const auto found =
std::ranges::find(intents, life.identity.life, &CellularLifeIntent::life_id);
if (life.presence != CellularPresence::suspended || found == intents.end() ||
found->intent != frozen)
return refuse(CellularEnvironmentError::unsupported);
}
}
if (!lives.advance_tick(intents))
return std::unexpected(CellularEnvironmentError::biology);
auto executed = lives.advance_tick_with_mutations(intents, selections);
if (!executed)
return refuse(CellularEnvironmentError::biology);
auto& members = population_->members_;
std::erase_if(members, [&lives](const auto& member) {
return std::ranges::find(lives.lives(), member.life, [](const auto& life) {
@@ -353,14 +366,30 @@ CellularEnvironment::advance_unattended(std::vector<CellularLifeIntent>& intents
}) == lives.lives().end();
});
// The persisted policy's exact result; no random materialization or resampling.
if (population_->policy_.automatic) {
if (population_->conversion_sequence_ == std::numeric_limits<std::uint64_t>::max())
return std::unexpected(CellularEnvironmentError::overflow);
if (population_->policy_.automatic)
population_->apply_policy();
}
progress_ = std::move(exchange->progress);
exported_.value += exchange->heat_export.value;
return CellularEnvironmentFlow{exchange->report.imported, exchange->heat_export};
exchange->report.biology = std::move(*executed);
return Step{std::move(exchange->report)};
}
std::expected<CellularEnvironmentTickReport, CellularEnvironmentError>
CellularEnvironment::advance_tick(std::span<const CellularLifeIntent> controlled,
std::span<const CellularMutationSelection> selections) {
std::vector<CellularLifeIntent> intents(controlled.begin(), controlled.end());
auto step = joint_step(intents, selections, StepMode::live);
if (!step)
return std::unexpected(step.error());
return std::move(step->report);
}
std::expected<CellularEnvironmentFlow, CellularEnvironmentError>
CellularEnvironment::advance_unattended(std::vector<CellularLifeIntent>& intents, bool record) {
auto step = joint_step(intents, {}, record ? StepMode::record : StepMode::replay);
if (!step)
return std::unexpected(step.error());
return CellularEnvironmentFlow{step->report.imported, step->report.exported};
}
CellularPopulationBoundary CellularEnvironment::population_boundary() const {
return {population_->conversion_sequence_, population_->members_};
@@ -502,8 +531,9 @@ CellularEnvironment::restore(std::span<const std::uint8_t> bytes, std::uint64_t
return std::unexpected(candidate.error());
(*candidate)->progress_ = std::move(progress);
(*candidate)->exported_ = exported;
// Environmental flows are part of the nested ledger, never in addition to it.
accounting::Inventory flows;
// Environmental flows are part of the nested ledger, never in addition to it; a
// rules-11 owner's light is booked there too.
accounting::Inventory flows{(*candidate)->state().captured_light(), {}};
for (const auto& done : (*candidate)->progress_)
if (!add(flows, done.imported))
return std::unexpected(CellularEnvironmentError::conservation);
@@ -73,10 +73,9 @@ execute_environment_batch(const CellularEnvironment& base, CellularEnvironmentBa
if (record) {
population.biology.header = h;
population.biology.ticks.clear();
population.biology.format_version =
state.rules_version() == cellular_lives_inheritance_rules
? cellular_batch_inheritance_format
: cellular_batch_format;
population.biology.format_version = cellular_retained_plans(state.rules_version())
? cellular_batch_inheritance_format
: cellular_batch_format;
}
for (std::size_t index = 0; index < count; ++index) {
std::vector<CellularLifeIntent> intents;
+35
View File
@@ -0,0 +1,35 @@
#include "evo/server/lifecycle/cellular_light.hpp"
#include <limits>
namespace evo::server {
namespace {
bool multiply(std::uint64_t& value, std::uint64_t factor) noexcept {
if (factor != 0 && value > std::numeric_limits<std::uint64_t>::max() / factor)
return false;
value *= factor;
return true;
}
} // namespace
std::optional<std::uint64_t> cellular_light_capture(const biology::Genome& genome,
std::uint32_t extent_um,
const CellularLight& light,
bool moving) noexcept {
if (!genome.carries(biology::Capability::photosynthesis) || light.numerator == 0 ||
light.denominator == 0)
return 0;
const auto efficiency = genome.parameter(biology::Capability::photosynthesis);
if (!efficiency)
return std::nullopt;
// Exact checked products before the single rounding; overflow is refused.
std::uint64_t energy = extent_um;
if (!multiply(energy, extent_um) || !multiply(energy, light.numerator) ||
!multiply(energy, *efficiency) || (moving && !multiply(energy, light.moving_per_thousand)))
return std::nullopt;
std::uint64_t divisor = light.denominator;
if (!multiply(divisor, 1000) || (moving && !multiply(divisor, 1000)))
return std::nullopt;
return energy / divisor;
}
} // namespace evo::server
+130 -24
View File
@@ -22,6 +22,7 @@ constexpr std::uint64_t cellular_lives_v5_magic = 0x3530564C43564541ULL; // AEVC
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::size_t cellular_lives_header_bytes = 212;
constexpr std::size_t cellular_site_bytes = 8;
constexpr std::size_t cellular_life_v1_bytes = 168;
@@ -39,6 +40,9 @@ 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;
constexpr std::size_t cellular_offspring_revision_bytes = 32;
std::uint64_t checksum(std::span<const std::uint8_t> bytes) noexcept {
@@ -585,6 +589,8 @@ struct CellularLives::State {
std::uint64_t next_bud_sequence{1}; // Format 5: the next bud identity's sequence.
CellularBoundaryLedger boundary{};
std::vector<CellularOffspringRevision> offspring_revisions;
CellularLight light{}; // Format 9 (ADR-0175).
accounting::Picojoules captured{}; // Format 9: light credited to reserves so far.
State(std::uint64_t world_id, std::uint64_t region_id, std::uint64_t frame_id,
CellularLivesConfig cfg, NurseryConfig nursery_definition,
@@ -803,8 +809,7 @@ CellularLives::migration_replacement(std::vector<CellularOwnedLife> living,
std::expected<CellularLives::BoundarySavepoint, CellularLivesError>
CellularLives::exchange_boundary(std::span<const biology::CellularPatch> deposits,
accounting::Picojoules heat_export) {
if (state_->format_version != cellular_lives_migration_format &&
state_->format_version != cellular_lives_inheritance_format)
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);
@@ -846,13 +851,13 @@ CellularLives::exchange_boundary(std::span<const biology::CellularPatch> deposit
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,
rules == cellular_lives_inheritance_rules ? &state_->offspring_revisions : nullptr);
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);
if (!total)
return std::unexpected(total.error());
BoundarySavepoint savepoint{std::move(state_->habitat), state_->heat, state_->current_total,
@@ -892,6 +897,27 @@ std::span<const CellularLifeTickFeedback> CellularLives::last_tick_feedback() co
return last_tick_feedback_;
}
std::expected<std::unique_ptr<CellularLives>, 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;
}
const CellularLight& CellularLives::light() const noexcept {
return state_->light;
}
accounting::Picojoules CellularLives::captured_light() const noexcept {
return state_->captured;
}
std::span<const CellularOffspringRevision> CellularLives::offspring_revisions() const noexcept {
return state_->offspring_revisions;
}
@@ -925,7 +951,8 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
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 inheritance = state_->format_version >= cellular_lives_inheritance_format;
const bool lit = state_->format_version == cellular_lives_light_format;
const auto life_bytes = inheritance ? cellular_life_v6_bytes + 8
: state_->format_version == cellular_lives_legacy_format
? cellular_life_v1_bytes
@@ -938,10 +965,11 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
: causes ? cellular_corpse_v4_bytes
: cellular_corpse_bytes;
const bool migration = state_->format_version >= cellular_lives_migration_format;
const auto 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 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 +
@@ -966,6 +994,7 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
: 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
: lit ? cellular_lives_v9_magic
: inheritance ? cellular_lives_v8_magic
: migration ? cellular_lives_v7_magic
: cellular_lives_v2_magic;
@@ -1001,6 +1030,14 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
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);
}
for (const auto site : state_->nursery_config.sites)
out.site(site);
for (const auto& life : state_->lives) {
@@ -1267,7 +1304,7 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
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)
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; });
@@ -1284,7 +1321,7 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
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
state_->format_version >= cellular_lives_inheritance_format ? &state_->offspring_revisions
: nullptr);
if (!current)
return std::unexpected{current.error()};
@@ -1297,6 +1334,8 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
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;
return candidate;
}
@@ -1319,9 +1358,14 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
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.
const bool inheritance_version = magic == cellular_lives_v8_magic &&
format_version == cellular_lives_inheritance_format &&
rules_version == cellular_lives_inheritance_rules;
// Format 9 is exactly rules 11; format 8 exactly rules 10.
const bool light_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 &&
@@ -1353,6 +1397,8 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
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);
const auto saved_world = in.get();
const auto saved_region = in.get();
const auto saved_frame = in.get();
@@ -1398,6 +1444,19 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
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<std::uint32_t>(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};
}
const auto life_bytes = inheritance_version ? cellular_life_v6_bytes + 8
: legacy ? cellular_life_v1_bytes
: presence_version ? cellular_life_v6_bytes
@@ -1407,10 +1466,11 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
: bud_version ? cellular_corpse_v5_bytes
: engulf_version ? cellular_corpse_v4_bytes
: cellular_corpse_bytes;
const auto expected_size = (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) +
const auto expected_size = (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 +
@@ -1610,6 +1670,8 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
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;
if (!std::ranges::equal(bytes, restored->snapshot()))
return std::unexpected{CellularLivesError::noncanonical};
return restored;
@@ -1645,7 +1707,7 @@ CellularLives::advance_tick_with_mutations(std::span<const CellularLifeIntent> i
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 = state_->rules_version == cellular_lives_inheritance_rules;
const bool inheritance_rules = cellular_retained_plans(state_->rules_version);
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).
@@ -2136,6 +2198,50 @@ CellularLives::advance_tick_with_mutations(std::span<const CellularLifeIntent> i
*total, state_->format_version, state_->rules_version, state_->boundary);
next->next_bud_sequence = next_bud_sequence;
next->offspring_revisions = std::move(next_offspring_revisions);
next->light = state_->light;
next->captured = state_->captured;
// ADR-0175: light, from this tick's own intentions, credited to every active,
// unfrozen photosynthetic survivor's reserve and to the boundary inflow together.
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);
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<std::uint64_t>::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;
}
}
std::vector<CellularLifeTickFeedback> feedback;
feedback.reserve(proposal->lives.size());
for (const auto& result : proposal->lives) {
+3 -3
View File
@@ -20,8 +20,8 @@ CellularPopulation::create(std::unique_ptr<CellularLives> state, CellularTierPol
state->format_version() == cellular_lives_migration_format)) ||
(state->rules_version() == cellular_lives_maturation_rules &&
state->format_version() == cellular_lives_migration_format) ||
(state->rules_version() == cellular_lives_inheritance_rules &&
state->format_version() == cellular_lives_inheritance_format));
(cellular_retained_plans(state->rules_version()) &&
state->format_version() >= cellular_lives_inheritance_format));
if (!supported || policy.materialize_radius_um == 0 ||
policy.collapse_radius_um <= policy.materialize_radius_um ||
policy.collapse_radius_um > biology::cellular_motion_axis_limit_um)
@@ -44,7 +44,7 @@ std::uint64_t CellularPopulation::conversion_sequence() const noexcept {
return conversion_sequence_;
}
std::uint32_t CellularPopulation::format_version() const noexcept {
if (state_->format_version() == cellular_lives_inheritance_format)
if (state_->format_version() >= cellular_lives_inheritance_format)
return cellular_population_inheritance_format;
return state_->format_version() == cellular_lives_migration_format ? 2U : 1U;
}
@@ -84,8 +84,8 @@ class Reader {
bool population_interval_safe(const CellularLives& state) noexcept {
return (state.rules_version() == cellular_lives_foraging_rules ||
state.rules_version() == cellular_lives_maturation_rules ||
(state.rules_version() == cellular_lives_inheritance_rules &&
state.format_version() == cellular_lives_inheritance_format)) &&
(cellular_retained_plans(state.rules_version()) &&
state.format_version() >= cellular_lives_inheritance_format)) &&
std::ranges::all_of(state.lives(), [](const auto& life) {
return life.account == LifeAccount{} || life.presence == CellularPresence::suspended;
});
@@ -103,7 +103,7 @@ unattended_population_inputs(const CellularLives& base, const CellularBatchHeade
if (!working)
return std::unexpected(CellularPopulationError::format);
CellularBatch batch{header, {}};
if (base.rules_version() == cellular_lives_inheritance_rules)
if (cellular_retained_plans(base.rules_version()))
batch.format_version = cellular_batch_inheritance_format;
while ((*working)->tick() < header.end_tick) {
auto intents = wildlife_intents(**working, (*working)->tick() + 1);
@@ -140,6 +140,15 @@ wildlife_intents(const CellularLives& state, std::uint64_t tick) {
continue;
}
}
if (state.rules_version() >= cellular_lives_photosynthesis_rules &&
state.light().numerator != 0 && genome->carries(biology::Capability::photosynthesis)) {
const auto still = cellular_light_capture(*genome, extent, state.light(), false);
const auto period = budget->rate_microseconds / 50'000;
if (still && period != 0 && *still >= budget->maintenance.value / period) {
intents.push_back({life.identity.life, intent});
continue;
}
}
const auto perceived = state.perceive(life.identity.life);
if (!perceived)
return std::unexpected{perceived.error()};
+149 -2
View File
@@ -85,8 +85,9 @@ void audit(const CellularEnvironment& value) {
expected.matter[channel].value +=
ledger.incoming.matter[channel].value - ledger.outgoing.matter[channel].value;
require(state.current_total() == expected, "joint owner broke open-boundary closure");
require(ledger.incoming == value.imported() &&
ledger.outgoing == Inventory{value.exported(), {}},
auto environmental = value.imported();
environmental.energy.value += state.captured_light().value; // A rules-11 owner's light.
require(ledger.incoming == environmental && ledger.outgoing == Inventory{value.exported(), {}},
"environment flows differ from the nested boundary ledger");
for (std::size_t index = 0; index < value.sources().size(); ++index) {
const auto& made = value.sources()[index];
@@ -238,6 +239,151 @@ void raw_and_cohort() {
<< raw->exported().value << " pJ at tick " << raw->tick() << '\n';
}
// ADR-0175: a rules-11 region whose founder is born after the upgrade (founder 4).
Owner producer_region(std::uint64_t irradiance) {
auto state = opening(7, true, 1, false);
checked(state->advance_tick({}), "producer genesis tick");
state = checked(state->migration_upgrade_candidate(), "boundary upgrade");
state = checked(state->maturation_upgrade_candidate(), "maturation upgrade");
state = checked(state->inheritance_upgrade_candidate(), "inheritance upgrade");
const CellularLight light{irradiance, 1, {irradiance == 0 ? 0 : 1ULL << 50}};
require(!state->photosynthesis_upgrade_candidate({1, 0, {1}}) &&
!state->photosynthesis_upgrade_candidate({1, 1, {0}}),
"invalid light declared");
state = checked(state->photosynthesis_upgrade_candidate(light), "photosynthesis upgrade");
require(state->rules_version() == cellular_lives_photosynthesis_rules &&
state->format_version() == cellular_lives_light_format && state->light() == light &&
!state->photosynthesis_upgrade_candidate(light),
"photosynthesis upgrade repeated, wrong versions or lost light");
LifeAccount account{};
account.back() = 1;
state = checked(state->birth_candidate({account, 1}, {100, 100, 100, 100, {state->tick()}}),
"founder 4 birth");
const auto genome = state->archive().find(100);
require(genome && genome->schema_version() == biology::genome_schema_v5 &&
!genome->carries(biology::Capability::photosynthesis),
"founder 4 is not schema 5 without photosynthesis");
return state;
}
bool photosynthetic(const CellularLives& state, std::uint64_t genome) {
const auto found = state.archive().find(genome);
return found && found->carries(biology::Capability::photosynthesis);
}
void closed(const CellularLives& state) {
const auto& ledger = state.boundary_ledger();
auto expected = state.opening_total();
expected.energy.value += ledger.incoming.energy.value - ledger.outgoing.energy.value;
require(state.current_total() == expected && ledger.incoming.energy == state.captured_light(),
"lit region broke closure or booked light outside the ledger");
}
struct Producers {
std::unique_ptr<CellularPopulation> population;
std::uint64_t plan{}, child{}, captured{}, lit_ticks{}, still{};
};
// The founder earns photosynthesis as its offspring plan (rules 10+), buds a child that
// expresses it, and that child captures light inside the owner's own tick.
Producers grow_producers(std::uint64_t irradiance) {
Producers out;
out.population = checked(
CellularPopulation::create(producer_region(irradiance), {false, 900, 1'600}), "producers");
auto& population = *out.population;
for (unsigned tick = 0; tick < 80'000 && out.plan == 0; ++tick) {
const auto& life = population.state().lives().front();
if (!life.mutation.offer) {
checked(population.advance_tick(controlled(population.state())), "feed");
continue;
}
const auto& offer = *life.mutation.offer;
const auto found = std::ranges::find_if(offer.candidates, [](const auto& candidate) {
return candidate.target == biology::Capability::photosynthesis &&
candidate.effect == biology::MutationEffect::acquire;
});
const auto successor = 2'000'000 + tick;
// Decided before the tick: the tick replaces the state the offer lives in.
const bool acquire = found != offer.candidates.end();
const CellularMutationSelection selection{100, life.mutation.event_index,
life.mutation.offer_tick, successor,
acquire ? found->operator_id : std::uint16_t{0}};
checked(population.advance_tick(controlled(population.state()), std::span{&selection, 1}),
"selection tick");
if (acquire)
out.plan = successor;
}
require(
out.plan != 0 && photosynthetic(population.state(), out.plan) &&
!photosynthetic(population.state(), population.state().lives().front().identity.genome),
"founder never planned photosynthesis or expressed it itself");
for (unsigned tick = 0; tick < 40'000 && out.child == 0; ++tick) {
checked(population.advance_tick(controlled(population.state(), true)), "bud");
for (const auto& life : population.state().lives())
if (life.parent_life == 100 && photosynthetic(population.state(), life.identity.genome))
out.child = life.identity.life;
}
require(out.child != 0, "no child expressed the photosynthesis plan");
for (unsigned tick = 0; tick < 400; ++tick) {
const auto before = population.state().captured_light().value;
const auto intents =
checked(wildlife_intents(population.state(), population.state().tick() + 1), "intents");
for (const auto& intent : intents) {
const auto life = std::ranges::find(population.state().lives(), intent.life_id,
[](const auto& l) { return l.identity.life; });
if (photosynthetic(population.state(), life->identity.genome) &&
intent.intent == biology::CellularStepIntent{})
++out.still;
}
checked(population.advance_tick(controlled(population.state())), "lit tick");
const auto gained = population.state().captured_light().value - before;
out.captured += gained;
out.lit_ticks += gained > 0 ? 1 : 0;
closed(population.state());
}
return out;
}
void producers() {
auto trial = grow_producers(cellular_light_trial_irradiance);
require(trial.captured > 0 && trial.lit_ticks > 0, "a photosynthetic child captured no light");
const auto& state = trial.population->state();
const auto bytes = state.snapshot();
require(bytes.size() > 8 && bytes[7] == '9', "lit region not owner format 9");
auto restored =
checked(CellularPopulation::restore(trial.population->snapshot(), state.world(),
state.region(), state.frame(), state.tick()),
"lit restore");
for (unsigned tick = 0; tick < 200; ++tick) {
checked(trial.population->advance_tick(controlled(trial.population->state())), "a");
checked(restored->advance_tick(controlled(restored->state())), "b");
require(trial.population->snapshot() == restored->snapshot(),
"lit region diverged after restore");
}
// A joint owner nests the lit owner: its own infall stays separate from the light.
const auto& lit_state = trial.population->state();
auto joint_config = config({}, 9);
joint_config.geometry.box.width = {lit_state.area().width_um};
joint_config.geometry.box.height = {lit_state.area().height_um};
auto joint = checked(CellularEnvironment::create(std::move(restored), std::move(joint_config)),
"lit joint");
for (unsigned tick = 0; tick < 200; ++tick) {
step(*joint);
audit(*joint);
}
require(joint->state().captured_light().value > 0, "nested owner stopped capturing");
// Without light nothing is captured, and a producer forages as before.
auto dark = grow_producers(0);
require(dark.captured == 0 && dark.population->state().captured_light().value == 0,
"a dark region captured light");
// Same history until the plan, then capture scales exactly with irradiance. (These
// producers always touch food, so they hold still in any light; the light-driven
// holding-still branch is not observable in this rich fixture.)
auto bright = grow_producers(cellular_light_trial_irradiance * 20);
require(bright.child == trial.child && bright.captured == 20 * trial.captured &&
bright.still == trial.still && dark.still == trial.still,
"capture did not scale with irradiance or light changed the controller");
std::cout << "producers: plan " << trial.plan << ", child " << trial.child << ", captured "
<< trial.captured << " pJ over " << trial.lit_ticks << " lit ticks (bright "
<< bright.captured << ", still intents " << bright.still << " vs dark " << dark.still
<< ")\n";
}
// A full habitat refuses new deposits: bubbles are counted skipped, never deferred.
void capacity() {
auto value = environment(founders(),
@@ -517,6 +663,7 @@ int main(int argc, char** argv) {
atomic_and_restore();
raw_and_cohort();
capacity();
producers();
traces();
refusals();
auto value = restart_fixture();
+2 -2
View File
@@ -174,12 +174,12 @@ void rule_versions_and_invalid_growth() {
v3->structure_density == v2->structure_density &&
v3->maintenance_per_kilogram == v2->maintenance_per_kilogram &&
development_rate_microseconds(3) == development_rate_microseconds(2));
for (const auto version : {0U, 5U, 99U}) {
for (const auto version : {0U, 6U, 99U}) {
const auto missing = rules_for(version);
CHECK(!missing && missing.error() == DevelopmentError::unsupported_rules);
}
auto source = draft();
source.development_version = 5;
source.development_version = 6; // Version 5 exists since rules 11 (ADR-0175).
const auto future = build(source);
const auto derived = derive_phenotype(future, {1000, 0}, temperate);
CHECK(!derived && derived.error() == DevelopmentError::unsupported_rules);
+14 -3
View File
@@ -116,7 +116,8 @@ void capability_and_range_rules() {
draft.capabilities.push_back({Capability::thermal_tolerance, 1, 1U << capability_count});
reject(draft, GenomeError::unknown_capability);
// Every boundary of every declared range, from both sides, in each schema's own table.
for (const auto schema : {genome_schema_v1, genome_schema_v2, genome_schema_v3}) {
for (const auto schema :
{genome_schema_v1, genome_schema_v2, genome_schema_v3, genome_schema_v5}) {
const auto& table = *capability_schema_for(schema);
const auto fresh = [&] {
auto d = founder();
@@ -126,6 +127,16 @@ void capability_and_range_rules() {
for (std::size_t index = 0; index < capability_count; ++index) {
const auto kind = static_cast<Capability>(index);
const auto& limits = table[index];
// An empty range (photosynthesis before schema 5) admits no value at all.
if (limits.maximum < limits.minimum) {
CHECK(kind == Capability::photosynthesis && schema != genome_schema_v5);
for (const auto value : {0U, 1U, 100U, 1000U}) {
draft = fresh();
draft.capabilities.push_back({kind, value, 0});
reject(draft, GenomeError::parameter_out_of_range);
}
continue;
}
for (const auto value : {limits.minimum, limits.maximum}) {
draft = fresh();
std::erase_if(draft.capabilities,
@@ -351,10 +362,10 @@ void schema_v2_rates() {
v1.capabilities[4].parameter = 1'000'001;
reject(v1, GenomeError::parameter_out_of_range);
auto unknown = founder();
unknown.schema_version = 5; // Schema 4 exists since rules 7 (ADR-0137).
unknown.schema_version = 6; // Schema 5 exists since rules 11 (ADR-0175).
reject(unknown, GenomeError::unsupported_version);
auto bytes = Genome::create(founder())->encode();
bytes[8] = 5; // Schema field; decode refuses before the checksum matters.
bytes[8] = 6; // Schema field; decode refuses before the checksum matters.
CHECK(!Genome::decode(bytes) &&
Genome::decode(bytes).error() == GenomeError::unsupported_version);
}
+2 -2
View File
@@ -385,12 +385,12 @@ void rules_fail_closed() {
const auto m3 = metabolic_rules_for(3);
CHECK(m2 && m3 && m3->movement_per_kilogram == m2->movement_per_kilogram &&
m3->intake_energy_per_kilogram == m2->intake_energy_per_kilogram);
for (const auto version : {0U, 5U, 99U}) {
for (const auto version : {0U, 6U, 99U}) {
const auto missing = metabolic_rules_for(version);
CHECK(!missing && missing.error() == DevelopmentError::unsupported_rules);
}
auto source = draft();
source.development_version = 5;
source.development_version = 6;
const auto future = build(source);
const auto refused = metabolic_budget(future, {1000, 0}, temperate);
CHECK(!refused && refused.error() == DevelopmentError::unsupported_rules);
+1 -1
View File
@@ -315,7 +315,7 @@ void invalid_contexts_are_refused() {
// An unsupported development version leaves no eligible operator at all,
// because every successor fails to derive a budget.
auto source = draft();
source.development_version = 5;
source.development_version = 6;
const auto future = build(source);
const auto empty = mutation_candidates(future, context(1));
CHECK(!empty && empty.error() == MutationError::no_candidates);
+137
View File
@@ -0,0 +1,137 @@
#include "evo/biology/founder.hpp"
#include "evo/biology/mutation.hpp"
#include "evo/server/lifecycle/cellular_light.hpp"
#include <algorithm>
#include <iostream>
#include <stdexcept>
#include <string>
namespace {
using namespace evo;
using namespace evo::biology;
using namespace evo::server;
void require(bool condition, const char* message) {
if (!condition)
throw std::runtime_error(message);
}
template <typename T, typename E> T checked(std::expected<T, E> value, const char* message) {
if (!value)
throw std::runtime_error(std::string{message} + ": " +
std::to_string(static_cast<unsigned>(value.error())));
return std::move(*value);
}
Genome with(const Genome& base, std::uint32_t efficiency) {
GenomeDraft draft{base.id() + 1, 2, base.development_version(), {base.id()}, {}, {}};
draft.schema_version = base.schema_version();
draft.capabilities.assign(base.capabilities().begin(), base.capabilities().end());
draft.capabilities.push_back({Capability::photosynthesis, efficiency, 0});
return checked(Genome::create(draft), "photosynthetic genome");
}
constexpr EnvironmentState reference{293'150, {}};
// Founder 4 is founder 3 with a schema that can express photosynthesis; it starts without.
void founders() {
const auto three = checked(primitive_founder(5, 5, primitive_founder_v3), "founder 3");
const auto four = checked(primitive_founder(5, 5, primitive_founder_v4), "founder 4");
require(!four.carries(Capability::photosynthesis) && four.schema_version() == 5 &&
four.development_version() == 5,
"founder 4 carries photosynthesis or wrong versions");
const auto a = checked(metabolic_budget(three, {1000, 0}, reference), "founder 3 budget");
const auto b = checked(metabolic_budget(four, {1000, 0}, reference), "founder 4 budget");
require(a.phenotype == b.phenotype && a.body == b.body && a.maintenance == b.maintenance &&
a.reproduction_investment == b.reproduction_investment,
"founder 4 differs from founder 3 without photosynthesis");
require(checked(primitive_endowment(primitive_founder_v4), "endowment 4") ==
checked(primitive_endowment(primitive_founder_v3), "endowment 3"),
"founder 4 endowment changed");
// Earlier schemas cannot carry it at any efficiency.
GenomeDraft old{9, 9, 4, {}, {}, genome_schema_v4};
old.capabilities.assign(three.capabilities().begin(), three.capabilities().end());
old.capabilities.push_back({Capability::photosynthesis, 100, 0});
require(Genome::create(old).error() == GenomeError::parameter_out_of_range,
"schema 4 accepted photosynthesis");
}
// Organelles: p/4 of structure as membrane mass (upkept twice), speed down by p/2.
void costs() {
const auto four = checked(primitive_founder(5, 5, primitive_founder_v4), "founder 4");
const auto base = checked(metabolic_budget(four, {1000, 0}, reference), "base budget");
for (const auto efficiency : {100U, 500U, 1000U}) {
const auto producer = with(four, efficiency);
const auto budget = checked(metabolic_budget(producer, {1000, 0}, reference), "producer");
const auto organelles = base.phenotype.structural_mass / 4 * efficiency / 1000;
require(budget.phenotype.membrane_mass == base.phenotype.membrane_mass + organelles &&
budget.phenotype.structural_mass == base.phenotype.structural_mass &&
budget.phenotype.extent == base.phenotype.extent &&
budget.maintenance.value > base.maintenance.value &&
budget.phenotype.movement_speed ==
base.phenotype.movement_speed * (1000 - efficiency / 2) / 1000,
"photosynthesis costs differ from the declared trial rule");
const CellularLight light{cellular_light_trial_irradiance, 1, {1ULL << 50}};
const auto captured_still =
cellular_light_capture(producer, budget.phenotype.extent, light, false);
const auto captured_moving =
cellular_light_capture(producer, budget.phenotype.extent, light, true);
require(captured_still.has_value() && captured_moving.has_value(), "capture overflowed");
const auto still = captured_still.value_or(0), moving = captured_moving.value_or(0);
const auto section = std::uint64_t{budget.phenotype.extent} * budget.phenotype.extent;
require(still == section * cellular_light_trial_irradiance * efficiency / 1000 &&
moving == still / 4,
"light capture differs from cross-section x irradiance x efficiency");
std::cout << "photosynthesis " << efficiency << ": maintenance "
<< budget.maintenance.value / 20 << " pJ/tick (founder "
<< base.maintenance.value / 20 << "), capture still " << still << ", moving "
<< moving << ", speed " << budget.phenotype.movement_speed << " um/s\n";
}
require(cellular_light_capture(four, 20, {cellular_light_trial_irradiance, 1, {1}}, false) == 0,
"a genome without the capability captured light");
}
// Schema 5 offers photosynthesis through the appended operators; earlier schemas never do.
void offers() {
const auto catalog = mutation_catalog();
require(catalog.size() == 32, "catalog size");
for (std::uint16_t id = 29; id <= 32; ++id)
require(catalog[id - 1].target == Capability::photosynthesis,
"photosynthesis operators are not IDs 29-32");
const auto four = checked(primitive_founder(5, 5, primitive_founder_v4), "founder 4");
const auto three = checked(primitive_founder(5, 5, primitive_founder_v3), "founder 3");
bool offered = false;
for (std::uint64_t event = 1; event <= 400 && !offered; ++event) {
const MutationContext context{0x5EED, 1, event, 8, {1000, 0}, reference};
const auto old = checked(mutation_candidates(three, context), "schema 4 offer");
require(std::ranges::none_of(
old.candidates,
[](const auto& c) { return c.target == Capability::photosynthesis; }),
"schema 4 lineage offered photosynthesis");
const auto offer = checked(mutation_candidates(four, context), "schema 5 offer");
const auto found = std::ranges::find_if(offer.candidates, [](const auto& c) {
return c.target == Capability::photosynthesis && c.effect == MutationEffect::acquire;
});
if (found == offer.candidates.end())
continue;
offered = true;
require(found->parameter == photosynthesis_acquired_start,
"acquired photosynthesis does not start at the trial value");
const auto successor =
checked(select_mutation(four, context, offer, found->operator_id, 77, 77), "select");
require(*successor.parameter(Capability::photosynthesis) == photosynthesis_acquired_start,
"selected successor lost photosynthesis");
}
require(offered, "schema 5 never offered photosynthesis");
}
} // namespace
int main() {
try {
founders();
costs();
offers();
std::cout << "photosynthesis contracts passed\n";
return 0;
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 1;
}
}