#include "evo/client/application.hpp" #include "evo/client/organism_inspector.hpp" #include "evo/render/environment.hpp" #include "evo/render/organism.hpp" #include "remote_session.hpp" #include #include #include #include #include #include #include #include #include #include #include #include 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 + inspector + 5 host UI rectangles // (capture bar, intention dot, and in remote mode the connection and intent chips). constexpr std::size_t host_ui_rectangles = 5; constexpr std::size_t organism_budget = evo::render::max_rectangles - evo::render::max_environment_rectangles - evo::client::inspector_rectangles - host_ui_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 fields; std::unique_ptr terrain; std::vector footprint; // Static presentation population: phenotypes derive from real genomes, but no // ecology runs here. Two remnants show the dead encoding. std::vector 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(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 make_authority() { FixtureAuthority authority; std::vector sites; std::vector 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(x + 8); const auto uy = static_cast(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(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 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 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 parse_layer(std::string_view name) { using Mode = evo::render::EnvironmentDisplay::Mode; constexpr std::array 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(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; } } // namespace int main(int argc, char** argv) try { evo::client::Config config; unsigned frames = 0, refresh_every = 1; bool inspect = false; evo::render::EnvironmentDisplay display; evo::client_app::RemoteOptions remote_options; for (int i = 1; i < argc; ++i) { const std::string_view arg{argv[i]}; if (arg == "--hidden") config.hidden = true; else if (arg == "--inspect") inspect = true; else if (arg == "--connect" && i + 1 < argc) remote_options.connect = argv[++i]; else if (arg == "--server-name" && i + 1 < argc) remote_options.server_name = argv[++i]; else if (arg == "--ca" && i + 1 < argc) remote_options.authority = argv[++i]; else if (arg == "--grants" && i + 1 < argc) remote_options.grants = 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 { std::fputs("usage: evo-client [--renderer NAME] [--hidden] [--frames 1..100000]\n" " [--layer water|nitrogen|...|heat|moisture]\n" " [--refresh-every 1..1000] [--inspect]\n" " [--connect HOST:PORT --server-name NAME --ca FILE " "--grants FILE]\n", stderr); return 2; } } // Remote mode (M9.7): views and intentions go through a dev session; the local // fixture authority is not created at all. std::optional remote; if (remote_options.any()) { if (!evo::client_app::remote_available || !remote_options.complete()) { std::fputs("remote mode needs --connect, --server-name, --ca and --grants " "(and a build with EVO_BUILD_NETWORK)\n", stderr); return 2; } remote = evo::client_app::RemoteSession::open(remote_options); if (!remote) { std::fputs("client session configuration error\n", stderr); return 1; } } std::optional authority; if (!remote) { authority = make_authority(); if (!authority) { std::fputs("client environment fixture error\n", stderr); return 1; } } evo::client::EnvironmentLayer environment; evo::client::OrganismLayer population; auto app = evo::client::Application::open(config); if (!app) { std::fprintf(stderr, "client initialization error=%d\n", static_cast(app.error())); return 1; } // 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; std::puts("Arrows: pan | wheel: zoom | WASD: intention indicator | Tab: UI capture (orange)"); std::puts("Status chips (environment, organisms): green current | amber stale | red none;" " magenta marker: organisms truncated"); std::vector 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(result.error())); return 1; } const auto state = (*app)->state(); if (state.closed) break; const auto now = std::chrono::steady_clock::now(); const double seconds = std::clamp(std::chrono::duration(now - previous).count(), 0.0, 0.1); previous = now; 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; if (remote) remote->step(now, *intention); // The fixture authority advances at its own cadence. Presentations refresh // every N authority ticks; in between the advanced watermark shows as stale. if (!remote && 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; } 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(state.logical_width)), std::clamp(navigation.pointer.y, 0.0, static_cast(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; const auto& shown_environment = remote ? remote->environment() : environment; const auto& shown_organisms = remote ? remote->organisms() : population; // Copied presentation only; clipped to the viewport before float conversion. if (!evo::render::build_environment(boxes, shown_environment.current(), shown_environment.freshness(), *camera, display) || !evo::render::append_organisms(boxes, organism_budget, shown_organisms.current(), shown_organisms.freshness(), *camera)) return 1; // Engineering inspector: biology gauges for the hovered organism only. if (const auto* shown = shown_organisms.current(); inspect && shown != nullptr) if (const auto index = evo::client::pick_organism(*shown, *camera, navigation.pointer)) if (!evo::client::append_inspector(boxes, evo::client::inspector_rectangles, shown->cells()[*index], *camera)) return 1; } boxes.push_back({8, 8, 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(intention->move_x) / 50, 48 - static_cast(intention->move_y) / 50, 8, 8, {240, 240, 240, 255}}); if (remote) remote->status(boxes); const auto frame = evo::render::Frame::create(boxes, {16, 20, 28, 255}); if (!frame) return 1; const auto result = (*app)->present(*frame); if (!result) { std::fprintf(stderr, "client frame error=%d\n", static_cast(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; }