Files
aevolution/apps/evo-client/main.cpp
T
dingoandClaude Opus 5.5 be69cae652
Foundation / checks (checks) (push) Successful in 47m40s
Foundation / checks (client) (push) Successful in 17m27s
Foundation / checks (deploy) (push) Successful in 4m17s
Foundation / checks (ecs) (push) Successful in 4m31s
Foundation / checks (network) (push) Successful in 22m1s
Foundation / checks (tsan) (push) Successful in 13m10s
Foundation / checks (postgres) (push) Successful in 20m54s
Foundation / image (push) Successful in 4m15s
Foundation / postgres-tools (push) Successful in 5m32s
Foundation / server-image (push) Successful in 7m15s
Cellular rules 8: pools and bubbles fed by contact (ADR-0136 step A)
Square patches invited camping and left the space between them empty. Rules 8 run on a
format-2 habitat of deposits:
- pools and single-nutrient bubbles at free micrometre centres, each with a stable id
  and a contact radius; the cellular-v7 opening scatters bubbles reproducibly from the
  genesis commit (three in ten in loose clumps) and lists pools with --pool;
- every cell drains what it touches, up to its intake rate per tick, with no target; a
  pool gives at most a quarter of that rate; an emptied deposit disappears;
- a dead cell's detritus breaks into one bubble per non-empty channel;
- wildlife swims to the nearest non-empty deposit and feeds by touch.

Bundle v9 (habitat 2) and schema v43 admit it. Session v11 carries the owner's 512
nearest deposits (id, centre, radius, shape, a drained flag and 16-bit amount codes)
instead of patches; every other cellular message is v10's. The client asks for v11,
draws bubbles (nutrient-coloured, pulsing while drained, popping when gone) and pools as
puddles, slows near food and sends no feed target; the HUD summarises food in range.
Earlier rules, regions and v10 clients are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 00:38:21 -04:00

946 lines
49 KiB
C++

