#include "evo/biology/cellular_offers.hpp" #include "evo/biology/cellular_triggers.hpp" #include "evo/core/random.hpp" #include #include #include #include #include #include #include #include #include // Rules-13 offers (ADR-0179; Cellular_mutation_plan.md section 3): triggers move affinity // scores, scores set weights, weights set floored and capped chances summing to the options, // and a systematic draw picks distinct mutations with exactly those chances. namespace { using namespace evo; using namespace evo::biology; void check(bool condition, std::source_location at = std::source_location::current()) { if (!condition) throw std::runtime_error("cellular offers line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) CellularActivity with(CellularSignal signal, std::uint64_t value = 1, std::uint16_t heading = 0) { CellularActivity activity{}; activity[signal] = value; activity.heading = heading; return activity; } // Runs a trigger over `ticks` ticks of `activity`, counting fires. std::uint32_t run(const CellularTriggerSpec& spec, CellularTriggerState& state, const CellularActivity& activity, std::uint32_t ticks) { std::uint32_t fired = 0; for (std::uint32_t t = 0; t < ticks; ++t) fired += cellular_trigger_tick(spec, 0, state, activity) ? 1U : 0U; return fired; } void triggers() { using K = CellularTriggerKind; using S = CellularSignal; const auto thrusting = with(S::thrust); const CellularActivity idle{}; // Accumulate: every 200 thrust ticks, idle ticks do not count. CellularTriggerState s{}; const CellularTriggerSpec thrust10{K::accumulate, S::thrust, 200}; CHECK(run(thrust10, s, thrusting, 199) == 0 && run(thrust10, s, idle, 50) == 0 && run(thrust10, s, thrusting, 1) == 1 && run(thrust10, s, thrusting, 400) == 2); // Absence: fires after 100 idle ticks running; any thrust restarts it. s = {}; const CellularTriggerSpec quiet{K::absence, S::thrust, 100}; CHECK(run(quiet, s, idle, 99) == 0 && run(quiet, s, thrusting, 1) == 0 && run(quiet, s, idle, 99) == 0 && run(quiet, s, idle, 1) == 1); // A tuned threshold replaces the spec's. s = {}; CHECK(!cellular_trigger_tick(quiet, 2, s, idle) && cellular_trigger_tick(quiet, 2, s, idle)); // Count: 3 presses within 10 ticks fire; spread out they do not. s = {}; const CellularTriggerSpec presses{K::count, S::brake_press, 10, 3}; const auto press = with(S::brake_press); CHECK(run(presses, s, press, 1) == 0 && run(presses, s, idle, 3) == 0 && run(presses, s, press, 1) == 0 && run(presses, s, idle, 3) == 0 && run(presses, s, press, 1) == 1); // The third press 8 ticks after the first. s = {}; CHECK(run(presses, s, press, 1) + run(presses, s, idle, 12) + run(presses, s, press, 1) + run(presses, s, idle, 12) + run(presses, s, press, 1) == 0); // Count without a window: any 3. s = {}; const CellularTriggerSpec failures{K::count, S::engulf_too_large, 0, 3}; const auto fail = with(S::engulf_too_large); CHECK(run(failures, s, fail, 1) + run(failures, s, idle, 5'000) + run(failures, s, fail, 2) == 1); // Event: each tick it happens. s = {}; CHECK(run({K::event, S::engulf_success}, s, with(S::engulf_success), 3) == 3); // Share: at the end of each 4-tick window, carbon at least half of all matter collected. s = {}; const CellularTriggerSpec diet{K::share, S::collected_carbon, 4, 0, S::collected_matter, 500}; CellularActivity rich{}; rich[S::collected_carbon] = 6; rich[S::collected_matter] = 10; CellularActivity poor{}; poor[S::collected_carbon] = 1; poor[S::collected_matter] = 10; CHECK(run(diet, s, rich, 3) == 0 && run(diet, s, rich, 1) == 1 && run(diet, s, poor, 4) == 0 && run(diet, s, idle, 4) == 0); // Regular: thrust at least every 3 ticks for 10 ticks fires; a longer gap breaks the run. s = {}; const CellularTriggerSpec pulsed{K::regular, S::thrust, 10, 0, {}, 0, 3}; std::uint32_t fired = 0; for (int t = 0; t < 12; ++t) fired += cellular_trigger_tick(pulsed, 0, s, t % 3 == 0 ? thrusting : idle) ? 1U : 0U; CHECK(fired == 1); s = {}; fired = 0; for (int t = 0; t < 30; ++t) fired += cellular_trigger_tick(pulsed, 0, s, t % 5 == 0 ? thrusting : idle) ? 1U : 0U; CHECK(fired == 0); // Straight: 5 thrust ticks within 20 degrees of one heading; a sharp change restarts. s = {}; const CellularTriggerSpec line{K::straight, S::thrust, 5, 0, {}, 0, 0, 3'641}; CHECK(run(line, s, with(S::thrust, 1, 1'000), 4) == 0 && run(line, s, with(S::thrust, 1, 3'000), 1) == 1); s = {}; CHECK(run(line, s, with(S::thrust, 1, 0), 4) == 0 && run(line, s, with(S::thrust, 1, 10'000), 4) == 0 && run(line, s, with(S::thrust, 1, 10'000), 1) == 1); // Turns: 3 turns of more than 90 degrees within 20 ticks. s = {}; const CellularTriggerSpec weave{K::turns, S::thrust, 20, 3, {}, 0, 0, 16'384}; fired = 0; for (const std::uint16_t heading : std::array{0, 20'000, 40'000, 60'000, 60'100}) fired += cellular_trigger_tick(weave, 0, s, with(S::thrust, 1, heading)) ? 1U : 0U; CHECK(fired == 1); // Wrapping: 65,000 to 1,000 is a small turn. s = {}; CHECK(!cellular_trigger_tick(weave, 0, s, with(S::thrust, 1, 65'000)) && !cellular_trigger_tick(weave, 0, s, with(S::thrust, 1, 1'000)) && s.first == 0); } void affinity() { std::vector tuning; for (const auto& spec : cellular_catalog()) tuning.push_back(cellular_default_tuning(spec)); CellularAffinity a{}; // Ten seconds of thrust raises Strong Propulsion (index 0) and lowers Light Propulsion (6). const auto thrusting = with(CellularSignal::thrust); for (int t = 0; t < 200; ++t) cellular_affinity_tick(a, thrusting, tuning, {}); CHECK(a.score[0] == 100 && a.score[6] == -100); // Scores stay within bounds, and a disabled mutation does not move. tuning[0].increase_points = 5'000; tuning[6].enabled = false; for (int t = 0; t < 200; ++t) cellular_affinity_tick(a, thrusting, tuning, {-1'000, 1'000}); CHECK(a.score[0] == 1'000 && a.score[6] == -100); } void weights() { const CellularOfferRules rules{}; CHECK(cellular_offer_weight(100, 0, rules) == 100'000); CHECK(cellular_offer_weight(100, 1'000, rules) == 1'000'000); CHECK(cellular_offer_weight(100, 500, rules) == 550'000); CHECK(cellular_offer_weight(100, -1'000, rules) == 0); CHECK(cellular_offer_weight(100, -500, rules) == 50'000); CHECK(cellular_offer_weight(100, 9'999, rules) == 1'000'000); // Clamped to score_max. } std::uint64_t sum(const std::vector& values) { return std::accumulate(values.begin(), values.end(), std::uint64_t{0}); } void chances() { const CellularOfferRules rules{}; // Ten equal weights share 300% equally. const std::vector equal(10, 1'000); const auto even = cellular_offer_chances(equal, rules); CHECK(even && std::ranges::all_of(*even, [](std::uint32_t c) { return c == 300'000; })); // One heavy weight is capped at 70%; one zero weight sits at the floor. std::vector mixed{1'000, 1'000, 1'000, 1'000, 1'000'000, 0}; const auto capped = cellular_offer_chances(mixed, rules); CHECK(capped && (*capped)[4] == 700'000 && (*capped)[5] == 10 && sum(*capped) == 3'000'000); CHECK(capped && capped.value()[0] - capped.value()[3] <= 1); // Rounding over four. // Four mutations cannot fill three options at a 70% cap. CHECK(!cellular_offer_chances(std::vector(4, 1'000), rules)); // Seed ensemble: every allocation sums exactly and respects the bounds and the order. Random random{11}; for (int round = 0; round < 300; ++round) { const auto m = 5 + random.next() % 45; std::vector w(m); for (auto& weight : w) weight = random.next() % 4 == 0 ? random.next() % 1'000'000'000 : random.next() % 200'000; const auto c = cellular_offer_chances(w, rules); CHECK(c.has_value()); if (!c) continue; CHECK(sum(*c) == 3'000'000); for (std::size_t i = 0; i < m; ++i) { CHECK((*c)[i] >= 10 && (*c)[i] <= 700'000); for (std::size_t j = 0; j < m; ++j) if (w[i] > w[j]) CHECK((*c)[i] + 1 >= (*c)[j]); } } } void systematic_draw() { const CellularOfferRules rules{}; const std::vector w{5, 900'000, 3'000, 3'000, 40'000, 0, 120'000}; const auto c = cellular_offer_chances(w, rules); CHECK(c.has_value()); if (!c) return; std::vector picked(c->size(), 0); for (std::uint32_t u = 0; u < cellular_chance_whole; ++u) { const auto draw = cellular_systematic_draw(*c, 3, u); CHECK(draw.size() == 3 && std::set(draw.begin(), draw.end()).size() == 3); for (const auto index : draw) ++picked[index]; } // Over every u, each mutation appears in exactly its chance's share of draws. for (std::size_t i = 0; i < c->size(); ++i) CHECK(picked[i] == (*c)[i]); } } // namespace int main() { try { triggers(); affinity(); weights(); chances(); systematic_draw(); } catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1; } std::puts("PASS cellular triggers, affinity, chances and the systematic draw"); return 0; }