Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m29s
Foundation / postgres-tools (push) Successful in 24s
Foundation / server-image (push) Successful in 4m33s
Foundation / image (push) Successful in 4m59s
Session v14 carries the rules-13 revamp: a body block in the owner's view (members, emergence threshold, exclusions, Emerge open, payable energy, mass and the 20 traits), become, emerge and channel exclusions on actions, become on mutation choices, catalog offers (id, chance, cost) and the emerged ending. Older sessions never see a v14 field. The client shows Stay / Become offspring offers named from the shared catalog, continuing as a bud, the organism and its Emerge button, kept channels, the body and the emerged end screen. Bundle 15 (rules 13 on owner format 11) is durable: schema 60 admits it raw-only, stores become as bit 15 of the choice's operator, widens the action input and mutation results, and publishes the 14 -> 15 revamp profile migration. evo-world-clone opens cellular-v10 (cellular-v9 plus the revamp upgrade from --revamp-tuning), resumable and recoverable. Wildlife counts reserve matter as energy, waits for the bud fee, grows organisms one short of emerging, and hunts by the region step's rules-13 engulf test. The play summary adds organisms, offers and the spent pool. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
618 lines
28 KiB
C++
618 lines
28 KiB
C++
// M9.8c toolkit-independent UI model: labels keep data states distinct, selection
|
|
// follows presentations, the launcher bounds credentials and errors, and the outcome
|
|
// log stays bounded.
|
|
#include "cellular_controls.hpp"
|
|
#include "cellular_play.hpp"
|
|
#include "cellular_scene.hpp"
|
|
#include "evo/client/labels.hpp"
|
|
#include "evo/client/launcher.hpp"
|
|
#include "evo/client/outcome_log.hpp"
|
|
#include "evo/client/selection.hpp"
|
|
#include "evo/client/session_host.hpp"
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo;
|
|
using namespace evo::client;
|
|
void check(bool ok, std::source_location at = std::source_location::current()) {
|
|
if (!ok)
|
|
throw std::runtime_error("client UI model line " + std::to_string(at.line()));
|
|
}
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
template <class T> const T& required(const std::optional<T>& value) {
|
|
if (!value)
|
|
throw std::runtime_error("missing client model test value");
|
|
return *value;
|
|
}
|
|
constexpr world::WorldIdentity identity{3, 9};
|
|
|
|
EnvironmentCell cell(std::int64_t x) {
|
|
EnvironmentCell c;
|
|
c.voxel = {x, 0, 0};
|
|
c.chunk_revision = 4;
|
|
c.habitat = {{0}, {0}, {0}, {1000}, {1000}, {10}};
|
|
c.volume = {10'000'000};
|
|
c.substrate = {1};
|
|
c.terrain_material = {1};
|
|
c.terrain_fill = world::fill_scale;
|
|
c.presence[0] = FieldPresence::present; // Water: value.
|
|
c.quantity[0] = 80'000'000;
|
|
c.presence[2] = FieldPresence::present; // Phosphorus: present zero.
|
|
c.presence[1] = FieldPresence::missing; // Nitrogen: missing.
|
|
c.moisture_status = world::MoistureStatus::available;
|
|
c.moisture = {1, 4};
|
|
return c;
|
|
}
|
|
EnvironmentPresentation environment(std::vector<EnvironmentCell> cells, std::uint64_t tick = 1) {
|
|
auto p = EnvironmentPresentation::create({identity, tick, 1}, 0b111, 0, cells);
|
|
CHECK(p);
|
|
return std::move(*p);
|
|
}
|
|
OrganismCell organism(std::uint64_t id, std::uint64_t x_um) {
|
|
OrganismCell o;
|
|
o.id = id;
|
|
o.voxel = {0, 0, 0};
|
|
o.x = {x_um};
|
|
o.y = {500000};
|
|
o.phenotype.extent = 20;
|
|
o.phenotype.structural_mass = 8'000'000;
|
|
o.phenotype.membrane_mass = 1'000'000;
|
|
o.phenotype.total_mass = 9'000'000;
|
|
o.phenotype.conversion_per_thousand = 400;
|
|
o.growth.realized_per_thousand = 1000;
|
|
return o;
|
|
}
|
|
OrganismPresentation organisms(std::vector<OrganismCell> cells, std::uint64_t tick = 1) {
|
|
auto p = OrganismPresentation::create({identity, tick, 0}, 0, cells);
|
|
CHECK(p);
|
|
return std::move(*p);
|
|
}
|
|
|
|
void cellular_assistance() {
|
|
using namespace client_app;
|
|
auto own = organism(42, 980);
|
|
own.y = {2000};
|
|
own.phenotype.movement_speed = 10000;
|
|
auto population = organisms({own});
|
|
network::CellularPerception view{2, 42, {{1000, 2000, 100, {}}}, {}};
|
|
CellularControls controls;
|
|
const Intention diagonal{1, 2, 707, -707};
|
|
auto steering = steer_cellular(controls, diagonal, &view, &population, {});
|
|
CHECK(steering.patch == std::pair<std::uint32_t, std::uint32_t>{1000, 2000});
|
|
CHECK(steering.intention.move_x == 35 && steering.intention.move_y == -35);
|
|
own.x = {979};
|
|
population = organisms({own});
|
|
CHECK(!steer_cellular(controls, diagonal, &view, &population, {}).patch);
|
|
controls.slow_near_food = false;
|
|
controls.precision = true;
|
|
controls.speed_percent = 50;
|
|
steering = steer_cellular(controls, diagonal, &view, &population, {});
|
|
CHECK(steering.intention.move_x == 70 && steering.intention.move_y == -70);
|
|
controls.auto_feed = false;
|
|
CHECK(steer_cellular(controls, {}, &view, &population, {{9000, 9000}}).patch ==
|
|
std::pair<std::uint32_t, std::uint32_t>{9000, 9000});
|
|
controls.auto_feed = true;
|
|
view.patches[0].energy_pj = 0;
|
|
own.x = {1000};
|
|
population = organisms({own});
|
|
CHECK(!steer_cellular(controls, {}, &view, &population, {}).patch);
|
|
view.patches[0].matter_fg[2] = 1;
|
|
CHECK(steer_cellular(controls, {}, &view, &population, {}).patch);
|
|
view.patches.push_back({0, 2000, 100, {}});
|
|
CHECK(steer_cellular(controls, {}, &view, &population, {}).patch ==
|
|
std::pair<std::uint32_t, std::uint32_t>{0, 2000});
|
|
view.patches.back().energy_pj = 0;
|
|
CHECK(steer_cellular(controls, {}, &view, &population, {}).patch ==
|
|
std::pair<std::uint32_t, std::uint32_t>{1000, 2000});
|
|
view.life_identity = 0;
|
|
CHECK(!steer_cellular(controls, {}, &view, &population, {}).patch);
|
|
network::CellularOfferedCandidate candidate;
|
|
candidate.cost_energy_pj = 10;
|
|
candidate.cost_matter_fg = {1, 2, 3, 4};
|
|
network::CellularLifeDiagnostics reserve;
|
|
reserve.reserve_energy_pj = 10;
|
|
reserve.reserve_matter_fg = {1, 2, 3, 4};
|
|
CHECK(can_fund(candidate, reserve));
|
|
reserve.reserve_matter_fg[3] = 3;
|
|
CHECK(!can_fund(candidate, reserve));
|
|
reserve.reserve_matter_fg[3] = 4;
|
|
reserve.reserve_energy_pj = 9;
|
|
CHECK(!can_fund(candidate, reserve));
|
|
std::vector<render::Rectangle> scene;
|
|
patch_box(scene, {0, 80}, {80, 0}, true, true, true, 80, 80);
|
|
CHECK(scene.size() == patch_rectangles);
|
|
for (const auto& r : scene)
|
|
CHECK(r.x >= 0 && r.y >= 0 && r.x + r.width <= 80 && r.y + r.height <= 80);
|
|
}
|
|
void labels() {
|
|
const auto c = cell(0);
|
|
const auto water = describe_field(c, world::Field::water);
|
|
const auto nitrogen = describe_field(c, world::Field::nitrogen);
|
|
const auto phosphorus = describe_field(c, world::Field::phosphorus);
|
|
const auto carbon = describe_field(c, world::Field::organic_carbon);
|
|
CHECK(water.kind == ValueKind::value &&
|
|
water.text.starts_with("80000000 fg (8 fg/um3, log2 3.0)"));
|
|
CHECK(nitrogen.kind == ValueKind::missing && nitrogen.text.starts_with("MISSING"));
|
|
CHECK(phosphorus.kind == ValueKind::zero && phosphorus.text == "0 fg (present zero)");
|
|
CHECK(carbon.kind == ValueKind::not_requested);
|
|
// Every state reads differently: missing is never shown as 0, zero never as missing.
|
|
const std::vector<std::string> texts{water.text, nitrogen.text, phosphorus.text, carbon.text};
|
|
for (std::size_t i = 0; i < texts.size(); ++i)
|
|
for (std::size_t j = i + 1; j < texts.size(); ++j)
|
|
CHECK(texts[i] != texts[j]);
|
|
CHECK(nitrogen.text.find('0') == std::string::npos);
|
|
CHECK(describe_moisture(c).text == "25.00 % saturated");
|
|
auto dry = c;
|
|
dry.moisture_status = world::MoistureStatus::zero_capacity;
|
|
CHECK(describe_moisture(dry).kind == ValueKind::undefined);
|
|
dry.moisture_status = world::MoistureStatus::missing_water;
|
|
CHECK(describe_moisture(dry).kind == ValueKind::missing);
|
|
dry.moisture_status = world::MoistureStatus::available;
|
|
dry.moisture = {0, 1};
|
|
CHECK(describe_moisture(dry).kind == ValueKind::zero);
|
|
CHECK(field_name(world::Field::heat) == "Heat" && field_unit(world::Field::heat) == "pJ" &&
|
|
field_unit(world::Field::organic_other) == "fg");
|
|
CHECK(freshness_name(Freshness::stale).starts_with("STALE") &&
|
|
freshness_name(Freshness::none) != freshness_name(Freshness::current));
|
|
CHECK(density_scale(world::Field::water).find("-30") != std::string::npos);
|
|
const auto rows = organism_rows(organism(77, 500000));
|
|
CHECK(rows.size() == 15 && rows[0].value == "alive");
|
|
const auto extent =
|
|
std::ranges::find_if(rows, [](const Row& r) { return r.label == "Extent (side)"; });
|
|
CHECK(extent != rows.end() && extent->value == "20" && extent->unit == "um");
|
|
const auto speed =
|
|
std::ranges::find_if(rows, [](const Row& r) { return r.label == "Movement speed"; });
|
|
CHECK(speed != rows.end() && speed->value == "none");
|
|
for (const auto& r : rows)
|
|
CHECK(r.value.find("77") == std::string::npos); // The opaque id is never displayed.
|
|
const auto cell_info = cell_rows(c);
|
|
CHECK(cell_info[1].value == "rock" && cell_info[2].value == "100.0");
|
|
}
|
|
|
|
void selection() {
|
|
const auto env = environment({cell(0), cell(1)});
|
|
const auto orgs = organisms({organism(5, 500000), organism(6, 500010)});
|
|
auto camera = Camera::create({800, 600, 800, 600}, {500, 500}, 1000);
|
|
CHECK(camera);
|
|
Selection s;
|
|
s.pick({400, 300}, &env, &orgs, *camera); // Both organisms overlap: topmost (6) wins.
|
|
CHECK(s.kind() == Selection::Kind::organism && s.organism(&orgs) && s.organism(&orgs)->id == 6);
|
|
// The organism disappears from the next presentation: selection clears.
|
|
const auto later = organisms({organism(5, 500000)}, 2);
|
|
CHECK(s.refresh(&env, &later) == Selection::Change::organism_gone);
|
|
CHECK(s.kind() == Selection::Kind::none);
|
|
// No organism under the point: the habitat cell beneath it is selected.
|
|
s.pick({700, 300}, &env, &later, *camera);
|
|
CHECK(s.kind() == Selection::Kind::cell && s.cell(&env) && s.cell(&env)->voxel.x == 0);
|
|
// Without a presentation the selection is kept (unknown is not gone).
|
|
CHECK(s.refresh(nullptr, nullptr) == Selection::Change::none &&
|
|
s.kind() == Selection::Kind::cell);
|
|
const auto shrunk = environment({cell(1)}, 3);
|
|
CHECK(s.refresh(&shrunk, &later) == Selection::Change::cell_gone);
|
|
// Outside any data: nothing.
|
|
auto far = Camera::create({800, 600, 800, 600}, {-50000, 500}, 1000);
|
|
CHECK(far);
|
|
s.pick({400, 300}, &env, &orgs, *far);
|
|
CHECK(s.kind() == Selection::Kind::none);
|
|
}
|
|
|
|
void launcher() {
|
|
CHECK(parse_endpoint("127.0.0.1:17400") && parse_endpoint("127.0.0.1:17400")->port == 17400);
|
|
CHECK(parse_endpoint("dev-region.evolution.test:443"));
|
|
CHECK(parse_endpoint("[::1]:9") && parse_endpoint("[::1]:9")->host == "::1");
|
|
for (const auto* bad :
|
|
{"", "host", ":1", "host:0", "host:65536", "host:x", "bad host:1", "a;b:1", "[zz]:1"})
|
|
CHECK(!parse_endpoint(bad));
|
|
CHECK(!parse_endpoint(std::string(2000, 'a') + ":1"));
|
|
const auto dir = std::filesystem::temp_directory_path() /
|
|
("evo-launcher-" +
|
|
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
|
|
std::filesystem::create_directories(dir);
|
|
const auto write = [&](const char* name, const std::string& bytes) {
|
|
std::ofstream out{dir / name, std::ios::binary};
|
|
out << bytes;
|
|
return (dir / name).string();
|
|
};
|
|
ConnectForm form;
|
|
form.authority_path =
|
|
write("ca.pem", "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----\n");
|
|
form.grants_path = write("grants.bin", std::string(grant_record_bytes * 3, '\x01'));
|
|
const auto loaded = load_connect(form);
|
|
// The default endpoint is the dev route (ADR-0087); records are M10 grants (160 bytes).
|
|
CHECK(loaded && loaded->grants.size() == 3 && loaded->endpoint.port == 7400 &&
|
|
loaded->endpoint.host == "void.aeternalisgames.com" && grant_record_bytes == 160 &&
|
|
loaded->server_name == "void.aeternalisgames.com" && // The dev certificate's name.
|
|
loaded->authority_path == form.authority_path);
|
|
const auto refused_with = [&](const ConnectForm& f, LaunchError e) {
|
|
const auto r = load_connect(f);
|
|
return !r && r.error() == e;
|
|
};
|
|
auto f = form;
|
|
f.endpoint = "nope";
|
|
CHECK(refused_with(f, LaunchError::endpoint));
|
|
f = form;
|
|
f.server_name = "bad name";
|
|
CHECK(refused_with(f, LaunchError::server_name));
|
|
f = form;
|
|
f.authority_path.clear();
|
|
CHECK(refused_with(f, LaunchError::authority_path));
|
|
f = form;
|
|
f.authority_path = (dir / "missing.pem").string();
|
|
CHECK(refused_with(f, LaunchError::authority_unreadable));
|
|
f = form;
|
|
f.authority_path = write("not-ca.pem", "hello");
|
|
CHECK(refused_with(f, LaunchError::authority_invalid));
|
|
f = form;
|
|
f.authority_path =
|
|
write("huge.pem", "-----BEGIN CERTIFICATE-----" + std::string(max_authority_bytes, 'A'));
|
|
CHECK(refused_with(f, LaunchError::authority_invalid));
|
|
f = form;
|
|
f.grants_path = write("partial.bin", std::string(grant_record_bytes + 1, '\x01'));
|
|
CHECK(refused_with(f, LaunchError::grants_invalid));
|
|
f = form;
|
|
f.grants_path =
|
|
write("many.bin", std::string(grant_record_bytes * (max_grant_records + 1), '\x01'));
|
|
CHECK(refused_with(f, LaunchError::grants_invalid));
|
|
f = form;
|
|
f.grants_path = (dir / "missing.bin").string();
|
|
CHECK(refused_with(f, LaunchError::grants_unreadable));
|
|
// Messages never echo file content.
|
|
for (auto e = 0; e <= static_cast<int>(LaunchError::no_session); ++e)
|
|
CHECK(launch_error_text(static_cast<LaunchError>(e)).find('\x01') ==
|
|
std::string_view::npos);
|
|
std::error_code ignored;
|
|
std::filesystem::remove_all(dir, ignored);
|
|
|
|
Launcher l;
|
|
CHECK(l.phase() == LaunchPhase::choosing && l.begin_connect());
|
|
CHECK(!l.begin_connect()); // Already connecting.
|
|
l.observe(ConnectSignal::not_ready);
|
|
l.observe(ConnectSignal::lost);
|
|
l.observe(ConnectSignal::lost);
|
|
CHECK(l.phase() == LaunchPhase::connecting);
|
|
l.observe(ConnectSignal::lost); // Third loss before any welcome: bounded failure.
|
|
CHECK(l.phase() == LaunchPhase::failed && l.error() == LaunchError::server_unreachable);
|
|
CHECK(l.begin_connect() && l.phase() == LaunchPhase::connecting); // Retry.
|
|
l.observe(ConnectSignal::refused);
|
|
CHECK(l.phase() == LaunchPhase::failed && l.error() == LaunchError::grant_refused);
|
|
l.cancel();
|
|
CHECK(l.phase() == LaunchPhase::choosing && l.begin_connect());
|
|
l.observe(ConnectSignal::welcome);
|
|
CHECK(l.phase() == LaunchPhase::connected && l.ever_connected());
|
|
for (int i = 0; i < 5; ++i)
|
|
l.observe(ConnectSignal::lost); // After a welcome: reconnecting, never failed.
|
|
CHECK(l.phase() == LaunchPhase::connecting);
|
|
l.observe(ConnectSignal::welcome);
|
|
l.observe(ConnectSignal::exhausted);
|
|
CHECK(l.phase() == LaunchPhase::failed && l.error() == LaunchError::grants_exhausted);
|
|
l.cancel();
|
|
l.start_fixture();
|
|
CHECK(l.phase() == LaunchPhase::fixture && !l.begin_connect());
|
|
l.observe(ConnectSignal::welcome); // Ignored outside a connect flow.
|
|
CHECK(l.phase() == LaunchPhase::fixture);
|
|
}
|
|
|
|
void outcome_log() {
|
|
OutcomeLog log;
|
|
log.record({1, OutcomeState::sent});
|
|
log.record({1, OutcomeState::admitted});
|
|
log.record({1, OutcomeState::durable, 0, 40, 3});
|
|
CHECK(log.entries().size() == 1 && log.entries()[0].state == OutcomeState::durable &&
|
|
log.entries()[0].commit_sequence == 3);
|
|
for (std::uint64_t s = 2; s < 2 + 200; ++s)
|
|
log.record({s, OutcomeState::unknown});
|
|
CHECK(log.entries().size() == OutcomeLog::capacity &&
|
|
log.evicted() == 201 - OutcomeLog::capacity);
|
|
CHECK(log.entries().back().sequence == 201);
|
|
}
|
|
// Host/session boundary: the visible mode and the session lifetime change together.
|
|
struct Server {
|
|
bool available{};
|
|
int steps{}, welcomes{}, intentions{}, alive{};
|
|
};
|
|
class FakeSession {
|
|
public:
|
|
explicit FakeSession(Server& server) : server_{&server} {
|
|
++server_->alive;
|
|
}
|
|
FakeSession(FakeSession&& other) noexcept : server_{std::exchange(other.server_, nullptr)} {}
|
|
FakeSession& operator=(FakeSession&&) = delete;
|
|
FakeSession(const FakeSession&) = delete;
|
|
FakeSession& operator=(const FakeSession&) = delete;
|
|
~FakeSession() {
|
|
if (server_ != nullptr)
|
|
--server_->alive;
|
|
}
|
|
void step(std::chrono::steady_clock::time_point, const Intention& intention, UiState&,
|
|
Launcher& launcher) {
|
|
++server_->steps;
|
|
if (!server_->available) {
|
|
launcher.observe(ConnectSignal::lost);
|
|
return;
|
|
}
|
|
if (!welcomed_) {
|
|
welcomed_ = true;
|
|
++server_->welcomes; // Spends a grant.
|
|
launcher.observe(ConnectSignal::welcome);
|
|
}
|
|
if (intention.move_x != 0 || intention.move_y != 0)
|
|
++server_->intentions;
|
|
}
|
|
|
|
private:
|
|
Server* server_;
|
|
bool welcomed_{};
|
|
};
|
|
void session_host() {
|
|
const auto now = std::chrono::steady_clock::now();
|
|
UiState ui;
|
|
const Intention move{1, 0, 1000, 0};
|
|
Server server;
|
|
SessionHost<FakeSession> host;
|
|
CHECK(!host.connect(std::nullopt) && host.session() == nullptr);
|
|
// Connecting -> Local fixture: the attempt ends; a later server sees nothing.
|
|
CHECK(host.connect(FakeSession{server}) && server.alive == 1);
|
|
host.step(now, move, ui);
|
|
CHECK(server.steps == 1 && host.launcher().phase() == LaunchPhase::connecting);
|
|
host.enter_fixture();
|
|
CHECK(server.alive == 0 && host.launcher().phase() == LaunchPhase::fixture);
|
|
server.available = true;
|
|
for (int i = 0; i < 10; ++i)
|
|
host.step(now, move, ui);
|
|
CHECK(server.steps == 1 && server.welcomes == 0 && server.intentions == 0);
|
|
// Failed -> Local fixture: the failure already dropped the session.
|
|
host.cancel();
|
|
server.available = false;
|
|
CHECK(host.connect(FakeSession{server}));
|
|
for (int i = 0; i < Launcher::max_attempts_without_welcome; ++i)
|
|
host.step(now, move, ui);
|
|
CHECK(host.launcher().phase() == LaunchPhase::failed && server.alive == 0);
|
|
host.enter_fixture();
|
|
server.available = true;
|
|
host.step(now, move, ui);
|
|
CHECK(server.welcomes == 0 && server.intentions == 0 && host.session() == nullptr);
|
|
// Ordinary live use still works, and Cancel ends it.
|
|
host.cancel();
|
|
CHECK(host.connect(FakeSession{server}));
|
|
host.step(now, move, ui);
|
|
CHECK(host.launcher().phase() == LaunchPhase::connected && server.welcomes == 1 &&
|
|
server.intentions == 1);
|
|
host.cancel();
|
|
host.step(now, move, ui);
|
|
CHECK(server.alive == 0 && server.intentions == 1 &&
|
|
host.launcher().phase() == LaunchPhase::choosing);
|
|
// Connect is refused outside choosing/failed and leaves no session behind.
|
|
host.enter_fixture();
|
|
// (Separate statements: the by-value argument may live until the full expression ends.)
|
|
CHECK(!host.connect(FakeSession{server}));
|
|
CHECK(server.alive == 0 && host.session() == nullptr);
|
|
}
|
|
void cellular_play() {
|
|
using namespace evo::client_app;
|
|
using namespace evo::network;
|
|
CellularPlay play;
|
|
play.initialize(100);
|
|
CHECK(play.birth_request() == 100 && play.birth_pending());
|
|
play.connected();
|
|
play.observe({101, 900, {}, CellularLifeDiagnostics{}});
|
|
CHECK(play.can_act() && !play.can_restart());
|
|
CellularLifeDiagnostics feedback;
|
|
feedback.has_tick_effects = true;
|
|
feedback.bud = CellularBudOutcome::insufficient_funding;
|
|
play.observe({101, 900, {}, feedback});
|
|
play.observe({102, 900, {}, CellularLifeDiagnostics{}});
|
|
CHECK(play.bud_feedback() ==
|
|
std::pair{std::uint64_t{101}, CellularBudOutcome::insufficient_funding});
|
|
const CellularMutationOffer offer{101, 900, 1, 100, {{3, 2, 0, 50, 20, 30}}};
|
|
play.observe_offer(offer);
|
|
CHECK(!play.queue(CellAction::mutation, 102, {900, 2, 100, 3}));
|
|
CHECK(!play.queue(CellAction::mutation, 100, {900, 1, 100, 3}));
|
|
CHECK(!play.queue(CellAction::mutation, 102, {900, 1, 100, 8}));
|
|
CHECK(play.queue(CellAction::mutation, 102, {900, 1, 100, 3}));
|
|
const auto id = required(play.pending()).id;
|
|
CHECK(!play.queue(CellAction::bud, 102)); // Double clicks cannot create another action.
|
|
play.sent();
|
|
play.receipt({id, AdmitStatus::not_ready, 101, 0});
|
|
CHECK(required(play.pending()).state == CellActionState::unresolved);
|
|
play.disconnected();
|
|
CHECK(!play.can_act() && !play.offer());
|
|
play.connected();
|
|
CHECK(!play.can_act());
|
|
play.observe({103, 900, {}, CellularLifeDiagnostics{}});
|
|
play.receipt({id, AdmitStatus::invalid_action, 103, 0});
|
|
CHECK(required(play.pending()).state ==
|
|
CellActionState::unresolved); // Refused retry != failed original.
|
|
play.outcome({id, ActionResult::committed, 102, 1});
|
|
CHECK(!play.pending() && play.history().back().state == CellActionState::committed);
|
|
CHECK(play.queue(CellAction::bud, 104));
|
|
const auto bud = required(play.pending()).id;
|
|
play.sent();
|
|
play.observe_end({104, 900, CellularDeathReason::starved});
|
|
play.observe({103, 900, {}, CellularLifeDiagnostics{}}); // Retained view is older than death.
|
|
CHECK(play.life() == 0 && play.can_restart() && !play.can_act());
|
|
CHECK(play.restart());
|
|
const auto request = play.birth_request();
|
|
CHECK(request != 100 && !play.restart());
|
|
play.birth({100, PrimitiveLifeResult::born, 900, 1}); // Old request cannot finish this birth.
|
|
CHECK(play.birth_pending());
|
|
play.birth({request, PrimitiveLifeResult::born, 901, 3});
|
|
CHECK(!play.can_restart()); // Birth reply may precede the first new-life view.
|
|
play.observe({105, 901, {}, CellularLifeDiagnostics{}});
|
|
play.observe_end({104, 900, CellularDeathReason::starved});
|
|
CHECK(play.life() == 901 && !play.ended() && !play.pending());
|
|
play.outcome({bud, ActionResult::not_committed, 0, 0});
|
|
CHECK(play.history().back().state == CellActionState::refused);
|
|
for (int i = 0; i < 20; ++i) {
|
|
CHECK(play.queue(CellAction::engulf, 106));
|
|
const auto action = required(play.pending()).id;
|
|
play.sent();
|
|
play.outcome({action, ActionResult::unknown, 0, 0});
|
|
play.keep_unknown();
|
|
}
|
|
CHECK(play.history().size() == CellularPlay::history_limit);
|
|
CHECK(play.history().back().state == CellActionState::unresolved);
|
|
play.disconnected();
|
|
CHECK(!play.queue(CellAction::engulf, 106) && !play.can_restart());
|
|
play.connected();
|
|
play.observe({106, 901, {}, CellularLifeDiagnostics{}});
|
|
CHECK(play.queue(CellAction::bud, 107));
|
|
play.disconnected();
|
|
CHECK(!play.pending() && play.history().back().state == CellActionState::refused);
|
|
CellularPlay exhausted;
|
|
exhausted.initialize(std::numeric_limits<std::uint64_t>::max());
|
|
CHECK(exhausted.allocate_id() == 0 && exhausted.allocate_id() == 0);
|
|
}
|
|
// Recent actions keep what the region did: the effect reported in the action's tick view
|
|
// is attached to that engulf, even after its committed outcome moved it to the history.
|
|
void cellular_action_effects() {
|
|
using namespace evo::client_app;
|
|
using namespace evo::network;
|
|
CellularPlay play;
|
|
play.initialize(50);
|
|
play.connected();
|
|
play.observe({200, 700, {}, CellularLifeDiagnostics{}});
|
|
CHECK(play.queue(CellAction::engulf, 203));
|
|
const auto id = required(play.pending()).id;
|
|
play.sent();
|
|
play.outcome({id, ActionResult::committed, 203, 1});
|
|
CHECK(!play.pending() && !play.history().back().engulf);
|
|
CellularLifeDiagnostics effect;
|
|
effect.has_tick_effects = true;
|
|
effect.engulf = CellularEngulfResult::membrane_too_thick;
|
|
play.observe({203, 700, {}, effect});
|
|
CHECK(play.history().back().engulf == CellularEngulfResult::membrane_too_thick);
|
|
// A later engulf result does not overwrite the reported one.
|
|
effect.engulf = CellularEngulfResult::engulfed;
|
|
play.observe({204, 700, {}, effect});
|
|
CHECK(play.history().back().engulf == CellularEngulfResult::membrane_too_thick);
|
|
}
|
|
// Rules 13 (v14): a bud may carry become, a choice its become, Emerge is a discrete action,
|
|
// and an emerged ending ends the life like any other.
|
|
void cellular_revamp_actions() {
|
|
using namespace evo::client_app;
|
|
using namespace evo::network;
|
|
CellularPlay play;
|
|
play.initialize(70);
|
|
play.connected();
|
|
CellularLifeDiagnostics body;
|
|
body.members = 1;
|
|
play.observe({300, 800, {}, body});
|
|
CHECK(play.queue(CellAction::bud, 301, {}, true) && required(play.pending()).become);
|
|
play.sent();
|
|
play.outcome({required(play.pending()).id, ActionResult::committed, 301, 1});
|
|
CHECK(play.history().back().become);
|
|
CHECK(play.queue(CellAction::engulf, 302, {}, true) && !required(play.pending()).become);
|
|
play.sent();
|
|
play.outcome({required(play.pending()).id, ActionResult::committed, 302, 1});
|
|
play.observe_offer(CellularMutationOffer{303, 800, 1, 300, {{12, 0, 0, 700'000, 0, 0}}});
|
|
CHECK(play.queue(CellAction::mutation, 304, {800, 1, 300, 12, true}) &&
|
|
required(play.pending()).choice.become);
|
|
play.sent();
|
|
play.outcome({required(play.pending()).id, ActionResult::committed, 304, 1});
|
|
CHECK(play.queue(CellAction::emerge, 305));
|
|
play.sent();
|
|
play.observe_end({305, 800, CellularDeathReason::emerged});
|
|
CHECK(play.life() == 0 && play.ended() && play.ended()->cause == CellularDeathReason::emerged &&
|
|
play.can_restart());
|
|
}
|
|
void cellular_energy_and_birth_wait() {
|
|
using namespace evo::client_app;
|
|
using namespace evo::network;
|
|
CellularPlay play;
|
|
play.initialize(1);
|
|
play.connected();
|
|
CHECK(!play.can_restart());
|
|
play.birth({1, PrimitiveLifeResult::pending, 7, 0});
|
|
CHECK(!play.can_restart());
|
|
play.birth({1, PrimitiveLifeResult::insufficient_funding, 7, 0});
|
|
CHECK(!play.fresh() && play.can_restart()); // Refusal arrives without any world view.
|
|
CHECK(play.restart() && play.birth_request() == 2 && !play.restart());
|
|
play.birth({1, PrimitiveLifeResult::no_placement, 7, 0});
|
|
CHECK(play.birth_pending()); // Delayed answer to an older request is ignored.
|
|
play.birth({2, PrimitiveLifeResult::existing_life, 9, 0});
|
|
CHECK(!play.can_restart()); // Wait for that existing life instead of offering another birth.
|
|
CellularLifeDiagnostics d;
|
|
d.reserve_energy_pj = 200;
|
|
play.observe({10, 9, {}, d});
|
|
CHECK(!play.energy_change());
|
|
play.observe({11, 0, {}, {}}); // The bridge may clear a view before sending its replacement.
|
|
d.reserve_energy_pj = 150;
|
|
play.observe({11, 9, {}, d});
|
|
CHECK(required(play.energy_change()).falling && required(play.energy_change()).amount == 50);
|
|
play.observe({11, 9, {}, d});
|
|
CHECK(required(play.energy_change()).amount == 50); // Duplicate views retain the change.
|
|
d.reserve_energy_pj = 175;
|
|
play.observe({15, 9, {}, d});
|
|
CHECK(!required(play.energy_change()).falling && required(play.energy_change()).amount == 25 &&
|
|
required(play.energy_change()).from_tick == 11);
|
|
play.disconnected();
|
|
CHECK(!play.energy_change());
|
|
play.connected();
|
|
play.observe({16, 9, {}, d});
|
|
CHECK(!play.energy_change());
|
|
play.observe({17, 10, {}, d});
|
|
CHECK(!play.energy_change()); // A different life starts a new baseline.
|
|
}
|
|
} // namespace
|
|
|
|
// A cell faces the way it moved (y up in the world is up on screen), eases into a turn,
|
|
// ignores sub-step jitter and camera panning, and is forgotten once it is not drawn.
|
|
void cell_headings() {
|
|
using namespace evo::client_app;
|
|
auto camera = Camera::create({800, 600, 800, 600}, {5, 5}, 100);
|
|
CHECK(camera);
|
|
CellHeadings headings;
|
|
CHECK(!headings.update(1, {5, 5}, *camera));
|
|
headings.end_frame();
|
|
CHECK(!headings.update(1, {5.001, 5}, *camera)); // Below the step: still unknown.
|
|
headings.end_frame();
|
|
const auto east = headings.update(1, {5.1, 5}, *camera);
|
|
CHECK(east && std::abs(*east) < 1e-4F);
|
|
headings.end_frame();
|
|
auto panned = Camera::create({800, 600, 800, 600}, {9, 2}, 100);
|
|
CHECK(panned);
|
|
const auto still = headings.update(1, {5.1, 5}, *panned);
|
|
CHECK(still && std::abs(*still) < 1e-4F);
|
|
headings.end_frame();
|
|
// Moving north is screen up (negative y): the heading eases toward -pi/2.
|
|
const auto turning = headings.update(1, {5.1, 5.2}, *camera);
|
|
CHECK(turning && *turning < 0 && *turning > -1.5707F);
|
|
headings.end_frame();
|
|
float heading = turning.value_or(0);
|
|
for (int i = 0; i < 60; ++i) {
|
|
heading = headings.update(1, {5.1, 5.2}, *camera).value_or(0);
|
|
headings.end_frame();
|
|
}
|
|
CHECK(std::abs(heading + 1.5708F) < 1e-3F);
|
|
headings.end_frame(); // Not drawn this frame: forgotten.
|
|
CHECK(!headings.update(1, {6, 6}, *camera));
|
|
}
|
|
int main() try {
|
|
labels();
|
|
selection();
|
|
launcher();
|
|
outcome_log();
|
|
session_host();
|
|
cellular_play();
|
|
cellular_action_effects();
|
|
cellular_revamp_actions();
|
|
cellular_energy_and_birth_wait();
|
|
cellular_assistance();
|
|
cell_headings();
|
|
std::puts("client UI model tests passed");
|
|
return 0;
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "%s\n", e.what());
|
|
return 1;
|
|
}
|