Files
aevolution/tests/cellular_revamp_tuning_tests.cpp
T
dingoandClaude Opus 5.5 f454e038a1
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m32s
Foundation / postgres-tools (push) Successful in 21s
Foundation / server-image (push) Successful in 4m12s
Foundation / image (push) Successful in 4m52s
feat(lifecycle): rules 13 multicellular organisms and Emerge
Adhesion turns a cell into a two-member organism: one life with a member
count, one genome and one reserve, developed as its genome with the target
size times its members. The single cell ends as an empty merged corpse.
An organism expresses accepted mutations as a whole, paid from its reserve;
its buds add internal members (wildlife stops one short of the threshold);
the extra members' mass loads its thrust. At the emergence threshold the
Emerge intent exports the body and reserve through the boundary ledger and
ends the life as emerged.

Records the maintainer's 2026-10-23 decisions in ADR-0179 and the project
vision (whole-organism mutations; the playtest form of Emerge).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 06:50:19 -04:00

185 lines
8.6 KiB
C++

#include "evo/biology/cellular_revamp_tuning.hpp"
#include <cstdio>
#include <fstream>
#include <iterator>
#include <source_location>
#include <stdexcept>
#include <string>
// The rules-13 revamp tuning file (ADR-0179): same format and refusals as the rules-12 file,
// with its own keys.
namespace {
using namespace evo::biology;
void check(bool condition, std::source_location at = std::source_location::current()) {
if (!condition)
throw std::runtime_error("cellular revamp tuning line " + std::to_string(at.line()));
}
#define CHECK(expression) check(static_cast<bool>(expression))
CellularRevampTuning trial() {
CellularRevampTuning t{.version = 1,
.body_essential_upkeep_per_mille = 250,
.body_reserve_load_per_mille = 1'000,
.body_growth_per_tick_centi_mille = 500,
.energy_burn_carbon_pj_per_kfg = 2'000,
.energy_burn_nitrogen_pj_per_kfg = 2'000,
.energy_burn_phosphorus_pj_per_kfg = 2'000,
.energy_burn_other_pj_per_kfg = 2'000,
.feeding_membrane_collection_per_mille_per_point = 2,
.predation_engulf_ratio_milli = 1'500,
.predation_engulf_reserve_percent = 100,
.predation_kill_bubble_per_mille = 500,
.spent_drip_interval_ticks = 20,
.spent_drip_bubble_pj = 20'000'000,
.spent_drip_bubble_fg = 1'000'000,
.mutation_options = 3,
.mutation_floor_ppm = 10,
.mutation_cap_ppm = 700'000,
.mutation_score_min = -1'000,
.mutation_score_max = 1'000,
.mutation_max_multiplier_per_mille = 10'000,
.mutation_min_multiplier_per_mille = 0,
.mutation_offer_interval_ticks = 500,
.mutation_min_points = 25,
.mutation_max_points = 1'000,
.mutation_recipe_min_share = 20,
.mutation_max_offspring = 10,
.mutation_carbon_for_light_fg = 20'000'000,
.mutation_buds_for_adhesion = 5,
.reproduction_split_share_per_mille = 500,
.reproduction_split_min_growth_per_mille = 1'000,
.reproduction_bud_fee_e_pj = 0,
.reproduction_bud_fee_c_fg = 0,
.reproduction_bud_fee_n_fg = 0,
.reproduction_bud_fee_p_fg = 0,
.reproduction_bud_fee_o_fg = 0,
.reproduction_bud_fee_scale_percent = 0,
.reproduction_organism_cap = 256,
.organism_load_per_mille = 500,
.organism_emerge_members = 8,
.organism_emerge_mass_fg = 100'000'000,
.organism_emerge_reserve_pj = 0};
const auto catalog = cellular_catalog();
for (std::size_t i = 0; i < catalog.size(); ++i)
t.mutations.at(i) = cellular_default_tuning(catalog[i]);
return t;
}
std::string with(std::string text, const std::string& key, const std::string& value) {
const auto at = text.find(key + " = ");
check(at != std::string::npos);
const auto end = text.find('\n', at);
return text.replace(at, end - at, key + " = " + value);
}
CellularTuningErrorKind error_of(const std::string& text) {
const auto parsed = parse_cellular_revamp_tuning(text);
check(!parsed.has_value());
return parsed.error().kind;
}
// Per-mutation overrides are optional, change only their field, and refuse unknown names,
// unknown fields, duplicates and out-of-range values.
void mutation_overrides() {
const auto base = encode_cellular_revamp_tuning(trial());
// The canonical text lists every override; a file may omit them all.
std::string bare;
for (std::size_t at = 0; at < base.size();) {
const auto end = base.find('\n', at);
const auto line = base.substr(at, end - at);
if (!line.starts_with("mutation.") || line.find('.', 9) == std::string::npos ||
line.find('.', 9) > line.find(' '))
bare += line + "\n";
at = end + 1;
}
CHECK(parse_cellular_revamp_tuning(bare) == trial());
const auto tuned =
parse_cellular_revamp_tuning(bare + "mutation.strong_propulsion.cost_e_pj = 1_000\n"
"mutation.strong_propulsion.cost_scale_percent = 50\n"
"mutation.adhesion.enabled = 0\n");
CHECK(tuned.has_value());
if (!tuned)
return;
auto expected = trial();
expected.mutations.at(0).cost.energy.value = 1'000;
expected.mutations.at(0).cost_scale_percent = 50;
expected.mutations.at(48).enabled = false;
CHECK(*tuned == expected);
CHECK(error_of(bare + "mutation.unknown_thing.enabled = 1\n") ==
CellularTuningErrorKind::unknown_key);
CHECK(error_of(bare + "mutation.adhesion.colour = 1\n") ==
CellularTuningErrorKind::unknown_key);
CHECK(error_of(bare + "mutation.adhesion.enabled = 1\nmutation.adhesion.enabled = 0\n") ==
CellularTuningErrorKind::duplicate_key);
CHECK(error_of(bare + "mutation.adhesion.cost_scale_percent = 101\n") ==
CellularTuningErrorKind::out_of_range);
CHECK(error_of(with(bare, "mutation.floor_ppm", "800000")) ==
CellularTuningErrorKind::inconsistent);
}
void canonical_round_trip() {
const auto text = encode_cellular_revamp_tuning(trial());
const auto parsed = parse_cellular_revamp_tuning(text);
CHECK(parsed && *parsed == trial());
CHECK(encode_cellular_revamp_tuning(*parsed) == text);
const auto commented =
"# heading\n\n" + with(text, "body.essential_upkeep_per_mille", "2_50 # c");
CHECK(parse_cellular_revamp_tuning(commented) == trial());
}
void refusals() {
const auto base = encode_cellular_revamp_tuning(trial());
CHECK(error_of(base + "unknown.key = 1\n") == CellularTuningErrorKind::unknown_key);
CHECK(error_of(base + "tuning.version = 1\n") == CellularTuningErrorKind::duplicate_key);
CHECK(error_of(base + "no equals sign\n") == CellularTuningErrorKind::syntax);
CHECK(error_of(with(base, "body.essential_upkeep_per_mille", "1001")) ==
CellularTuningErrorKind::out_of_range);
CHECK(error_of(with(base, "body.essential_upkeep_per_mille", "x")) ==
CellularTuningErrorKind::invalid_value);
CHECK(error_of(with(base, "tuning.version", "2")) ==
CellularTuningErrorKind::unsupported_version);
auto missing = base;
missing.erase(missing.find("body.essential_upkeep_per_mille"));
const auto parsed = parse_cellular_revamp_tuning(missing);
CHECK(!parsed && parsed.error().kind == CellularTuningErrorKind::missing_key &&
parsed.error().key == "body.essential_upkeep_per_mille");
CHECK(error_of(with(base, "spent.drip_bubble_fg", "0")) ==
CellularTuningErrorKind::inconsistent);
CHECK(error_of(with(base, "predation.engulf_reserve_percent", "101")) ==
CellularTuningErrorKind::out_of_range);
// Rules-12 keys belong in the other file.
CHECK(error_of(base + "region.width_um = 60000\n") == CellularTuningErrorKind::unknown_key);
CHECK(error_of(std::string(max_cellular_revamp_tuning_bytes + 1, '#')) ==
CellularTuningErrorKind::too_large);
}
// The checked-in DEV revamp tuning file must parse; CTest passes its path when it is present.
void repository_file(const char* path) {
std::ifstream file(path, std::ios::binary);
CHECK(file.good());
const std::string text{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
const auto parsed = parse_cellular_revamp_tuning(text);
if (!parsed)
std::fprintf(stderr, "%s: line %zu %s: %s\n", path, parsed.error().line,
parsed.error().key.c_str(),
std::string{describe(parsed.error().kind)}.c_str());
CHECK(parsed && *parsed == trial());
}
} // namespace
int main(int argc, char** argv) {
try {
canonical_round_trip();
refusals();
mutation_overrides();
if (argc > 1)
repository_file(argv[1]);
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
std::puts("PASS cellular revamp tuning file");
return 0;
}