Files
aevolution/tests/cellular_revamp_tuning_tests.cpp
T
dingoandClaude Opus 5.5 7e5775b6f7
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 4s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m34s
Foundation / postgres-tools (push) Successful in 22s
Foundation / server-image (push) Successful in 4m16s
Foundation / image (push) Successful in 4m47s
feat(lifecycle): rules 13 behaviour-weighted mutation offers in the owner
Phase 3 of the cellular revamp build plan (ADR-0179), server half.

- Every owned, active rules-13 life gathers its activity each tick from every
  phase (thrust and drift, brake presses, feeding and the collection limits,
  matter burned by channel, energy by use, contact with larger cells, engulf
  outcomes, growth blocked by a channel, buds made, refused or lost young, the
  reserve against the body) and advances its 98 triggers and 49 affinity scores.
- Active play earns an offer every interval: eligible catalog mutations of the
  life's plan, weighted by affinity, drawn with the floored and capped chances
  and a seeded systematic draw (a retry draws the same offer). Wildlife,
  newborns and frozen cells earn nothing; a plan without schema-7 traits has no
  catalog.
- A choice must name the life's own pending offer. It edits the offspring plan
  (phase 4 turns this into the split), pays the mutation's tuned cost from the
  reserve (matter may stand in for its energy, excluded channels excepted) and
  reclaims it as seeded random bubbles, merging into the farthest deposit at the
  deposit limit. Unaffordable choices keep the offer; declines clear it.
- Offspring inherit affinity scores and lineage progress. Growth speed scales
  the growth step with a carried fraction.
- Format 11 persists the offer tunables and each life's mutation state; the
  revamp tuning file gains the offer keys and optional per-mutation overrides
  (mutation.<key>.<field>), defaulting to the catalog with zero costs.

Tests cover per-mutation overrides and refusals, the collection-limit flags,
offers from active play, founder-5 plans never offered, exact restore of a
pending offer, a choice editing only the plan and reclaiming its cost with
closure, unaffordable choices, declines, foreign choices, and thrust moving
affinity. Refreshes the DEV session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 18:58:32 -04:00

172 lines
7.8 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};
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;
}