Files
aevolution/apps/evo-client/main.cpp
T
dingoandClaude Opus 5.5 14e676426f Fix M9.8d review findings in binding capture
Arming capture drops the toolkit's held keys/modifiers and queued keyboard
input; the chosen key stays owned until release or focus loss so its repeats,
text and release reach neither toolkit nor world. Idle toolkit frames run when
nothing is drawn and the toolkit queue is bounded. Controls host logic moves to
ControlsFlow with an Apply -> save -> restart -> load rehearsal; key test events
now carry realistic keycodes and modifiers with positive controls.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 16:07:09 -04:00

561 lines
27 KiB
C++

#include "controls_flow.hpp"
#include "evo/client/application.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 <memory>
#include <optional>
#include <string_view>
#include <thread>
#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;
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)};
}
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());
}
} // 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;
for (int i = 1; i < argc; ++i) {
const std::string_view arg{argv[i]};
if (arg == "--hidden")
config.hidden = true;
else if (arg == "--fixture")
start_fixture = true;
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 == "--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 [--renderer NAME] [--hidden] [--frames 1..100000]\n"
" [--fixture | --connect HOST:PORT --server-name NAME "
"--ca FILE --grants FILE]\n"
" [--layer water|nitrogen|...|heat|moisture]\n"
" [--refresh-every 1..1000] [--pick X,Y] "
"[--screenshot FILE.bmp --frames N]\n"
" [--controls FILE] [--show-controls]\n"
"Without --fixture or --connect the launcher opens.\n",
stderr);
return 2;
}
}
if ((start_fixture && connect_now) || (!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;
// 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);
if (!opened) {
form_error = evo::client::LaunchError::endpoint;
return 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();
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;
};
int drawn_organisms = -1;
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.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.visible_organisms = drawn_organisms;
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.connect || actions.retry) && connect(buffers.form())) {
selection.clear();
}
if (actions.cancel || actions.back) {
host.cancel(); // Drops the connection; its unresolved outcomes are unknown.
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();
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));
controls.step(actions, **app, ui);
actions = {};
// The launcher and modal dialogs own input: no world movement or selection.
(*app)->set_ui_capture(mode() == Mode::launcher || ui.dialog().has_value() ||
controls.open());
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.
// 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;
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 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);
const double width = state.logical_width, height = state.logical_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, {16, 20, 28, 255});
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;
}