#pragma once // M9.8c engineering panels (ADR-0084). Drawn inside Application's overlay callback; // they read presentation copies and report what the user asked for. Only this file // pair and the platform adapter use the toolkit. #include "evo/client/auth.hpp" #include "evo/client/bindings.hpp" #include "evo/client/camera.hpp" #include "evo/client/environment_view.hpp" #include "evo/client/launcher.hpp" #include "evo/client/organism_view.hpp" #include "evo/client/outcome_log.hpp" #include "evo/client/selection.hpp" #include "evo/client/ui_state.hpp" #include "evo/render/environment.hpp" #include "remote_session.hpp" #include #include #include #include #include namespace evo::client_app { enum class Mode : std::uint8_t { launcher, fixture, remote }; // The cellular microscope view (2026-10-16 UI), in logical window coordinates. The client // loop builds it from copied presentations each frame; the panels draw it with the // toolkit, since membranes, flagella and granules are not rectangles. Appearance comes // from the phenotype only: size from extent, flagella from movement speed, wall // thickness from membrane mass, organelles from energy conversion. struct SceneCell { float x{}, y{}, radius{}, membrane{}; int flagella{}, organelles{}; bool own{}, dead{}, stale{}; std::uint64_t seed{}; // Stable per organism: organelle layout (and orientation at rest). bool facing{}; // Heading is known: the cell faces it, flagella trailing. float heading{}; // Screen radians. // What hovering the cell shows (its replicated phenotype; no hidden state). std::uint32_t extent_um{}, speed_um_s{}, conversion_per_thousand{}, grown_per_thousand{}; std::uint64_t mass_fg{}, membrane_fg{}, ingestion_fg_s{}; std::uint32_t photosynthesis_per_thousand{}; // Zero unless the owner's view lists it. int chloroplasts{}; // ADR-0176: green organelles in proportion to photosynthesis. }; struct ScenePatch { float x{}, y{}, half{}; // Centre and half side of the 1 mm contact footprint. std::array stock{}; // Energy pJ, then C, N, P, other fg. bool target{}, stale{}; std::uint64_t seed{}; }; // ADR-0136 (v11): a pool (a puddle) or a bubble, centred, with its contact radius in pixels. struct SceneDeposit { float x{}, y{}, radius{}; std::array stock{}; // Approximate (v11 amount codes), same channels. bool pool{}, drained{}, stale{}; std::uint64_t seed{}; }; // A bubble that just ran out: an expanding, fading ring for a moment. struct ScenePop { float x{}, y{}, radius{}, age{}; // Age 0..1 over the pop's life. int channel{}; }; // Rules 12: one streak of the local current; dx/dy in pixels, strength 0..1 by speed. struct SceneFlow { float x{}, y{}, dx{}, dy{}, strength{}; std::uint32_t seed{}; }; struct CellularScene { std::vector flows; std::vector patches; std::vector deposits; std::vector pops; std::vector cells; // Camera mapping for the local observation map; no undiscovered world state. client::WorldPoint camera_centre{}; bool stale{}; // The region's walls on screen (liquid regions, from the perceived current configuration), // whether the owner's cell is against one, and how many cells the region holds. bool region{}; float region_left{}, region_top{}, region_right{}, region_bottom{}; bool at_edge{}; std::size_t region_cells{}; }; // Notice layout (logical pixels); the window name is the prefix plus the notice id. inline constexpr float notice_width = 320, notice_close_width = 22; inline constexpr const char* notice_window_prefix = "##notice"; // Text-field storage for the connect form (bounded; never persisted). struct FormBuffers { bool engineering{}; bool evolution_open{}; // The mutation window (E or the callout opens it). bool notes_minimized{}, vitals_minimized{}, map_minimized{}; bool bud_become{}; // Rules 13: the next bud is the player's cell. CellularControls cellular_controls; std::array endpoint{}, server_name{}, authority{}, grants{}; void load(const client::ConnectForm& form); [[nodiscard]] client::ConnectForm form() const; }; // One key slot of one action in the controls panel. struct ControlSlot { client::Action action{}; bool secondary{}; friend bool operator==(const ControlSlot&, const ControlSlot&) = default; }; struct PanelView { Mode mode{Mode::launcher}; const client::Launcher* launcher{}; std::optional form_error; bool remote_available{}; bool cellular_trial{}; client::AuthStatus auth; const client::EnvironmentLayer* environment{}; const client::OrganismLayer* organisms{}; const client::Selection* selection{}; const client::UiState* ui{}; std::optional remote; const network::CellularPerception* cellular_perception{}; const CellularPlay* cellular_play{}; const CellularScene* cellular_scene{}; // Drawn under the panels when present. std::optional> cellular_feed_target; const client::OutcomeLog* outcomes{}; int visible_organisms{-1}; // -1 when unknown. const client::Bindings* bindings{}; // In force (hints). // Controls panel, drawn while `controls` is set. Edits stay in the draft until Apply. const client::BindingEditor* controls{}; std::optional capturing; // Waiting for the next key press. std::optional controls_problem; }; struct PanelActions { bool fixture{}, connect{}, cancel{}, retry{}, back{}, ask_disconnect{}; bool sign_in{}, sign_out{}, auth_connect{}, cancel_sign_in{}; std::optional dismiss_notice, confirm_dialog, cancel_dialog; bool open_controls{}, apply_controls{}, reset_controls{}, close_controls{}, cancel_capture{}; std::optional capture_key; std::optional clear_secondary; std::optional cellular_trial; std::optional> feed_patch; bool stop_feeding{}; std::optional cell_action; bool cell_become{}; // With a bud: continue as it (v14). std::optional mutation; bool restart_life{}, keep_unknown{}; }; // Draws every panel for this frame. `display` may be changed by the layer selector. [[nodiscard]] PanelActions draw_panels(const PanelView& view, FormBuffers& form, render::EnvironmentDisplay& display); } // namespace evo::client_app