#include "evo/biology/cellular_revamp_tuning.hpp" #include #include #include #include #include #include // 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(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 = 500, .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(file), std::istreambuf_iterator()}; 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; }