Files
aevolution/apps/evo-client/panels.hpp
T
dingoandClaude Opus 5.5 28629e1001
Foundation / checks (ecs) (push) Successful in 2m23s
Foundation / checks (deploy) (push) Successful in 4m12s
Foundation / checks (tsan) (push) Successful in 11m26s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (network) (push) Canceled after 17m48s
Foundation / checks (postgres) (push) Canceled after 17m48s
Foundation / checks (checks) (push) Canceled after 17m53s
Foundation / checks (client) (push) Canceled after 17m58s
Cellular microscope UI: living cells, nutrient food, HUD and evolution cards
From the maintainer's design review. In cellular play the world sits in a rounded
eyepiece with a vignette:
- Cells are drawn from their phenotype: the membrane wall thickens with membrane
  mass, flagella follow speed, organelles follow energy conversion, and a dead
  cell's membrane is torn.
- Food patches are granules coloured by nutrient, so a nutrient that runs out
  loses its colour.

The side panels become a HUD:
- a status pill and Field notes;
- Vitals in readable units (nJ, ng) with bars toward the next bud;
- an action dock with the last result explained;
- a "Mutation ready [E]" callout opening an evolution window of cards with
  before/after drawings and per-nutrient costs, which also handles the end of a
  life.

New ink, lavender and amber palette. Client only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 08:53:55 -04:00

104 lines
4.6 KiB
C++

#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/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 <array>
#include <cstdint>
#include <optional>
#include <utility>
#include <vector>
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: orientation and organelle layout.
};
struct ScenePatch {
float x{}, y{}, half{}; // Centre and half side of the 1 mm contact footprint.
std::array<std::uint64_t, 5> stock{}; // Energy pJ, then C, N, P, other fg.
bool target{}, stale{};
std::uint64_t seed{};
};
struct CellularScene {
std::vector<ScenePatch> patches;
std::vector<SceneCell> 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).
CellularControls cellular_controls;
std::array<char, client::max_field_bytes> 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<client::LaunchError> 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<RemoteStatus> remote;
const network::CellularPerception* cellular_perception{};
const CellularPlay* cellular_play{};
const CellularScene* cellular_scene{}; // Drawn under the panels when present.
std::optional<std::pair<std::uint32_t, std::uint32_t>> 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<ControlSlot> capturing; // Waiting for the next key press.
std::optional<client::BindingProblem> controls_problem;
};
struct PanelActions {
bool fixture{}, connect{}, cancel{}, retry{}, back{}, ask_disconnect{};
bool sign_in{}, sign_out{}, auth_connect{}, cancel_sign_in{};
std::optional<std::uint64_t> dismiss_notice, confirm_dialog, cancel_dialog;
bool open_controls{}, apply_controls{}, reset_controls{}, close_controls{}, cancel_capture{};
std::optional<ControlSlot> capture_key;
std::optional<client::Action> clear_secondary;
std::optional<bool> cellular_trial;
std::optional<std::pair<std::uint32_t, std::uint32_t>> feed_patch;
bool stop_feeding{};
std::optional<CellAction> cell_action;
std::optional<MutationChoice> 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