Foundation / checks (ecs) (push) Successful in 3m21s
Foundation / checks (deploy) (push) Successful in 5m39s
Foundation / checks (tsan) (push) Successful in 11m43s
Foundation / checks (network) (push) Successful in 22m3s
Foundation / checks (client) (push) Successful in 22m35s
Foundation / checks (checks) (push) Successful in 46m53s
Foundation / checks (postgres) (push) Successful in 48m22s
Foundation / postgres-tools (push) Successful in 1m17s
Foundation / image (push) Successful in 3m31s
Foundation / server-image (push) Successful in 6m7s
The region 6 playtest found a speed mutation adding 6,667 um/s (1/300 of the range, 33x a founder), so buds seemed to teleport; reproduction made buds bigger and dearer; and wildlife never hunted. Rules 7: - genome schema 4: a step is a tenth of the current value (at least 1); an acquired capability starts at the founder's value instead of a minimum it could never grow from; - development 4: a bud is always half the body, and reproduction takes value/2000 off its construction energy (founders save a quarter; matter is never discounted); - twins: a seeded roll (reproduction/2 per thousand) splits one affordable bud's investment into two quarter-size buds; - wildlife engulfs a touching cell the region step lets it take, players' included. Founder 3, owner format 6 (no new state), bundle v8 and schema v42; the cellular-v6 opening provisions it. The client's mutation callout shrinks to a "Mutation [E]" pill and its candidate texts describe the new steps. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
596 lines
31 KiB
C++
596 lines
31 KiB
C++
#include "evo/biology/founder.hpp"
|
|
#include "evo/processes/genome_strategy.hpp"
|
|
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo::biology;
|
|
using namespace evo::accounting;
|
|
void check(bool condition, std::source_location location = std::source_location::current()) {
|
|
if (!condition) {
|
|
throw std::runtime_error("metabolism line " + std::to_string(location.line()));
|
|
}
|
|
}
|
|
#define CHECK(expression) check(static_cast<bool>(expression))
|
|
// The ADR-0031 fixture: an exact 20 micrometre cube at full growth, so every
|
|
// budget below is hand-calculable against the declared compositions.
|
|
GenomeDraft draft() {
|
|
return {7,
|
|
1,
|
|
1,
|
|
{},
|
|
{{Capability::energy_conversion, 400, 0},
|
|
{Capability::membrane, 10, 0},
|
|
{Capability::target_size, 8'000'000, 0}}};
|
|
}
|
|
Genome build(const GenomeDraft& source) {
|
|
const auto genome = Genome::create(source);
|
|
check(genome.has_value());
|
|
return *genome;
|
|
}
|
|
GenomeDraft capable() {
|
|
auto source = draft();
|
|
source.capabilities.push_back({Capability::movement, 250, 0});
|
|
source.capabilities.push_back({Capability::ingestion, 120'000, 0});
|
|
source.capabilities.push_back({Capability::reproduction, 300, 0});
|
|
return source;
|
|
}
|
|
// Every channel stocked alike, so availability never accidentally hides a
|
|
// per-element shortfall except where a test sets one deliberately.
|
|
constexpr Inventory pooled(std::uint64_t value) {
|
|
return {{value}, {Femtograms{value}, Femtograms{value}, Femtograms{value}, Femtograms{value}}};
|
|
}
|
|
constexpr EnvironmentState temperate{293'150, pooled(1'000'000'000)};
|
|
bool fits_within(const Inventory& needed, const Inventory& available) {
|
|
if (needed.energy.value > available.energy.value) {
|
|
return false;
|
|
}
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
if (needed.matter[index].value > available.matter[index].value) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
std::uint64_t matter_total(const Inventory& inventory) {
|
|
std::uint64_t sum = 0;
|
|
for (const auto& mass : inventory.matter) {
|
|
sum += mass.value;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
void hand_calculated_budget() {
|
|
const auto genome = build(capable());
|
|
const auto budget = metabolic_budget(genome, {1000, 0}, temperate);
|
|
CHECK(budget);
|
|
// Structure 8e6 fg at 500/150/50/300, membrane 28.8e6 fg at 700/50/100/150.
|
|
CHECK(budget->body.matter[0].value == 24'160'000); // 4.0e6 + 20.16e6 carbon
|
|
CHECK(budget->body.matter[1].value == 2'640'000); // 1.2e6 + 1.44e6 nitrogen
|
|
CHECK(budget->body.matter[2].value == 3'280'000); // 0.4e6 + 2.88e6 phosphorus
|
|
CHECK(budget->body.matter[3].value == 6'720'000); // 2.4e6 + 4.32e6 other
|
|
CHECK(budget->body.energy.value == 0); // A body is matter, not energy.
|
|
// A split conserves the whole mass exactly, with nothing lost to rounding.
|
|
CHECK(matter_total(budget->body) == budget->phenotype.total_mass);
|
|
CHECK(budget->maintenance.value == 160'000);
|
|
CHECK(budget->movement.value == 184'000); // 36800 * 20 * 250 / 1000
|
|
CHECK(budget->demand.value == 344'000);
|
|
CHECK(budget->intake_limit.energy.value == 240'000); // 4800 fg at 50000 per 1000
|
|
CHECK(budget->intake_limit.matter[0].value == 2400); // 4800 fg by structure shares
|
|
CHECK(budget->intake_limit.matter[1].value == 720);
|
|
CHECK(budget->intake_limit.matter[2].value == 240);
|
|
CHECK(budget->intake_limit.matter[3].value == 1440);
|
|
CHECK(matter_total(budget->intake_limit) == budget->phenotype.ingestion_rate);
|
|
CHECK(budget->assimilation_per_thousand == 400);
|
|
// A parent divides the body it has, so the investment keeps its composition.
|
|
CHECK(budget->reproduction_investment.matter[0].value == 7'248'000);
|
|
CHECK(budget->reproduction_investment.matter[1].value == 792'000);
|
|
CHECK(budget->reproduction_investment.matter[2].value == 984'000);
|
|
CHECK(budget->reproduction_investment.matter[3].value == 2'016'000);
|
|
CHECK(matter_total(budget->reproduction_investment) == 11'040'000); // 30% of the body
|
|
CHECK(budget->reproduction_investment.energy.value == 441'600); // priced at 40 per 1000
|
|
// A finished organism has nothing left to build.
|
|
CHECK(matter_total(budget->construction.intake) == 0);
|
|
CHECK(matter_total(budget->construction.release) == 0);
|
|
CHECK(budget->construction.intake.energy.value == 0);
|
|
}
|
|
|
|
void construction_composes_each_compartment() {
|
|
const auto genome = build(capable());
|
|
const auto budget = metabolic_budget(genome, {500, 0}, temperate);
|
|
CHECK(budget);
|
|
// The step adds 400,000 fg of structure and 2,232,000 fg of membrane, each
|
|
// composed by its own shares rather than by one blended ratio.
|
|
CHECK(budget->construction.intake.matter[0].value == 200'000 + 1'562'400);
|
|
CHECK(budget->construction.intake.matter[1].value == 60'000 + 111'600);
|
|
CHECK(budget->construction.intake.matter[2].value == 20'000 + 223'200);
|
|
CHECK(budget->construction.intake.matter[3].value == 120'000 + 334'800);
|
|
CHECK(matter_total(budget->construction.intake) == 2'632'000);
|
|
CHECK(matter_total(budget->construction.release) == 0); // Nothing floors here.
|
|
CHECK(budget->construction.intake.energy.value == 105'280);
|
|
// What a plan reports as material is the net of the transition.
|
|
const auto plan = plan_development(genome, {500, 0}, temperate);
|
|
CHECK(plan && plan->material_required == matter_total(budget->construction.intake) -
|
|
matter_total(budget->construction.release));
|
|
CHECK(plan->energy_required == budget->construction.intake.energy.value);
|
|
CHECK(budget->construction.after == plan->after);
|
|
// Unaffordable growth leaves nothing to move.
|
|
const EnvironmentState barren{293'150, pooled(0)};
|
|
const auto starved = metabolic_budget(genome, {500, 0}, barren);
|
|
CHECK(starved && matter_total(starved->construction.intake) == 0);
|
|
CHECK(matter_total(starved->construction.release) == 0);
|
|
CHECK(starved->construction.intake.energy.value == 0);
|
|
}
|
|
|
|
void construction_reproduces_the_derived_body() {
|
|
// Composing the mass difference would fund C25 N7 P2 other16 here, leaving
|
|
// nitrogen and phosphorus one short and other two over, so spending it could
|
|
// not produce the body the same rules derive.
|
|
auto source = draft();
|
|
source.capabilities[2].parameter = 1001; // target size
|
|
const auto genome = build(source);
|
|
const auto before = metabolic_budget(genome, {10, 0}, temperate);
|
|
CHECK(before);
|
|
CHECK(before->body.matter[0].value == 5 && before->body.matter[1].value == 1);
|
|
CHECK(before->body.matter[2].value == 0 && before->body.matter[3].value == 4);
|
|
CHECK(before->construction.intake.matter[0].value == 25);
|
|
CHECK(before->construction.intake.matter[1].value == 8);
|
|
CHECK(before->construction.intake.matter[2].value == 3);
|
|
CHECK(before->construction.intake.matter[3].value == 14);
|
|
CHECK(matter_total(before->construction.intake) == 50);
|
|
CHECK(matter_total(before->construction.release) == 0);
|
|
const auto after = metabolic_budget(genome, {60, 0}, temperate);
|
|
CHECK(after);
|
|
CHECK(after->body.matter[0].value == 30 && after->body.matter[1].value == 9);
|
|
CHECK(after->body.matter[2].value == 3 && after->body.matter[3].value == 18);
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
CHECK(before->body.matter[index].value + before->construction.intake.matter[index].value -
|
|
before->construction.release.matter[index].value ==
|
|
after->body.matter[index].value);
|
|
}
|
|
// A step can also free a femtogram as the declared shares rebalance. At a
|
|
// target of 20 fg a full step moves the body from 13 to 14 fg: carbon and
|
|
// nitrogen each gain one while other falls from 6 to 5.
|
|
source.capabilities[2].parameter = 20;
|
|
const auto small = build(source);
|
|
const auto crawling = metabolic_budget(small, {650, 0}, temperate);
|
|
CHECK(crawling && crawling->phenotype.structural_mass == 13);
|
|
CHECK(crawling->body.matter[3].value == 6);
|
|
CHECK(crawling->construction.after == (GrowthState{700, 0}));
|
|
CHECK(crawling->construction.intake.matter[0].value == 1);
|
|
CHECK(crawling->construction.intake.matter[1].value == 1);
|
|
CHECK(crawling->construction.intake.matter[2].value == 0);
|
|
CHECK(crawling->construction.release.matter[3].value == 1);
|
|
const auto stepped = metabolic_budget(small, {700, 0}, temperate);
|
|
CHECK(stepped && stepped->phenotype.structural_mass == 14);
|
|
CHECK(stepped->body.matter[3].value == 5);
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
CHECK(crawling->body.matter[index].value +
|
|
crawling->construction.intake.matter[index].value -
|
|
crawling->construction.release.matter[index].value ==
|
|
stepped->body.matter[index].value);
|
|
}
|
|
}
|
|
|
|
void released_matter_never_funds_another_element() {
|
|
// The 13 to 14 fg step again: net growth is one femtogram, but it acquires a
|
|
// carbon and a nitrogen while freeing one of other. Released other is neither
|
|
// carbon nor nitrogen, so a single femtogram cannot fund it whatever channel
|
|
// that femtogram sits in.
|
|
auto source = draft();
|
|
source.capabilities[2].parameter = 20;
|
|
const auto genome = build(source);
|
|
for (std::size_t channel = 0; channel < 4; ++channel) {
|
|
Inventory single{{1'000'000}, {}};
|
|
single.matter[channel].value = 1; // One femtogram, and only one.
|
|
const EnvironmentState scarce{293'150, single};
|
|
// The mass-only plan is what would be fooled: it sees a net of one
|
|
// femtogram against a pool of one and admits the step.
|
|
const auto plan = plan_development(genome, {650, 0}, scarce);
|
|
CHECK(plan && plan->after == (GrowthState{700, 0}) && plan->material_required == 1);
|
|
const auto budget = metabolic_budget(genome, {650, 0}, scarce);
|
|
CHECK(budget);
|
|
CHECK(budget->construction.after != (GrowthState{700, 0})); // Not funded.
|
|
// Nothing is acquired at all: the steps that remain change no mass.
|
|
CHECK(matter_total(budget->construction.intake) == 0);
|
|
CHECK(matter_total(budget->construction.release) == 0);
|
|
CHECK(fits_within(budget->construction.intake, single));
|
|
const auto reached = metabolic_budget(genome, budget->construction.after, scarce);
|
|
CHECK(reached && reached->phenotype.structural_mass == 13);
|
|
}
|
|
// A carbon and a nitrogen together are exactly what the step needs.
|
|
Inventory exact{{1'000'000}, {}};
|
|
exact.matter[0].value = 1;
|
|
exact.matter[1].value = 1;
|
|
const auto precise = metabolic_budget(genome, {650, 0}, {293'150, exact});
|
|
CHECK(precise && precise->construction.after == (GrowthState{700, 0}));
|
|
CHECK(precise->construction.intake.matter[0].value == 1);
|
|
CHECK(precise->construction.intake.matter[1].value == 1);
|
|
CHECK(precise->construction.release.matter[3].value == 1);
|
|
}
|
|
|
|
void enormous_availability_still_funds_growth() {
|
|
const auto genome = build(capable());
|
|
// Budgeting reads the same availability bound, so a wrapped total would
|
|
// refuse this step too. Four channels of 2^62 sum to exactly 2^64.
|
|
constexpr std::uint64_t vast = 1ULL << 62U;
|
|
const Inventory enormous{
|
|
{std::numeric_limits<std::uint64_t>::max()},
|
|
{Femtograms{vast}, Femtograms{vast}, Femtograms{vast}, Femtograms{vast}}};
|
|
const auto budget = metabolic_budget(genome, {500, 0}, {293'150, enormous});
|
|
const auto ordinary = metabolic_budget(genome, {500, 0}, temperate);
|
|
CHECK(budget && ordinary);
|
|
CHECK(budget->construction.after == (GrowthState{550, 0}));
|
|
CHECK(budget->construction == ordinary->construction);
|
|
CHECK(matter_total(budget->construction.intake) == 2'632'000);
|
|
}
|
|
|
|
void every_transition_is_affordable_channel_by_channel() {
|
|
auto source = capable();
|
|
for (const std::uint32_t target : {1U, 999U, 1001U, 9'999U, 123'457U, 8'000'000U}) {
|
|
source.capabilities[2].parameter = target;
|
|
const auto genome = build(source);
|
|
for (const std::uint32_t realized : {0U, 1U, 13U, 333U, 500U, 950U, 1000U}) {
|
|
for (const std::uint64_t stock : {0ULL, 1ULL, 7ULL, 1'000'000ULL}) {
|
|
const EnvironmentState environment{293'150, pooled(stock)};
|
|
const auto budget = metabolic_budget(genome, {realized, 0}, environment);
|
|
CHECK(budget);
|
|
// Whatever a step reports, every element of it must be there.
|
|
CHECK(fits_within(budget->construction.intake, environment.available));
|
|
// A funded step never exceeds what the mass-only plan proposed.
|
|
const auto plan = plan_development(genome, {realized, 0}, environment);
|
|
CHECK(plan && budget->construction.after.realized_per_thousand <=
|
|
plan->after.realized_per_thousand);
|
|
CHECK(budget->construction.after.damage_per_thousand == 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void every_transition_conserves_each_channel() {
|
|
auto source = capable();
|
|
for (const std::uint32_t target : {1U, 999U, 1001U, 9'999U, 123'457U, 8'000'000U}) {
|
|
source.capabilities[2].parameter = target;
|
|
const auto genome = build(source);
|
|
for (const std::uint32_t realized : {0U, 1U, 13U, 333U, 500U, 950U, 1000U}) {
|
|
for (const std::uint64_t material : {0ULL, 1ULL, 7ULL, 1'000'000'000ULL}) {
|
|
const EnvironmentState environment{293'150, pooled(material)};
|
|
const auto budget = metabolic_budget(genome, {realized, 0}, environment);
|
|
const auto plan = plan_development(genome, {realized, 0}, environment);
|
|
CHECK(budget && plan);
|
|
const auto reached =
|
|
metabolic_budget(genome, budget->construction.after, environment);
|
|
CHECK(reached);
|
|
// Spending the budget must reproduce the derived body exactly, on
|
|
// every channel, not merely in total.
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
CHECK(budget->body.matter[index].value +
|
|
budget->construction.intake.matter[index].value -
|
|
budget->construction.release.matter[index].value ==
|
|
reached->body.matter[index].value);
|
|
}
|
|
// The net of the transition is what the plan charges material for.
|
|
CHECK(matter_total(budget->construction.intake) >=
|
|
matter_total(budget->construction.release));
|
|
CHECK(matter_total(budget->construction.intake) -
|
|
matter_total(budget->construction.release) <=
|
|
plan->material_required);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void repeated_growth_conserves_each_channel() {
|
|
auto source = capable();
|
|
source.capabilities[2].parameter = 123'457;
|
|
const auto genome = build(source);
|
|
// Walk a body from nothing to its target one funded step at a time, checking
|
|
// every channel across the whole history rather than only one transition.
|
|
GrowthState growth{0, 0};
|
|
Inventory acquired{}, freed{};
|
|
const auto opening = metabolic_budget(genome, growth, temperate);
|
|
CHECK(opening);
|
|
for (int step = 0; step < 40 && growth.realized_per_thousand < 1000; ++step) {
|
|
const auto budget = metabolic_budget(genome, growth, temperate);
|
|
CHECK(budget &&
|
|
budget->construction.after.realized_per_thousand > growth.realized_per_thousand);
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
acquired.matter[index].value += budget->construction.intake.matter[index].value;
|
|
freed.matter[index].value += budget->construction.release.matter[index].value;
|
|
}
|
|
growth = budget->construction.after;
|
|
}
|
|
CHECK(growth.realized_per_thousand == 1000);
|
|
const auto finished = metabolic_budget(genome, growth, temperate);
|
|
CHECK(finished);
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
CHECK(opening->body.matter[index].value + acquired.matter[index].value -
|
|
freed.matter[index].value ==
|
|
finished->body.matter[index].value);
|
|
}
|
|
}
|
|
|
|
void thicker_membrane_costs_matter_and_maintenance() {
|
|
auto source = capable();
|
|
const auto thin = metabolic_budget(build(source), {1000, 0}, temperate);
|
|
source.capabilities[1].parameter = 20; // membrane, twice as thick
|
|
const auto thick = metabolic_budget(build(source), {1000, 0}, temperate);
|
|
CHECK(thin && thick);
|
|
// Costs more matter to build and more energy to hold.
|
|
CHECK(matter_total(thick->body) == 65'600'000);
|
|
CHECK(matter_total(thick->body) > matter_total(thin->body));
|
|
CHECK(thick->maintenance.value == 304'000); // 65600*2 + 57600*3
|
|
CHECK(thick->maintenance.value > thin->maintenance.value);
|
|
// Membrane is the carbon-rich compartment, so composition shifts, not just mass.
|
|
CHECK(thick->body.matter[0].value == 44'320'000);
|
|
const auto thin_carbon_share = thin->body.matter[0].value * 1000 / matter_total(thin->body);
|
|
const auto thick_carbon_share = thick->body.matter[0].value * 1000 / matter_total(thick->body);
|
|
CHECK(thick_carbon_share > thin_carbon_share);
|
|
// Hauling the heavier body costs more, so a thick membrane is paid for twice.
|
|
CHECK(thick->movement.value > thin->movement.value);
|
|
// These budgets are untouched: nothing here is a multiplier over a total.
|
|
CHECK(thick->intake_limit == thin->intake_limit);
|
|
CHECK(thick->phenotype.movement_speed == thin->phenotype.movement_speed);
|
|
CHECK(thick->assimilation_per_thousand == thin->assimilation_per_thousand);
|
|
CHECK(thick->phenotype.structural_mass == thin->phenotype.structural_mass);
|
|
// Doubling one parameter moves the affected budgets by different ratios.
|
|
const auto mass_ratio = matter_total(thick->body) * 1000 / matter_total(thin->body);
|
|
const auto maintenance_ratio = thick->maintenance.value * 1000 / thin->maintenance.value;
|
|
CHECK(mass_ratio != maintenance_ratio);
|
|
}
|
|
|
|
void size_moves_several_budgets_together() {
|
|
const auto genome = build(capable());
|
|
const auto small = metabolic_budget(genome, {500, 0}, temperate);
|
|
const auto large = metabolic_budget(genome, {1000, 0}, temperate);
|
|
CHECK(small && large);
|
|
CHECK(matter_total(large->body) > matter_total(small->body));
|
|
CHECK(large->maintenance.value > small->maintenance.value);
|
|
CHECK(large->movement.value > small->movement.value);
|
|
CHECK(matter_total(large->intake_limit) > matter_total(small->intake_limit));
|
|
CHECK(matter_total(large->reproduction_investment) >
|
|
matter_total(small->reproduction_investment));
|
|
// Uptake rises with surface while maintenance rises with mass, so the two do
|
|
// not move together: size is a genuine tradeoff, not a uniform gain.
|
|
const auto uptake_ratio =
|
|
matter_total(large->intake_limit) * 1000 / matter_total(small->intake_limit);
|
|
const auto maintenance_ratio = large->maintenance.value * 1000 / small->maintenance.value;
|
|
CHECK(uptake_ratio != maintenance_ratio);
|
|
}
|
|
|
|
void absent_capabilities_cost_nothing() {
|
|
const auto bare = build(draft());
|
|
const auto budget = metabolic_budget(bare, {1000, 0}, temperate);
|
|
CHECK(budget);
|
|
CHECK(budget->movement.value == 0); // No movement capability.
|
|
CHECK(budget->demand.value == budget->maintenance.value);
|
|
CHECK(matter_total(budget->intake_limit) == 0); // No ingestion capability.
|
|
CHECK(budget->intake_limit.energy.value == 0);
|
|
CHECK(matter_total(budget->reproduction_investment) == 0); // No reproduction capability.
|
|
CHECK(budget->reproduction_investment.energy.value == 0);
|
|
// A body still costs maintenance whatever it cannot do.
|
|
CHECK(budget->maintenance.value == 160'000);
|
|
CHECK(matter_total(budget->body) == 36'800'000);
|
|
}
|
|
|
|
void rules_fail_closed() {
|
|
CHECK(metabolic_rules_for(1));
|
|
// Version 3 (rules 6) keeps version 2's metabolism; 4 is unknown.
|
|
const auto m2 = metabolic_rules_for(2);
|
|
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}) {
|
|
const auto missing = metabolic_rules_for(version);
|
|
CHECK(!missing && missing.error() == DevelopmentError::unsupported_rules);
|
|
}
|
|
auto source = draft();
|
|
source.development_version = 5;
|
|
const auto future = build(source);
|
|
const auto refused = metabolic_budget(future, {1000, 0}, temperate);
|
|
CHECK(!refused && refused.error() == DevelopmentError::unsupported_rules);
|
|
const auto genome = build(draft());
|
|
const auto invalid = metabolic_budget(genome, {1001, 0}, temperate);
|
|
CHECK(!invalid && invalid.error() == DevelopmentError::invalid_growth);
|
|
// Both compositions are declared, and both sum to the whole.
|
|
const auto rules = metabolic_rules_for(1);
|
|
std::uint32_t structure_total{}, membrane_total{};
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
structure_total += rules->structure[index];
|
|
membrane_total += rules->membrane[index];
|
|
}
|
|
CHECK(structure_total == 1000 && membrane_total == 1000);
|
|
}
|
|
|
|
void splits_conserve_at_awkward_masses() {
|
|
// Masses chosen so every share floors, forcing the last channel to absorb it.
|
|
auto source = draft();
|
|
for (const std::uint32_t target : {1001U, 9'999U, 123'457U, 999'999'999U}) {
|
|
source.capabilities[2].parameter = target;
|
|
const auto genome = build(source);
|
|
for (const std::uint32_t realized : {1U, 333U, 999U, 1000U}) {
|
|
const auto budget = metabolic_budget(genome, {realized, 0}, temperate);
|
|
CHECK(budget);
|
|
// Whatever the rounding, the parts always sum back to the whole.
|
|
CHECK(matter_total(budget->body) == budget->phenotype.total_mass);
|
|
CHECK(matter_total(budget->intake_limit) == budget->phenotype.ingestion_rate);
|
|
}
|
|
}
|
|
}
|
|
|
|
void a_genome_drives_a_feeding_tick() {
|
|
using namespace evo::processes;
|
|
const auto genome = build(capable());
|
|
const auto opening =
|
|
Inventory{{0}, {Femtograms{0}, Femtograms{0}, Femtograms{0}, Femtograms{0}}};
|
|
const auto consumer = consumer_for(genome, {1000, 0}, temperate, opening);
|
|
CHECK(consumer);
|
|
const auto budget = metabolic_budget(genome, {1000, 0}, temperate);
|
|
CHECK(budget && consumer->intake_limit == budget->intake_limit);
|
|
CHECK(consumer->assimilation_per_thousand == 400);
|
|
CHECK(consumer->opening == opening); // The caller's, never invented.
|
|
// The derived cap drives a real community tick and the ledger still balances.
|
|
const ProducerConfig plants{
|
|
{{1'000'000}, 1},
|
|
{2, 1},
|
|
1000,
|
|
{1},
|
|
{Femtograms{4000}, Femtograms{4000}, Femtograms{4000}, Femtograms{4000}}};
|
|
const std::array configs{*consumer};
|
|
auto community = FeedingCommunity::create(
|
|
plants, {10'000'000},
|
|
{Femtograms{100'000}, Femtograms{100'000}, Femtograms{100'000}, Femtograms{100'000}},
|
|
configs);
|
|
CHECK(community);
|
|
Inventory total{};
|
|
for (const auto& balance : community->balances()) {
|
|
total.energy.value += balance.energy.value;
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
total.matter[index].value += balance.matter[index].value;
|
|
}
|
|
}
|
|
const std::array meal{FeedIntent{
|
|
1, 2, 1, {{100}, {Femtograms{2000}, Femtograms{720}, Femtograms{240}, Femtograms{1440}}}}};
|
|
const auto receipts = community->advance(evo::Tick{1}, meal);
|
|
CHECK(receipts && receipts->size() == 1);
|
|
Inventory after{};
|
|
for (const auto& balance : community->balances()) {
|
|
after.energy.value += balance.energy.value;
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
after.matter[index].value += balance.matter[index].value;
|
|
}
|
|
}
|
|
CHECK(after == total); // Conserved exactly, as every M2 tick must be.
|
|
// A bite past the genome's derived cap is refused by the existing contract.
|
|
const std::array excessive{FeedIntent{
|
|
1, 2, 1, {{100}, {Femtograms{2401}, Femtograms{0}, Femtograms{0}, Femtograms{0}}}}};
|
|
const auto denied = community->advance(evo::Tick{2}, excessive);
|
|
CHECK(!denied && denied.error() == FeedingError::intake_limit);
|
|
}
|
|
} // namespace
|
|
// Development version 2 (ADR-0099) and the primitive founder (ADR-0098 decision 7): rates
|
|
// per second, and a first bud fundable in about 5, 10 and 15 minutes feeding all, half
|
|
// and a third of the time while moving at full speed throughout. Tunable targets, so
|
|
// the bounds are the decision's range, not exact values.
|
|
void development_v2_and_the_first_bud() {
|
|
const auto founder = primitive_founder(1, 1);
|
|
CHECK(founder && founder->schema_version() == 2 && founder->development_version() == 2);
|
|
CHECK(!primitive_founder(0, 1));
|
|
const auto budget = metabolic_budget(*founder, {1000, 0}, temperate);
|
|
CHECK(budget);
|
|
const auto& p = budget->phenotype;
|
|
CHECK(budget->rate_microseconds == 1'000'000 && p.extent == 20 && p.surface == 2400);
|
|
CHECK(p.membrane_mass == 2'880'000 && p.total_mass == 10'880'000);
|
|
CHECK(p.maintenance == 108'800 + 43'200); // 10 and 15 pJ/s per 1000 fg.
|
|
CHECK(p.movement_speed == 200 && p.ingestion_rate == 22'960); // 574000 * 2400 / 60000.
|
|
CHECK(budget->movement.value == 108'800); // 10880 * 50 * 200 / 1000.
|
|
const auto at = [&](std::uint32_t share) { return bud_funding_seconds(*budget, share); };
|
|
const auto funded_all = at(1000), funded_half = at(500), funded_third = at(333);
|
|
CHECK(funded_all && funded_half && funded_third);
|
|
const auto all = funded_all.value_or(0), half = funded_half.value_or(0),
|
|
third = funded_third.value_or(0);
|
|
std::cout << "first bud seconds: all=" << all << " half=" << half << " third=" << third << "\n";
|
|
CHECK(all >= 270 && all <= 330);
|
|
CHECK(half >= 540 && half <= 660);
|
|
CHECK(third >= 810 && third <= 990);
|
|
CHECK(all < half && half < third);
|
|
CHECK(!at(100)); // Feeding a tenth of the time while always moving never funds a bud.
|
|
CHECK(!at(0) && !at(1001));
|
|
// Version 1 rates stay per 50 ms tick, and the M2 fixtures accept only version 1.
|
|
const auto v1 = metabolic_budget(build(capable()), {1000, 0}, temperate);
|
|
CHECK(v1 && v1->rate_microseconds == 50'000);
|
|
CHECK(!evo::processes::consumer_for(*founder, {1000, 0}, temperate, {}));
|
|
CHECK(evo::processes::consumer_for(build(capable()), {1000, 0}, temperate, {}));
|
|
// Without the reproduction capability there is nothing to fund.
|
|
auto plain = draft();
|
|
plain.schema_version = 2;
|
|
plain.development_version = 2;
|
|
CHECK(!bud_funding_seconds(*metabolic_budget(build(plain), {1000, 0}, temperate), 1000));
|
|
}
|
|
|
|
// 2026-10-15 balance: founder 2 (rules 6) is schema 3 and development 3. Its body, upkeep
|
|
// and reserve equal founder 1's; only construction energy falls, to 13/40 of it.
|
|
void founder_v2_builds_the_same_cell_for_less_energy() {
|
|
const auto v1 = primitive_founder(1, 1, primitive_founder_v1);
|
|
const auto v2 = primitive_founder(1, 1, primitive_founder_v2);
|
|
CHECK(v1 && v2 && v2->schema_version() == 3 && v2->development_version() == 3);
|
|
const auto b1 = metabolic_budget(*v1, {1000, 0}, temperate);
|
|
const auto b2 = metabolic_budget(*v2, {1000, 0}, temperate);
|
|
CHECK(b1 && b2 && b1->body == b2->body &&
|
|
b1->phenotype.maintenance == b2->phenotype.maintenance &&
|
|
b1->phenotype.extent == b2->phenotype.extent);
|
|
CHECK(b2->reproduction_investment.energy.value * 40 <=
|
|
b1->reproduction_investment.energy.value * 13 + 40);
|
|
const auto e1 = primitive_endowment(primitive_founder_v1);
|
|
const auto e2 = primitive_endowment(primitive_founder_v2);
|
|
CHECK(e1 && e2 && e1->body == e2->body && e1->reserve == e2->reserve &&
|
|
e2->construction.value < e1->construction.value &&
|
|
e2->construction.value * 40 <= e1->construction.value * 13 + 40);
|
|
CHECK(*primitive_endowment() == *e1); // The default stays founder 1.
|
|
}
|
|
|
|
// ADR-0137 (development 4): a bud is always half the body, and reproduction takes value /
|
|
// 2000 off its construction energy; the matter is never discounted.
|
|
void founder_v3_buds_more_cheaply_with_skill() {
|
|
const auto v2 = primitive_founder(1, 1, primitive_founder_v2);
|
|
const auto v3 = primitive_founder(1, 1, primitive_founder_v3);
|
|
CHECK(v2 && v3 && v3->schema_version() == 4 && v3->development_version() == 4);
|
|
const auto b2 = metabolic_budget(*v2, {1000, 0}, temperate);
|
|
const auto b3 = metabolic_budget(*v3, {1000, 0}, temperate);
|
|
CHECK(b2 && b3 && b2->body == b3->body && b2->phenotype == b3->phenotype);
|
|
const auto full = b2->reproduction_investment.energy.value; // Founders invest 500.
|
|
CHECK(b3->reproduction_investment.matter == b2->reproduction_investment.matter);
|
|
CHECK(b3->reproduction_investment.energy.value == full - full / 4);
|
|
const auto with_skill = [&](std::uint32_t reproduction) {
|
|
GenomeDraft draft;
|
|
draft.schema_version = genome_schema_v4;
|
|
draft.id = 2;
|
|
draft.origin_event = 1;
|
|
draft.development_version = 4;
|
|
for (const auto& record : v3->capabilities())
|
|
draft.capabilities.push_back(record);
|
|
for (auto& record : draft.capabilities)
|
|
if (record.kind == Capability::reproduction)
|
|
record.parameter = reproduction;
|
|
const auto genome = Genome::create(draft);
|
|
CHECK(genome.has_value());
|
|
const auto budget = metabolic_budget(genome.value_or(*v3), {1000, 0}, temperate);
|
|
CHECK(budget.has_value());
|
|
return budget.value_or(*b3).reproduction_investment;
|
|
};
|
|
// The bud stays half the body at any skill; full skill halves its energy.
|
|
CHECK(with_skill(100).matter == b3->reproduction_investment.matter);
|
|
CHECK(with_skill(1000).matter == b3->reproduction_investment.matter);
|
|
CHECK(with_skill(1000).energy.value == full - full / 2);
|
|
CHECK(with_skill(1).energy.value > with_skill(1000).energy.value);
|
|
}
|
|
|
|
int main() try {
|
|
hand_calculated_budget();
|
|
construction_composes_each_compartment();
|
|
construction_reproduces_the_derived_body();
|
|
released_matter_never_funds_another_element();
|
|
enormous_availability_still_funds_growth();
|
|
every_transition_is_affordable_channel_by_channel();
|
|
every_transition_conserves_each_channel();
|
|
repeated_growth_conserves_each_channel();
|
|
thicker_membrane_costs_matter_and_maintenance();
|
|
size_moves_several_budgets_together();
|
|
absent_capabilities_cost_nothing();
|
|
rules_fail_closed();
|
|
splits_conserve_at_awkward_masses();
|
|
a_genome_drives_a_feeding_tick();
|
|
development_v2_and_the_first_bud();
|
|
founder_v2_builds_the_same_cell_for_less_energy();
|
|
founder_v3_buds_more_cheaply_with_skill();
|
|
std::cout << "PASS metabolic budgets, composition splits and genome-driven feeding\n";
|
|
return 0;
|
|
} catch (...) {
|
|
return 1;
|
|
}
|