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 4s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m29s
Foundation / server-image (push) Successful in 5s
Foundation / postgres-tools (push) Successful in 19s
Foundation / image (push) Successful in 4m50s
Maintainer tuning for the next playtest, on the current server image: - 100 starting wildlife (was 32) on their own ADR-0180 identity range, 900000003616-900000003715; - every pool and bubble holds three times region 14's food; - the nursery funds 256 founders' worth (was 64), so the wildlife leave room for player births; - the bud fee scale drops to 50%. The grant broker routes accounts to region 15; region 14 stays stored. Refreshes the session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
194 lines
9.2 KiB
C++
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 = 100,
|
|
.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 = 50,
|
|
.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;
|
|
}
|