Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (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 5s
Foundation / checks (deploy) (push) Successful in 4m23s
Foundation / postgres-tools (push) Successful in 29s
Foundation / server-image (push) Successful in 4m10s
Foundation / image (push) Successful in 4m31s
The cellular owner gains rules 12 on owner format 10: an explicit no-tick format-9/rules-11 upgrade declares the region's liquid rules (current configuration, founder handling and deposit motion, from the tuning file and a seed when the region opens), converts the habitat to format 3 and starts lives at rest. Founders born afterwards are founder 5 (genome schema 6). Each tick derives every life's handling from its genome and the declared founder handling, samples the current at its footprint and steps the shared liquid motion; afterwards bubbles move with the current and the drift moving cells induce, and touching bubbles merge. Format 10 persists the rules and each life's motion state; restore regenerates the identical current field. Brake is a new step intent, valid only under rules 12, carried in trace 4 as flag bit 1 (SQL never parses that byte; player action records keep it zero). Tests cover the upgrade, exact restore, swimming and braking, moving food with fixed pools, restore continuing a live run, and brake traces replaying exactly. Genomes from before schema 6 handle as founders. Refreshes the DEV session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
239 lines
10 KiB
C++
239 lines
10 KiB
C++
#include "evo/accounting/rates.hpp"
|
|
#include "evo/biology/cellular_tuning.hpp"
|
|
#include "evo/biology/founder.hpp"
|
|
|
|
#include <cstdio>
|
|
#include <fstream>
|
|
#include <iterator>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
namespace {
|
|
using namespace evo::biology;
|
|
void check(bool value, std::source_location at = std::source_location::current()) {
|
|
if (!value)
|
|
throw std::runtime_error("cellular tuning line " + std::to_string(at.line()));
|
|
}
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
|
|
CellularTuning v0() {
|
|
return {.version = 1,
|
|
.region_width_um = 60'000,
|
|
.region_height_um = 60'000,
|
|
.region_organism_cap = 2'000,
|
|
.region_deposit_limit = 8'192,
|
|
.region_perception_radius_um = 5'000,
|
|
.founder_thrust_um_per_s2 = 400,
|
|
.founder_reverse_thrust_um_per_s2 = 400,
|
|
.founder_drag_ppm_per_tick = 95'163,
|
|
.founder_lateral_drag_ppm_per_tick = 95'163,
|
|
.founder_turn_heading_per_s = 65'536,
|
|
.currents_min_count = 2,
|
|
.currents_max_count = 4,
|
|
.currents_min_width_um = 3'000,
|
|
.currents_max_width_um = 6'000,
|
|
.currents_min_speed_um_per_s = 60,
|
|
.currents_max_speed_um_per_s = 300,
|
|
.currents_grid_pitch_um = 250,
|
|
.food_merged_bubble_cap_multiple = 8,
|
|
.food_visible_moving_bubbles = 256,
|
|
.food_induced_drift_radius_um = 200,
|
|
.food_induced_drift_max_um_per_s = 100,
|
|
.food_induced_drift_decay_ppm_per_tick = 95'163,
|
|
.thermal_ambient_min_mk = 278'150,
|
|
.thermal_ambient_max_mk = 313'150,
|
|
.founder_preferred_mk = 293'150,
|
|
.founder_comfort_band_mk = 5'000,
|
|
.founder_body_tau_ms = 20'000,
|
|
.founder_lethal_cold_mk = 273'150,
|
|
.founder_lethal_heat_mk = 318'150,
|
|
.thermal_off_preference_per_mille_per_k = 80,
|
|
.thermal_transition_per_mille_per_k = 40,
|
|
.thermal_multiplier_cap_per_mille = 8'000,
|
|
.lifecycle_logout_delay_ms = 10'000,
|
|
.mutation_step_points = 5,
|
|
.mutation_paired_points = 2,
|
|
.mutation_recovery_floor_per_mille = 100,
|
|
.mutation_offer_interval_ms = 25'000,
|
|
.mutation_offer_options = 3};
|
|
}
|
|
|
|
// Replaces the first `key = ...` line of canonical text.
|
|
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_tuning(text);
|
|
check(!parsed.has_value());
|
|
return parsed.error().kind;
|
|
}
|
|
|
|
void canonical_round_trip() {
|
|
const auto text = encode_cellular_tuning(v0());
|
|
const auto parsed = parse_cellular_tuning(text);
|
|
CHECK(parsed && *parsed == v0());
|
|
CHECK(encode_cellular_tuning(*parsed) == text);
|
|
}
|
|
|
|
void comments_separators_and_whitespace() {
|
|
auto text = "# heading\n\n" + encode_cellular_tuning(v0());
|
|
text = with(text, "region.width_um", "60_000 # trailing comment\r");
|
|
text = with(text, "region.height_um", "\t60000");
|
|
const auto parsed = parse_cellular_tuning(text);
|
|
CHECK(parsed && *parsed == v0());
|
|
}
|
|
|
|
void refusals() {
|
|
const auto base = encode_cellular_tuning(v0());
|
|
CHECK(error_of(base + "unknown.key = 1\n") == CellularTuningErrorKind::unknown_key);
|
|
CHECK(error_of(base + "region.width_um = 60000\n") == CellularTuningErrorKind::duplicate_key);
|
|
CHECK(error_of(base + "no equals sign\n") == CellularTuningErrorKind::syntax);
|
|
CHECK(error_of(base + "Region.Width = 1\n") == CellularTuningErrorKind::syntax);
|
|
CHECK(error_of(with(base, "region.width_um", "60k")) == CellularTuningErrorKind::invalid_value);
|
|
CHECK(error_of(with(base, "region.width_um", "60__000")) ==
|
|
CellularTuningErrorKind::invalid_value);
|
|
CHECK(error_of(with(base, "region.width_um", "")) == CellularTuningErrorKind::invalid_value);
|
|
CHECK(error_of(with(base, "region.width_um", "999")) == CellularTuningErrorKind::out_of_range);
|
|
CHECK(error_of(with(base, "founder.drag_ppm_per_tick", "1000000")) ==
|
|
CellularTuningErrorKind::out_of_range);
|
|
CHECK(error_of(with(base, "region.width_um", "# missing")) ==
|
|
CellularTuningErrorKind::invalid_value);
|
|
CHECK(error_of(with(base, "currents.min_count", "5")) == CellularTuningErrorKind::inconsistent);
|
|
CHECK(error_of(with(base, "founder.preferred_mk", "320000")) ==
|
|
CellularTuningErrorKind::inconsistent);
|
|
CHECK(error_of(with(base, "tuning.version", "2")) ==
|
|
CellularTuningErrorKind::unsupported_version);
|
|
auto missing = base;
|
|
missing.erase(missing.find("mutation.offer_options"));
|
|
const auto parsed = parse_cellular_tuning(missing);
|
|
CHECK(!parsed && parsed.error().kind == CellularTuningErrorKind::missing_key &&
|
|
parsed.error().key == "mutation.offer_options");
|
|
const auto line = parse_cellular_tuning(base + "\nbad\n");
|
|
CHECK(!line && line.error().line == 41);
|
|
CHECK(error_of(std::string(max_cellular_tuning_bytes + 1, '#')) ==
|
|
CellularTuningErrorKind::too_large);
|
|
}
|
|
|
|
void founder_handling() {
|
|
const auto handling = founder_cellular_handling(v0(), {1'000}, {900});
|
|
CHECK(handling.thrust_q10 == 20'480 && handling.reverse_thrust_q10 == 20'480);
|
|
CHECK(handling.forward_drag_ppm == 95'163 && handling.lateral_drag_ppm == 95'163);
|
|
CHECK(handling.turn == 3'276);
|
|
CHECK(handling.thrust_cost.value == 1'000 && handling.reverse_cost.value == 900);
|
|
}
|
|
|
|
Genome founder_genome(const MovementArrangement& arrangement, bool movement = true) {
|
|
const auto founder = primitive_founder(1, 1, primitive_founder_v5);
|
|
check(founder.has_value());
|
|
GenomeDraft draft{2, 2, 6, {1}, {}, genome_schema_v6, arrangement};
|
|
for (const auto& record : founder->capabilities())
|
|
if (movement || record.kind != Capability::movement)
|
|
draft.capabilities.push_back(record);
|
|
const auto genome = Genome::create(draft);
|
|
check(genome.has_value());
|
|
return *genome;
|
|
}
|
|
|
|
CellularHandling handling_of(const Genome& genome) {
|
|
const auto budget = metabolic_budget(genome, {1'000, 0}, {293'150, {}});
|
|
check(budget.has_value());
|
|
const auto handling = derive_cellular_handling(genome, *budget, v0());
|
|
check(handling.has_value());
|
|
return *handling;
|
|
}
|
|
|
|
void derived_handling() {
|
|
const auto founder = primitive_founder(1, 1, primitive_founder_v5);
|
|
CHECK(founder && founder->movement_arrangement() == founder_movement_arrangement);
|
|
const auto budget = metabolic_budget(*founder, {1'000, 0}, {293'150, {}});
|
|
CHECK(budget);
|
|
const auto base = handling_of(*founder);
|
|
// The founder arrangement reproduces the tuned founder handling exactly.
|
|
const auto full =
|
|
*evo::accounting::per_tick(budget->movement.value, 50'000, evo::accounting::Rounding::up);
|
|
CHECK(base == founder_cellular_handling(v0(), {full}, {full}));
|
|
CHECK(full > 0);
|
|
|
|
auto a = founder_movement_arrangement;
|
|
a.output = 105; // 001: more thrust, costing more per tick.
|
|
const auto strong = handling_of(founder_genome(a));
|
|
CHECK(strong.thrust_q10 == 21'504 && strong.thrust_cost.value > base.thrust_cost.value);
|
|
CHECK(strong.reverse_thrust_q10 == base.reverse_thrust_q10);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.efficiency = 105; // 002: same thrust, cheaper.
|
|
const auto economical = handling_of(founder_genome(a));
|
|
CHECK(economical.thrust_q10 == base.thrust_q10 &&
|
|
economical.thrust_cost.value < base.thrust_cost.value);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.steering = 105; // 004
|
|
CHECK(handling_of(founder_genome(a)).turn == 3'439);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.streamlining = 105; // 005: forward drag only.
|
|
const auto straight = handling_of(founder_genome(a));
|
|
CHECK(straight.forward_drag_ppm == 90'631 && straight.lateral_drag_ppm == 95'163);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.braking = 105; // 006
|
|
CHECK(handling_of(founder_genome(a)).reverse_thrust_q10 == 21'504);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.coasting = 105; // 008: both drags at 100/105, about 95.24%.
|
|
const auto coaster = handling_of(founder_genome(a));
|
|
CHECK(coaster.forward_drag_ppm == 90'631 && coaster.lateral_drag_ppm == 90'631);
|
|
|
|
a = founder_movement_arrangement;
|
|
a.output = 0; // 009: shed propulsion drifts but cannot thrust or turn.
|
|
const auto shed = handling_of(founder_genome(a));
|
|
CHECK(shed.thrust_q10 == 0 && shed.reverse_thrust_q10 == 0 && shed.turn == 0);
|
|
CHECK(shed.thrust_cost.value == 0 && shed.forward_drag_ppm == base.forward_drag_ppm);
|
|
CHECK(handling_of(founder_genome(founder_movement_arrangement, false)).thrust_q10 == 0);
|
|
|
|
const auto old = primitive_founder(1, 1, primitive_founder_v4);
|
|
CHECK(old);
|
|
const auto old_budget = metabolic_budget(*old, {1'000, 0}, {293'150, {}});
|
|
// Genomes from before schema 6 handle as founders.
|
|
CHECK(old_budget);
|
|
const auto old_handling = derive_cellular_handling(*old, *old_budget, v0());
|
|
CHECK(old_handling && old_handling->thrust_q10 == base.thrust_q10 &&
|
|
old_handling->forward_drag_ppm == base.forward_drag_ppm);
|
|
}
|
|
|
|
// The checked-in DEV 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_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 == v0());
|
|
}
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
try {
|
|
canonical_round_trip();
|
|
comments_separators_and_whitespace();
|
|
refusals();
|
|
founder_handling();
|
|
derived_handling();
|
|
if (argc > 1)
|
|
repository_file(argv[1]);
|
|
} catch (const std::exception& error) {
|
|
std::fprintf(stderr, "%s\n", error.what());
|
|
return 1;
|
|
}
|
|
std::puts("cellular tuning contracts passed");
|
|
return 0;
|
|
}
|