Files
aevolution/tests/cellular_revamp_tuning_tests.cpp
T
dingo ff121c3ed1
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m27s
Foundation / postgres-tools (push) Successful in 30s
Foundation / server-image (push) Successful in 4m16s
Foundation / image (push) Successful in 4m54s
feat(cellular): seed dev wildlife and tune budding playtests
2026-10-26 12:01:57 -04:00

194 lines
9.2 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,
.playtest_starting_wildlife_cells = 32,
.body_essential_upkeep_per_mille = 250,
.body_reserve_load_per_mille = 1'000,
.body_growth_per_tick_centi_mille = 625,
.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 = 500,
.reproduction_bud_fee_e_pj = 250'000,
.reproduction_bud_fee_c_fg = 100'000,
.reproduction_bud_fee_n_fg = 30'000,
.reproduction_bud_fee_p_fg = 10'000,
.reproduction_bud_fee_o_fg = 60'000,
.reproduction_bud_fee_scale_percent = 100,
.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(with(base, "playtest.starting_wildlife_cells", "256")) ==
CellularTuningErrorKind::out_of_range);
CHECK(error_of(with(base, "playtest.starting_wildlife_cells", "-1")) ==
CellularTuningErrorKind::out_of_range);
auto legacy = base;
const auto start = legacy.find("playtest.starting_wildlife_cells");
legacy.erase(start, legacy.find('\n', start) - start + 1);
CHECK(parse_cellular_revamp_tuning(legacy)->playtest_starting_wildlife_cells == 0);
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;
}