Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m22s
Foundation / postgres-tools (push) Successful in 22s
Foundation / server-image (push) Successful in 4m21s
Foundation / image (push) Successful in 5m6s
Phase 4 of the cellular revamp build plan (ADR-0179), server half. - A chosen mutation now splits the cell (Cellular_reproduction_plan.md section 4): split_cell divides body and reserve per channel by the tuned share, each cell develops the largest body its own genome builds from its part, and the rest joins its reserve, conserving every channel. Both plans carry the mutation; only the offspring expresses it. A split is refused, spending nothing and keeping the offer, below the tuned growth, without room beside the cell or at the region's organism cap. - Stay or become: a choice (trace mutation byte 34) or a bud (step intent bit 2 of byte 13) can hand control to the offspring; the parent becomes wildlife. Ownership now follows the account under rules 13, so validation and plan history accept a founder that became wildlife (ADR-0163 succession). - Buds under rules 13: litter replaces the 25% twin (whole hundreds plus a chance, up to the tuned maximum, sharing one investment), the tuned bud fee is charged once and reclaimed, and births stop at the organism cap. - New results split_applied and split_refused; owners below rules 13 refuse a become. The revamp tuning file gains the reproduction keys. Tests cover the split's conservation and refusals, stay and become splits with exact restore, a refused second split, the cap, become validation and the litter count. Refreshes the DEV session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
181 lines
8.4 KiB
C++
181 lines
8.4 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};
|
|
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;
|
|
}
|