Cellular microscope UI: living cells, nutrient food, HUD and evolution cards
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

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>
This commit is contained in:
dingo
2026-10-16 08:53:55 -04:00
co-authored by Claude Opus 5.5
parent ab5c29227c
commit 28629e1001
8 changed files with 883 additions and 392 deletions
+69 -18
View File
@@ -467,6 +467,8 @@ int main(int argc, char** argv) try {
bool auth_connect = false; // Connect when the requested grant arrives.
auto grant_requested = std::chrono::steady_clock::time_point{};
int drawn_organisms = -1;
evo::client_app::CellularScene scene; // Rebuilt each frame in cellular play.
bool scene_active = false;
evo::client_app::PanelActions actions;
(*app)->set_overlay([&] {
evo::client_app::PanelView view;
@@ -488,6 +490,7 @@ int main(int argc, char** argv) try {
view.cellular_feed_target = cellular_feed_target;
}
view.visible_organisms = drawn_organisms;
view.cellular_scene = scene_active ? &scene : nullptr;
view.bindings = &(*app)->bindings();
controls.fill(view);
actions = evo::client_app::draw_panels(view, buffers, display);
@@ -719,10 +722,16 @@ int main(int argc, char** argv) try {
*camera, display))
return 1;
const double width = state.logical_width, height = state.logical_height;
// Cellular patches under the organisms, so the own cell draws on top of them.
if (const auto* remote = host.session();
remote && mode() == Mode::remote && cellular_trial)
if (const auto* perception = remote->cellular_perception())
// 2026-10-16 microscope view: in cellular play, patches and cells are a scene the
// panels draw as granules and living cells; elsewhere organisms stay rectangles.
scene.patches.clear();
scene.cells.clear();
scene_active = false;
const auto* cellular_remote = host.session();
const bool microscope = cellular_remote && mode() == Mode::remote && cellular_trial;
if (microscope) {
const bool fresh = cellular_remote->cellular_play().fresh();
if (const auto* perception = cellular_remote->cellular_perception())
for (const auto& patch : perception->patches) {
const auto low =
camera->world_to_screen({static_cast<double>(patch.x_um) / 1000,
@@ -730,20 +739,62 @@ int main(int argc, char** argv) try {
const auto high = camera->world_to_screen(
{(static_cast<double>(patch.x_um) + 1000) / 1000,
(static_cast<double>(patch.y_um) + 1000) / 1000});
if (low && high)
evo::client_app::patch_box(
boxes, *low, *high, patch.energy_pj != 0,
std::ranges::any_of(patch.matter_fg, [](auto v) { return v != 0; }),
cellular_feed_target && cellular_feed_target->first == patch.x_um &&
cellular_feed_target->second == patch.y_um,
width, height, !remote->cellular_play().fresh());
if (!low || !high)
continue;
evo::client_app::ScenePatch p;
p.x = static_cast<float>((low->x + high->x) / 2);
p.y = static_cast<float>((low->y + high->y) / 2);
p.half = static_cast<float>(std::abs(high->x - low->x) / 2);
p.stock = {patch.energy_pj, patch.matter_fg[0], patch.matter_fg[1],
patch.matter_fg[2], patch.matter_fg[3]};
p.target = cellular_feed_target &&
cellular_feed_target->first == patch.x_um &&
cellular_feed_target->second == patch.y_um;
p.stale = !fresh;
p.seed = (static_cast<std::uint64_t>(patch.x_um) << 32U) ^ patch.y_um;
scene.patches.push_back(p);
}
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 auto own = cellular_remote->cellular_play().life();
if (orgs)
for (const auto& cell : orgs->cells()) {
const auto bounds = evo::render::organism_bounds(cell, *camera);
if (bounds.right < 0 || bounds.left > width || bounds.bottom < 0 ||
bounds.top > height)
continue;
const auto& ph = cell.phenotype;
evo::client_app::SceneCell c;
c.x = static_cast<float>((bounds.left + bounds.right) / 2);
c.y = static_cast<float>((bounds.top + bounds.bottom) / 2);
c.radius = static_cast<float>((bounds.right - bounds.left) / 2);
// One flagellum per 150 um/s of speed (a founder swims at 200).
c.flagella = ph.movement_speed == 0
? 0
: static_cast<int>(std::min<std::uint32_t>(
6, 1 + ph.movement_speed / 150));
const double wall = ph.total_mass == 0
? 0.0
: static_cast<double>(ph.membrane_mass) /
static_cast<double>(ph.total_mass);
c.membrane = static_cast<float>(std::clamp(1.0 + wall * 6.0, 1.0, 7.0));
c.organelles = 2 + static_cast<int>(std::min<std::uint32_t>(
3, ph.conversion_per_thousand / 250));
c.own = own != 0 && cell.id == own;
c.dead = cell.state == evo::client::OrganismState::dead;
c.stale =
org_layer && org_layer->freshness() != evo::client::Freshness::current;
c.seed = cell.id;
scene.cells.push_back(c);
}
drawn_organisms = static_cast<int>(scene.cells.size());
scene_active = true;
} else {
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);
}
if (const auto* remote = host.session(); remote && mode() == Mode::remote) {
for (const auto& m : remote->markers())
if (const auto at = camera->world_to_screen({m.x_mm, m.y_mm}))
@@ -772,7 +823,7 @@ int main(int argc, char** argv) try {
8,
8,
{240, 240, 240, 255}});
const auto frame = evo::render::Frame::create(boxes, {16, 20, 28, 255});
const auto frame = evo::render::Frame::create(boxes, {14, 12, 18, 255}); // Ink.
if (!frame)
return 1;
if (!screenshot.empty() && count + 1 == frames && !(*app)->request_screenshot(screenshot))
+680 -314
View File
File diff suppressed because it is too large Load Diff
+24
View File
@@ -16,15 +16,38 @@
#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);
@@ -50,6 +73,7 @@ struct PanelView {
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.
@@ -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-20261016T123415-16196:1792164855"}
- {name: REGION_SESSION_WINDOW, value: "dev-20261016T125355-89029:1792166035"}
- {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"}
ports:
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
+16
View File
@@ -27,6 +27,22 @@ watermark, grants left, the snapshot, interest and snapshot bytes, and the last
intentions with their outcome (sent, admitted, rejected, simulated, unknown; M10.5c). That list is the record;
short notifications expire and can be dismissed.
**Microscope view** (2026-10-16, cellular play): the world sits inside a rounded eyepiece
with a vignette. Cells are drawn from their phenotype: a membrane whose wall thickens
with membrane mass, one flagellum per 150 um/s of speed, coral organelles by energy
conversion, a torn membrane when dead. Food patches are granules coloured by nutrient
(energy gold, carbon umber, nitrogen blue, phosphorus rose, other grey); a nutrient
that runs out loses its colour. The HUD:
- a status pill;
- Field notes (legend, food in range, steering, recent actions, help);
- Vitals (energy and matter in readable units, bars toward the next bud);
- an action dock (feed, engulf, bud, last result);
- a "Mutation ready [E]" callout opening the evolution window (cards with before/after
drawings and per-nutrient costs, Choose, Decline all), which also shows the end of
a life.
The toolkit draws these shapes; the rectangle renderer still draws everything else.
**Sign in / Register** (Windows, ADR-0131) opens the system browser for Keycloak.
After sign-in the client fetches a 10-minute grant from `grants.aeternalisgames.com`
and connects to the cellular DEV region. It renews the grant before expiry and after a
+24
View File
@@ -7831,3 +7831,27 @@ Executed locally: WSL `m97-postgres` 79/79 CTests; `postgres-check.sh --full`,
including the v41 upgrade and drift drills; clang-tidy-19 on the changed sources; WSL
client 14/14 with clang-tidy plus the Xvfb check; MSVC `client-package` 18/18;
clang-format 19.
## 2026-10-16 — cellular microscope UI (CI pending)
Client-only redesign from the maintainer's design review (concept canvas A, C and E):
- **Palette:** an ink and lavender theme with amber for shortages.
- **Eyepiece:** a rounded viewport with a vignette.
- **Cells and food:** cells drawn from the phenotype (wall thickness, flagella,
organelles, torn when dead); food patches as nutrient-coloured granules.
- **HUD:** a status pill, Field notes, Vitals in readable units, and an action dock.
- **Evolution window:** a "Mutation ready [E]" callout opens it, with before/after
drawings and per-nutrient costs; it also shows the end of a life.
No protocol, server or simulation change. Per-candidate discard waits for rules 7
(ADR-0135).
Tests: `client-panels` now checks that each HUD window (Vitals, Actions, status,
callout, Field notes) fits the viewport at 640, 960 and 1280. It draws a scene with
patches, a live cell and a dead cell. E opens the evolution window. An unaffordable
candidate cannot be chosen, and Decline all sends operator 0. Bud from the dock
works, and Begin a new life works.
Executed locally: WSL clang-19 `client-probe` with clang-tidy 14/14 plus the Xvfb
X11 lifecycle check; MSVC `client-package` 18/18; clang-format 19. Screenshots of
the HUD at three sizes, the evolution window and the end of a life were reviewed.
+18 -18
View File
@@ -56,26 +56,26 @@ struct Toolkit {
style.FramePadding = {10, 6};
style.ItemSpacing = {8, 9};
auto* colors = style.Colors;
colors[ImGuiCol_WindowBg] = {0.035F, 0.065F, 0.085F, 0.97F};
colors[ImGuiCol_ChildBg] = {0.055F, 0.095F, 0.12F, 0.9F};
colors[ImGuiCol_PopupBg] = {0.045F, 0.08F, 0.10F, 1.0F};
colors[ImGuiCol_Border] = {0.18F, 0.31F, 0.34F, 0.65F};
colors[ImGuiCol_Text] = {0.88F, 0.94F, 0.93F, 1.0F};
colors[ImGuiCol_TextDisabled] = {0.52F, 0.66F, 0.68F, 1.0F};
colors[ImGuiCol_FrameBg] = {0.10F, 0.18F, 0.21F, 1.0F};
colors[ImGuiCol_FrameBgHovered] = {0.15F, 0.28F, 0.31F, 1.0F};
colors[ImGuiCol_FrameBgActive] = {0.18F, 0.35F, 0.36F, 1.0F};
colors[ImGuiCol_Button] = {0.10F, 0.30F, 0.28F, 1.0F};
colors[ImGuiCol_ButtonHovered] = {0.16F, 0.45F, 0.38F, 1.0F};
colors[ImGuiCol_ButtonActive] = {0.20F, 0.55F, 0.44F, 1.0F};
colors[ImGuiCol_Header] = {0.10F, 0.26F, 0.28F, 1.0F};
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_HeaderHovered] = colors[ImGuiCol_ButtonHovered];
colors[ImGuiCol_HeaderActive] = colors[ImGuiCol_ButtonActive];
colors[ImGuiCol_TitleBg] = {0.04F, 0.09F, 0.12F, 1.0F};
colors[ImGuiCol_TitleBgActive] = {0.08F, 0.20F, 0.22F, 1.0F};
colors[ImGuiCol_CheckMark] = {0.40F, 0.88F, 0.68F, 1.0F};
colors[ImGuiCol_Tab] = {0.08F, 0.17F, 0.20F, 1.0F};
colors[ImGuiCol_TabSelected] = {0.12F, 0.32F, 0.31F, 1.0F};
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_TabHovered] = colors[ImGuiCol_ButtonHovered];
base_style = ImGui::GetStyle();
platform = ImGui_ImplSDL3_InitForSDLRenderer(window, target);
+51 -41
View File
@@ -447,6 +447,13 @@ void cellular_panels(const std::filesystem::path& review) {
view.remote->cellular_trial = true;
view.remote->server_tick = 102;
view.remote->region = 4;
// 2026-10-16 microscope view: patches as granules and cells, drawn under the HUD.
CellularScene scene;
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({500, 220, 14, 4.0F, 0, 2, false, true, false, 77});
view.cellular_scene = &scene;
PanelActions action;
app->set_overlay([&] { action = draw_panels(view, form, display); });
const auto draw = [&] {
@@ -454,11 +461,18 @@ void cellular_panels(const std::filesystem::path& review) {
};
for (int i = 0; i < 3; ++i)
draw();
auto* journal = ImGui::FindWindowByName("Cellular field journal");
CHECK(journal && journal->Active && journal->ScrollMax.x == 0);
CHECK(journal->Pos.x >= 0 && journal->Pos.y >= 0 &&
journal->Pos.x + journal->Size.x <= static_cast<float>(width) &&
journal->Pos.y + journal->Size.y <= static_cast<float>(height));
// Every HUD window fits the viewport without sideways scrolling.
const auto fits = [&](const ImGuiWindow* w) {
return w && w->Active && w->ScrollMax.x == 0 && w->Pos.x >= 0 && w->Pos.y >= 0 &&
w->Pos.x + w->Size.x <= static_cast<float>(width) &&
w->Pos.y + w->Size.y <= static_cast<float>(height);
};
auto* vitals = ImGui::FindWindowByName("Vitals");
auto* dock = ImGui::FindWindowByName("Actions");
CHECK(fits(vitals) && fits(dock) && fits(ImGui::FindWindowByName("##mode")));
CHECK(fits(ImGui::FindWindowByName("##mutation"))); // The offer callout.
if (width >= 880)
CHECK(fits(ImGui::FindWindowByName("Field notes")));
if (!review.empty()) {
std::filesystem::create_directories(review);
auto later = perception;
@@ -469,31 +483,6 @@ void cellular_panels(const std::filesystem::path& review) {
CHECK(app->request_screenshot(
(review / ("cellular-" + std::to_string(width) + ".bmp")).string()));
draw();
auto* tabs = GImGui->TabBars.GetByKey(journal->GetID("cell-tabs"));
CHECK(tabs);
const auto choose_tab = [&](const char* name) {
for (auto& tab : tabs->Tabs)
if (std::string_view{ImGui::TabBarGetTabName(tabs, &tab)} == name) {
const float x = tabs->BarRect.Min.x + tab.Offset + tab.Width / 2;
const float y = tabs->BarRect.GetCenter().y;
mouse(id, SDL_EVENT_MOUSE_MOTION, x, y);
draw();
mouse(id, SDL_EVENT_MOUSE_BUTTON_DOWN, x, y);
draw();
mouse(id, SDL_EVENT_MOUSE_BUTTON_UP, x, y);
for (int i = 0; i < 3; ++i)
draw();
CHECK(tabs->SelectedTabId == tab.ID);
return;
}
CHECK(false);
};
choose_tab("Food");
CHECK(journal->ScrollMax.x == 0);
CHECK(app->request_screenshot(
(review / ("cellular-food-" + std::to_string(width) + ".bmp")).string()));
draw();
choose_tab("Cell");
const auto saved_offer = play.offer();
play.disconnected();
play.connected();
@@ -506,17 +495,35 @@ void cellular_panels(const std::filesystem::path& review) {
}
if (width != 960)
continue;
// E opens the mutation window over the world.
SDL_Event e_key{};
e_key.type = SDL_EVENT_KEY_DOWN;
e_key.key.windowID = id;
e_key.key.scancode = SDL_SCANCODE_E;
e_key.key.key = SDLK_E;
e_key.key.down = true;
CHECK(SDL_PushEvent(&e_key));
draw();
auto e_up = e_key;
e_up.type = SDL_EVENT_KEY_UP;
e_up.key.down = false;
CHECK(SDL_PushEvent(&e_up));
for (int i = 0; i < 3; ++i)
draw();
CHECK(form.evolution_open);
const auto* evolution = ImGui::FindWindowByName("Evolution");
CHECK(evolution && evolution->Active && evolution->ScrollMax.x == 0);
CHECK(evolution->Pos.x >= journal->Pos.x + journal->Size.x &&
evolution->Pos.x + evolution->Size.x <= static_cast<float>(width));
CHECK(fits(evolution));
if (!review.empty()) {
CHECK(app->request_screenshot((review / "cellular-evolution.bmp").string()));
draw();
}
// Click the first production choice. Pointer ownership prevents world selection.
const auto probe = [&](const ImGuiWindow* panel, float x_fraction, const auto& done) {
const float x = panel->Pos.x + panel->Size.x * x_fraction;
// Every button is at least a frame high. Half-frame spacing still hits
// each button, including disabled ones, without rendering every five pixels.
const int stride = std::max(1, static_cast<int>(ImGui::GetFrameHeight() / 2));
for (int offset = 90; static_cast<float>(offset) < panel->Size.y - 10;
for (int offset = 8; static_cast<float>(offset) < panel->Size.y - 10;
offset += stride) {
const float y = panel->Pos.y + static_cast<float>(offset);
mouse(id, SDL_EVENT_MOUSE_MOTION, x, y);
@@ -539,22 +546,25 @@ void cellular_panels(const std::filesystem::path& review) {
const auto chose_candidate = [&] {
return action.mutation.has_value() && action.mutation->operator_id != 0;
};
CHECK(!probe(evolution, 0.5F, chose_candidate));
CHECK(!probe(evolution, 0.17F, chose_candidate));
action.mutation.reset();
CHECK(probe(evolution, 0.5F, [&] { return action.mutation.has_value(); }));
CHECK(probe(evolution, 0.17F, [&] { return action.mutation.has_value(); }));
CHECK(action.mutation == MutationChoice{901, 1, 100, 0});
action.mutation.reset();
perception.diagnostics = diagnostics;
draw();
CHECK(probe(evolution, 0.5F, chose_candidate));
CHECK(probe(evolution, 0.17F, chose_candidate));
CHECK(action.mutation == MutationChoice{901, 1, 100, 3});
CHECK(play.queue(CellAction::mutation, 102, required(action.mutation)));
const auto mutation_id = required(play.pending()).id;
draw();
CHECK(!probe(evolution, 0.5F, [&] { return action.mutation.has_value(); }));
CHECK(!probe(evolution, 0.17F, [&] { return action.mutation.has_value(); }));
play.outcome({mutation_id, network::ActionResult::committed, 103, 5});
draw();
CHECK(probe(journal, 0.75F, [&] { return action.cell_action == CellAction::bud; }));
bool budded = false;
for (float fraction = 0.1F; fraction < 1.0F && !budded; fraction += 0.1F)
budded = probe(dock, fraction, [&] { return action.cell_action == CellAction::bud; });
CHECK(budded);
play.observe_end({104, 901, network::CellularDeathReason::engulfed});
perception = {104, 0, {}, {}};
play.observe(perception);
@@ -563,10 +573,10 @@ void cellular_panels(const std::filesystem::path& review) {
CHECK(app->request_screenshot((review / "cellular-death.bmp").string()));
draw();
}
CHECK(probe(evolution, 0.5F, [&] { return action.restart_life; }));
CHECK(probe(evolution, 0.17F, [&] { return action.restart_life; }));
CHECK(play.restart());
draw();
CHECK(!probe(evolution, 0.5F, [&] { return action.restart_life; }));
CHECK(!probe(evolution, 0.17F, [&] { return action.restart_life; }));
}
}
} // namespace