From 8ce609d344a0314c7af5ae02748920c672698fc3 Mon Sep 17 00:00:00 2001 From: dingo Date: Thu, 22 Oct 2026 09:08:03 -0400 Subject: [PATCH] feat(client): add liquid presentation and clearer cellular HUD --- apps/evo-client/main.cpp | 21 +- apps/evo-client/panels.cpp | 352 ++++++++++++++---- apps/evo-client/panels.hpp | 5 + .../region/dev-session-route/listener.yaml | 2 +- docs/adr/0081-organism-presentation.md | 10 + ...136-open-energy-and-scattered-nutrients.md | 9 + docs/architecture/CLIENT_ARCHITECTURE.md | 7 + docs/engineering/CLIENT.md | 12 +- docs/engineering/CLIENT_VISUAL_REFRESH.md | 84 +++++ docs/engineering/VALIDATION.md | 51 +++ src/client/platform/application.cpp | 39 +- tests/client_panels.cpp | 98 ++++- 12 files changed, 596 insertions(+), 94 deletions(-) create mode 100644 docs/engineering/CLIENT_VISUAL_REFRESH.md diff --git a/apps/evo-client/main.cpp b/apps/evo-client/main.cpp index 4ba3664..31b47ec 100644 --- a/apps/evo-client/main.cpp +++ b/apps/evo-client/main.cpp @@ -758,6 +758,8 @@ int main(int argc, char** argv) try { const bool microscope = cellular_remote && mode() == Mode::remote && cellular_trial; if (microscope) { const bool fresh = cellular_remote->cellular_play().fresh(); + scene.camera_centre = camera->centre(); + scene.stale = !fresh; if (const auto* perception = cellular_remote->cellular_perception()) for (const auto& patch : perception->patches) { const auto low = @@ -803,12 +805,18 @@ int main(int argc, char** argv) try { const auto low = camera->screen_to_world({0, height}); const auto high = camera->screen_to_world({width, 0}); if (flow_field && low && high) { - const double span = std::max(high->x_mm - low->x_mm, 0.001); + const double span = + std::max({high->x_mm - low->x_mm, high->y_mm - low->y_mm, 0.001}); const double step = std::max(0.4, span / 28); - for (double y = std::floor(low->y_mm / step) * step; y <= high->y_mm; - y += step) - for (double x = std::floor(low->x_mm / step) * step; x <= high->x_mm; - x += step) { + const double first_x = std::floor(low->x_mm / step) * step; + const double first_y = std::floor(low->y_mm / step) * step; + const int columns = + std::clamp(static_cast((high->x_mm - first_x) / step) + 1, 1, 30); + const int rows = + std::clamp(static_cast((high->y_mm - first_y) / step) + 1, 1, 30); + for (int row = 0; row < rows; ++row) + for (int column = 0; column < columns; ++column) { + const double x = first_x + column * step, y = first_y + row * step; const auto flow = flow_field->sample(static_cast(x * 1000), static_cast(y * 1000)); @@ -829,7 +837,8 @@ int main(int argc, char** argv) try { static_cast(sx / norm * length), static_cast(sy / norm * length), static_cast(std::min(speed, 300.0) / 300), - static_cast(x * 7919 + y * 104729)}); + static_cast( + static_cast(x * 7919 + y * 104729))}); } } } diff --git a/apps/evo-client/panels.cpp b/apps/evo-client/panels.cpp index 5ed2120..28f5d1d 100644 --- a/apps/evo-client/panels.cpp +++ b/apps/evo-client/panels.cpp @@ -716,6 +716,50 @@ ImVec2 add(ImVec2 a, ImVec2 b) noexcept { ImVec2 times(ImVec2 a, float k) noexcept { return {a.x * k, a.y * k}; } +ImU32 opacity(ImU32 c, unsigned alpha) { + return (c & ~IM_COL32_A_MASK) | (alpha << IM_COL32_A_SHIFT); +} +// Shared nutrient silhouettes at every scale: lipid-like energy lobes, carbon facets, +// nitrogen vesicles, phosphorus rosettes and angular detritus. These are visual symbols, +// not a claim about chemical species. Zero stock never emits a glyph. +void draw_food(ImDrawList& list, ImVec2 at, float r, std::size_t channel, bool stale, + std::uint64_t seed) { + const auto c = nutrient_colors.at(channel); + const unsigned alpha = stale ? 90U : 225U; + if (r < 3.5F) { + list.AddNgonFilled(at, r, opacity(c, alpha), channel == 1 || channel == 4 ? 4 : 6); + return; + } + list.AddCircleFilled(at, r * 1.35F, opacity(c, stale ? 8U : 18U), 16); + if (channel == 0 || channel == 2) { + const int count = channel == 0 ? 3 : 4; + for (int i = 0; i < count; ++i) { + const float a = static_cast(i) * 6.2832F / static_cast(count); + const auto p = add(at, {std::cos(a) * r * 0.38F, std::sin(a) * r * 0.38F}); + list.AddCircleFilled(p, r * 0.6F, opacity(c, alpha / 2), 12); + list.AddCircle(p, r * 0.6F, opacity(c, alpha), 12, 1.0F); + } + } else { + const int count = channel == 3 ? 10 : 6; + const float angle = unit_of(seed) * 6.2832F; + std::array points{}; + for (int i = 0; i < count; ++i) { + const float a = angle + static_cast(i) * 6.2832F / static_cast(count); + const float radius = r * (channel == 3 && i % 2 != 0 ? 0.65F : 1.0F); + points.at(static_cast(i)) = + add(at, {std::cos(a) * radius, std::sin(a) * radius}); + } + // A triangle fan also handles the concave rosette correctly. + for (int i = 0; i < count; ++i) + list.AddTriangleFilled(at, points.at(static_cast(i)), + points.at(static_cast((i + 1) % count)), + opacity(c, alpha / 2)); + list.AddPolyline(points.data(), count, opacity(c, alpha), ImDrawFlags_Closed, 1.0F); + list.AddLine(points[0], points[3], opacity(c, alpha / 2), 1.0F); + } + list.AddCircleFilled({at.x - r * 0.23F, at.y - r * 0.26F}, std::max(0.8F, r * 0.15F), + IM_COL32(240, 253, 255, stale ? 60 : 210), 8); +} // One cell: an ellipse membrane (thicker wall for more membrane), flagella waving behind // the long axis (one per movement step), coral organelles and a nucleus. Dead cells show a // torn membrane. Nothing here is a player/NPC label: every cell is drawn by biology alone; @@ -728,10 +772,9 @@ void draw_cell(ImDrawList& list, const SceneCell& c, float time) { const ImVec2 centre{c.x, c.y}; const ImVec2 radius{r * 1.25F, r * 0.82F}; const auto alpha = static_cast(c.stale ? 120 : 255); - const ImU32 wall = c.dead ? IM_COL32(138, 132, 176, alpha * 2 / 3) - : c.own ? IM_COL32(201, 212, 255, alpha) - : IM_COL32(150, 144, 190, alpha * 9 / 10); - const ImU32 body = c.own ? IM_COL32(170, 185, 255, 38) : IM_COL32(170, 160, 220, 28); + const ImU32 wall = + c.dead ? IM_COL32(138, 132, 176, alpha * 2 / 3) : IM_COL32(157, 226, 241, alpha); + const ImU32 body = IM_COL32(67, 154, 182, alpha / 4); if (!c.dead) { for (int i = 0; i < c.flagella; ++i) { const float spread = @@ -762,13 +805,31 @@ void draw_cell(ImDrawList& list, const SceneCell& c, float time) { return; } list.AddEllipse(centre, radius, wall, angle, 0, std::max(1.0F, c.membrane)); - const ImU32 organelle = c.own ? IM_COL32(255, 122, 102, 235) : IM_COL32(184, 90, 76, 220); + list.AddEllipse(centre, times(radius, 0.87F), IM_COL32(116, 174, 238, alpha / 2), angle, 0, + 1.0F); + // Interior highlights give the cytoplasm depth without introducing extra capabilities. + if (r >= 12) { + list.AddEllipseFilled(add(centre, times(normal, -r * 0.26F)), {r * 0.65F, r * 0.19F}, + IM_COL32(186, 246, 239, alpha / 8), angle); + for (int k = 0; k < 9; ++k) { + const auto key = c.seed * 19U + static_cast(k); + const auto at = add(add(centre, times(axis, (unit_of(key) - 0.5F) * r * 1.7F)), + times(normal, (unit_of(key + 3) - 0.5F) * r)); + list.AddCircleFilled(at, std::max(0.7F, r * 0.025F), IM_COL32(180, 240, 245, alpha / 2), + 6); + } + } + const ImU32 organelle = IM_COL32(255, 176, 94, alpha); for (int k = 0; k < c.organelles; ++k) { const auto key = c.seed * 31U + static_cast(k); const float u = unit_of(key) - 0.55F, v = unit_of(key + 7U) - 0.5F; - list.AddCircleFilled( - add(add(centre, times(axis, u * radius.x * 1.1F)), times(normal, v * radius.y * 0.9F)), - std::max(1.5F, r * 0.16F), organelle); + const auto at = + add(add(centre, times(axis, u * radius.x * 1.1F)), times(normal, v * radius.y * 0.9F)); + list.AddEllipseFilled(at, {std::max(1.5F, r * 0.19F), std::max(1.0F, r * 0.12F)}, organelle, + angle); + if (r >= 18) + list.AddLine(add(at, times(axis, -r * 0.1F)), add(at, times(axis, r * 0.1F)), + IM_COL32(124, 75, 62, alpha), 1.0F); } // Producers (ADR-0176): chloroplasts, more of them for more efficient cells. for (int k = 0; k < c.chloroplasts; ++k) { @@ -776,12 +837,13 @@ void draw_cell(ImDrawList& list, const SceneCell& c, float time) { const float u = unit_of(key) - 0.55F, v = unit_of(key + 5U) - 0.5F; const ImVec2 at = add(add(centre, times(axis, u * radius.x * 1.1F)), times(normal, v * radius.y * 0.9F)); - list.AddCircleFilled(at, std::max(1.8F, r * 0.18F), IM_COL32(64, 168, 84, 230)); - list.AddCircleFilled(at, std::max(0.8F, r * 0.08F), IM_COL32(150, 222, 128, 230)); + list.AddCircleFilled(at, std::max(1.8F, r * 0.18F), IM_COL32(64, 168, 84, alpha)); + list.AddCircleFilled(at, std::max(0.8F, r * 0.08F), IM_COL32(150, 222, 128, alpha)); } const ImVec2 nucleus = add(centre, times(axis, radius.x * 0.42F)); - list.AddCircleFilled(nucleus, std::max(2.0F, r * 0.3F), IM_COL32(224, 86, 63, 220)); - list.AddCircleFilled(nucleus, std::max(1.0F, r * 0.14F), IM_COL32(255, 156, 134, 235)); + list.AddCircleFilled(nucleus, std::max(2.0F, r * 0.35F), IM_COL32(166, 100, 217, alpha / 2)); + list.AddCircle(nucleus, std::max(2.0F, r * 0.3F), IM_COL32(222, 175, 250, alpha), 20, 1.0F); + list.AddCircleFilled(nucleus, std::max(1.0F, r * 0.14F), IM_COL32(245, 190, 245, alpha)); if (c.own) list.AddEllipse(centre, {radius.x * 1.2F + 4.0F, radius.y * 1.2F + 4.0F}, IM_COL32(169, 155, 255, 110), angle, 0, 2.0F); @@ -804,11 +866,8 @@ void draw_patch(ImDrawList& list, const ScenePatch& p) { for (int i = 0; i < count; ++i) { const auto key = p.seed * 131U + channel * 977U + static_cast(i); const float a = unit_of(key) * 6.2832F, d = std::sqrt(unit_of(key + 3U)) * half * 0.85F; - auto color = nutrient_colors.at(channel); - if (p.stale) - color = (color & 0x00FFFFFFU) | (110U << IM_COL32_A_SHIFT); - list.AddCircleFilled({p.x + std::cos(a) * d, p.y + std::sin(a) * d}, - grain * (0.7F + 0.6F * unit_of(key + 5U)), color); + draw_food(list, {p.x + std::cos(a) * d, p.y + std::sin(a) * d}, + grain * (0.7F + 0.6F * unit_of(key + 5U)), channel, p.stale, key); } } } @@ -839,47 +898,36 @@ void draw_bubble(ImDrawList& list, const SceneDeposit& d, float time) { (color & 0x00FFFFFFU) | (glow << IM_COL32_A_SHIFT)); } } - const auto alpha = static_cast(d.stale ? 90 : 210); - color = (color & 0x00FFFFFFU) | (alpha << IM_COL32_A_SHIFT); - list.AddCircleFilled({d.x, d.y}, r, (color & 0x00FFFFFFU) | ((alpha / 3) << IM_COL32_A_SHIFT)); - list.AddCircle({d.x, d.y}, r, color, 0, std::max(1.0F, r * 0.18F)); - list.AddCircleFilled({d.x - r * 0.35F, d.y - r * 0.35F}, std::max(0.8F, r * 0.22F), - IM_COL32(255, 255, 255, d.stale ? 40 : 110)); + if (d.stock.at(channel) != 0) + draw_food(list, {d.x, d.y}, r, channel, d.stale, d.seed); } -// A pool is a puddle: a seeded, wobbling outline around its contact disc, granules inside -// in its nutrients' colours, fewer as it drains. +// A thin enclosing membrane follows the contact disc. Its contents are the same nutrient +// glyphs as free food, never extra resource identities or additional collision shapes. void draw_pool(ImDrawList& list, const SceneDeposit& d, float time) { const float r = std::max(d.radius, 8.0F); - constexpr int points = 28; - for (int i = 0; i < points; ++i) { - const float a = 6.2832F * static_cast(i) / points; - const auto key = d.seed * 7919U + static_cast(i); - const float wobble = 0.82F + 0.3F * unit_of(key) + 0.04F * std::sin(time * 0.7F + a * 3); - list.PathLineTo({d.x + std::cos(a) * r * wobble, d.y + std::sin(a) * r * wobble}); - } - list.PathFillConvex(IM_COL32(52, 40, 58, d.stale ? 50 : 110)); - for (int i = 0; i < points; ++i) { - const float a = 6.2832F * static_cast(i) / points; - const auto key = d.seed * 7919U + static_cast(i); - const float wobble = 0.82F + 0.3F * unit_of(key) + 0.04F * std::sin(time * 0.7F + a * 3); - list.PathLineTo({d.x + std::cos(a) * r * wobble, d.y + std::sin(a) * r * wobble}); - } - list.PathStroke(IM_COL32(120, 96, 130, d.drained ? 220 : 140), ImDrawFlags_Closed, 1.5F); - const float grain = std::clamp(r * 0.05F, 1.5F, 5.0F); + const ImVec2 centre{d.x, d.y}; + const int alpha = d.stale ? 65 : 170; + list.AddCircleFilled(centre, r, IM_COL32(84, 177, 163, d.stale ? 12 : 25), 64); + list.AddCircle(centre, r, IM_COL32(166, 220, 199, alpha), 64, 1.25F); + list.AddCircle(centre, r - 3, IM_COL32(116, 190, 188, alpha / 3), 64, 1.0F); + list.PathArcTo(centre, r - 1, 3.5F, 4.8F, 16); + list.PathStroke(IM_COL32(220, 249, 219, alpha), 0, 2.0F); + if (d.drained && !d.stale) + list.AddCircle(centre, r + 2, + IM_COL32(178, 240, 218, static_cast(50 + 30 * std::sin(time * 6))), 64, + 2.0F); + const float grain = std::clamp(r * 0.09F, 2.0F, 11.0F); for (std::size_t channel = 0; channel < d.stock.size(); ++channel) { const auto amount = d.stock.at(channel); if (amount == 0) continue; const auto count = std::clamp( - static_cast(2.0 + 3.0 * std::log10(static_cast(amount) / 1.0e5)), 1, 40); + static_cast(2.0 + 3.0 * std::log10(static_cast(amount) / 1.0e5)), 1, 18); for (int i = 0; i < count; ++i) { const auto key = d.seed * 131U + channel * 977U + static_cast(i); const float a = unit_of(key) * 6.2832F, dist = std::sqrt(unit_of(key + 3U)) * r * 0.75F; - auto color = nutrient_colors.at(channel); - if (d.stale) - color = (color & 0x00FFFFFFU) | (110U << IM_COL32_A_SHIFT); - list.AddCircleFilled({d.x + std::cos(a) * dist, d.y + std::sin(a) * dist}, - grain * (0.7F + 0.6F * unit_of(key + 5U)), color); + draw_food(list, {d.x + std::cos(a) * dist, d.y + std::sin(a) * dist}, + grain * (0.7F + 0.6F * unit_of(key + 5U)), channel, d.stale, key); } } } @@ -939,8 +987,29 @@ void inspect_cell(ImDrawList& list, const SceneCell& c) { } ImGui::EndTooltip(); } -// Rules 12: currents as faint drifting streaks under the food, so the flow is readable before -// a cell commits to it. Specks are thin lines, never discs, so they never read as food. +// Optical depth and caustics: decorative illumination, never temperature or hidden food. +// The fixed 24 x 16 mesh bounds cost independently of resolution and camera zoom. +void draw_liquid(ImDrawList& list, ImVec2 size, float time) { + constexpr int columns = 24, rows = 16; + const auto tint = [&](int x, int y) { + const float u = static_cast(x) / columns, v = static_cast(y) / rows; + const float wave = 0.5F + 0.5F * std::sin(u * 8 + v * 5 + std::sin(v * 9 + time * 0.08F)); + const float light = std::pow(wave, 7.0F); + return IM_COL32(static_cast(12 + 9 * wave), + static_cast(37 + 24 * wave + 10 * light), + static_cast(55 + 23 * wave + 14 * light), 255); + }; + for (int y = 0; y < rows; ++y) + for (int x = 0; x < columns; ++x) { + list.AddRectFilledMultiColor( + {static_cast(x) * size.x / columns, static_cast(y) * size.y / rows}, + {static_cast(x + 1) * size.x / columns, + static_cast(y + 1) * size.y / rows}, + tint(x, y), tint(x + 1, y), tint(x + 1, y + 1), tint(x, y + 1)); + } +} +// Rules 12: translucent ribbons follow the sampled local current. Their travelling +// highlights move along that direction; width/brightness encode speed, never temperature. void draw_flows(ImDrawList& list, const std::vector& flows, float time) { for (const auto& f : flows) { const float phase = std::fmod(time * 0.5F + static_cast(f.seed % 97U) / 97.0F, 1.0F); @@ -948,22 +1017,37 @@ void draw_flows(ImDrawList& list, const std::vector& flows, float tim const auto alpha = static_cast((24.0F + 80.0F * f.strength) * fade); const ImVec2 from{f.x + f.dx * (phase - 0.5F), f.y + f.dy * (phase - 0.5F)}; const ImVec2 to{from.x + f.dx * 0.6F, from.y + f.dy * 0.6F}; - list.AddLine(from, to, IM_COL32(140, 200, 235, alpha), 1.4F); + const ImVec2 start{f.x - f.dx, f.y - f.dy}, end{f.x + f.dx, f.y + f.dy}; + const ImVec2 bend{-f.dy * 0.16F, f.dx * 0.16F}; + const ImVec2 middle{f.x, f.y}; + list.AddTriangleFilled(start, add(middle, bend), add(middle, times(bend, -1)), + IM_COL32(67, 180, 217, 8)); + list.AddTriangleFilled(end, add(middle, bend), add(middle, times(bend, -1)), + IM_COL32(67, 180, 217, 8)); + list.AddLine(from, to, IM_COL32(125, 213, 239, alpha / 3), 5.0F); + list.AddLine(from, to, IM_COL32(172, 234, 248, alpha), 1.2F); } } void draw_scene(const PanelView& v) { if (!v.cellular_scene) return; auto& list = *ImGui::GetBackgroundDrawList(); - const auto time = static_cast(ImGui::GetTime()); + const auto time = v.cellular_scene->stale ? 0.0F : static_cast(ImGui::GetTime()); + draw_liquid(list, ImGui::GetIO().DisplaySize, time); draw_flows(list, v.cellular_scene->flows, time); for (const auto& patch : v.cellular_scene->patches) draw_patch(list, patch); + const auto visible = [&](const SceneDeposit& d) { + const float reach = std::max(d.radius * 3, 12.0F); + const auto size = ImGui::GetIO().DisplaySize; + return d.x + reach >= 0 && d.y + reach >= 0 && d.x - reach <= size.x && + d.y - reach <= size.y; + }; for (const auto& deposit : v.cellular_scene->deposits) - if (deposit.pool) + if (deposit.pool && visible(deposit)) draw_pool(list, deposit, time); for (const auto& deposit : v.cellular_scene->deposits) - if (!deposit.pool) + if (!deposit.pool && visible(deposit)) draw_bubble(list, deposit, time); for (const auto& pop : v.cellular_scene->pops) draw_pop(list, pop); @@ -1009,6 +1093,34 @@ bool bud_known(const network::CellularLifeDiagnostics& d) { return d.bud_cost_energy_pj != 0 || std::ranges::any_of(d.bud_cost_matter_fg, [](std::uint64_t x) { return x != 0; }); } +// One control standard: rounded, bordered, full label, visible hover/pressed/disabled. +// Accent denotes action family, never funding or whether the server accepted it. +bool action_button(const char* label, ImVec2 size, ImVec4 accent) { + ImGui::PushStyleColor(ImGuiCol_Button, + {accent.x * 0.23F, accent.y * 0.23F, accent.z * 0.23F, 1}); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, + {accent.x * 0.38F, accent.y * 0.38F, accent.z * 0.38F, 1}); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, + {accent.x * 0.5F, accent.y * 0.5F, accent.z * 0.5F, 1}); + ImGui::PushStyleColor(ImGuiCol_Border, {accent.x, accent.y, accent.z, 0.7F}); + const bool pressed = ImGui::Button(label, size); + ImGui::PopStyleColor(4); + return pressed; +} +void panel_heading(const char* title, bool& minimized) { + ImGui::PushID(title); + const float right = ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x; + ImGui::AlignTextToFramePadding(); + ImGui::TextUnformatted(title); + ImGui::SameLine(); + ImGui::SetCursorPosX(right - ImGui::CalcTextSize(" + ").x - + 2 * ImGui::GetStyle().FramePadding.x); + if (ImGui::SmallButton(minimized ? " + " : " - ")) + minimized = !minimized; + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("%s %s", minimized ? "Expand" : "Minimize", title); + ImGui::PopID(); +} // Status pill at the top: region, phase, tick, and the two always-available actions. void hud_status(const PanelView& v, PanelActions& a) { const auto& io = ImGui::GetIO(); @@ -1047,7 +1159,7 @@ void hud_status(const PanelView& v, PanelActions& a) { } // Lower left: energy in readable units, its trend, and the matter reserve. When the bud // cost is known, each bar is progress toward the next bud on that nutrient. -void hud_vitals(const PanelView& v, bool compact) { +void hud_vitals(const PanelView& v, FormBuffers& form, bool compact) { const auto& io = ImGui::GetIO(); const float clearance = eyepiece_clearance(); const float width = std::min(px(300), io.DisplaySize.x - 2 * px(12)); @@ -1059,9 +1171,18 @@ void hud_vitals(const PanelView& v, bool compact) { const auto* d = diagnostics(v); if (!play || play->life() == 0) return; // The life window speaks for a cell that is not alive. - ImGui::SetNextWindowSizeConstraints({width, 0}, {width, io.DisplaySize.y}); + const float max_height = + compact ? std::max(px(120), io.DisplaySize.y - px(220)) : io.DisplaySize.y * 0.43F; + ImGui::SetNextWindowSizeConstraints({width, 0}, {width, max_height}); ImGui::Begin("Vitals", nullptr, hud_flags | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_AlwaysAutoResize); + panel_heading("Your cell", form.vitals_minimized); + if (form.vitals_minimized) { + if (d) + ImGui::Text("Energy %s", energy_text(d->reserve_energy_pj).c_str()); + ImGui::End(); + return; + } if (!play->fresh()) ImGui::TextColored(amber, "Waiting for a fresh server view"); if (!d) { @@ -1069,6 +1190,10 @@ void hud_vitals(const PanelView& v, bool compact) { ImGui::End(); return; } + ImGui::TextDisabled("Body -- Water --"); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip("Temperatures are not reported by this session.\nThermal gradients are " + "not yet available."); section("ENERGY"); if (const auto& change = play->energy_change(); change) { ImGui::SameLine(); @@ -1141,16 +1266,16 @@ void hud_dock(const PanelView& v, FormBuffers& form, PanelActions& a, bool compa (ImGui::GetContentRegionAvail().x - 2 * ImGui::GetStyle().ItemSpacing.x) / 3.0F; const bool active = play && play->fresh() && play->life() != 0; ImGui::BeginDisabled(!active); - if (ImGui::Button(form.cellular_controls.auto_feed ? "Feed: auto" : "Feed: manual", - {each, px(44)})) + if (action_button(form.cellular_controls.auto_feed ? "Feed: auto" : "Feed: manual", + {each, px(44)}, {0.32F, 0.90F, 0.73F, 1})) form.cellular_controls.auto_feed = !form.cellular_controls.auto_feed; ImGui::EndDisabled(); ImGui::SameLine(); ImGui::BeginDisabled(!play || !play->can_act()); - if (ImGui::Button("Engulf", {each, px(44)})) + if (action_button("Engulf", {each, px(44)}, {0.38F, 0.68F, 1.0F, 1})) a.cell_action = CellAction::engulf; ImGui::SameLine(); - if (ImGui::Button("Bud", {each, px(44)})) + if (action_button("Bud", {each, px(44)}, {0.82F, 0.53F, 0.96F, 1})) a.cell_action = CellAction::bud; ImGui::EndDisabled(); // What a bud needs, by nutrient (ADR-0129 amendment). @@ -1196,10 +1321,20 @@ void hud_notes(const PanelView& v, FormBuffers& form, PanelActions& a, bool comp const float clearance = eyepiece_clearance(); ImGui::SetNextWindowPos({clearance, px(64)}, ImGuiCond_Always); ImGui::SetNextWindowSizeConstraints({px(260), 0}, - {px(260), std::max(px(120), io.DisplaySize.y * 0.45F)}); - ImGui::Begin("Field notes", nullptr, hud_flags | ImGuiWindowFlags_AlwaysAutoResize); + {px(260), std::max(px(120), io.DisplaySize.y * 0.41F)}); + ImGui::Begin("Field notes", nullptr, + hud_flags | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_AlwaysAutoResize); + panel_heading("Field notes", form.notes_minimized); + if (form.notes_minimized) { + ImGui::End(); + return; + } for (std::size_t i = 0; i < nutrient_names.size(); ++i) { - dot(nutrient_colors.at(i)); + const float glyph_size = ImGui::GetTextLineHeight(); + const auto at = ImGui::GetCursorScreenPos(); + draw_food(*ImGui::GetWindowDrawList(), {at.x + glyph_size / 2, at.y + glyph_size / 2}, + glyph_size * 0.36F, i, false, i); + ImGui::Dummy({glyph_size, glyph_size}); ImGui::SameLine(0, ImGui::GetStyle().ItemInnerSpacing.x); ImGui::TextUnformatted(nutrient_names.at(i)); if (i % 2 == 0 && i + 1 < nutrient_names.size()) @@ -1502,6 +1637,96 @@ void evolution_window(const PanelView& v, FormBuffers& form, PanelActions& a, bo form.evolution_open = false; ImGui::End(); } +void hud_map(const PanelView& v, FormBuffers& form, bool compact) { + if (!v.cellular_scene) + return; + const auto& scene = *v.cellular_scene; + const auto& io = ImGui::GetIO(); + const float width = px(compact ? 184.0F : 210.0F); + ImGui::SetNextWindowPos({io.DisplaySize.x - (compact ? px(12) : eyepiece_clearance()), px(126)}, + ImGuiCond_Always, {1, 0}); + ImGui::SetNextWindowSizeConstraints({width, 0}, {width, io.DisplaySize.y - px(200)}); + ImGui::Begin("Nearby", nullptr, + hud_flags | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_AlwaysAutoResize); + panel_heading("Nearby", form.map_minimized); + if (form.map_minimized) { + ImGui::End(); + return; + } + auto at = ImGui::GetCursorScreenPos(); + const float available = ImGui::GetContentRegionAvail().x; + const float side = std::min(available, px(compact ? 96.0F : 178.0F)); + at.x += (available - side) / 2; + const ImVec2 centre{at.x + side / 2, at.y + side / 2}; + const float r = side * 0.39F; + auto& list = *ImGui::GetWindowDrawList(); + list.AddCircleFilled(centre, r, IM_COL32(13, 39, 48, 255), 48); + list.AddCircle(centre, r, IM_COL32(110, 180, 192, 180), 48, 1.0F); + list.AddCircle(centre, r / 2, IM_COL32(110, 180, 192, 35), 32, 1.0F); + list.AddLine({centre.x - r, centre.y}, {centre.x + r, centre.y}, IM_COL32(110, 180, 192, 35)); + list.AddLine({centre.x, centre.y - r}, {centre.x, centre.y + r}, IM_COL32(110, 180, 192, 35)); + const auto label = [&](ImVec2 p, const char* text) { + const auto size = ImGui::CalcTextSize(text); + list.AddText({p.x - size.x / 2, p.y - size.y / 2}, IM_COL32(196, 224, 238, 255), text); + }; + label({centre.x, at.y + px(6)}, "+Y"); + label({centre.x, at.y + side - px(6)}, "-Y"); + label({at.x + px(7), centre.y}, "-X"); + label({at.x + side - px(7), centre.y}, "+X"); + // Fixed six millimetre radius, camera centred. Only replicated observations enter. + const auto marker = [&](double x, double y, ImU32 color, bool pool, bool cell, bool own) { + const float dx = static_cast((x - scene.camera_centre.x_mm) / 6.0); + const float dy = static_cast((scene.camera_centre.y_mm - y) / 6.0); + if (dx * dx + dy * dy > 0.94F * 0.94F) + return; + const ImVec2 p{centre.x + dx * r, centre.y + dy * r}; + if (scene.stale) + color = opacity(color, 85); + if (pool) + list.AddCircle(p, px(4), color, 12, 1.0F); + else if (cell) + list.AddTriangleFilled({p.x, p.y - px(3)}, {p.x - px(3), p.y + px(3)}, + {p.x + px(3), p.y + px(3)}, color); + else + list.AddCircleFilled(p, px(1.6F), color, 6); + if (own) + list.AddCircle(p, px(6), color, 12, 1.0F); + }; + if (const auto* seen = v.cellular_perception) { + for (const auto& d : seen->deposits) { + const auto channel = static_cast( + std::distance(d.amount_codes.begin(), + std::max_element(d.amount_codes.begin(), d.amount_codes.end()))); + if (d.amount_codes.at(channel) != 0) + marker(d.x_um / 1000.0, d.y_um / 1000.0, nutrient_colors.at(channel), + d.shape == network::CellularDepositShape::pool, false, false); + } + for (const auto& p : seen->patches) + if (p.energy_pj != 0 || + std::ranges::any_of(p.matter_fg, [](auto amount) { return amount != 0; })) + marker(p.x_um / 1000.0 + 0.5, p.y_um / 1000.0 + 0.5, nutrient_colors[0], true, + false, false); + } + if (v.organisms && v.organisms->current()) + for (const auto& cell : v.organisms->current()->cells()) + marker(static_cast(cell.voxel.x) * static_cast(world::cell_pitch_mm) + + static_cast(cell.x.value) / 1000.0, + static_cast(cell.voxel.y) * static_cast(world::cell_pitch_mm) + + static_cast(cell.y.value) / 1000.0, + IM_COL32(181, 232, 242, 255), false, true, + v.cellular_play && cell.id == v.cellular_play->life()); + ImGui::Dummy({side, side}); + disabled_wrapped(compact ? "6 mm / local axes" : "6 mm radius / local axes"); + if (scene.stale) + ImGui::TextColored(amber, "Last observation - stale"); + else + disabled_wrapped(compact ? "Received view" : "Observed food and cells"); + if (ImGui::IsWindowHovered()) + ImGui::SetTooltip( + "Camera-centred local map. Unseen space is unknown.\nRings: pools. Dots: nutrients. " + "Triangles: cells.\nLocal +Y is up; planetary north is not defined."); + ImGui::End(); +} void cellular(const PanelView& v, FormBuffers& form, PanelActions& a) { const auto& io = ImGui::GetIO(); const bool compact = io.DisplaySize.x < px(880); @@ -1514,7 +1739,8 @@ void cellular(const PanelView& v, FormBuffers& form, PanelActions& a) { } hud_status(v, a); hud_notes(v, form, a, compact); - hud_vitals(v, compact); + hud_vitals(v, form, compact); + hud_map(v, form, compact); hud_dock(v, form, a, compact); hud_callout(v, form); evolution_window(v, form, a, compact); diff --git a/apps/evo-client/panels.hpp b/apps/evo-client/panels.hpp index 59d23e9..b74deb2 100644 --- a/apps/evo-client/panels.hpp +++ b/apps/evo-client/panels.hpp @@ -4,6 +4,7 @@ // 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" @@ -67,6 +68,9 @@ struct CellularScene { 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{}; }; // Notice layout (logical pixels); the window name is the prefix plus the notice id. inline constexpr float notice_width = 320, notice_close_width = 22; @@ -75,6 +79,7 @@ inline constexpr const char* notice_window_prefix = "##notice"; struct FormBuffers { bool engineering{}; bool evolution_open{}; // The mutation window (E or the callout opens it). + bool notes_minimized{}, vitals_minimized{}, map_minimized{}; CellularControls cellular_controls; std::array endpoint{}, server_name{}, authority{}, grants{}; void load(const client::ConnectForm& form); diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index c5dba4a..351fdbc 100644 --- a/deploy/kubernetes/region/dev-session-route/listener.yaml +++ b/deploy/kubernetes/region/dev-session-route/listener.yaml @@ -12,7 +12,7 @@ spec: env: - {name: REGION_SESSION, value: "dev"} - {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"} - - {name: REGION_SESSION_WINDOW, value: "dev-20261022T125200-c1e6e708:1792687920"} + - {name: REGION_SESSION_WINDOW, value: "ui-20261022T130803-a1d37601:1792688883"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/adr/0081-organism-presentation.md b/docs/adr/0081-organism-presentation.md index f17f776..8361519 100644 --- a/docs/adr/0081-organism-presentation.md +++ b/docs/adr/0081-organism-presentation.md @@ -70,3 +70,13 @@ add labels outside these APIs; review must keep debug overlays out of player UI. ## Consequences M9.7 builds `OrganismPresentation` from server views. Any new visual parameter must derive from biology and update this ADR, tests and ORGANISM_RENDERING.md. + +## Presentation amendment, 2026-10-22 + +The native microscope now layers translucent cyan membranes and cytoplasm, amber +metabolic organelles and a violet centre. Existing phenotype mappings for extent, +wall thickness, flagella, conversion and producer chloroplasts remain in force. +Identical biology receives the same palette; the controlled cell differs only by +its existing focus ring. Dead outlines remain broken and stale opacity is applied +to organelles as well as the membrane. No new biological parameter is introduced. +See [the visual refresh](../engineering/CLIENT_VISUAL_REFRESH.md). diff --git a/docs/adr/0136-open-energy-and-scattered-nutrients.md b/docs/adr/0136-open-energy-and-scattered-nutrients.md index 600abd4..c9e0ce1 100644 --- a/docs/adr/0136-open-energy-and-scattered-nutrients.md +++ b/docs/adr/0136-open-energy-and-scattered-nutrients.md @@ -187,3 +187,12 @@ Existing regions keep their rules versions and are never migrated in place - **ADR-0120:** in the new rules version, square patches and the intake target become pools, bubbles and contact feeding. - **ADR-0124:** detritus becomes bubbles. + +## Presentation amendment, 2026-10-22 + +The maintainer requested nutrient silhouettes, a thin enclosing pool membrane and +a more colorful liquid scene. The native client now uses nutrient-specific glyphs +inside the unchanged contact discs, with a zero-stock channel absent. These are +presentation symbols, not new chemical species, resource identities or membrane +physics. The existing single-channel deposit and contact-feeding contracts remain +unchanged. See [the scoped visual refresh](../engineering/CLIENT_VISUAL_REFRESH.md). diff --git a/docs/architecture/CLIENT_ARCHITECTURE.md b/docs/architecture/CLIENT_ARCHITECTURE.md index 4269568..0298e62 100644 --- a/docs/architecture/CLIENT_ARCHITECTURE.md +++ b/docs/architecture/CLIENT_ARCHITECTURE.md @@ -104,3 +104,10 @@ markers and stock cards use copied sensor data only. A final birth refusal permi an explicit new request even before a perception arrives; pending/unknown requests retain their ID and an existing-life result waits for that life. These are app presentation/control policies, not biological rules. + +The [2026-10-22 visual refresh](../engineering/CLIENT_VISUAL_REFRESH.md) stays +inside the existing native app/toolkit boundary. Its local map consumes replicated +observations only; optical liquid shading is not a thermal field. Body temperature, +ambient temperature and directional heat guidance remain pending authoritative +phase-3 state and a negotiated perception contract. Existing public library and +wire interfaces are unchanged. diff --git a/docs/engineering/CLIENT.md b/docs/engineering/CLIENT.md index cfa16dc..f72191d 100644 --- a/docs/engineering/CLIENT.md +++ b/docs/engineering/CLIENT.md @@ -88,7 +88,7 @@ provision a region. Sent/admitted are distinct from committed. A committed engulf/bud intention does not itself prove biological success; the tick feedback reports its effect. -The dark teal UI uses the existing embedded scalable font. At narrow sizes the +The blue-green UI uses the existing embedded scalable font. At narrow sizes the Evolution panel becomes the **Life** tab; panels remain within the viewport and scroll vertically. Existing Ctrl+= / Ctrl+- scaling and rebindable movement apply. Food patches have a thin contact boundary and a stock marker, with amber for the @@ -212,3 +212,13 @@ unload behavior and qualification evidence are documented in VALIDATION.md. Headless defaults keep both `EVO_BUILD_CLIENT` and `EVO_BUILD_CLIENT_PROBE` OFF. No prepared SDL sources, display or client runtime are needed for `evo-sim` or server tests. No Kubernetes deployment change belongs to this desktop gate. + +## 2026-10-22 liquid presentation + +[The native visual refresh](CLIENT_VISUAL_REFRESH.md) adds blue-green optical +texture, flowing current ribbons, nutrient silhouettes, thin pool membranes, +a shared brighter cell palette and colored action buttons. Field notes, Vitals +and Nearby can minimize and restore. Nearby is a camera-centred map of received +observations with a local-axis compass; it never reveals hidden food. Temperature +readouts remain explicitly unavailable until phase 3 and a session contract carry +real body/ambient observations. No simulation or protocol version changes. diff --git a/docs/engineering/CLIENT_VISUAL_REFRESH.md b/docs/engineering/CLIENT_VISUAL_REFRESH.md new file mode 100644 index 0000000..49d7b0e --- /dev/null +++ b/docs/engineering/CLIENT_VISUAL_REFRESH.md @@ -0,0 +1,84 @@ +# Cellular liquid presentation refresh + +Scope: native client presentation, 2026-10-22, requested by the maintainer using +the screenshots, two recordings and visual references in `Aevolution-Client-SS`. +This is a procedural first pass using the existing SDL3/ImGui renderer, not the +photorealistic lighting of the reference images. No asset or runtime dependency +is added. Headless libraries, biological rules, persistence and wire formats are +unchanged. + +## Visual language + +- Blue-green liquid illumination replaces the black eyepiece interior. A fixed + caustic mesh gives optical texture; it carries no environmental measurement. + Current ribbons and travelling highlights follow the replicated flow field. + A maximum 30 by 30 sample grid bounds cost even in a tall viewport. +- Nutrients keep their established colors and gain distinct silhouettes: gold + lobes for energy, umber facets for carbon, blue vesicles for nitrogen, rose + rosettes for phosphorus, pale angular fragments for other matter. These are + readable symbols, not asserted chemical structures. At very small sizes they + simplify to solid marks. The legend uses the same shapes. +- Pools have a thin circular membrane on their contact disc, containing those + same nutrient symbols. A zero channel emits no shapes. Entire deposits remain + owned and removed by the server; the client does not consume or split them. + The decorative membrane neither blocks a cell nor changes collision geometry. +- All living cells share cyan membranes, translucent cytoplasm, amber metabolic + organelles and a violet centre. Wall thickness, motility, conversion and green + producer organelles retain their existing phenotype mappings. The viewer's + own cell has only its existing focus ring, not a different biological palette. + Dead cells keep their broken outline; stale scenes freeze cosmetic motion and + dim observed objects. + +## Controls and navigation + +Buttons share a rounded, bordered treatment with distinct hover, pressed and +disabled states. The action dock uses mint for feeding, blue for engulfing and +violet for budding. Labels and authoritative enable/disable logic remain intact; +color alone does not communicate affordability or success. Existing bindings +remain authoritative; decorative shortcut numbers are not invented. + +Field notes, Vitals and Nearby have explicit minus/plus buttons. Collapsing +Vitals retains energy. State lasts for the client session; it is not saved. +The responsive compact layout keeps the dock and map within the viewport. + +Nearby is a camera-centred observation map with a fixed six-millimetre radius. +It reads the received food and organism views only, including observations +outside the viewport. Empty space means unknown, not confirmed empty. Rings +denote pools, dots nutrients and triangles cells; the controlled cell has a ring. +The compass labels local +Y/-Y and +X/-X, consistent with the camera. Planetary +north and a global explored-world map have not been defined by this gate. +Disconnected data is explicitly stale. The map is read-only and cannot issue +movement or reveal unobserved resources. + +## Temperature contract gap and proposed follow-up + +Inspection found an architectural dependency: session v13 has reserves, motion, +currents and observed food, but no body or ambient temperature observations. +[ADR-0178](../adr/0178-durable-liquid-region.md) and phase 3 of the +[region/movement plan](../../Cellular_Region_Movement_Plan.md) explicitly leave +the thermal field and per-cell thermal state pending. A client-only gradient +or body temperature would fabricate game state. Implementation of that affected +feature stops here. + +Vitals reserves a `Body -- / Water --` readout with an explanation on hover. +No heat colors, danger thresholds or warmer/colder arrows are emitted. + +Proposed resolution, not an accepted protocol or biological rule: + +1. Complete phase 3's authoritative body/ambient model and its versioned + persistence/replay contract. +2. Add bounded, perception-filtered body and local ambient temperatures with + units, freshness and availability to a new negotiated session version. +3. Define the spatial sampling distance and visible-neighbour coverage for + warmer/colder guidance. No client extrapolation into hidden regions. +4. Render measured body/water values and a separate thermal overlay. A direction + arrow requires sufficient current samples; equal, missing or stale samples + suppress it. Comfort and harm use observed phenotype limits, not UI constants. + +## Validation + +The native panel suite exercises multiple sizes, collapse/restore and input +capture alongside existing mutation, affordability and action tests. See +[VALIDATION](VALIDATION.md) for executed builds, screenshots and environmental +limits. The supplied reference art is design input, not a runtime asset or a +claim of achieved photorealism. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index edbe1a0..0f415c8 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -10127,3 +10127,54 @@ changes; CMake/CTest, clang-format, clang-tidy, and sanitizers are not applicabl to this prose addition and were not run. Design viability and balance remain unqualified. The AGENTS.md-required pre-push window update is desired Git configuration only, not a deployment. + +## 2026-10-22 - Native liquid UI refresh + +Scope: `apps/evo-client` scene/HUD, the private platform theme, and native panel +regressions. See [visual design and the thermal contract gap](CLIENT_VISUAL_REFRESH.md). +No biological, persistence or wire version changed. Existing unrelated drafts and +server work were preserved. + +Executed: + +- MSVC 19.44 / toolset 14.44, Release with NDEBUG: configured/built `client` and + `client-network` through `tools/windows-check.ps1`. Client CTest 10/10; final + `client-network` CTest 18/18 with local loopback access outside the sandbox. +- Ubuntu/WSL Clang 19: configured from the `client` preset in `build/m12-ui-clang` + with `EVO_ENABLE_TIDY=ON`, built all client preset targets, CTest client label + 10/10. Changed production sources and panel tests passed clang-tidy with warnings + as errors. Xvfb/X11 lifecycle executable exited 0. +- `asan` preset in `build/client-asan`, client enabled: rebuilt client, panel and + lifecycle targets; ASan+UBSan panel, lifecycle and smoke CTests 3/3. +- clang-format-19 dry-run with `--Werror` passed for the five changed C++ files. +- Production panel renderer exercised at 640x480, 960x640 and 1280x800: window + bounds, non-overlap with the action dock, minimize/restore with input capture, + and existing hover/mutation/affordability/bud/restart paths. World draw-list + checks verify each nutrient disappears independently at zero and stale food + retains dimmed silhouettes. No golden or simulation version was changed. +- Native BMP review frames (including Evolution and death) were generated in + ignored `build/ui-review/final` and visually inspected. The final fixture cell + was moved clear of HUD panels and its pool stocked to inspect the new shapes; + the panel suite was rerun after that fixture-only adjustment. These images + are local fixtures, not a live DEV session or performance benchmark. + +Environmental limits and initial failures: + +- Windows tests initially could not save bindings in the sandbox's default temp + directory. Setting TMP and TEMP to `build/ui-review/tmp` resolved both bindings + and control-save checks. +- The sandboxed network run was 13/18: five loopback connection tests could not + establish sessions. The same final production build passed all 18 outside the + sandbox. No production endpoint or World0 was contacted by those checks. +- Physical DPI, GPU rendering, motion comfort, accessibility and low-spec frame + cost still require interactive hardware review. This procedural rendering does + not implement the photographic lighting/blur of the supplied concept images. +- Two local MP4s were reviewed through sampled frame sheets. An imageio-ffmpeg + decoder was installed only in ignored `build/ui-review-tools` for that analysis; + it is not a repository or client dependency. +- Body/ambient readings and thermal direction remain unavailable because session + v13 carries neither. The UI shows dashes and explains the missing observations; + the proposed phase-3 follow-up is documented rather than fabricated client state. + +The AGENTS.md-required pre-push session-window refresh is desired Git configuration +only. No deployment, live reachability, World0 mutation or world reset is claimed. diff --git a/src/client/platform/application.cpp b/src/client/platform/application.cpp index 67286cd..563b293 100644 --- a/src/client/platform/application.cpp +++ b/src/client/platform/application.cpp @@ -51,33 +51,34 @@ struct Toolkit { auto& style = ImGui::GetStyle(); style.WindowRounding = 12; style.ChildRounding = 8; - style.FrameRounding = 6; + style.FrameRounding = 10; + style.FrameBorderSize = 1; style.PopupRounding = 8; style.GrabRounding = 6; style.WindowPadding = {16, 14}; style.FramePadding = {10, 6}; style.ItemSpacing = {8, 9}; auto* colors = style.Colors; - colors[ImGuiCol_WindowBg] = {0.090F, 0.078F, 0.114F, 0.94F}; // Ink (2026-10-16 palette). - colors[ImGuiCol_ChildBg] = {0.114F, 0.098F, 0.141F, 0.9F}; - colors[ImGuiCol_PopupBg] = {0.090F, 0.078F, 0.114F, 1.0F}; - colors[ImGuiCol_Border] = {0.165F, 0.141F, 0.200F, 0.9F}; - colors[ImGuiCol_Text] = {0.945F, 0.925F, 0.902F, 1.0F}; - colors[ImGuiCol_TextDisabled] = {0.678F, 0.643F, 0.722F, 1.0F}; - colors[ImGuiCol_FrameBg] = {0.125F, 0.106F, 0.157F, 1.0F}; - colors[ImGuiCol_FrameBgHovered] = {0.165F, 0.141F, 0.200F, 1.0F}; - colors[ImGuiCol_FrameBgActive] = {0.227F, 0.196F, 0.271F, 1.0F}; - colors[ImGuiCol_Button] = {0.165F, 0.137F, 0.278F, 1.0F}; - colors[ImGuiCol_ButtonHovered] = {0.239F, 0.204F, 0.400F, 1.0F}; - colors[ImGuiCol_ButtonActive] = {0.294F, 0.247F, 0.561F, 1.0F}; - colors[ImGuiCol_Header] = {0.165F, 0.137F, 0.278F, 1.0F}; + colors[ImGuiCol_WindowBg] = {0.038F, 0.075F, 0.125F, 0.96F}; + colors[ImGuiCol_ChildBg] = {0.055F, 0.100F, 0.157F, 0.94F}; + colors[ImGuiCol_PopupBg] = {0.045F, 0.080F, 0.137F, 0.98F}; + colors[ImGuiCol_Border] = {0.34F, 0.46F, 0.60F, 0.75F}; + colors[ImGuiCol_Text] = {0.92F, 0.97F, 0.98F, 1.0F}; + colors[ImGuiCol_TextDisabled] = {0.64F, 0.76F, 0.82F, 1.0F}; + colors[ImGuiCol_FrameBg] = {0.075F, 0.15F, 0.21F, 1.0F}; + colors[ImGuiCol_FrameBgHovered] = {0.12F, 0.25F, 0.32F, 1.0F}; + colors[ImGuiCol_FrameBgActive] = {0.16F, 0.33F, 0.40F, 1.0F}; + colors[ImGuiCol_Button] = {0.14F, 0.22F, 0.36F, 1.0F}; + colors[ImGuiCol_ButtonHovered] = {0.23F, 0.36F, 0.52F, 1.0F}; + colors[ImGuiCol_ButtonActive] = {0.28F, 0.43F, 0.60F, 1.0F}; + colors[ImGuiCol_Header] = {0.12F, 0.20F, 0.30F, 1.0F}; colors[ImGuiCol_HeaderHovered] = colors[ImGuiCol_ButtonHovered]; colors[ImGuiCol_HeaderActive] = colors[ImGuiCol_ButtonActive]; - colors[ImGuiCol_TitleBg] = {0.078F, 0.067F, 0.098F, 1.0F}; - colors[ImGuiCol_TitleBgActive] = {0.125F, 0.106F, 0.157F, 1.0F}; - colors[ImGuiCol_CheckMark] = {0.663F, 0.608F, 1.0F, 1.0F}; - colors[ImGuiCol_Tab] = {0.114F, 0.098F, 0.141F, 1.0F}; - colors[ImGuiCol_TabSelected] = {0.165F, 0.137F, 0.278F, 1.0F}; + colors[ImGuiCol_TitleBg] = {0.045F, 0.09F, 0.15F, 1.0F}; + colors[ImGuiCol_TitleBgActive] = {0.075F, 0.15F, 0.23F, 1.0F}; + colors[ImGuiCol_CheckMark] = {0.36F, 0.89F, 0.78F, 1.0F}; + colors[ImGuiCol_Tab] = {0.075F, 0.14F, 0.21F, 1.0F}; + colors[ImGuiCol_TabSelected] = {0.14F, 0.25F, 0.35F, 1.0F}; colors[ImGuiCol_TabHovered] = colors[ImGuiCol_ButtonHovered]; base_style = ImGui::GetStyle(); platform = ImGui_ImplSDL3_InitForSDLRenderer(window, target); diff --git a/tests/client_panels.cpp b/tests/client_panels.cpp index 08960c6..2134027 100644 --- a/tests/client_panels.cpp +++ b/tests/client_panels.cpp @@ -405,6 +405,7 @@ void cellular_panels(const std::filesystem::path& review) { EnvironmentLayer environment; OrganismLayer organisms; CellularPlay play; + CHECK(organisms.accept(*population)); play.initialize(100); play.connected(); network::CellularLifeDiagnostics diagnostics; @@ -449,13 +450,24 @@ void cellular_panels(const std::filesystem::path& review) { view.remote->region = 4; // 2026-10-16 microscope view: patches as granules and cells, drawn under the HUD. CellularScene scene; + scene.camera_centre = camera->centre(); + for (int y = 100; y < height; y += 50) + for (int x = 40; x < width; x += 55) + scene.flows.push_back({static_cast(x), static_cast(y), 22, -10, 0.7F, + static_cast(x + y)}); scene.patches.push_back({200, 200, 60, {50000, 100, 20, 10, 40}, false, false, 1}); scene.patches.push_back({400, 260, 60, {0, 90, 0, 8, 0}, true, false, 2}); - scene.cells.push_back({300, 300, 24, 2.5F, 2, 3, true, false, false, 901}); + scene.cells.push_back({440, 350, 34, 2.5F, 2, 3, true, false, false, 901}); scene.cells.push_back({500, 220, 14, 4.0F, 0, 2, false, true, false, 77}); // ADR-0136: a pool, a draining bubble, a still one and a pop draw under the HUD. - scene.deposits.push_back( - {620, 320, 50, {90000, 4000, 900, 300, 1200}, true, false, false, 5}); + scene.deposits.push_back({600, + 350, + 65, + {90000000, 40000000, 9000000, 3000000, 12000000}, + true, + false, + false, + 5}); scene.deposits.push_back({360, 330, 4, {0, 52000, 0, 0, 0}, false, true, false, 6}); scene.deposits.push_back({380, 360, 4, {2000000, 0, 0, 0, 0}, false, false, false, 7}); scene.pops.push_back({400, 300, 4, 0.4F, 3}); @@ -477,8 +489,84 @@ void cellular_panels(const std::filesystem::path& review) { auto* dock = ImGui::FindWindowByName("Actions"); CHECK(fits(vitals) && fits(dock) && fits(ImGui::FindWindowByName("##mode"))); CHECK(fits(ImGui::FindWindowByName("##mutation"))); // The offer callout. + CHECK(fits(ImGui::FindWindowByName("Nearby"))); + const auto disjoint = [](const ImGuiWindow* a, const ImGuiWindow* b) { + return a->Pos.x + a->Size.x <= b->Pos.x || b->Pos.x + b->Size.x <= a->Pos.x || + a->Pos.y + a->Size.y <= b->Pos.y || b->Pos.y + b->Size.y <= a->Pos.y; + }; + CHECK(disjoint(vitals, dock) && disjoint(ImGui::FindWindowByName("Nearby"), dock)); if (width >= 880) - CHECK(fits(ImGui::FindWindowByName("Field notes"))); + CHECK(fits(ImGui::FindWindowByName("Field notes")) && + disjoint(vitals, ImGui::FindWindowByName("Field notes"))); + // Minimize/restore stays local to the panel, including a same-batch click. + const auto toggle = [&](const char* name, bool& minimized) { + const auto* panel = ImGui::FindWindowByName(name); + CHECK(panel); + const float expanded = panel->Size.y; + const auto click_heading = [&] { + const float x = + panel->Pos.x + panel->Size.x - ImGui::GetStyle().WindowPadding.x - 20; + const float y = + panel->Pos.y + ImGui::GetStyle().WindowPadding.y + ImGui::GetFrameHeight() / 2; + mouse(id, SDL_EVENT_MOUSE_MOTION, x, y); + mouse(id, SDL_EVENT_MOUSE_BUTTON_DOWN, x, y); + mouse(id, SDL_EVENT_MOUSE_BUTTON_UP, x, y); + CHECK(app->poll_events() && !app->take_navigation().click); + for (int i = 0; i < 3; ++i) + draw(); + }; + click_heading(); + CHECK(minimized && panel->Size.y < expanded && fits(panel)); + click_heading(); + CHECK(!minimized && fits(panel)); + }; + toggle("Vitals", form.vitals_minimized); + toggle("Nearby", form.map_minimized); + if (width >= 880) + toggle("Field notes", form.notes_minimized); + mouse(id, SDL_EVENT_MOUSE_MOTION, 5, 5); + // A depleted channel vanishes independently. Stale observations retain the food + // silhouettes but never their fresh opacity. Inspect the world draw list, not HUD. + if (width == 960) { + const auto saved_scene = scene; + scene = {}; + scene.deposits.push_back({450, + 300, + 70, + {10000000, 10000000, 10000000, 10000000, 10000000}, + true, + false, + false, + 5}); + constexpr std::array colors{IM_COL32(255, 214, 107, 225), IM_COL32(201, 138, 91, 225), + IM_COL32(111, 183, 255, 225), IM_COL32(255, 127, 178, 225), + IM_COL32(184, 178, 196, 225)}; + const auto has_color = [&](ImU32 color) { + const auto& vertices = ImGui::GetBackgroundDrawList()->VtxBuffer; + return std::any_of(vertices.begin(), vertices.end(), + [&](const ImDrawVert& vertex) { return vertex.col == color; }); + }; + draw(); + for (auto color : colors) + CHECK(has_color(color)); + for (std::size_t channel = 0; channel < colors.size(); ++channel) { + scene.deposits[0].stock[channel] = 0; + draw(); + CHECK(!has_color(colors[channel])); + for (std::size_t remaining = channel + 1; remaining < colors.size(); ++remaining) + CHECK(has_color(colors[remaining])); + } + scene.deposits[0].stock.fill(10000000); + scene.deposits[0].stale = true; + scene.stale = true; + draw(); + for (auto color : colors) { + CHECK(!has_color(color)); + CHECK(has_color((color & ~IM_COL32_A_MASK) | (90U << IM_COL32_A_SHIFT))); + } + scene = saved_scene; + draw(); + } if (!review.empty()) { std::filesystem::create_directories(review); auto later = perception; @@ -486,6 +574,8 @@ void cellular_panels(const std::filesystem::path& review) { later.diagnostics->reserve_energy_pj -= 50; play.observe(later); view.cellular_feed_target = {{2000, 3000}}; + for (int i = 0; i < 3; ++i) + draw(); CHECK(app->request_screenshot( (review / ("cellular-" + std::to_string(width) + ".bmp")).string())); draw();