#include "cellular_scene.hpp"
#include "controls_flow.hpp"
#include "evo/client/application.hpp"
#include "evo/client/auth.hpp"
#include "evo/client/launcher.hpp"
#include "evo/client/selection.hpp"
#include "evo/client/session_host.hpp"
#include "evo/client/ui_state.hpp"
#include "evo/render/environment.hpp"
#include "evo/render/organism.hpp"
#include "panels.hpp"
#include "remote_session.hpp"
#include <algorithm>
#include <array>
#include <charconv>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <exception>
#include <filesystem>
#include <map>
#include <memory>
#include <optional>
#include <span>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
namespace {
using evo::world::Field;
constexpr evo::world::WorldIdentity fixture_identity{1, 1};
constexpr std::int64_t fixture_z = -16000;
// Water, nitrogen (never opened: missing), phosphorus (present zero), organic and
// incident energy (never opened: missing). Unrequested fields draw hollow outlines.
constexpr std::uint32_t fixture_mask = (1U << 0) | (1U << 1) | (1U << 2) | (1U << 7) | (1U << 8);
constexpr unsigned frames_per_authority_tick = 60;
// Frame composition: environment bound + organisms + 6 host rectangles (capture bar,
// intention dot, 4-sided selection highlight). Text and panels are the toolkit overlay.
constexpr std::size_t host_rectangles =
6 + evo::client_app::patch_rectangles * evo::network::max_cellular_perceived_patches;
// M11.3: the cellular arena is millimetres across, far below the metre-scale default
// camera; the first view frames this much of it around the own cell.
constexpr double cellular_view_mm = 6;
constexpr std::size_t organism_budget =
evo::render::max_rectangles - evo::render::max_environment_rectangles - host_rectangles;
// Local in-memory stand-in for authoritative region views until M9.7. It is never
// persisted or published; the client presentation only copies its read-only views.
struct FixtureAuthority {
std::unique_ptr<evo::world::FieldStore> fields;
std::unique_ptr<evo::world::ChunkStore> terrain;
std::vector<evo::world::VoxelAddress> footprint;
// Static presentation population: phenotypes derive from real genomes, but no
// ecology runs here. Two remnants show the dead encoding.
std::vector<evo::client::OrganismCell> organisms;
std::uint64_t tick{1};
};
bool add_organism(FixtureAuthority& authority, std::uint64_t id, evo::world::VoxelAddress voxel,
std::uint64_t x_um, std::uint64_t y_um) {
using evo::biology::Capability;
const auto k = static_cast<std::uint32_t>(id);
evo::biology::GenomeDraft draft{
id,
1,
1,
{},
{{Capability::energy_conversion, 200 + 100 * (k % 7), 0}, {Capability::membrane, 10, 0}}};
if (k % 3 == 0)
draft.capabilities.push_back({Capability::movement, 50, 0});
if (k % 2 == 0)
draft.capabilities.push_back({Capability::ingestion, 2000, 0});
draft.capabilities.push_back({Capability::target_size, 8'000'000, 0});
const auto genome = evo::biology::Genome::create(draft);
if (!genome)
return false;
constexpr evo::biology::EnvironmentState temperate{
293'150, {{1'000'000'000}, {evo::accounting::Femtograms{1'000'000'000}, {}, {}, {}}}};
const auto cell = evo::client::present_organism(
id, voxel, {x_um}, {y_um}, *genome, {400 + 100 * (k % 7), k % 5 == 0 ? 300U : 0U},
temperate,
k == 5 || k == 23 ? evo::client::OrganismState::dead : evo::client::OrganismState::alive);
if (!cell)
return false;
authority.organisms.push_back(*cell);
return true;
}
std::optional<FixtureAuthority> make_authority() {
FixtureAuthority authority;
std::vector<evo::world::FieldSite> sites;
std::vector<std::uint64_t> water, energy;
for (std::int64_t x = -8; x < 8; ++x)
for (std::int64_t y = -4; y < 4; ++y) {
const auto ux = static_cast<std::uint64_t>(x + 8);
const auto uy = static_cast<std::uint64_t>(y + 4);
authority.footprint.push_back({x, y, fixture_z});
// Habitat boxes vary to show their boundaries inside each 1 m voxel.
const evo::world::HabitatBox box{{50000 * (ux % 4)}, {40000 * uy}, {0},
{800000 - 30000 * uy}, {500000 + 10000 * ux}, {100}};
sites.push_back({authority.footprint.back(), box, {1}});
const auto volume = box.width.value * box.height.value * box.depth.value;
water.push_back(volume >> (2 * ux / 3 + uy));
energy.push_back((ux + 1) * (uy + 1) * (volume >> 4));
}
const std::uint64_t zero = 0;
const evo::world::FieldOpening opening[]{
{Field::water, water}, {Field::phosphorus, {&zero, 1}}, {Field::organic_energy, energy}};
const evo::world::FieldDefaults defaults{{evo::accounting::Femtograms{0},
evo::accounting::Femtograms{1ULL << 50},
evo::accounting::Femtograms{0}}};
constexpr std::size_t budget = 4'000'000;
auto fields =
evo::world::FieldStore::create(fixture_identity, 1, defaults, sites, opening, budget);
auto terrain = evo::world::ChunkStore::create({}, 32, budget);
if (!fields || !terrain)
return std::nullopt;
authority.fields = std::move(*fields);
authority.terrain = std::move(*terrain);
for (const auto voxel : authority.footprint)
if (!authority.terrain->load(evo::world::split(voxel, evo::world::base_chunk_edge)->chunk))
return std::nullopt;
// A 4x4 cluster 60 um apart in voxel (0, 0) for zoomed inspection, then one
// organism in every other voxel of the fixture.
std::uint64_t id = 1;
for (std::uint64_t i = 0; i < 16; ++i)
if (!add_organism(authority, id++, {0, 0, fixture_z}, 410000 + 60 * (i % 4),
480000 + 60 * (i / 4)))
return std::nullopt;
for (std::int64_t x = -8; x < 8; x += 2)
for (std::int64_t y = -4; y < 4; y += 2)
if (!add_organism(authority, id++, {x, y, fixture_z}, 500000, 500000))
return std::nullopt;
return authority;
}
// One conserved same-channel water move per authority tick (finite fixture stock).
bool advance(FixtureAuthority& authority) {
const auto sites = authority.fields->sites().size();
const auto from = static_cast<std::size_t>(authority.tick * 7 % sites);
const auto amount = authority.fields->read(from, Field::water);
if (!amount)
return false;
++authority.tick;
if (*amount < 8)
return true;
const auto moved = authority.fields->transfer(authority.tick, Field::water, from,
(from + 1) % sites, *amount / 8);
return moved || moved.error() == evo::world::FieldError::capacity;
}
std::optional<evo::client::EnvironmentPresentation> query(const FixtureAuthority& authority) {
const auto view = evo::world::query_environment(
*authority.fields, *authority.terrain, authority.tick, authority.footprint, fixture_mask);
if (!view)
return std::nullopt;
auto presentation = evo::client::present_environment(*view, fixture_z);
if (!presentation)
return std::nullopt;
return std::move(*presentation);
}
std::optional<evo::client::OrganismPresentation> organisms(const FixtureAuthority& authority) {
auto presentation = evo::client::OrganismPresentation::create(
{fixture_identity, authority.tick, 1}, fixture_z, authority.organisms);
if (!presentation)
return std::nullopt;
return std::move(*presentation);
}
std::optional<evo::render::EnvironmentDisplay> parse_layer(std::string_view name) {
using Mode = evo::render::EnvironmentDisplay::Mode;
constexpr std::array<std::string_view, evo::world::field_count> names{"water",
"nitrogen",
"phosphorus",
"organic-carbon",
"organic-nitrogen",
"organic-phosphorus",
"organic-other",
"organic-energy",
"incident-energy",
"heat"};
if (name == "moisture")
return evo::render::EnvironmentDisplay{Mode::moisture};
for (std::size_t i = 0; i < names.size(); ++i)
if (name == names.at(i))
return evo::render::EnvironmentDisplay{Mode::field, static_cast<Field>(i)};
return std::nullopt;
}
bool parse_count(std::string_view value, unsigned limit, unsigned& out) {
const auto [end, error] = std::from_chars(value.data(), value.data() + value.size(), out);
return error == std::errc{} && end == value.data() + value.size() && out != 0 && out <= limit;
}
std::optional<evo::client::ScreenPoint> parse_point(std::string_view value) {
const auto comma = value.find(',');
unsigned x = 0, y = 0;
if (comma == std::string_view::npos || !parse_count(value.substr(0, comma), 32768, x) ||
!parse_count(value.substr(comma + 1), 32768, y))
return std::nullopt;
return evo::client::ScreenPoint{static_cast<double>(x), static_cast<double>(y)};
}
// A probe marker (ADR-0094): the own one larger and amber, others smaller and blue; stale
// ones (no current authority, ADR-0095) grey; ghosts (arriving, ADR-0096) violet. Clipped
// to the viewport.
void marker_box(std::vector<evo::render::Rectangle>& out, double x, double y, bool own, bool stale,
bool ghost, double width, double height) {
const double half = own ? 7 : 4;
const double x0 = std::max(x - half, 0.0), y0 = std::max(y - half, 0.0);
const double x1 = std::min(x + half, width), y1 = std::min(y + half, height);
if (x1 > x0 && y1 > y0)
out.push_back({static_cast<float>(x0), static_cast<float>(y0), static_cast<float>(x1 - x0),
static_cast<float>(y1 - y0),
stale ? evo::render::Color{120, 120, 120, 255}
: ghost ? evo::render::Color{190, 120, 230, 255}
: own ? evo::render::Color{250, 190, 40, 255}
: evo::render::Color{90, 170, 250, 255}});
}
void outline(std::vector<evo::render::Rectangle>& out, double l, double t, double r, double b,
double width, double height) {
const auto rect = [&](double x0, double y0, double x1, double y1) {
x0 = std::max(x0, 0.0);
y0 = std::max(y0, 0.0);
x1 = std::min(x1, width);
y1 = std::min(y1, height);
if (x1 > x0 && y1 > y0)
out.push_back({static_cast<float>(x0),
static_cast<float>(y0),
static_cast<float>(x1 - x0),
static_cast<float>(y1 - y0),
{255, 255, 255, 255}});
};
rect(l, t, r, t + 2);
rect(l, b - 2, r, b);
rect(l, t + 2, l + 2, b - 2);
rect(r - 2, t + 2, r, b - 2);
}
std::uint64_t milliseconds(std::chrono::steady_clock::time_point t) {
return static_cast<std::uint64_t>(
std::chrono::duration_cast<std::chrono::milliseconds>(t.time_since_epoch()).count());
}
// Wall-clock seconds: grant expiry is UTC (the session compares the server's welcome).
std::uint64_t utc_seconds() {
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch())
.count());
}
} // namespace
int main(int argc, char** argv) try {
using evo::client_app::Mode;
evo::client::Config config;
unsigned frames = 0, refresh_every = 1;
bool start_fixture = false;
std::optional<evo::client::ScreenPoint> scripted_pick;
std::string screenshot;
std::filesystem::path controls_path; // Empty: per-user settings directory.
bool show_controls = false;
evo::render::EnvironmentDisplay display;
evo::client::ConnectForm form;
bool connect_now = false;
bool cellular_trial = false;
std::string auth_profile; // ADR-0131: one saved login per --profile.
for (int i = 1; i < argc; ++i) {
const std::string_view arg{argv[i]};
if (arg == "--version") { // Build identity for tester reports (ADR-0086).
std::printf("evo-client %s (Aeternalis Evolution engineering client; remote "
"sessions %s)\n",
EVO_BUILD_IDENTITY,
evo::client_app::remote_available ? "available" : "unavailable");
return 0;
}
if (arg == "--hidden")
config.hidden = true;
else if (arg == "--fixture")
start_fixture = true;
else if (arg == "--cellular")
cellular_trial = true;
else if (arg == "--profile" && i + 1 < argc) {
auth_profile = argv[++i];
if (auth_profile.empty() || !evo::client::auth_profile_valid(auth_profile))
return 2;
} else if (arg == "--connect" && i + 1 < argc) {
form.endpoint = argv[++i];
connect_now = true;
} else if (arg == "--server-name" && i + 1 < argc)
form.server_name = argv[++i];
else if (arg == "--ca" && i + 1 < argc)
form.authority_path = argv[++i];
else if (arg == "--grants" && i + 1 < argc)
form.grants_path = argv[++i];
else if (arg == "--renderer" && i + 1 < argc)
config.renderer = argv[++i];
else if (arg == "--frames" && i + 1 < argc) {
if (!parse_count(argv[++i], 100000, frames))
return 2;
} else if (arg == "--refresh-every" && i + 1 < argc) {
if (!parse_count(argv[++i], 1000, refresh_every))
return 2;
} else if (arg == "--layer" && i + 1 < argc) {
const auto layer = parse_layer(argv[++i]);
if (!layer)
return 2;
display = *layer;
} else if (arg == "--pick" && i + 1 < argc) { // Engineering automation only.
scripted_pick = parse_point(argv[++i]);
if (!scripted_pick)
return 2;
} else if (arg == "--size" && i + 1 < argc) { // Initial window size, WIDTH,HEIGHT.
const auto size = parse_point(argv[++i]);
if (!size || size->x < 320 || size->y < 240)
return 2;
config.width = static_cast<int>(size->x);
config.height = static_cast<int>(size->y);
} else if (arg == "--screenshot" && i + 1 < argc) { // Last frame, as BMP.
screenshot = argv[++i];
} else if (arg == "--controls" && i + 1 < argc) {
controls_path = argv[++i];
if (controls_path.empty())
return 2;
} else if (arg == "--show-controls") { // Engineering review: open the panel.
show_controls = true;
} else {
std::fputs("usage: evo-client [--version] [--renderer NAME] [--hidden] "
"[--frames 1..100000] [--size W,H]\n"
" [--fixture | --connect HOST:PORT --server-name NAME "
"--ca FILE --grants FILE [--cellular]]\n"
" [--layer water|nitrogen|...|heat|moisture]\n"
" [--refresh-every 1..1000] [--pick X,Y] "
"[--screenshot FILE.bmp --frames N]\n"
" [--controls FILE] [--show-controls] [--profile NAME]\n"
"Without --fixture or --connect the launcher opens.\n",
stderr);
return 2;
}
}
if ((start_fixture && connect_now) || (start_fixture && cellular_trial) ||
(!screenshot.empty() && frames == 0))
return 2;
// Launcher phase and remote session change together (fixture/live distinction).
evo::client::SessionHost<evo::client_app::RemoteSession> host;
const auto& launcher = host.launcher();
evo::client::UiState ui;
evo::client::Selection selection;
evo::client_app::FormBuffers buffers;
buffers.load(form);
std::optional<evo::client::LaunchError> form_error;
std::optional<FixtureAuthority> authority;
evo::client::EnvironmentLayer environment;
evo::client::OrganismLayer population;
std::optional<std::uint64_t> disconnect_dialog;
std::optional<std::pair<std::uint32_t, std::uint32_t>> cellular_feed_target;
bool cellular_framed = false; // The camera has been zoomed to the cellular arena.
// Validates the form and opens a fresh session; errors stay in the launcher.
const auto connect = [&](const evo::client::ConnectForm& f) {
form_error.reset();
if constexpr (!evo::client_app::remote_available) {
form_error = evo::client::LaunchError::no_session;
return false;
} else {
const auto material = evo::client::load_connect(f);
if (!material) {
form_error = material.error();
return false;
}
auto opened = evo::client_app::RemoteSession::open(*material, cellular_trial);
if (!opened) {
form_error = evo::client::LaunchError::endpoint;
return false;
}
cellular_framed = false;
return host.connect(std::move(opened));
}
};
// ADR-0131: a broker grant names its region route; only the region CA comes from the
// form. The grant stays in memory and the session asks for the next one itself.
const auto grant_material = [&](const evo::client::AuthGrant& grant) {
auto f = buffers.form();
f.endpoint = grant.endpoint;
f.server_name = grant.server_name;
return evo::client::load_connect(f, std::span{&grant.bytes, 1});
};
const auto connect_signed_in = [&](const evo::client::AuthGrant& grant) {
form_error.reset();
if constexpr (!evo::client_app::remote_available) {
form_error = evo::client::LaunchError::no_session;
return false;
} else {
const auto material = grant_material(grant);
if (!material) {
form_error = material.error();
return false;
}
cellular_trial = true; // The DEV broker world is the cellular trial (ADR-0131).
auto opened = evo::client_app::RemoteSession::open(*material, cellular_trial);
if (!opened) {
form_error = evo::client::LaunchError::endpoint;
return false;
}
opened->manage_grants();
cellular_framed = false;
return host.connect(std::move(opened));
}
};
const auto enter_fixture = [&] {
if (!authority) {
authority = make_authority();
if (!authority)
return false;
}
environment.reset();
population.reset();
selection.clear();
cellular_feed_target.reset();
host.enter_fixture(); // Ends any remote attempt: nothing runs behind the banner.
return true;
};
if (start_fixture && !enter_fixture()) {
std::fputs("client environment fixture error\n", stderr);
return 1;
}
if (connect_now && !connect(form)) {
std::fprintf(stderr, "client session configuration error: %s\n",
std::string{evo::client::launch_error_text(
form_error.value_or(evo::client::LaunchError::no_session))}
.c_str());
return 1;
}
auto app = evo::client::Application::open(config);
if (!app) {
std::fprintf(stderr, "client initialization error=%d\n", static_cast<int>(app.error()));
return 1;
}
// Controls (ADR-0085): per-user file unless --controls names one.
if (controls_path.empty())
if (const auto dir = evo::client::Application::settings_directory())
controls_path = *dir / "controls-v1.txt";
// Notices expire on the same monotonic clock the loop uses.
static_cast<void>(ui.advance(milliseconds(std::chrono::steady_clock::now())).has_value());
evo::client_app::ControlsFlow controls{controls_path};
controls.load(**app, ui);
if (show_controls)
controls.show(**app);
// A minimized native window may start with no drawable area. Adopt the
// native viewport before projecting; until then use the requested size.
auto camera = evo::client::Camera::create(
{config.width, config.height, config.width, config.height}, {}, 0.05);
if (!camera)
return 1;
const auto mode = [&] {
const auto phase = launcher.phase();
if (phase == evo::client::LaunchPhase::fixture)
return Mode::fixture;
if (phase == evo::client::LaunchPhase::connected ||
(phase == evo::client::LaunchPhase::connecting && launcher.ever_connected()))
return Mode::remote;
return Mode::launcher; // Choosing, failed, or the first connection attempt.
};
const auto shown_environment = [&]() -> const evo::client::EnvironmentLayer* {
if (mode() == Mode::fixture)
return &environment;
if (const auto* remote = host.session(); remote && mode() == Mode::remote)
return &remote->environment();
return nullptr;
};
const auto shown_organisms = [&]() -> const evo::client::OrganismLayer* {
if (mode() == Mode::fixture)
return &population;
if (const auto* remote = host.session(); remote && mode() == Mode::remote)
return &remote->organisms();
return nullptr;
};
// ADR-0131 browser sign-in (Windows); elsewhere the panel offers manual grants only.
evo::client::AuthClient auth{evo::client::native_auth_platform(auth_profile)};
bool auth_connect = false; // Connect when the requested grant arrives.
auto grant_requested = std::chrono::steady_clock::time_point{};
int drawn_organisms = -1;
evo::client_app::CellularScene scene; // Rebuilt each frame in cellular play.
evo::client_app::CellHeadings headings; // Where each drawn cell last moved.
// ADR-0136: deposits seen in the last view (to notice a bubble that ran out) and the
// pops still fading, in world coordinates with their start time.
struct SeenDeposit {
double x_mm{}, y_mm{};
std::uint32_t radius_um{};
int channel{};
};
struct LivePop {
SeenDeposit at;
std::chrono::steady_clock::time_point start;
};
std::map<std::uint32_t, SeenDeposit> seen_deposits;
std::uint64_t seen_deposit_tick{};
std::vector<LivePop> live_pops;
bool scene_active = false;
evo::client_app::PanelActions actions;
(*app)->set_overlay([&] {
evo::client_app::PanelView view;
view.mode = mode();
view.launcher = &launcher;
view.form_error = form_error;
view.remote_available = evo::client_app::remote_available;
view.cellular_trial = cellular_trial;
view.auth = auth.status();
view.environment = shown_environment();
view.organisms = shown_organisms();
view.selection = &selection;
view.ui = &ui;
if (const auto* remote = host.session(); remote && view.mode == Mode::remote) {
view.remote = remote->status();
view.outcomes = &remote->outcomes();
view.cellular_perception = remote->cellular_perception();
view.cellular_play = &remote->cellular_play();
view.cellular_feed_target = cellular_feed_target;
}
view.visible_organisms = drawn_organisms;
view.cellular_scene = scene_active ? &scene : nullptr;
view.bindings = &(*app)->bindings();
controls.fill(view);
actions = evo::client_app::draw_panels(view, buffers, display);
});
std::vector<evo::render::Rectangle> boxes;
std::uint64_t count = 0;
auto previous = std::chrono::steady_clock::now();
while (frames == 0 || count < frames) {
if (auto result = (*app)->poll_events(); !result) {
std::fprintf(stderr, "client event error=%d\n", static_cast<int>(result.error()));
return 1;
}
const auto state = (*app)->state();
if (state.closed)
break;
const auto now = std::chrono::steady_clock::now();
static_cast<void>(ui.advance(milliseconds(now)).has_value()); // Monotonic clock.
const double seconds =
std::clamp(std::chrono::duration<double>(now - previous).count(), 0.0, 0.1);
previous = now;
// Panel actions from the previous rendered frame.
if (actions.fixture && !enter_fixture())
return 1;
if (actions.cellular_trial)
cellular_trial = *actions.cellular_trial;
if ((actions.connect || actions.retry) && connect(buffers.form())) {
selection.clear();
}
if (actions.cancel || actions.back) {
host.cancel(); // Drops the connection; its unresolved outcomes are unknown.
cellular_feed_target.reset();
selection.clear();
}
if (actions.ask_disconnect && !disconnect_dialog)
if (const auto id = ui.open_dialog("Disconnect from the dev region?",
"Intentions without a final outcome will be "
"unknown. Views stop updating."))
disconnect_dialog = *id;
if (actions.confirm_dialog && actions.confirm_dialog == disconnect_dialog &&
ui.close_dialog(*actions.confirm_dialog)) {
disconnect_dialog.reset();
host.cancel();
cellular_feed_target.reset();
selection.clear();
}
if (actions.cancel_dialog && ui.close_dialog(*actions.cancel_dialog))
disconnect_dialog.reset();
if (actions.dismiss_notice)
static_cast<void>(ui.dismiss(*actions.dismiss_notice));
if (actions.stop_feeding) {
cellular_feed_target.reset();
buffers.cellular_controls.auto_feed = false;
}
if (actions.feed_patch) {
cellular_feed_target = actions.feed_patch;
buffers.cellular_controls.auto_feed = false;
}
if (auto* remote = host.session(); remote && mode() == Mode::remote) {
if (actions.cell_action && remote->request_cellular(*actions.cell_action))
cellular_feed_target.reset();
if (actions.mutation)
static_cast<void>(remote->request_cellular(evo::client_app::CellAction::mutation,
*actions.mutation));
if (actions.restart_life && remote->restart_cellular()) {
cellular_feed_target.reset();
selection.clear();
}
if (actions.keep_unknown)
remote->keep_cellular_unknown();
remote->set_cellular_feed_target(cellular_trial ? cellular_feed_target : std::nullopt);
remote->set_cellular_controls(buffers.cellular_controls);
}
// ADR-0131 sign-in. One request at a time; grants arrive on a later frame.
if (actions.sign_in && auth.sign_in()) {
auth_connect = true;
grant_requested = now;
}
if (actions.auth_connect && auth.request_grant()) {
auth_connect = true;
grant_requested = now;
}
if (actions.cancel_sign_in) {
auth.cancel();
auth_connect = false;
}
if (actions.sign_out) {
host.cancel(); // Logout revokes every grant; do not keep a session behind it.
cellular_feed_target.reset();
selection.clear();
auth_connect = false;
static_cast<void>(auth.sign_out());
}
if (auto grant = auth.take_grant()) {
if (auth_connect) {
auth_connect = false;
if (connect_signed_in(*grant))
selection.clear();
} else if (auto* remote = host.session()) {
// Refresh or reconnect material for the live session (same account).
if (const auto material = grant_material(*grant))
static_cast<void>(remote->supply_grant(*material));
}
grant->bytes.fill(0);
}
if (const auto status = auth.status(); !status.busy && auth_connect && !status.signed_in)
auth_connect = false; // Sign-in failed or was cancelled; the panel shows why.
// About a minute before expiry, or after a lost connection; never for a session the
// launcher has given up on (superseded by another client, cancelled).
const bool live = launcher.phase() == evo::client::LaunchPhase::connecting ||
launcher.phase() == evo::client::LaunchPhase::connected;
if (const auto* remote = host.session();
live && remote && remote->needs_grant(utc_seconds()) &&
now - grant_requested >= std::chrono::seconds{5} && auth.request_grant())
grant_requested = now;
controls.step(actions, **app, ui);
actions = {};
// The launcher and modal dialogs own input: no world movement or selection.
const auto* input_session = host.session();
const bool cell_input_blocked = input_session && input_session->cellular_trial() &&
(!input_session->cellular_play().fresh() ||
input_session->cellular_play().life() == 0 ||
input_session->cellular_play().ended().has_value());
(*app)->set_ui_capture(mode() == Mode::launcher || ui.dialog().has_value() ||
controls.open() || cell_input_blocked);
const auto navigation = (*app)->take_navigation();
// Local input counter; in remote mode the session sets the server tick.
const auto intention = (*app)->sample_intention(count);
if (!intention)
return 1;
host.step(now, *intention, ui); // Only while connecting or connected.
if (const auto* remote = host.session(); remote && cellular_trial)
cellular_feed_target = remote->cellular_feed_target();
// M10.5c: the camera follows the server's view until the user moves it; from then
// on its centre is the session's interest (the server clamps and filters it).
if (auto* remote = host.session(); remote && mode() == Mode::remote) {
if (const auto centre = remote->take_recentre())
if (auto moved = evo::client::Camera::create(camera->viewport(), *centre,
camera->units_per_mm()))
*camera = *moved;
remote->focus(camera->centre());
}
// The fixture authority advances at its own cadence. Presentations refresh
// every N authority ticks; in between the advanced watermark shows as stale.
if (mode() == Mode::fixture && count % frames_per_authority_tick == 0) {
if (count != 0 && !advance(*authority))
return 1;
if ((authority->tick - 1) % refresh_every == 0) {
auto next = query(*authority);
auto cells = organisms(*authority);
if (!next || !cells || !environment.accept(std::move(*next)) ||
!population.accept(std::move(*cells)))
return 1;
}
if (!environment.observe(
{fixture_identity, authority->tick, authority->fields->last_command()}) ||
!population.observe({fixture_identity, authority->tick, 1}))
return 1;
}
const auto* env_layer = shown_environment();
const auto* org_layer = shown_organisms();
const auto* env = env_layer ? env_layer->current() : nullptr;
const auto* orgs = org_layer ? org_layer->current() : nullptr;
const auto change = selection.refresh(env, orgs);
if (change == evo::client::Selection::Change::organism_gone)
static_cast<void>(ui.notify("The selected organism is no longer present.",
evo::client::NoticeLevel::info)
.has_value());
else if (change == evo::client::Selection::Change::cell_gone)
static_cast<void>(ui.notify("The selected habitat cell is no longer in view.",
evo::client::NoticeLevel::info)
.has_value());
boxes.clear();
if (state.logical_width > 0 && state.logical_height > 0 && state.pixel_width > 0 &&
state.pixel_height > 0) {
if (!camera->resize({state.logical_width, state.logical_height, state.pixel_width,
state.pixel_height}))
return 1;
// M11.3: keep the own cell (organism id == life identity) centred, framing the
// arena once; the player's zoom is kept after that.
if (const auto* remote = host.session();
remote && mode() == Mode::remote && cellular_trial && orgs != nullptr)
if (const auto* perception = remote->cellular_perception();
perception && perception->life_identity != 0) {
const auto cells = orgs->cells();
const auto own = std::ranges::find(cells, perception->life_identity,
&evo::client::OrganismCell::id);
if (own != cells.end()) {
const double pitch = evo::world::cell_pitch_mm;
evo::client::WorldPoint centre{static_cast<double>(own->voxel.x) * pitch +
static_cast<double>(own->x.value) / 1000,
static_cast<double>(own->voxel.y) * pitch +
static_cast<double>(own->y.value) /
1000};
const double scale =
cellular_framed ? camera->units_per_mm()
: static_cast<double>(std::min(state.logical_width,
state.logical_height)) /
cellular_view_mm;
// Keep the followed cell in the visible arena beside the journal.
const double shift = state.logical_width < 880 ? 171.0 : -10.0;
centre.x_mm -= shift / scale;
centre.y_mm += 29.0 / scale;
if (auto moved =
evo::client::Camera::create(camera->viewport(), centre, scale)) {
*camera = *moved;
cellular_framed = true;
}
}
}
if (auto result =
camera->pan({navigation.x * 400 * seconds, navigation.y * 400 * seconds});
!result && result.error() != evo::client::CameraError::out_of_range)
return 1;
const evo::client::ScreenPoint anchor{
std::clamp(navigation.pointer.x, 0.0, static_cast<double>(state.logical_width)),
std::clamp(navigation.pointer.y, 0.0, static_cast<double>(state.logical_height))};
if (auto result = camera->zoom(std::exp2(navigation.wheel / 4), anchor);
!result && result.error() != evo::client::CameraError::out_of_range)
return 1;
if (navigation.click)
selection.pick(*navigation.click, env, orgs, *camera);
if (scripted_pick && env != nullptr) {
selection.pick(*scripted_pick, env, orgs, *camera);
scripted_pick.reset();
}
// Copied presentation only; clipped to the viewport before float conversion.
if (!evo::render::build_environment(
boxes, env, env_layer ? env_layer->freshness() : evo::client::Freshness::none,
*camera, display))
return 1;
const double width = state.logical_width, height = state.logical_height;
// 2026-10-16 microscope view: in cellular play, patches and cells are a scene the
// panels draw as granules and living cells; elsewhere organisms stay rectangles.
scene.patches.clear();
scene.deposits.clear();
scene.pops.clear();
scene.cells.clear();
scene_active = false;
const auto* cellular_remote = host.session();
const bool microscope = cellular_remote && mode() == Mode::remote && cellular_trial;
if (microscope) {
const bool fresh = cellular_remote->cellular_play().fresh();
if (const auto* perception = cellular_remote->cellular_perception())
for (const auto& patch : perception->patches) {
const auto low =
camera->world_to_screen({static_cast<double>(patch.x_um) / 1000,
static_cast<double>(patch.y_um) / 1000});
const auto high = camera->world_to_screen(
{(static_cast<double>(patch.x_um) + 1000) / 1000,
(static_cast<double>(patch.y_um) + 1000) / 1000});
if (!low || !high)
continue;
evo::client_app::ScenePatch p;
p.x = static_cast<float>((low->x + high->x) / 2);
p.y = static_cast<float>((low->y + high->y) / 2);
p.half = static_cast<float>(std::abs(high->x - low->x) / 2);
p.stock = {patch.energy_pj, patch.matter_fg[0], patch.matter_fg[1],
patch.matter_fg[2], patch.matter_fg[3]};
p.target = cellular_feed_target &&
cellular_feed_target->first == patch.x_um &&
cellular_feed_target->second == patch.y_um;
p.stale = !fresh;
p.seed = (static_cast<std::uint64_t>(patch.x_um) << 32U) ^ patch.y_um;
scene.patches.push_back(p);
}
// ADR-0136 (v11): pools and bubbles, centred; a vanished bubble pops.
if (const auto* perception = cellular_remote->cellular_perception()) {
const auto now_pop = std::chrono::steady_clock::now();
std::map<std::uint32_t, SeenDeposit> current;
for (const auto& d : perception->deposits) {
std::array<std::uint64_t, 5> stock{};
for (std::size_t c = 0; c < stock.size(); ++c)
stock.at(c) = evo::network::deposit_amount_value(d.amount_codes.at(c));
int channel = 0;
for (std::size_t c = 1; c < stock.size(); ++c)
if (stock.at(c) > stock.at(static_cast<std::size_t>(channel)))
channel = static_cast<int>(c);
const SeenDeposit seen{static_cast<double>(d.x_um) / 1000,
static_cast<double>(d.y_um) / 1000, d.radius_um,
channel};
current[d.id] = seen;
const auto centre = camera->world_to_screen({seen.x_mm, seen.y_mm});
const auto edge = camera->world_to_screen(
{seen.x_mm + static_cast<double>(d.radius_um) / 1000, seen.y_mm});
if (!centre || !edge)
continue;
evo::client_app::SceneDeposit drawn;
drawn.x = static_cast<float>(centre->x);
drawn.y = static_cast<float>(centre->y);
drawn.radius = static_cast<float>(std::abs(edge->x - centre->x));
drawn.stock = stock;
drawn.pool = d.shape == evo::network::CellularDepositShape::pool;
drawn.drained = d.drained;
drawn.stale = !fresh;
drawn.seed = d.id;
scene.deposits.push_back(drawn);
}
// A bubble absent from a newer view while its old spot is still in
// sight ran out (or left the sensor's edge, which a pop also suits).
if (perception->tick != seen_deposit_tick) {
for (const auto& [id, old] : seen_deposits)
if (!current.contains(id) && live_pops.size() < 256)
live_pops.push_back({old, now_pop});
seen_deposits = std::move(current);
seen_deposit_tick = perception->tick;
}
constexpr auto pop_life = std::chrono::milliseconds{350};
std::erase_if(live_pops, [&](const LivePop& pop) {
return now_pop - pop.start > pop_life;
});
for (const auto& pop : live_pops) {
const auto centre = camera->world_to_screen({pop.at.x_mm, pop.at.y_mm});
const auto edge = camera->world_to_screen(
{pop.at.x_mm + static_cast<double>(pop.at.radius_um) / 1000,
pop.at.y_mm});
if (!centre || !edge)
continue;
const auto age = std::chrono::duration<float>(now_pop - pop.start).count() /
std::chrono::duration<float>(pop_life).count();
scene.pops.push_back({static_cast<float>(centre->x),
static_cast<float>(centre->y),
static_cast<float>(std::abs(edge->x - centre->x)),
age, pop.at.channel});
}
}
const auto own = cellular_remote->cellular_play().life();
if (orgs)
for (const auto& cell : orgs->cells()) {
const auto bounds = evo::render::organism_bounds(cell, *camera);
if (bounds.right < 0 || bounds.left > width || bounds.bottom < 0 ||
bounds.top > height)
continue;
const auto& ph = cell.phenotype;
evo::client_app::SceneCell c;
c.x = static_cast<float>((bounds.left + bounds.right) / 2);
c.y = static_cast<float>((bounds.top + bounds.bottom) / 2);
c.radius = static_cast<float>((bounds.right - bounds.left) / 2);
// One flagellum per 150 um/s of speed (a founder swims at 200).
c.flagella = ph.movement_speed == 0
? 0
: static_cast<int>(std::min<std::uint32_t>(
6, 1 + ph.movement_speed / 150));
const double wall = ph.total_mass == 0
? 0.0
: static_cast<double>(ph.membrane_mass) /
static_cast<double>(ph.total_mass);
c.membrane = static_cast<float>(std::clamp(1.0 + wall * 6.0, 1.0, 7.0));
c.organelles = 2 + static_cast<int>(std::min<std::uint32_t>(
3, ph.conversion_per_thousand / 250));
c.own = own != 0 && cell.id == own;
c.dead = cell.state == evo::client::OrganismState::dead;
c.stale =
org_layer && org_layer->freshness() != evo::client::Freshness::current;
c.seed = cell.id;
// The organism projection's world position (organism_bounds).
constexpr auto pitch = static_cast<double>(evo::world::cell_pitch_mm);
const evo::client::WorldPoint at{
static_cast<double>(cell.voxel.x) * pitch +
static_cast<double>(cell.x.value) / 1000,
static_cast<double>(cell.voxel.y) * pitch +
static_cast<double>(cell.y.value) / 1000};
c.extent_um = ph.extent;
c.speed_um_s = ph.movement_speed;
c.conversion_per_thousand = ph.conversion_per_thousand;
c.grown_per_thousand = cell.growth.realized_per_thousand;
c.mass_fg = ph.total_mass;
c.membrane_fg = ph.membrane_mass;
c.ingestion_fg_s = ph.ingestion_rate;
if (const auto heading = headings.update(cell.id, at, *camera)) {
c.facing = true;
c.heading = *heading;
}
scene.cells.push_back(c);
}
headings.end_frame();
drawn_organisms = static_cast<int>(scene.cells.size());
scene_active = true;
} else {
const auto report = evo::render::append_organisms(
boxes, organism_budget, orgs,
org_layer ? org_layer->freshness() : evo::client::Freshness::none, *camera);
if (!report)
return 1;
drawn_organisms = static_cast<int>(report->drawn);
}
if (const auto* remote = host.session(); remote && mode() == Mode::remote) {
for (const auto& m : remote->markers())
if (const auto at = camera->world_to_screen({m.x_mm, m.y_mm}))
marker_box(boxes, at->x, at->y, m.own, m.stale, m.ghost, width, height);
}
if (const auto* o = selection.organism(orgs)) {
const auto b = evo::render::organism_bounds(*o, *camera);
outline(boxes, b.left - 3, b.top - 3, b.right + 3, b.bottom + 3, width, height);
} else if (const auto* c = selection.cell(env)) {
const double pitch = evo::world::cell_pitch_mm;
const auto low = camera->world_to_screen({static_cast<double>(c->voxel.x) * pitch,
static_cast<double>(c->voxel.y) * pitch});
const auto high =
camera->world_to_screen({static_cast<double>(c->voxel.x + 1) * pitch,
static_cast<double>(c->voxel.y + 1) * pitch});
if (low && high)
outline(boxes, low->x, high->y, high->x, low->y, width, height);
}
}
boxes.push_back({8, static_cast<float>(std::max(state.logical_height - 20, 0)), 64, 8,
(*app)->ui_captured() ? evo::render::Color{240, 140, 32, 255}
: evo::render::Color{64, 180, 140, 255}});
boxes.push_back({36 + static_cast<float>(intention->move_x) / 50,
static_cast<float>(std::max(state.logical_height - 48, 0)) -
static_cast<float>(intention->move_y) / 50,
8,
8,
{240, 240, 240, 255}});
const auto frame = evo::render::Frame::create(boxes, {14, 12, 18, 255}); // Ink.
if (!frame)
return 1;
if (!screenshot.empty() && count + 1 == frames && !(*app)->request_screenshot(screenshot))
return 2;
const auto result = (*app)->present(*frame);
if (!result) {
std::fprintf(stderr, "client frame error=%d\n", static_cast<int>(result.error()));
return 1;
}
if (*result == evo::client::Step::closed)
break;
++count;
std::this_thread::sleep_for(std::chrono::milliseconds{16});
}
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "client exception: %.200s\n", e.what());
return 1;
} catch (...) {
std::fputs("client exception\n", stderr);
return 1;
}