Upgrade cellular client to v10 with readable play and assisted steering
This commit is contained in:
@@ -0,0 +1,79 @@
|
||||
#pragma once
|
||||
#include "evo/client/input.hpp"
|
||||
#include "evo/client/organism_view.hpp"
|
||||
#include "evo/network/session_protocol.hpp"
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <optional>
|
||||
#include <utility>
|
||||
|
||||
namespace evo::client_app {
|
||||
struct CellularControls {
|
||||
bool auto_feed{true}, slow_near_food{true}, precision{};
|
||||
int speed_percent{100};
|
||||
};
|
||||
struct CellularSteering {
|
||||
client::Intention intention;
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> patch;
|
||||
};
|
||||
// Assistance uses only the owner's copied view. It never predicts or moves a body.
|
||||
// The cellular bridge currently encodes the footprint's lower-left position in x/y
|
||||
// (ADR-0102), unlike the centre offsets used by the general organism fixture.
|
||||
[[nodiscard]] inline CellularSteering
|
||||
steer_cellular(const CellularControls& controls, client::Intention intention,
|
||||
const network::CellularPerception* perception,
|
||||
const client::OrganismPresentation* organisms,
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> manual) {
|
||||
CellularSteering result{intention, controls.auto_feed ? std::nullopt : manual};
|
||||
double scale = static_cast<double>(std::clamp(controls.speed_percent, 1, 100)) / 100;
|
||||
if (controls.precision)
|
||||
scale *= 0.2;
|
||||
if (perception && organisms && perception->life_identity != 0) {
|
||||
const auto cells = organisms->cells();
|
||||
const auto own =
|
||||
std::ranges::find(cells, perception->life_identity, &client::OrganismCell::id);
|
||||
if (own != cells.end()) {
|
||||
const double x =
|
||||
static_cast<double>(own->voxel.x) * 1'000'000 + static_cast<double>(own->x.value);
|
||||
const double y =
|
||||
static_cast<double>(own->voxel.y) * 1'000'000 + static_cast<double>(own->y.value);
|
||||
const double extent = static_cast<double>(own->phenotype.extent);
|
||||
for (const auto& p : perception->patches) {
|
||||
if (p.energy_pj == 0 &&
|
||||
std::ranges::all_of(p.matter_fg, [](auto v) { return v == 0; }))
|
||||
continue;
|
||||
const double dx =
|
||||
std::max({static_cast<double>(p.x_um) - x - extent, x - p.x_um - 1000, 0.0});
|
||||
const double dy =
|
||||
std::max({static_cast<double>(p.y_um) - y - extent, y - p.y_um - 1000, 0.0});
|
||||
if (controls.auto_feed && !result.patch && dx == 0 && dy == 0)
|
||||
result.patch = {p.x_um, p.y_um};
|
||||
// Presentation preference: approach food at at most 500 um/s (25 um/tick).
|
||||
// Recomputed from the current phenotype after every mutation. Authority
|
||||
// still determines displacement, contact, funding and intake.
|
||||
if (controls.slow_near_food && dx <= 1000 && dy <= 1000 &&
|
||||
own->phenotype.movement_speed > 0)
|
||||
scale =
|
||||
std::min(scale, 500.0 / static_cast<double>(own->phenotype.movement_speed));
|
||||
}
|
||||
}
|
||||
}
|
||||
const auto component = [scale](std::int16_t value) {
|
||||
const auto scaled = static_cast<std::int16_t>(value * scale);
|
||||
// The protocol has finite precision; never turn held movement into a stop.
|
||||
return scaled == 0 && value != 0 ? static_cast<std::int16_t>(value > 0 ? 1 : -1) : scaled;
|
||||
};
|
||||
result.intention.move_x = component(intention.move_x);
|
||||
result.intention.move_y = component(intention.move_y);
|
||||
return result;
|
||||
}
|
||||
[[nodiscard]] inline bool can_fund(const network::CellularOfferedCandidate& candidate,
|
||||
const network::CellularLifeDiagnostics& reserve) {
|
||||
if (candidate.cost_energy_pj > reserve.reserve_energy_pj)
|
||||
return false;
|
||||
for (std::size_t i = 0; i < candidate.cost_matter_fg.size(); ++i)
|
||||
if (candidate.cost_matter_fg[i] > reserve.reserve_matter_fg[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
} // namespace evo::client_app
|
||||
@@ -0,0 +1,281 @@
|
||||
#pragma once
|
||||
|
||||
#include "evo/network/session_protocol.hpp"
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <deque>
|
||||
#include <limits>
|
||||
#include <optional>
|
||||
#include <utility>
|
||||
|
||||
namespace evo::client_app {
|
||||
// Presentation and outstanding requests only. No biological prediction or saved authority.
|
||||
struct MutationChoice {
|
||||
std::uint64_t life{}, event{}, offer_tick{};
|
||||
std::uint16_t operator_id{};
|
||||
friend bool operator==(const MutationChoice&, const MutationChoice&) = default;
|
||||
};
|
||||
enum class CellAction : std::uint8_t { engulf, bud, mutation };
|
||||
enum class CellActionState : std::uint8_t {
|
||||
queued,
|
||||
sent,
|
||||
admitted,
|
||||
unresolved,
|
||||
committed,
|
||||
no_effect,
|
||||
refused
|
||||
};
|
||||
struct CellActionRecord {
|
||||
CellAction kind{};
|
||||
CellActionState state{CellActionState::queued};
|
||||
std::uint64_t id{}, life{}, tick{};
|
||||
MutationChoice choice{};
|
||||
network::AdmitStatus refusal{network::AdmitStatus::admitted};
|
||||
};
|
||||
|
||||
class CellularPlay {
|
||||
public:
|
||||
static constexpr std::size_t history_limit = 8;
|
||||
void initialize(std::uint64_t first_id) {
|
||||
next_id_ = first_id == 0 ? 1 : first_id;
|
||||
birth_request_ = allocate_id();
|
||||
birth_pending_ = true;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t allocate_id() {
|
||||
const auto id = next_id_;
|
||||
if (next_id_ != 0)
|
||||
next_id_ = next_id_ == std::numeric_limits<std::uint64_t>::max() ? 0 : next_id_ + 1;
|
||||
return id;
|
||||
}
|
||||
void connected() {
|
||||
connected_ = true;
|
||||
}
|
||||
void disconnected() {
|
||||
connected_ = false;
|
||||
fresh_ = false;
|
||||
offer_.reset();
|
||||
if (pending_) {
|
||||
if (pending_->state == CellActionState::queued) {
|
||||
pending_->state = CellActionState::refused;
|
||||
finish();
|
||||
} else {
|
||||
pending_->state = CellActionState::unresolved;
|
||||
}
|
||||
}
|
||||
}
|
||||
void observe(const network::CellularPerception& view) {
|
||||
if (view.tick < view_tick_)
|
||||
return;
|
||||
view_tick_ = view.tick;
|
||||
fresh_ = true;
|
||||
if (ended_ && view.life_identity == ended_->life_identity)
|
||||
return; // A retained pre-death view must never revive this identity.
|
||||
// Never replay an intention onto a later life. Keep its uncertain result visible.
|
||||
if (life_ != view.life_identity) {
|
||||
offer_.reset();
|
||||
engulf_feedback_.reset();
|
||||
bud_feedback_.reset();
|
||||
if (pending_) {
|
||||
pending_->state = pending_->state == CellActionState::queued
|
||||
? CellActionState::refused
|
||||
: CellActionState::unresolved;
|
||||
finish();
|
||||
}
|
||||
}
|
||||
life_ = view.life_identity;
|
||||
if (view.diagnostics && view.diagnostics->has_tick_effects) {
|
||||
const auto& d = *view.diagnostics;
|
||||
if (d.engulf != network::CellularEngulfResult::not_reported &&
|
||||
d.engulf != network::CellularEngulfResult::not_requested)
|
||||
engulf_feedback_ = std::pair{view.tick, d.engulf};
|
||||
if (d.bud != network::CellularBudOutcome::not_reported &&
|
||||
d.bud != network::CellularBudOutcome::not_requested)
|
||||
bud_feedback_ = std::pair{view.tick, d.bud};
|
||||
}
|
||||
if (life_ != 0) {
|
||||
birth_pending_ = false;
|
||||
if (ended_ && ended_->life_identity != life_)
|
||||
ended_.reset();
|
||||
}
|
||||
}
|
||||
void observe_offer(const std::optional<network::CellularMutationOffer>& offer) {
|
||||
offer_ = offer && offer->life_identity == life_ && fresh_ && !ended_ ? offer : std::nullopt;
|
||||
}
|
||||
void observe_end(const network::CellularLifeEnded& ended) {
|
||||
if (ended.life_identity == seen_end_ || (life_ != 0 && life_ != ended.life_identity) ||
|
||||
(ended_ && ended_->tick >= ended.tick) || ended.tick < birth_tick_)
|
||||
return;
|
||||
seen_end_ = ended.life_identity;
|
||||
ended_ = ended;
|
||||
life_ = 0;
|
||||
offer_.reset();
|
||||
if (pending_ && pending_->state == CellActionState::queued) {
|
||||
pending_->state = CellActionState::refused;
|
||||
finish();
|
||||
}
|
||||
// The discrete action may still have a final result arriving in this poll.
|
||||
}
|
||||
[[nodiscard]] bool can_act() const {
|
||||
return connected_ && fresh_ && life_ != 0 && !ended_ && !pending_ && !birth_pending_;
|
||||
}
|
||||
[[nodiscard]] bool queue(CellAction kind, std::uint64_t tick, MutationChoice choice = {}) {
|
||||
if (!can_act() || tick == 0)
|
||||
return false;
|
||||
if (kind == CellAction::mutation &&
|
||||
(!offer_ || choice.life != life_ || choice.event != offer_->event_index ||
|
||||
choice.offer_tick != offer_->offer_tick || tick <= choice.offer_tick ||
|
||||
!std::ranges::any_of(offer_->candidates, [&](const auto& c) {
|
||||
return c.operator_id == choice.operator_id;
|
||||
})))
|
||||
return false;
|
||||
const auto id = allocate_id();
|
||||
if (id == 0)
|
||||
return false;
|
||||
pending_ = CellActionRecord{kind, CellActionState::queued, id, life_, tick, choice};
|
||||
return true;
|
||||
}
|
||||
void sent() {
|
||||
if (pending_)
|
||||
pending_->state = CellActionState::sent;
|
||||
}
|
||||
void rechecking() {
|
||||
if (pending_ && pending_->state != CellActionState::queued)
|
||||
pending_->state = CellActionState::unresolved;
|
||||
}
|
||||
void receipt(const network::ActionReceipt& receipt) {
|
||||
if (!pending_ || pending_->id != receipt.action_id)
|
||||
return;
|
||||
if (receipt.status == network::AdmitStatus::admitted ||
|
||||
receipt.status == network::AdmitStatus::duplicate) {
|
||||
pending_->state = CellActionState::admitted;
|
||||
} else if (pending_->kind == CellAction::mutation &&
|
||||
receipt.status == network::AdmitStatus::not_ready) {
|
||||
// The host can report not_ready after an uncertain durable reservation.
|
||||
pending_->state = CellActionState::unresolved;
|
||||
} else if (pending_->state != CellActionState::unresolved &&
|
||||
pending_->state != CellActionState::admitted) {
|
||||
pending_->state = CellActionState::refused;
|
||||
pending_->refusal = receipt.status;
|
||||
finish();
|
||||
}
|
||||
// A refused retry cannot disprove a previously admitted or uncertain action.
|
||||
}
|
||||
void outcome(const network::ActionOutcome& outcome) {
|
||||
if (!pending_ || pending_->id != outcome.action_id) {
|
||||
// Final replies may arrive after the life ended or the user kept an unknown.
|
||||
for (auto& record : history_)
|
||||
if (record.id == outcome.action_id && record.state == CellActionState::unresolved) {
|
||||
if (outcome.result == network::ActionResult::committed)
|
||||
record.state = CellActionState::committed;
|
||||
else if (outcome.result == network::ActionResult::committed_no_effect)
|
||||
record.state = CellActionState::no_effect;
|
||||
else if (outcome.result == network::ActionResult::not_committed)
|
||||
record.state = CellActionState::refused;
|
||||
}
|
||||
return;
|
||||
}
|
||||
using enum network::ActionResult;
|
||||
switch (outcome.result) {
|
||||
case committed:
|
||||
pending_->state = CellActionState::committed;
|
||||
break;
|
||||
case committed_no_effect:
|
||||
pending_->state = CellActionState::no_effect;
|
||||
break;
|
||||
case not_committed:
|
||||
pending_->state = CellActionState::refused;
|
||||
break;
|
||||
case pending:
|
||||
pending_->state = CellActionState::admitted;
|
||||
return;
|
||||
case unknown:
|
||||
pending_->state = CellActionState::unresolved;
|
||||
return;
|
||||
}
|
||||
finish();
|
||||
}
|
||||
// User may leave an uncertain result in the bounded record, never as a success/refusal.
|
||||
void keep_unknown() {
|
||||
if (pending_ && pending_->state == CellActionState::unresolved)
|
||||
finish();
|
||||
}
|
||||
[[nodiscard]] bool can_restart() const {
|
||||
return connected_ && fresh_ && life_ == 0 && !birth_pending_;
|
||||
}
|
||||
[[nodiscard]] bool restart() {
|
||||
if (!can_restart())
|
||||
return false;
|
||||
const auto id = allocate_id();
|
||||
if (id == 0)
|
||||
return false;
|
||||
birth_request_ = id;
|
||||
birth_pending_ = true;
|
||||
return true;
|
||||
}
|
||||
void birth(const network::PrimitiveLifeOutcome& result) {
|
||||
if (result.request_id != birth_request_)
|
||||
return;
|
||||
birth_result_ = result.result;
|
||||
birth_pending_ = result.result == network::PrimitiveLifeResult::pending ||
|
||||
result.result == network::PrimitiveLifeResult::unknown ||
|
||||
result.result == network::PrimitiveLifeResult::born;
|
||||
if (result.result == network::PrimitiveLifeResult::born) {
|
||||
ended_.reset();
|
||||
birth_tick_ = view_tick_;
|
||||
}
|
||||
}
|
||||
[[nodiscard]] std::uint64_t birth_request() const {
|
||||
return birth_request_;
|
||||
}
|
||||
[[nodiscard]] bool birth_pending() const {
|
||||
return birth_pending_;
|
||||
}
|
||||
[[nodiscard]] network::PrimitiveLifeResult birth_result() const {
|
||||
return birth_result_;
|
||||
}
|
||||
[[nodiscard]] std::uint64_t life() const {
|
||||
return life_;
|
||||
}
|
||||
[[nodiscard]] bool fresh() const {
|
||||
return connected_ && fresh_;
|
||||
}
|
||||
[[nodiscard]] const auto& offer() const {
|
||||
return offer_;
|
||||
}
|
||||
[[nodiscard]] const auto& ended() const {
|
||||
return ended_;
|
||||
}
|
||||
[[nodiscard]] const auto& pending() const {
|
||||
return pending_;
|
||||
}
|
||||
[[nodiscard]] const auto& history() const {
|
||||
return history_;
|
||||
}
|
||||
[[nodiscard]] const auto& engulf_feedback() const {
|
||||
return engulf_feedback_;
|
||||
}
|
||||
[[nodiscard]] const auto& bud_feedback() const {
|
||||
return bud_feedback_;
|
||||
}
|
||||
|
||||
private:
|
||||
void finish() {
|
||||
if (!pending_)
|
||||
return;
|
||||
if (history_.size() == history_limit)
|
||||
history_.pop_front();
|
||||
history_.push_back(*pending_);
|
||||
pending_.reset();
|
||||
}
|
||||
std::uint64_t next_id_{1}, life_{}, view_tick_{}, birth_tick_{}, birth_request_{}, seen_end_{};
|
||||
bool connected_{}, fresh_{}, birth_pending_{};
|
||||
network::PrimitiveLifeResult birth_result_{network::PrimitiveLifeResult::pending};
|
||||
std::optional<network::CellularMutationOffer> offer_;
|
||||
std::optional<network::CellularLifeEnded> ended_;
|
||||
std::optional<CellActionRecord> pending_;
|
||||
std::deque<CellActionRecord> history_;
|
||||
std::optional<std::pair<std::uint64_t, network::CellularEngulfResult>> engulf_feedback_;
|
||||
std::optional<std::pair<std::uint64_t, network::CellularBudOutcome>> bud_feedback_;
|
||||
};
|
||||
} // namespace evo::client_app
|
||||
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
#include "evo/client/camera.hpp"
|
||||
#include "evo/render/frame.hpp"
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
|
||||
namespace evo::client_app {
|
||||
inline constexpr std::size_t patch_rectangles = 3;
|
||||
// The border keeps the 1 mm contact footprint readable; the inset is decorative.
|
||||
// No stock percentage is invented: the centre mark means some stock remains.
|
||||
inline void patch_box(std::vector<render::Rectangle>& out, client::ScreenPoint low,
|
||||
client::ScreenPoint high, bool stocked, bool selected, double width,
|
||||
double height, bool stale = false) {
|
||||
const double minimum = selected ? 5 : 3;
|
||||
const double hx = std::max((high.x - low.x) / 2, minimum);
|
||||
const double hy = std::max((low.y - high.y) / 2, minimum);
|
||||
const double x = (low.x + high.x) / 2, y = (low.y + high.y) / 2;
|
||||
const auto rect = [&](double l, double t, double r, double b, render::Color color) {
|
||||
l = std::max(l, 0.0);
|
||||
t = std::max(t, 0.0);
|
||||
r = std::min(r, width);
|
||||
b = std::min(b, height);
|
||||
if (stale) {
|
||||
color.red /= 2;
|
||||
color.green /= 2;
|
||||
color.blue /= 2;
|
||||
}
|
||||
if (r > l && b > t)
|
||||
out.push_back({static_cast<float>(l), static_cast<float>(t), static_cast<float>(r - l),
|
||||
static_cast<float>(b - t), color});
|
||||
};
|
||||
rect(x - hx, y - hy, x + hx, y + hy,
|
||||
selected ? render::Color{233, 182, 85, 255}
|
||||
: stocked ? render::Color{49, 112, 105, 255}
|
||||
: render::Color{58, 69, 77, 255});
|
||||
if (hx <= 6 || hy <= 6)
|
||||
return;
|
||||
const double border = selected ? 2 : 1;
|
||||
rect(x - hx + border, y - hy + border, x + hx - border, y + hy - border,
|
||||
selected ? render::Color{53, 49, 31, 255} : render::Color{17, 40, 43, 255});
|
||||
if (stocked) {
|
||||
const double mark = std::clamp(std::min(hx, hy) * 0.08, 2.0, 5.0);
|
||||
rect(x - mark, y - mark, x + mark, y + mark,
|
||||
selected ? render::Color{233, 182, 85, 255} : render::Color{90, 185, 150, 255});
|
||||
}
|
||||
}
|
||||
} // namespace evo::client_app
|
||||
@@ -94,6 +94,8 @@ class ControlsFlow {
|
||||
static_cast<void>(ui.notify(text, level, lifetime_ms).has_value()); // Bounded.
|
||||
}
|
||||
void apply(client::Application& app, client::UiState& ui) {
|
||||
if (!editor_)
|
||||
return;
|
||||
const auto applied = editor_->apply();
|
||||
if (!applied) {
|
||||
problem_ = applied.error();
|
||||
|
||||
+50
-41
@@ -1,3 +1,4 @@
|
||||
#include "cellular_scene.hpp"
|
||||
#include "controls_flow.hpp"
|
||||
#include "evo/client/application.hpp"
|
||||
#include "evo/client/launcher.hpp"
|
||||
@@ -33,10 +34,11 @@ constexpr std::uint32_t fixture_mask = (1U << 0) | (1U << 1) | (1U << 2) | (1U <
|
||||
constexpr unsigned frames_per_authority_tick = 60;
|
||||
// Frame composition: environment bound + organisms + 6 host rectangles (capture bar,
|
||||
// intention dot, 4-sided selection highlight). Text and panels are the toolkit overlay.
|
||||
constexpr std::size_t host_rectangles = 6 + evo::network::max_cellular_perceived_patches;
|
||||
constexpr std::size_t host_rectangles =
|
||||
6 + evo::client_app::patch_rectangles * evo::network::max_cellular_perceived_patches;
|
||||
// M11.3: the cellular arena is millimetres across, far below the metre-scale default
|
||||
// camera; the first view frames this much of it around the own cell.
|
||||
constexpr double cellular_view_mm = 12;
|
||||
constexpr double cellular_view_mm = 6;
|
||||
constexpr std::size_t organism_budget =
|
||||
evo::render::max_rectangles - evo::render::max_environment_rectangles - host_rectangles;
|
||||
// Local in-memory stand-in for authoritative region views until M9.7. It is never
|
||||
@@ -204,28 +206,6 @@ void marker_box(std::vector<evo::render::Rectangle>& out, double x, double y, bo
|
||||
: own ? evo::render::Color{250, 190, 40, 255}
|
||||
: evo::render::Color{90, 170, 250, 255}});
|
||||
}
|
||||
// A cellular food patch over its true 1 mm footprint (contact means overlapping it), dim so
|
||||
// the cell stays visible on top; zoomed far out it shrinks to a bright marker instead.
|
||||
void patch_box(std::vector<evo::render::Rectangle>& out, evo::client::ScreenPoint low,
|
||||
evo::client::ScreenPoint high, bool stocked, bool selected, double width,
|
||||
double height) {
|
||||
const double minimum = selected ? 5 : 3;
|
||||
const double half_x = std::max((high.x - low.x) / 2, minimum);
|
||||
const double half_y = std::max((low.y - high.y) / 2, minimum);
|
||||
const bool footprint = half_x > 6 && half_y > 6;
|
||||
const double x = (low.x + high.x) / 2, y = (low.y + high.y) / 2;
|
||||
const double x0 = std::max(x - half_x, 0.0), y0 = std::max(y - half_y, 0.0);
|
||||
const double x1 = std::min(x + half_x, width), y1 = std::min(y + half_y, height);
|
||||
if (x1 > x0 && y1 > y0)
|
||||
out.push_back({static_cast<float>(x0), static_cast<float>(y0), static_cast<float>(x1 - x0),
|
||||
static_cast<float>(y1 - y0),
|
||||
selected ? (footprint ? evo::render::Color{120, 92, 24, 255}
|
||||
: evo::render::Color{250, 190, 40, 255})
|
||||
: stocked ? (footprint ? evo::render::Color{32, 100, 60, 255}
|
||||
: evo::render::Color{80, 220, 130, 255})
|
||||
: footprint ? evo::render::Color{52, 58, 64, 255}
|
||||
: evo::render::Color{115, 125, 135, 255}});
|
||||
}
|
||||
void outline(std::vector<evo::render::Rectangle>& out, double l, double t, double r, double b,
|
||||
double width, double height) {
|
||||
const auto rect = [&](double x0, double y0, double x1, double y1) {
|
||||
@@ -456,6 +436,7 @@ int main(int argc, char** argv) try {
|
||||
view.remote = remote->status();
|
||||
view.outcomes = &remote->outcomes();
|
||||
view.cellular_perception = remote->cellular_perception();
|
||||
view.cellular_play = &remote->cellular_play();
|
||||
view.cellular_feed_target = cellular_feed_target;
|
||||
}
|
||||
view.visible_organisms = drawn_organisms;
|
||||
@@ -508,23 +489,47 @@ int main(int argc, char** argv) try {
|
||||
disconnect_dialog.reset();
|
||||
if (actions.dismiss_notice)
|
||||
static_cast<void>(ui.dismiss(*actions.dismiss_notice));
|
||||
if (actions.stop_feeding)
|
||||
if (actions.stop_feeding) {
|
||||
cellular_feed_target.reset();
|
||||
if (actions.feed_patch)
|
||||
buffers.cellular_controls.auto_feed = false;
|
||||
}
|
||||
if (actions.feed_patch) {
|
||||
cellular_feed_target = actions.feed_patch;
|
||||
if (auto* remote = host.session(); remote && mode() == Mode::remote)
|
||||
buffers.cellular_controls.auto_feed = false;
|
||||
}
|
||||
if (auto* remote = host.session(); remote && mode() == Mode::remote) {
|
||||
if (actions.cell_action && remote->request_cellular(*actions.cell_action))
|
||||
cellular_feed_target.reset();
|
||||
if (actions.mutation)
|
||||
static_cast<void>(remote->request_cellular(evo::client_app::CellAction::mutation,
|
||||
*actions.mutation));
|
||||
if (actions.restart_life && remote->restart_cellular()) {
|
||||
cellular_feed_target.reset();
|
||||
selection.clear();
|
||||
}
|
||||
if (actions.keep_unknown)
|
||||
remote->keep_cellular_unknown();
|
||||
remote->set_cellular_feed_target(cellular_trial ? cellular_feed_target : std::nullopt);
|
||||
remote->set_cellular_controls(buffers.cellular_controls);
|
||||
}
|
||||
controls.step(actions, **app, ui);
|
||||
actions = {};
|
||||
// The launcher and modal dialogs own input: no world movement or selection.
|
||||
const auto* input_session = host.session();
|
||||
const bool cell_input_blocked = input_session && input_session->cellular_trial() &&
|
||||
(!input_session->cellular_play().fresh() ||
|
||||
input_session->cellular_play().life() == 0 ||
|
||||
input_session->cellular_play().ended().has_value());
|
||||
(*app)->set_ui_capture(mode() == Mode::launcher || ui.dialog().has_value() ||
|
||||
controls.open());
|
||||
controls.open() || cell_input_blocked);
|
||||
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;
|
||||
host.step(now, *intention, ui); // Only while connecting or connected.
|
||||
if (const auto* remote = host.session(); remote && cellular_trial)
|
||||
cellular_feed_target = remote->cellular_feed_target();
|
||||
// M10.5c: the camera follows the server's view until the user moves it; from then
|
||||
// on its centre is the session's interest (the server clamps and filters it).
|
||||
if (auto* remote = host.session(); remote && mode() == Mode::remote) {
|
||||
@@ -581,16 +586,20 @@ int main(int argc, char** argv) try {
|
||||
&evo::client::OrganismCell::id);
|
||||
if (own != cells.end()) {
|
||||
const double pitch = evo::world::cell_pitch_mm;
|
||||
const evo::client::WorldPoint centre{
|
||||
static_cast<double>(own->voxel.x) * pitch +
|
||||
static_cast<double>(own->x.value) / 1000,
|
||||
static_cast<double>(own->voxel.y) * pitch +
|
||||
static_cast<double>(own->y.value) / 1000};
|
||||
evo::client::WorldPoint centre{static_cast<double>(own->voxel.x) * pitch +
|
||||
static_cast<double>(own->x.value) / 1000,
|
||||
static_cast<double>(own->voxel.y) * pitch +
|
||||
static_cast<double>(own->y.value) /
|
||||
1000};
|
||||
const double scale =
|
||||
cellular_framed ? camera->units_per_mm()
|
||||
: static_cast<double>(std::min(state.logical_width,
|
||||
state.logical_height)) /
|
||||
cellular_view_mm;
|
||||
// Keep the followed cell in the visible arena beside the journal.
|
||||
const double shift = state.logical_width < 880 ? 171.0 : -10.0;
|
||||
centre.x_mm -= shift / scale;
|
||||
centre.y_mm += 29.0 / scale;
|
||||
if (auto moved =
|
||||
evo::client::Camera::create(camera->viewport(), centre, scale)) {
|
||||
*camera = *moved;
|
||||
@@ -632,14 +641,14 @@ int main(int argc, char** argv) try {
|
||||
{(static_cast<double>(patch.x_um) + 1000) / 1000,
|
||||
(static_cast<double>(patch.y_um) + 1000) / 1000});
|
||||
if (low && high)
|
||||
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);
|
||||
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());
|
||||
}
|
||||
const auto report = evo::render::append_organisms(
|
||||
boxes, organism_budget, orgs,
|
||||
|
||||
+338
-5
@@ -108,7 +108,9 @@ void launcher(const PanelView& v, FormBuffers& form, PanelActions& a) {
|
||||
ImGui::SetNextWindowSize({std::min(px(520), io.DisplaySize.x - px(16)), 0}, ImGuiCond_Always);
|
||||
ImGui::Begin("Aeternalis Evolution - engineering client", nullptr,
|
||||
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
|
||||
ImGui::TextWrapped("Choose a data source. Nothing here is a game or a player account.");
|
||||
ImGui::TextColored(green, "AETERNALIS / EVOLUTION");
|
||||
ImGui::TextWrapped("Begin a cellular life in the shared dev ecosystem, or explore the local "
|
||||
"engineering fixture.");
|
||||
if (ImGui::SmallButton("Controls..."))
|
||||
a.open_controls = true;
|
||||
ImGui::Separator();
|
||||
@@ -125,7 +127,7 @@ void launcher(const PanelView& v, FormBuffers& form, PanelActions& a) {
|
||||
ImGui::InputText("Dev CA file", form.authority.data(), form.authority.size());
|
||||
ImGui::InputText("Grant bundle file", form.grants.data(), form.grants.size());
|
||||
bool cellular_trial = v.cellular_trial;
|
||||
if (ImGui::Checkbox("Cellular trial (v9)", &cellular_trial))
|
||||
if (ImGui::Checkbox("Cellular play (v10)", &cellular_trial))
|
||||
a.cellular_trial = cellular_trial;
|
||||
const bool start = phase == LaunchPhase::choosing && ImGui::Button("Connect", {px(160), 0});
|
||||
ImGui::EndDisabled();
|
||||
@@ -513,6 +515,333 @@ void session(const PanelView& v, PanelActions& a) {
|
||||
ImGui::End();
|
||||
}
|
||||
|
||||
const char* cell_action_name(CellAction kind) {
|
||||
switch (kind) {
|
||||
case CellAction::engulf:
|
||||
return "Engulf";
|
||||
case CellAction::bud:
|
||||
return "Bud";
|
||||
case CellAction::mutation:
|
||||
return "Mutation";
|
||||
}
|
||||
return "Action";
|
||||
}
|
||||
const char* cell_action_state(CellActionState state) {
|
||||
switch (state) {
|
||||
case CellActionState::queued:
|
||||
return "Queued";
|
||||
case CellActionState::sent:
|
||||
return "Sent / awaiting admission";
|
||||
case CellActionState::admitted:
|
||||
return "Accepted / awaiting commit";
|
||||
case CellActionState::unresolved:
|
||||
return "Unresolved / outcome unknown";
|
||||
case CellActionState::committed:
|
||||
return "Committed";
|
||||
case CellActionState::no_effect:
|
||||
return "Committed / no effect";
|
||||
case CellActionState::refused:
|
||||
return "Refused / no new action";
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
void cell_record(const CellActionRecord& record) {
|
||||
ImGui::TextColored(record.state == CellActionState::committed ? green : amber, "%s",
|
||||
cell_action_name(record.kind));
|
||||
ImGui::TextWrapped("%s", cell_action_state(record.state));
|
||||
if (record.state == CellActionState::refused &&
|
||||
record.refusal != network::AdmitStatus::admitted)
|
||||
disabled_wrapped(std::string{cellular_admission_message(record.refusal)}.c_str());
|
||||
}
|
||||
void cell_vitals(const PanelView& v) {
|
||||
const auto* p = v.cellular_perception;
|
||||
const auto* play = v.cellular_play;
|
||||
ImGui::TextColored(green, "VITAL SIGNS");
|
||||
if (!play || !play->fresh())
|
||||
ImGui::TextColored(amber, "Waiting for a fresh server view");
|
||||
if (!p || !p->diagnostics || !play || play->life() == 0) {
|
||||
disabled_wrapped("Your cell's reserves will appear here when a living cell is visible.");
|
||||
return;
|
||||
}
|
||||
const auto& d = *p->diagnostics;
|
||||
ImGui::TextDisabled("ENERGY RESERVE");
|
||||
ImGui::PushFont(nullptr, 24);
|
||||
ImGui::TextWrapped("%llu pJ", static_cast<unsigned long long>(d.reserve_energy_pj));
|
||||
ImGui::PopFont();
|
||||
ImGui::Separator();
|
||||
if (ImGui::BeginTable("matter", 2, ImGuiTableFlags_SizingStretchSame)) {
|
||||
constexpr std::array names{"Carbon", "Nitrogen", "Phosphorus", "Other matter"};
|
||||
for (std::size_t i = 0; i < names.size(); ++i) {
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::TextDisabled("%s", names[i]);
|
||||
ImGui::Text("%llu fg", static_cast<unsigned long long>(d.reserve_matter_fg[i]));
|
||||
}
|
||||
ImGui::EndTable();
|
||||
}
|
||||
ImGui::Separator();
|
||||
if (!d.has_tick_effects) {
|
||||
disabled_wrapped("Tick effects are unavailable until the next committed tick.");
|
||||
return;
|
||||
}
|
||||
ImGui::TextWrapped("Last tick: upkeep %llu pJ / movement %llu pJ",
|
||||
static_cast<unsigned long long>(d.maintenance_cost_pj),
|
||||
static_cast<unsigned long long>(d.movement_cost_pj));
|
||||
constexpr std::array movement{"Unavailable", "Resting", "Moving", "Movement blocked",
|
||||
"Not enough energy to move"};
|
||||
constexpr std::array intake{"Unavailable", "Not feeding", "Food absorbed", "Food patch missing",
|
||||
"Move into contact to feed"};
|
||||
constexpr std::array engulf{"Unavailable",
|
||||
"Not requested",
|
||||
"Prey engulfed",
|
||||
"No eligible prey in contact",
|
||||
"Engulf unsupported here",
|
||||
"Engulf failed: no cell touching yours",
|
||||
"Engulf failed: prey is too large",
|
||||
"Engulf failed: prey's membrane is too thick"};
|
||||
constexpr std::array bud{"Unavailable",
|
||||
"Not requested",
|
||||
"Wildlife bud created",
|
||||
"Cell cannot bud yet",
|
||||
"Not enough resources to bud",
|
||||
"No space for a bud"};
|
||||
ImGui::TextWrapped("%s", movement.at(static_cast<std::size_t>(d.movement)));
|
||||
ImGui::TextWrapped("%s", intake.at(static_cast<std::size_t>(d.intake)));
|
||||
if (const auto& feedback = play->engulf_feedback(); feedback)
|
||||
ImGui::TextWrapped("%s (tick %llu)", engulf.at(static_cast<std::size_t>(feedback->second)),
|
||||
static_cast<unsigned long long>(feedback->first));
|
||||
if (const auto& feedback = play->bud_feedback(); feedback)
|
||||
ImGui::TextWrapped("%s (tick %llu)", bud.at(static_cast<std::size_t>(feedback->second)),
|
||||
static_cast<unsigned long long>(feedback->first));
|
||||
}
|
||||
void cell_food(const PanelView& v, PanelActions& a, FormBuffers& form) {
|
||||
ImGui::TextColored(green, "FEED & SURVIVE");
|
||||
ImGui::Checkbox("Feed automatically", &form.cellular_controls.auto_feed);
|
||||
ImGui::Checkbox("Slow near food", &form.cellular_controls.slow_near_food);
|
||||
ImGui::Checkbox("Precision steering (20%)", &form.cellular_controls.precision);
|
||||
ImGui::SetNextItemWidth(-1);
|
||||
ImGui::SliderInt("##speed", &form.cellular_controls.speed_percent, 1, 100, "Speed: %d%%");
|
||||
disabled_wrapped("Steer onto food. Automatic feeding targets a stocked patch touching your "
|
||||
"cell. Choose a patch below to switch to manual feeding.");
|
||||
const bool active = v.cellular_play && v.cellular_play->fresh() && v.cellular_play->life() != 0;
|
||||
ImGui::BeginDisabled(!active);
|
||||
if (v.cellular_feed_target && ImGui::Button("Stop feeding", {-1, 0}))
|
||||
a.stop_feeding = true;
|
||||
if (const auto* p = v.cellular_perception) {
|
||||
if (p->patches.empty())
|
||||
disabled_wrapped("No food is visible within sensor range.");
|
||||
for (const auto& patch : p->patches) {
|
||||
ImGui::PushID(static_cast<int>(patch.x_um));
|
||||
ImGui::PushID(static_cast<int>(patch.y_um));
|
||||
ImGui::Separator();
|
||||
ImGui::Text("Patch %u / %u um", patch.x_um, patch.y_um);
|
||||
ImGui::Text("%llu pJ", static_cast<unsigned long long>(patch.energy_pj));
|
||||
ImGui::TextWrapped("C %llu / N %llu / P %llu / other %llu fg",
|
||||
static_cast<unsigned long long>(patch.matter_fg[0]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[1]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[2]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[3]));
|
||||
const bool selected = v.cellular_feed_target == std::pair{patch.x_um, patch.y_um};
|
||||
if (selected)
|
||||
ImGui::TextColored(green, "FEEDING TARGET");
|
||||
else if (ImGui::Button("Feed here", {-1, 0}))
|
||||
a.feed_patch = {patch.x_um, patch.y_um};
|
||||
ImGui::PopID();
|
||||
ImGui::PopID();
|
||||
}
|
||||
}
|
||||
ImGui::EndDisabled();
|
||||
}
|
||||
void cell_actions(const PanelView& v, PanelActions& a) {
|
||||
const auto* play = v.cellular_play;
|
||||
ImGui::Separator();
|
||||
ImGui::TextColored(green, "ACT ONCE");
|
||||
ImGui::BeginDisabled(!play || !play->can_act());
|
||||
const float width = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) / 2;
|
||||
if (ImGui::Button("Engulf", {width, px(32)}))
|
||||
a.cell_action = CellAction::engulf;
|
||||
ImGui::SameLine();
|
||||
if (ImGui::Button("Bud", {width, px(32)}))
|
||||
a.cell_action = CellAction::bud;
|
||||
ImGui::EndDisabled();
|
||||
disabled_wrapped("Engulf attempts nearby prey. Bud funds an independent descendant; you keep "
|
||||
"your cell. Automatic feeding resumes after the action tick.");
|
||||
if (!play)
|
||||
return;
|
||||
if (const auto& pending = play->pending(); pending) {
|
||||
ImGui::Separator();
|
||||
cell_record(*pending);
|
||||
if (pending->state == CellActionState::unresolved) {
|
||||
disabled_wrapped("The reply was lost or is unavailable. Checking the original request; "
|
||||
"no second action is created.");
|
||||
if (ImGui::Button("Keep result as unknown", {-1, 0}))
|
||||
a.keep_unknown = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
void cell_evolution(const PanelView& v, PanelActions& a) {
|
||||
const auto* play = v.cellular_play;
|
||||
ImGui::TextColored(green, "LIFE & EVOLUTION");
|
||||
if (!play)
|
||||
return;
|
||||
if (play->life() == 0) {
|
||||
ImGui::Separator();
|
||||
if (const auto& ended = play->ended(); ended) {
|
||||
ImGui::TextColored(amber, "THIS LIFE HAS ENDED");
|
||||
const auto cause = ended->cause;
|
||||
ImGui::TextWrapped("%s", cause == network::CellularDeathReason::starved
|
||||
? "Your cell starved."
|
||||
: cause == network::CellularDeathReason::engulfed
|
||||
? "Your cell was engulfed."
|
||||
: "The cause was not recorded.");
|
||||
ImGui::TextWrapped("Its history and descendants remain. Your next life begins as a new "
|
||||
"primitive cell.");
|
||||
} else {
|
||||
ImGui::TextWrapped("%s", play->birth_pending() ? "Establishing your cell..."
|
||||
: "No active cell is visible.");
|
||||
disabled_wrapped("A missing view alone does not reveal a death cause. A suspended cell "
|
||||
"may still be waiting for space to resume.");
|
||||
}
|
||||
ImGui::BeginDisabled(!play->can_restart());
|
||||
if (ImGui::Button("Start new life", {-1, px(38)}))
|
||||
a.restart_life = true;
|
||||
ImGui::EndDisabled();
|
||||
if (v.remote && !v.remote->cellular_action.empty())
|
||||
ImGui::TextWrapped("%s", v.remote->cellular_action.c_str());
|
||||
return;
|
||||
}
|
||||
const auto& offer = play->offer();
|
||||
if (!offer) {
|
||||
ImGui::Separator();
|
||||
ImGui::TextWrapped("Feed. Adapt. Leave descendants.");
|
||||
disabled_wrapped("Useful feeding earns mutation opportunities. When an offer arrives, "
|
||||
"choose a tradeoff for this life.");
|
||||
ImGui::Spacing();
|
||||
disabled_wrapped("No offer is available yet. Wildlife descendants inherit your genome and "
|
||||
"live independently.");
|
||||
return;
|
||||
}
|
||||
ImGui::TextColored(amber, "MUTATION AVAILABLE");
|
||||
disabled_wrapped("Useful feeding earned this choice. Each change trades a capability against "
|
||||
"upkeep and body mass. The server checks your reserve when it commits.");
|
||||
constexpr std::array capabilities{"Energy conversion", "Membrane", "Movement",
|
||||
"Ingestion", "Reproduction", "Target size",
|
||||
"Thermal tolerance"};
|
||||
constexpr std::array effects{"Increase", "Decrease", "Acquire", "Shed"};
|
||||
for (const auto& c : offer->candidates) {
|
||||
ImGui::PushID(static_cast<int>(c.operator_id));
|
||||
ImGui::Separator();
|
||||
ImGui::TextWrapped("%s %s", effects.at(c.effect), capabilities.at(c.capability));
|
||||
constexpr std::array increase{"Convert more intake into usable energy.",
|
||||
"Build a thicker protective membrane.",
|
||||
"Raise your maximum movement speed.",
|
||||
"Raise how much food you can ingest per second.",
|
||||
"Increase your reproduction capability.",
|
||||
"Grow toward a larger target body mass.",
|
||||
"Widen your temperature tolerance."};
|
||||
constexpr std::array decrease{"Reduce energy conversion capability.",
|
||||
"Build a thinner membrane.",
|
||||
"Lower your maximum movement speed.",
|
||||
"Lower how much food you can ingest per second.",
|
||||
"Reduce your reproduction capability.",
|
||||
"Grow toward a smaller target body mass.",
|
||||
"Narrow your temperature tolerance."};
|
||||
disabled_wrapped(c.effect == 3 ? "Remove this capability from your genome."
|
||||
: c.effect == 2 ? "Add this capability to your genome."
|
||||
: c.effect == 0 ? increase.at(c.capability)
|
||||
: decrease.at(c.capability));
|
||||
constexpr std::array units{"per 1000", "um", "um/s", "fg/s", "per 1000", "fg", "mK"};
|
||||
ImGui::TextWrapped("Successor value %u %s", c.parameter, units.at(c.capability));
|
||||
ImGui::TextWrapped("Maintenance %llu pJ / s\nTotal mass %llu fg",
|
||||
static_cast<unsigned long long>(c.maintenance),
|
||||
static_cast<unsigned long long>(c.total_mass));
|
||||
const auto* perception = v.cellular_perception;
|
||||
const bool affordable =
|
||||
perception && perception->diagnostics && can_fund(c, *perception->diagnostics);
|
||||
ImGui::TextWrapped("Cost: %llu pJ\nC %llu / N %llu / P %llu / other %llu fg",
|
||||
static_cast<unsigned long long>(c.cost_energy_pj),
|
||||
static_cast<unsigned long long>(c.cost_matter_fg[0]),
|
||||
static_cast<unsigned long long>(c.cost_matter_fg[1]),
|
||||
static_cast<unsigned long long>(c.cost_matter_fg[2]),
|
||||
static_cast<unsigned long long>(c.cost_matter_fg[3]));
|
||||
if (!affordable)
|
||||
ImGui::TextColored(amber, "Need more reserves");
|
||||
ImGui::BeginDisabled(!affordable || !play->can_act() || !v.remote ||
|
||||
v.remote->server_tick <= offer->offer_tick);
|
||||
if (ImGui::Button("Choose mutation", {-1, px(30)}))
|
||||
a.mutation = MutationChoice{offer->life_identity, offer->event_index, offer->offer_tick,
|
||||
c.operator_id};
|
||||
ImGui::EndDisabled();
|
||||
ImGui::PopID();
|
||||
}
|
||||
}
|
||||
void cell_log(const PanelView& v, FormBuffers& form) {
|
||||
ImGui::TextColored(green, "ACTION RECORD");
|
||||
if (v.cellular_play) {
|
||||
const auto& records = v.cellular_play->history();
|
||||
if (records.empty())
|
||||
disabled_wrapped("Your discrete action results will appear here.");
|
||||
for (auto it = records.rbegin(); it != records.rend(); ++it) {
|
||||
cell_record(*it);
|
||||
ImGui::Separator();
|
||||
}
|
||||
}
|
||||
if (v.remote) {
|
||||
ImGui::TextWrapped("Region %llu / tick %llu / grants %zu",
|
||||
static_cast<unsigned long long>(v.remote->region),
|
||||
static_cast<unsigned long long>(v.remote->server_tick),
|
||||
v.remote->grants_left);
|
||||
}
|
||||
ImGui::Checkbox("Engineering panels", &form.engineering);
|
||||
disabled_wrapped("On disconnect your biology freezes immediately, but the cell remains "
|
||||
"vulnerable for the 10-second linger before suspension.");
|
||||
}
|
||||
void cellular(const PanelView& v, FormBuffers& form, PanelActions& a) {
|
||||
const auto& io = ImGui::GetIO();
|
||||
const float margin = px(12), top = px(58);
|
||||
const bool compact = io.DisplaySize.x < px(880);
|
||||
const float height = std::max(px(80), io.DisplaySize.y - top - margin);
|
||||
const float left_width = compact ? std::min(px(330), io.DisplaySize.x - 2 * margin) : px(280);
|
||||
const auto flags = ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize |
|
||||
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings;
|
||||
ImGui::SetNextWindowPos({margin, top}, ImGuiCond_Always);
|
||||
ImGui::SetNextWindowSize({left_width, height}, ImGuiCond_Always);
|
||||
ImGui::Begin("Cellular field journal", nullptr, flags);
|
||||
if (ImGui::BeginTabBar("cell-tabs")) {
|
||||
if (ImGui::BeginTabItem("Cell")) {
|
||||
disabled_wrapped(form.cellular_controls.auto_feed ? "AUTO FEED ON / steering in Food"
|
||||
: "MANUAL FEED / steering in Food");
|
||||
cell_vitals(v);
|
||||
cell_actions(v, a);
|
||||
if (v.bindings) {
|
||||
ImGui::Separator();
|
||||
disabled_wrapped(controls_hint(*v.bindings).c_str());
|
||||
}
|
||||
ImGui::EndTabItem();
|
||||
}
|
||||
if (ImGui::BeginTabItem("Food")) {
|
||||
cell_food(v, a, form);
|
||||
ImGui::EndTabItem();
|
||||
}
|
||||
if (compact && ImGui::BeginTabItem("Life")) {
|
||||
cell_evolution(v, a);
|
||||
ImGui::EndTabItem();
|
||||
}
|
||||
if (ImGui::BeginTabItem("Log")) {
|
||||
cell_log(v, form);
|
||||
ImGui::EndTabItem();
|
||||
}
|
||||
ImGui::EndTabBar();
|
||||
}
|
||||
ImGui::End();
|
||||
if (!compact) {
|
||||
ImGui::SetNextWindowPos({io.DisplaySize.x - margin, top}, ImGuiCond_Always, {1, 0});
|
||||
ImGui::SetNextWindowSize({px(300), height}, ImGuiCond_Always);
|
||||
ImGui::Begin("Evolution", nullptr, flags);
|
||||
cell_evolution(v, a);
|
||||
ImGui::End();
|
||||
}
|
||||
}
|
||||
|
||||
// Newest at the bottom right. Each notice wraps its text beside a reserved close
|
||||
// column, so the button is always visible; the stack stops at 60 % of the viewport
|
||||
// height and counts what it could not show (those still expire or can be dismissed
|
||||
@@ -605,9 +934,13 @@ PanelActions draw_panels(const PanelView& view, FormBuffers& form,
|
||||
launcher(view, form, actions);
|
||||
} else {
|
||||
banner(view, actions);
|
||||
legend(view, display);
|
||||
inspector(view);
|
||||
session(view, actions);
|
||||
if (view.remote && view.remote->cellular_trial)
|
||||
cellular(view, form, actions);
|
||||
if (!view.remote || !view.remote->cellular_trial || form.engineering) {
|
||||
legend(view, display);
|
||||
inspector(view);
|
||||
session(view, actions);
|
||||
}
|
||||
}
|
||||
controls(view, actions);
|
||||
notices(view, actions);
|
||||
|
||||
@@ -23,6 +23,8 @@ 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{};
|
||||
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;
|
||||
@@ -45,6 +47,7 @@ struct PanelView {
|
||||
const client::UiState* ui{};
|
||||
std::optional<RemoteStatus> remote;
|
||||
const network::CellularPerception* cellular_perception{};
|
||||
const CellularPlay* cellular_play{};
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> cellular_feed_target;
|
||||
const client::OutcomeLog* outcomes{};
|
||||
int visible_organisms{-1}; // -1 when unknown.
|
||||
@@ -63,6 +66,9 @@ struct PanelActions {
|
||||
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,
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
// M10.5c remote dev session for the engineering client (ADR-0093, over ADR-0091/0092
|
||||
// sessions). Without EVO_CLIENT_NETWORK (a build without EVO_BUILD_QUIC) remote mode is
|
||||
// unavailable. The client only presents copies of replicated snapshots and sends bounded
|
||||
// bounded intentions; the explicit cellular trial uses reliable v9 actions and its
|
||||
// intentions; the explicit cellular trial uses reliable v10 actions and its
|
||||
// owner-filtered perception view. Grant bytes stay inside the session: each is handed to one
|
||||
// connection and wiped here; never printed, shown or persisted.
|
||||
//
|
||||
@@ -31,6 +31,8 @@
|
||||
// is followed with a grant for that region. Grants are picked by their region claim (the
|
||||
// session-grant-v1 layout is public; the claim only routes, the region still verifies), so a
|
||||
// bundle may hold grants for several regions.
|
||||
#include "cellular_controls.hpp"
|
||||
#include "cellular_play.hpp"
|
||||
#include "evo/client/camera.hpp"
|
||||
#include "evo/client/environment_view.hpp"
|
||||
#include "evo/client/input.hpp"
|
||||
@@ -173,14 +175,8 @@ class RemoteSession {
|
||||
session.transport_.authority_pem_file = m.authority_path;
|
||||
session.grants_ = m.grants;
|
||||
session.cellular_trial_ = cellular_trial;
|
||||
session.next_cellular_action_id_ =
|
||||
static_cast<std::uint64_t>(std::chrono::system_clock::now().time_since_epoch().count());
|
||||
if (session.next_cellular_action_id_ == 0)
|
||||
session.next_cellular_action_id_ = 1;
|
||||
session.cellular_birth_request_id_ =
|
||||
session.next_cellular_action_id_ ^ 0x43454C4C00000000ULL;
|
||||
if (session.cellular_birth_request_id_ == 0)
|
||||
session.cellular_birth_request_id_ = 1;
|
||||
session.cellular_play_.initialize(static_cast<std::uint64_t>(
|
||||
std::chrono::system_clock::now().time_since_epoch().count()));
|
||||
session.used_.assign(m.grants.size(), false);
|
||||
// The endpoint typed in the launcher is the first grant's region.
|
||||
session.target_region_ = grant_region(m.grants.front());
|
||||
@@ -212,16 +208,48 @@ class RemoteSession {
|
||||
return cellular_trial_;
|
||||
}
|
||||
[[nodiscard]] const network::CellularPerception* cellular_perception() const noexcept {
|
||||
return client_ && client_->cellular_perception() ? &*client_->cellular_perception()
|
||||
: nullptr;
|
||||
if (!client_)
|
||||
return nullptr;
|
||||
const auto& p = client_->cellular_perception();
|
||||
return p ? &*p : nullptr;
|
||||
}
|
||||
[[nodiscard]] const std::string& cellular_action_status() const noexcept {
|
||||
return cellular_action_status_;
|
||||
}
|
||||
[[nodiscard]] const CellularPlay& cellular_play() const noexcept {
|
||||
return cellular_play_;
|
||||
}
|
||||
[[nodiscard]] bool request_cellular(CellAction kind, MutationChoice choice = {}) {
|
||||
const auto tick = kind == CellAction::mutation
|
||||
? server_tick_
|
||||
: server_tick_ + (sent_tick_ && *sent_tick_ == server_tick_ ? 2 : 1);
|
||||
if (!cellular_trial_ || !cellular_play_.queue(kind, tick, choice))
|
||||
return false;
|
||||
action_check_at_ = {};
|
||||
if (kind != CellAction::mutation)
|
||||
cellular_feed_target_.reset();
|
||||
return true;
|
||||
}
|
||||
[[nodiscard]] bool restart_cellular() {
|
||||
if (!cellular_trial_ || !cellular_play_.restart())
|
||||
return false;
|
||||
cellular_feed_target_.reset();
|
||||
birth_check_at_ = {};
|
||||
return true;
|
||||
}
|
||||
void keep_cellular_unknown() {
|
||||
cellular_play_.keep_unknown();
|
||||
}
|
||||
void set_cellular_controls(CellularControls controls) {
|
||||
cellular_controls_ = controls;
|
||||
}
|
||||
void set_cellular_feed_target(
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> target) noexcept {
|
||||
cellular_feed_target_ = target;
|
||||
}
|
||||
[[nodiscard]] auto cellular_feed_target() const noexcept {
|
||||
return cellular_feed_target_;
|
||||
}
|
||||
[[nodiscard]] RemoteStatus status() const {
|
||||
RemoteStatus s;
|
||||
const bool live = client_ && client_->state() == client::RegionSessionState::established;
|
||||
@@ -329,21 +357,28 @@ class RemoteSession {
|
||||
return;
|
||||
if (!established_)
|
||||
welcome(ui, launcher);
|
||||
if (cellular_trial_ && !cellular_birth_request_sent_ &&
|
||||
c.request_primitive_life(cellular_birth_request_id_))
|
||||
cellular_birth_request_sent_ = true;
|
||||
server_tick_ = c.server_tick();
|
||||
if (server_tick_ != observed_tick_) { // Every watermark or snapshot tick times the clock.
|
||||
observed_tick_ = server_tick_;
|
||||
clock_.observe(server_tick_, now);
|
||||
}
|
||||
if (cellular_trial_)
|
||||
send_cellular(intention);
|
||||
else
|
||||
send(intention);
|
||||
receipts();
|
||||
cellular_results();
|
||||
snapshot();
|
||||
if (cellular_trial_) {
|
||||
const auto old_life = cellular_play_.life();
|
||||
if (const auto& p = c.cellular_perception())
|
||||
cellular_play_.observe(*p);
|
||||
if (const auto& ended = c.life_ended())
|
||||
cellular_play_.observe_end(*ended);
|
||||
cellular_play_.observe_offer(c.mutation_offer());
|
||||
if (old_life != cellular_play_.life())
|
||||
cellular_feed_target_.reset();
|
||||
service_cellular(now);
|
||||
send_cellular(intention);
|
||||
} else {
|
||||
send(intention);
|
||||
}
|
||||
present(now);
|
||||
if (wanted_ && (!sent_interest_ || *wanted_ != *sent_interest_) &&
|
||||
now - interest_at_ >= std::chrono::milliseconds{250} && c.set_interest(*wanted_)) {
|
||||
@@ -413,7 +448,7 @@ class RemoteSession {
|
||||
return false;
|
||||
client::RegionSessionClientConfig config;
|
||||
if (cellular_trial_)
|
||||
config.protocol_version = network::session_protocol_v9;
|
||||
config.protocol_version = network::session_protocol_v10;
|
||||
const auto route = routes_.find(target_region_);
|
||||
config.transport = route != routes_.end() ? route->second : transport_;
|
||||
if (ticket_) { // A handoff: the ticket replaces a grant, once.
|
||||
@@ -462,7 +497,10 @@ class RemoteSession {
|
||||
backoff_ = std::min(backoff_ * 2, std::chrono::seconds{30});
|
||||
}
|
||||
void welcome(client::UiState& ui, client::Launcher& launcher) {
|
||||
const auto& w = *client_->welcome();
|
||||
const auto& welcome_message = client_->welcome();
|
||||
if (!welcome_message)
|
||||
return;
|
||||
const auto& w = *welcome_message;
|
||||
established_ = true;
|
||||
welcomed_ = true;
|
||||
backoff_ = std::chrono::seconds{2};
|
||||
@@ -486,6 +524,8 @@ class RemoteSession {
|
||||
markers_.clear();
|
||||
observed_tick_ = 0;
|
||||
stale_view_ = false;
|
||||
cellular_play_.connected();
|
||||
action_check_at_ = birth_check_at_ = {};
|
||||
launcher.observe(client::ConnectSignal::welcome);
|
||||
notify(ui, "Connected to the dev region (fresh baseline).", client::NoticeLevel::info);
|
||||
std::printf("session welcome session=%llu epoch=%llu tick=%llu\n",
|
||||
@@ -521,15 +561,49 @@ class RemoteSession {
|
||||
}
|
||||
void send_cellular(const client::Intention& intention) {
|
||||
if (server_tick_ == 0 || (sent_tick_ && server_tick_ <= *sent_tick_) ||
|
||||
next_cellular_action_id_ == 0)
|
||||
!cellular_play_.fresh() || cellular_play_.life() == 0 || cellular_play_.ended())
|
||||
return;
|
||||
const auto tick = server_tick_ + 1;
|
||||
if (!client_->send_cellular_action(next_cellular_action_id_, tick, intention.move_x,
|
||||
intention.move_y, cellular_feed_target_))
|
||||
const auto steering = steer_cellular(cellular_controls_, intention, cellular_perception(),
|
||||
organisms_.current(), cellular_feed_target_);
|
||||
cellular_feed_target_ = steering.patch;
|
||||
const auto id = cellular_play_.allocate_id();
|
||||
if (id == 0 ||
|
||||
!client_->send_cellular_action(id, tick, steering.intention.move_x,
|
||||
steering.intention.move_y, cellular_feed_target_))
|
||||
return;
|
||||
++next_cellular_action_id_;
|
||||
sent_tick_ = server_tick_;
|
||||
}
|
||||
void service_cellular(Clock::time_point now) {
|
||||
if (cellular_play_.birth_pending() && now >= birth_check_at_) {
|
||||
if (client_->request_primitive_life(cellular_play_.birth_request()))
|
||||
birth_check_at_ = now + std::chrono::seconds{2};
|
||||
}
|
||||
const auto& pending = cellular_play_.pending();
|
||||
if (!pending || now < action_check_at_)
|
||||
return;
|
||||
const auto& p = *pending;
|
||||
cellular_play_.rechecking(); // A refused retry cannot settle a lost original reply.
|
||||
bool sent = false;
|
||||
if (p.kind == CellAction::mutation) {
|
||||
sent = client_->send_cellular_mutation(p.id, p.tick, p.choice.life, p.choice.event,
|
||||
p.choice.offer_tick, p.choice.operator_id);
|
||||
} else if (p.state == CellActionState::queued) {
|
||||
if (p.tick > server_tick_ + 1)
|
||||
return; // Do not replace a movement/feeding intention already sent this tick.
|
||||
sent = client_->send_cellular_action(
|
||||
p.id, p.tick, 0, 0, {}, p.kind == CellAction::engulf, p.kind == CellAction::bud);
|
||||
if (sent)
|
||||
sent_tick_ = server_tick_; // The discrete intention owns this tick's target.
|
||||
} else {
|
||||
sent = client_->query_action(p.id); // A query can never bud a second time.
|
||||
}
|
||||
if (sent) {
|
||||
if (p.state == CellActionState::queued)
|
||||
cellular_play_.sent();
|
||||
action_check_at_ = now + std::chrono::seconds{2};
|
||||
}
|
||||
}
|
||||
void cellular_results() {
|
||||
for (const auto& receipt : client_->take_primitive_life_receipts())
|
||||
if (receipt.status != network::AdmitStatus::admitted)
|
||||
@@ -537,6 +611,9 @@ class RemoteSession {
|
||||
std::to_string(static_cast<unsigned>(receipt.status)) +
|
||||
")";
|
||||
for (const auto& outcome : client_->take_primitive_life_outcomes()) {
|
||||
if (outcome.request_id != cellular_play_.birth_request())
|
||||
continue;
|
||||
cellular_play_.birth(outcome);
|
||||
switch (outcome.result) {
|
||||
case network::PrimitiveLifeResult::born:
|
||||
cellular_action_status_ =
|
||||
@@ -559,15 +636,18 @@ class RemoteSession {
|
||||
break;
|
||||
case network::PrimitiveLifeResult::unknown:
|
||||
cellular_action_status_ = "Birth outcome is unknown; retrying exact request";
|
||||
cellular_birth_request_sent_ = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (const auto& receipt : client_->take_action_receipts())
|
||||
for (const auto& receipt : client_->take_action_receipts()) {
|
||||
cellular_play_.receipt(receipt);
|
||||
if (receipt.status != network::AdmitStatus::admitted)
|
||||
cellular_action_status_ = cellular_admission_message(receipt.status);
|
||||
for (const auto& outcome : client_->take_action_outcomes())
|
||||
}
|
||||
for (const auto& outcome : client_->take_action_outcomes()) {
|
||||
cellular_play_.outcome(outcome);
|
||||
cellular_action_status_ = cellular_outcome_message(outcome.result, outcome.tick);
|
||||
}
|
||||
}
|
||||
void receipts() {
|
||||
for (const auto& r : client_->take_intention_receipts()) {
|
||||
@@ -716,7 +796,8 @@ class RemoteSession {
|
||||
stale_view_ = was_established || stale_view_;
|
||||
predictor_.reset(); // The marker ended with its session.
|
||||
client_.reset();
|
||||
cellular_birth_request_sent_ = false;
|
||||
cellular_play_.disconnected();
|
||||
cellular_feed_target_.reset();
|
||||
established_ = false;
|
||||
// A crossing or a redirect is followed at once: no grant for a handoff, no pause.
|
||||
if (reason == SessionCloseReason::handed_off && offer && learn_route(offer->destination)) {
|
||||
@@ -809,10 +890,11 @@ class RemoteSession {
|
||||
bool established_{}, welcomed_{}, exhausted_{};
|
||||
bool following_{true}; // The camera follows the server's (default) view.
|
||||
bool cellular_trial_{};
|
||||
std::uint64_t next_cellular_action_id_{}, cellular_birth_request_id_{};
|
||||
CellularPlay cellular_play_;
|
||||
CellularControls cellular_controls_;
|
||||
Clock::time_point action_check_at_{}, birth_check_at_{};
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> cellular_feed_target_;
|
||||
std::string cellular_action_status_;
|
||||
bool cellular_birth_request_sent_{};
|
||||
};
|
||||
#else
|
||||
inline constexpr bool remote_available = false;
|
||||
@@ -839,8 +921,23 @@ class RemoteSession {
|
||||
[[nodiscard]] const std::string& cellular_action_status() const noexcept {
|
||||
return action_status_;
|
||||
}
|
||||
[[nodiscard]] const CellularPlay& cellular_play() const noexcept {
|
||||
return cellular_play_;
|
||||
}
|
||||
[[nodiscard]] bool request_cellular(CellAction, MutationChoice = {}) {
|
||||
return false;
|
||||
}
|
||||
[[nodiscard]] bool restart_cellular() {
|
||||
return false;
|
||||
}
|
||||
void keep_cellular_unknown() {}
|
||||
void set_cellular_controls(CellularControls) {}
|
||||
void set_cellular_feed_target(std::optional<std::pair<std::uint32_t, std::uint32_t>>) noexcept {
|
||||
}
|
||||
[[nodiscard]] std::optional<std::pair<std::uint32_t, std::uint32_t>>
|
||||
cellular_feed_target() const noexcept {
|
||||
return {};
|
||||
}
|
||||
[[nodiscard]] RemoteStatus status() const {
|
||||
RemoteStatus status;
|
||||
status.phase = "unavailable in this build";
|
||||
@@ -857,6 +954,7 @@ class RemoteSession {
|
||||
client::Launcher&) {}
|
||||
|
||||
private:
|
||||
CellularPlay cellular_play_;
|
||||
std::string action_status_;
|
||||
client::EnvironmentLayer environment_;
|
||||
client::OrganismLayer organisms_;
|
||||
|
||||
@@ -122,6 +122,7 @@ if(EVO_BUILD_CLIENT)
|
||||
evo_owned_target(evo-client-organism-tests)
|
||||
add_test(NAME client-organisms COMMAND evo-client-organism-tests)
|
||||
add_executable(evo-client-ui-model-tests tests/client_ui_model.cpp)
|
||||
target_include_directories(evo-client-ui-model-tests PRIVATE "${PROJECT_SOURCE_DIR}/apps/evo-client")
|
||||
target_link_libraries(evo-client-ui-model-tests PRIVATE evo_client_ui)
|
||||
evo_owned_target(evo-client-ui-model-tests)
|
||||
add_test(NAME client-ui-model COMMAND evo-client-ui-model-tests)
|
||||
|
||||
@@ -1,5 +1,15 @@
|
||||
# Project status and next steps
|
||||
|
||||
## Client update - 2026-10-14 (v10)
|
||||
|
||||
The desktop cellular client now negotiates v10, exposes mutations with funded
|
||||
costs, engulf/bud feedback, reserves, death and restart, and retains unresolved
|
||||
requests through reconnect. Automatic feeding, adjustable/precision steering,
|
||||
food approach assistance and a responsive teal interface address playtest
|
||||
usability. See [CLIENT](engineering/CLIENT.md) and the validation entry for
|
||||
checks and remaining live-play/hardware qualification. No deployment or world
|
||||
state change is part of this client update.
|
||||
|
||||
## Current gate - 2026-10-11 (M11.3 exploratory probe)
|
||||
|
||||
The maintainer reports that the Git checks passed, `evo-region` is running, and
|
||||
|
||||
@@ -2,8 +2,9 @@
|
||||
|
||||
This opens a resizable native window showing camera-controlled environment habitats
|
||||
and organisms either from a local in-memory fixture authority or from one dev
|
||||
region over an authenticated dev session. It does not run an ecosystem locally,
|
||||
predict remote state or implement cellular gameplay.
|
||||
region over an authenticated dev session. Cellular play uses the authoritative
|
||||
v10 server; the client presents observations and sends intentions. The separate
|
||||
engineering motion probe predicts only its synthetic marker.
|
||||
Contract: [client architecture](../architecture/CLIENT_ARCHITECTURE.md), ADR-0078.
|
||||
Camera/input: [contracts and limits](CAMERA_INPUT.md), ADR-0079.
|
||||
Environment: [presentation and encodings](ENVIRONMENT_RENDERING.md), ADR-0080.
|
||||
@@ -28,6 +29,69 @@ short notifications expire and can be dismissed.
|
||||
|
||||
## Build and run
|
||||
|
||||
### Cellular v10
|
||||
|
||||
Choose **Cellular play (v10)** before connecting, or add `--cellular` to the
|
||||
connection command. For the current M11.9 DEV opening use grants for world 100,
|
||||
region 4 and fresh playtest accounts (ADR-0123). The client does not deploy or
|
||||
provision a region.
|
||||
|
||||
- **Cell:** energy and C/N/P/other reserves, latest maintenance/movement/intake,
|
||||
and Engulf/Bud buttons. Engulf and Bud are individual requests; automatic feeding
|
||||
resumes after their action tick. The server chooses prey and funds/places descendants. Last observed
|
||||
engulf/bud feedback stays visible with its tick, even after later idle ticks.
|
||||
- **Food:** automatic feeding defaults on and targets the first stocked, contacted
|
||||
patch in the owner's ordered view. Manual selection disables auto-feed; Stop
|
||||
feeding disables it too. Speed (1-100%), precision (20% of selected speed), and
|
||||
Slow near food are local intention preferences. The latter defaults on and limits
|
||||
approach speed toward 500 um/s within 1 mm of a stocked patch, recomputed from the
|
||||
observed phenotype. Protocol integer precision can exceed that cap at extreme
|
||||
speeds. These preferences never change authoritative speed, contact or intake.
|
||||
- **Evolution:** choose one unranked mutation from the owner's earned offer.
|
||||
The current development-2 cellular trial uses per-second capability rates and
|
||||
maintenance; mass is in femtograms. Plain-language descriptions explain each
|
||||
capability change. Construction energy and all four matter costs use the amended
|
||||
v10 candidate records (ADR-0129); choices are disabled when current reserves cannot
|
||||
fund them. The server rechecks funding when the request commits.
|
||||
- **Life ended:** the server's cause, when delivered, and **Start new life**.
|
||||
Each new life uses a new request ID. Duplicate clicks and reconnects reuse the
|
||||
outstanding request, and held world input is cleared while no current life is
|
||||
available. A missing view alone is never presented as a known death.
|
||||
- **Log:** the last eight discrete requests and optional engineering panels.
|
||||
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
|
||||
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
|
||||
current target and dimming while disconnected. The camera starts at a closer 6 mm
|
||||
view and keeps the followed cell beside the journal. Organism shapes and biological
|
||||
colour encodings remain those of ADR-0081 for every controller.
|
||||
|
||||
One discrete request is outstanding at a time. During an automatic reconnect its
|
||||
ID and original payload stay in memory. Bud/engulf recovery queries the original
|
||||
action; mutation recovery repeats the exact selection. A lost reply remains
|
||||
unresolved until an authoritative final result arrives. **Keep result as unknown**
|
||||
retains it in the bounded record and permits another explicit request; it does
|
||||
not cancel the original. Request history is not persisted across app exit or an
|
||||
explicit disconnect to the launcher.
|
||||
|
||||
Existing protocol limits: a mutation result lost across a server restart may
|
||||
remain unresolved (the host's final-choice replay cache is transient); type 27
|
||||
death notices are not a historical death query. Automatic feeding uses observed
|
||||
contact, so a patch crossed entirely between observations can still be missed;
|
||||
slowing near food reduces that risk without predicting authority.
|
||||
|
||||
Coordinate contract discrepancy found during this work: the cellular bridge sends
|
||||
ADR-0102 lower-left footprint coordinates through the general presentation's
|
||||
centre-offset fields. Assistance deliberately interprets only cellular-session
|
||||
coordinates as the bridge sends them. Renderer/bridge geometry changes are deferred:
|
||||
a future scoped contract amendment should either carry an explicit coordinate
|
||||
convention or consistently convert the cellular presentation to centres, updating
|
||||
contact assistance, picking and replication tests together. This upgrade does not
|
||||
silently change the shared organism geometry contract.
|
||||
|
||||
After [explicit SDL preparation](CLIENT_DEPENDENCIES.md), in a compiler shell:
|
||||
|
||||
```sh
|
||||
|
||||
@@ -1,5 +1,41 @@
|
||||
# M9.8b/c UI state, launcher and event bounds
|
||||
|
||||
## Cellular v10 application state
|
||||
|
||||
`apps/evo-client/cellular_play.hpp` owns toolkit-independent presentation state:
|
||||
the current owner life/offer, latest death notice, one outstanding discrete action,
|
||||
and at most eight completed or unresolved records. It never changes biology.
|
||||
Receipts are admission only; outcomes settle a request. A refused retry cannot
|
||||
disprove a lost original reply. Mutation `not_ready` may mean an uncertain durable
|
||||
reservation, so it remains unresolved. IDs never wrap; stale offers, dead lives,
|
||||
unfresh sessions and duplicate clicks cannot submit new choices.
|
||||
|
||||
Reconnect drops the offer until a fresh owner view, cancels unsent queued actions,
|
||||
and retains sent requests for reconciliation. Life changes cannot carry a queued
|
||||
action to the new life. Delayed final replies can update retained unknown records.
|
||||
New lives receive new birth request IDs; retries of an outstanding birth keep its
|
||||
ID. Death messages are deduplicated so a retained notice cannot end a later life.
|
||||
Meaningful engulf/bud diagnostics retain their observed tick and reset on life
|
||||
change. UI does not infer action success from a receipt, empty view or vanished offer.
|
||||
|
||||
`cellular_controls.hpp` selects only stocked patches in observed contact, scales
|
||||
movement intentions for speed/precision/food assistance, and compares every mutation
|
||||
cost channel with the displayed reserve. `cellular_scene.hpp` renders each patch
|
||||
in at most three clipped rectangles; the application reserves that worst-case
|
||||
budget before drawing organisms. No dependency or simulation rule changes.
|
||||
|
||||
The v10 panels consume this state and return actions; the app owns session sends.
|
||||
Cell/Food/Log tabs and a separate Evolution panel replace the default engineering
|
||||
panels in cellular mode. A narrow viewport moves evolution to a Life tab. Log can
|
||||
show the existing engineering panels. The existing platform adapter owns the
|
||||
palette, rounded geometry, embedded font and input capture. `client-ui-model`,
|
||||
`client-remote-session` and `client-panels` exercise state, loopback v10 delivery,
|
||||
production widget clicks, duplicate suppression and bounded layout under NDEBUG.
|
||||
|
||||
`evo-client-panel-tests OUTPUT_DIRECTORY` additionally saves actual rendered
|
||||
review BMPs at 640x480, 960x640 and 1280x800, including the death screen; those use
|
||||
explicit test presentation values and are not evidence of a live DEV playtest.
|
||||
|
||||
Owned, toolkit-independent state; all calls on the client main thread. No authority
|
||||
or simulation state. Time is explicit monotonic milliseconds supplied by the host.
|
||||
|
||||
|
||||
@@ -28,8 +28,9 @@ outcomes. The UI adds a responsive cellular HUD and dark teal theme using the
|
||||
existing toolkit/font. See [CLIENT](CLIENT.md) for operation and protocol limits.
|
||||
|
||||
Human accessibility/hardware checks and first-session/repeated-life observations
|
||||
remain. Existing v10 signals do not provide detailed engulf refusals, full mutation
|
||||
prices, or historical death/result recovery across every server restart.
|
||||
remain. The amended v10 signals now display detailed engulf refusals and mutation
|
||||
prices, with affordability checks. Historical death/result recovery across every
|
||||
server restart remains a protocol limitation.
|
||||
|
||||
## Progress
|
||||
|
||||
|
||||
@@ -7494,3 +7494,38 @@ Executed locally: MSVC Debug 69/69, network 75/75, client-network protocol/QUIC/
|
||||
session/cellular 15/15 (`evo-client.exe` was in use and not relinked); the WSL
|
||||
PostgreSQL C++ suite; g++-14 `-Werror -Wshadow` and clang-tidy-19 on the changed
|
||||
sources and server main; clang-format 19.1.5.
|
||||
|
||||
## 2026-10-14 — desktop v10 play flow and presentation
|
||||
|
||||
Client-only integration of ADR-0121/0125/0127/0129, including the amended 64-byte
|
||||
mutation candidates: choice costs/affordability, per-channel reserves, latched
|
||||
engulf/bud diagnostics, death and restart. Discrete requests preserve their exact
|
||||
identity through reconnect and keep uncertain results explicit. Automatic feeding
|
||||
and speed/precision/food assistance send bounded intentions only. Responsive teal
|
||||
panels, closer framing and three-rectangle food patches use existing dependencies.
|
||||
|
||||
Executed locally:
|
||||
- MSVC Release/NDEBUG `tools/windows-check.ps1 -Preset client-package -Action check`:
|
||||
17/17 passed (117.56 s), including v6-v10 codec, QUIC sessions, remote-session
|
||||
recovery, production panel interaction and client smoke/lifecycle checks.
|
||||
- WSL Ubuntu Clang 19 Release warnings-as-errors build of the client and changed
|
||||
tests; `ctest --test-dir build/tidy-client-network -R
|
||||
'client-(ui-model|panels|remote-session)' --output-on-failure`: 3/3 (37.96 s).
|
||||
- Clang 19 ASan/UBSan `client-asan`: UI model, panels and lifecycle 3/3 (27.21 s).
|
||||
- clang-tidy-19 on changed client translation units, with app headers included:
|
||||
no owned-code findings; the final model/panel rerun also passed.
|
||||
- Repository `format-check` with clang-format 19 and `git diff --check` passed.
|
||||
- Production SDL/ImGui panels rendered with explicit test observations at 640x480,
|
||||
960x640 and 1280x800, plus death screen. Screenshots inspected in
|
||||
`build/v10-review`; UI tests cover mutation/bud/restart clicks, disabled
|
||||
unaffordable choices, duplicate suppression, clipping and scroll bounds.
|
||||
|
||||
Limits: these are loopback and synthetic presentation checks, not a live DEV
|
||||
playtest or hardware/DPI/accessibility qualification. The existing client-network
|
||||
executable was locked by running client sessions; those were left running and the
|
||||
separate client-package preset validated the Windows executable. Initial sandboxed
|
||||
Ninja subprocess startup required rerunning the authorized build outside the
|
||||
sandbox. No new dependency, simulation version/golden, deployment or World0 change.
|
||||
The existing cellular lower-left versus general presentation centre-coordinate
|
||||
discrepancy and proposed scoped resolution are recorded in CLIENT.md; shared
|
||||
organism geometry was not expanded as part of this gate.
|
||||
|
||||
@@ -10,9 +10,10 @@ trial value (ADR-0098, ADR-0120, ADR-0124, ADR-0125, ADR-0128).
|
||||
- A DEV region provisioned with the `cellular-v4` opening (rules 5: engulfment,
|
||||
detritus, budding wildlife, offline freeze) on a server image that passed CI.
|
||||
- An engineering client with the v10 path: movement, feeding, engulf, bud, the
|
||||
mutation offer and chooser, and the death and restart flow. Those screens are the
|
||||
maintainer's (M11.8 client half); a session without them tests less, and the
|
||||
notes must say which were present.
|
||||
mutation offer and chooser, and the death and restart flow. These screens are now
|
||||
implemented (see CLIENT.md), including amended v10 costs and engulf reasons.
|
||||
Record the client build and steering/feeding assistance settings; older clients
|
||||
test less, and the notes must say which screens were present.
|
||||
- A fresh grant bundle per participant (`renew-dev-m10.sh` output) and a three-hour
|
||||
session window.
|
||||
|
||||
|
||||
@@ -46,6 +46,37 @@ struct Toolkit {
|
||||
// scales with the window, which the bitmap font cannot do cleanly.
|
||||
if (io.Fonts->AddFontDefaultVector() == nullptr)
|
||||
return false;
|
||||
auto& style = ImGui::GetStyle();
|
||||
style.WindowRounding = 12;
|
||||
style.ChildRounding = 8;
|
||||
style.FrameRounding = 6;
|
||||
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.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_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_TabHovered] = colors[ImGuiCol_ButtonHovered];
|
||||
base_style = ImGui::GetStyle();
|
||||
platform = ImGui_ImplSDL3_InitForSDLRenderer(window, target);
|
||||
return platform && attach_renderer(target);
|
||||
|
||||
@@ -286,13 +286,15 @@ void toolkit_capture() {
|
||||
int presses = 0;
|
||||
bool text_focus = false;
|
||||
std::array<char, 32> text{}, field{};
|
||||
ImVec2 field_min{}, field_max{};
|
||||
ImVec2 field_min{}, field_max{}, button_centre{};
|
||||
app->set_overlay([&] {
|
||||
ImGui::SetNextWindowPos({0, 0}, ImGuiCond_Always);
|
||||
ImGui::SetNextWindowSize({150, 150}, ImGuiCond_Always);
|
||||
ImGui::SetNextWindowSize({180, 190}, ImGuiCond_Always);
|
||||
ImGui::Begin("panel", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
|
||||
if (ImGui::Button("Press", {130, 40}))
|
||||
++presses;
|
||||
const auto button_min = ImGui::GetItemRectMin(), button_max = ImGui::GetItemRectMax();
|
||||
button_centre = {(button_min.x + button_max.x) / 2, (button_min.y + button_max.y) / 2};
|
||||
ImGui::InputText("field", field.data(), field.size());
|
||||
field_min = ImGui::GetItemRectMin();
|
||||
field_max = ImGui::GetItemRectMax();
|
||||
@@ -331,7 +333,7 @@ void toolkit_capture() {
|
||||
// Over the widget: the button activates once, the world sees no click.
|
||||
// The panel exists before the user clicks (as every application panel does).
|
||||
CHECK(app->present(frame) == Step::rendered && app->present(frame) == Step::rendered);
|
||||
CHECK(!click(60, 30) && presses == 1 && app->ui_wants_pointer());
|
||||
CHECK(!click(button_centre.x, button_centre.y) && presses == 1 && app->ui_wants_pointer());
|
||||
// Open world: a click is delivered once, then consumed.
|
||||
const auto world = click(260, 200);
|
||||
CHECK(world && world->x == 260 && world->y == 200 && presses == 1);
|
||||
@@ -347,9 +349,9 @@ void toolkit_capture() {
|
||||
// nothing and the widget still activates on the toolkit's next frames.
|
||||
mouse(SDL_EVENT_MOUSE_MOTION, 260, 200);
|
||||
CHECK(app->poll_events() && app->present(frame) == Step::rendered && !app->ui_wants_pointer());
|
||||
mouse(SDL_EVENT_MOUSE_MOTION, 60, 30);
|
||||
mouse(SDL_EVENT_MOUSE_BUTTON_DOWN, 60, 30);
|
||||
mouse(SDL_EVENT_MOUSE_BUTTON_UP, 60, 30);
|
||||
mouse(SDL_EVENT_MOUSE_MOTION, button_centre.x, button_centre.y);
|
||||
mouse(SDL_EVENT_MOUSE_BUTTON_DOWN, button_centre.x, button_centre.y);
|
||||
mouse(SDL_EVENT_MOUSE_BUTTON_UP, button_centre.x, button_centre.y);
|
||||
CHECK(app->poll_events() && !app->take_navigation().click);
|
||||
for (int i = 0; i < 5 && presses == 1; ++i)
|
||||
CHECK(app->present(frame) == Step::rendered && app->poll_events());
|
||||
|
||||
+167
-1
@@ -2,8 +2,10 @@
|
||||
// software renderer, pinned toolkit). Notices fit their fixed-width window with a
|
||||
// visible close button; clicking it (move + press + release in one batch, no settling
|
||||
// frame) dismisses exactly that notice and never reaches the world.
|
||||
#include "cellular_scene.hpp"
|
||||
#include "controls_flow.hpp"
|
||||
#include "evo/client/application.hpp"
|
||||
#include "evo/render/organism.hpp"
|
||||
#include "panels.hpp"
|
||||
#include <SDL3/SDL.h>
|
||||
#include <array>
|
||||
@@ -25,6 +27,11 @@ void check(bool ok, std::source_location at = std::source_location::current()) {
|
||||
throw std::runtime_error("client panels line " + std::to_string(at.line()));
|
||||
}
|
||||
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
||||
template <class T> const T& required(const std::optional<T>& value) {
|
||||
if (!value)
|
||||
throw std::runtime_error("missing panel test value");
|
||||
return *value;
|
||||
}
|
||||
SDL_Window* window() {
|
||||
int count{};
|
||||
SDL_Window** windows = SDL_GetWindows(&count);
|
||||
@@ -349,12 +356,171 @@ void apply_save_restart() {
|
||||
CHECK(intention && intention->move_x == -1000);
|
||||
std::filesystem::remove_all(dir);
|
||||
}
|
||||
void cellular_panels(const std::filesystem::path& review) {
|
||||
for (const auto size : {std::pair{960, 640}, std::pair{1280, 800}, std::pair{640, 480}}) {
|
||||
const auto [width, height] = size;
|
||||
auto opened = Application::open({width, height, false, "software"});
|
||||
CHECK(opened);
|
||||
auto app = std::move(*opened);
|
||||
const auto id = SDL_GetWindowID(window());
|
||||
SDL_Event focus{};
|
||||
focus.type = SDL_EVENT_WINDOW_FOCUS_GAINED;
|
||||
focus.window.windowID = id;
|
||||
CHECK(SDL_PushEvent(&focus) && app->poll_events());
|
||||
std::vector<render::Rectangle> boxes{
|
||||
{0, 0, static_cast<float>(width), static_cast<float>(height), {8, 19, 25, 255}}};
|
||||
const auto camera =
|
||||
Camera::create({width, height, width, height}, {width < 880 ? 0.29 : 2.1, 3.29}, 100);
|
||||
CHECK(camera);
|
||||
for (int x = 0; x < 5; ++x)
|
||||
for (int y = 0; y < 6; ++y) {
|
||||
const auto low =
|
||||
camera->world_to_screen({static_cast<double>(x), static_cast<double>(y)});
|
||||
const auto high = camera->world_to_screen({x + 1.0, y + 1.0});
|
||||
CHECK(low && high);
|
||||
patch_box(boxes, *low, *high, (x + y) % 4 != 0, x == 2 && y == 3, width, height);
|
||||
}
|
||||
OrganismCell organism;
|
||||
organism.id = 901;
|
||||
organism.x = {2200};
|
||||
organism.y = {3200};
|
||||
organism.phenotype.extent = 300;
|
||||
organism.phenotype.total_mass = 10000;
|
||||
organism.phenotype.structural_mass = 9000;
|
||||
organism.phenotype.membrane_mass = 1000;
|
||||
organism.phenotype.conversion_per_thousand = 650;
|
||||
organism.phenotype.movement_speed = 500;
|
||||
organism.phenotype.ingestion_rate = 400;
|
||||
organism.growth.realized_per_thousand = 1000;
|
||||
const auto population =
|
||||
OrganismPresentation::create({{100, 1}, 102, 1}, 0, std::array{organism});
|
||||
CHECK(population);
|
||||
CHECK(render::append_organisms(boxes, 100, &*population, Freshness::current, *camera));
|
||||
const auto frame = render::Frame::create(boxes);
|
||||
CHECK(frame);
|
||||
UiState ui;
|
||||
Launcher launch;
|
||||
Selection selection;
|
||||
EnvironmentLayer environment;
|
||||
OrganismLayer organisms;
|
||||
CellularPlay play;
|
||||
play.initialize(100);
|
||||
play.connected();
|
||||
network::CellularLifeDiagnostics diagnostics;
|
||||
diagnostics.reserve_energy_pj = 248000;
|
||||
diagnostics.reserve_matter_fg = {15000, 2400, 800, 6000};
|
||||
diagnostics.has_tick_effects = true;
|
||||
diagnostics.maintenance_cost_pj = 80;
|
||||
diagnostics.movement_cost_pj = 20;
|
||||
diagnostics.movement = network::CellularMovementResult::moved;
|
||||
diagnostics.intake = network::CellularIntakeResult::acquired;
|
||||
diagnostics.engulf = network::CellularEngulfResult::membrane_too_thick;
|
||||
network::CellularPerception perception{
|
||||
102, 901, {{1000, 2000, 50000, {100, 20, 10, 40}}}, diagnostics};
|
||||
play.observe(perception);
|
||||
play.observe_offer(network::CellularMutationOffer{
|
||||
102,
|
||||
901,
|
||||
1,
|
||||
100,
|
||||
{{3, 2, 0, 500, 1600, 22000, 1200, {100, 20, 10, 40}},
|
||||
{5, 1, 0, 2, 2000, 26000, 5000, {500, 80, 20, 120}},
|
||||
{8, 3, 0, 400, 1800, 24000, 300000, {400, 60, 20, 100}}}});
|
||||
FormBuffers form;
|
||||
render::EnvironmentDisplay display;
|
||||
PanelView view;
|
||||
view.mode = Mode::remote;
|
||||
view.launcher = &launch;
|
||||
view.environment = &environment;
|
||||
view.organisms = &organisms;
|
||||
view.selection = &selection;
|
||||
view.ui = &ui;
|
||||
view.bindings = &app->bindings();
|
||||
view.cellular_perception = &perception;
|
||||
view.cellular_play = &play;
|
||||
view.remote.emplace();
|
||||
view.remote->phase = "connected";
|
||||
view.remote->cellular_trial = true;
|
||||
view.remote->server_tick = 102;
|
||||
view.remote->region = 4;
|
||||
PanelActions action;
|
||||
app->set_overlay([&] { action = draw_panels(view, form, display); });
|
||||
const auto draw = [&] {
|
||||
CHECK(app->poll_events() && app->present(*frame) == Step::rendered);
|
||||
};
|
||||
for (int i = 0; i < 3; ++i)
|
||||
draw();
|
||||
const 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));
|
||||
if (!review.empty()) {
|
||||
std::filesystem::create_directories(review);
|
||||
CHECK(app->request_screenshot(
|
||||
(review / ("cellular-" + std::to_string(width) + ".bmp")).string()));
|
||||
draw();
|
||||
}
|
||||
if (width != 960)
|
||||
continue;
|
||||
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));
|
||||
// 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;
|
||||
for (int offset = 90; static_cast<float>(offset) < panel->Size.y - 10; offset += 5) {
|
||||
const float y = panel->Pos.y + static_cast<float>(offset);
|
||||
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) {
|
||||
CHECK(app->present(*frame) == Step::rendered && app->poll_events());
|
||||
if (done())
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
auto depleted = diagnostics;
|
||||
depleted.reserve_energy_pj = 0;
|
||||
perception.diagnostics = depleted;
|
||||
draw();
|
||||
CHECK(!probe(evolution, 0.5F, [&] { return action.mutation.has_value(); }));
|
||||
perception.diagnostics = diagnostics;
|
||||
draw();
|
||||
CHECK(probe(evolution, 0.5F, [&] { return action.mutation.has_value(); }));
|
||||
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(); }));
|
||||
play.outcome({mutation_id, network::ActionResult::committed, 103, 5});
|
||||
draw();
|
||||
CHECK(probe(journal, 0.75F, [&] { return action.cell_action == CellAction::bud; }));
|
||||
play.observe_end({104, 901, network::CellularDeathReason::engulfed});
|
||||
perception = {104, 0, {}, {}};
|
||||
play.observe(perception);
|
||||
draw();
|
||||
if (!review.empty()) {
|
||||
CHECK(app->request_screenshot((review / "cellular-death.bmp").string()));
|
||||
draw();
|
||||
}
|
||||
CHECK(probe(evolution, 0.5F, [&] { return action.restart_life; }));
|
||||
CHECK(play.restart());
|
||||
draw();
|
||||
CHECK(!probe(evolution, 0.5F, [&] { return action.restart_life; }));
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() try {
|
||||
int main(int argc, char** argv) try {
|
||||
notices();
|
||||
controls_panel();
|
||||
apply_save_restart();
|
||||
cellular_panels(argc == 2 ? std::filesystem::path{argv[1]} : std::filesystem::path{});
|
||||
std::puts("client panel tests passed");
|
||||
return 0;
|
||||
} catch (const std::exception& e) {
|
||||
|
||||
@@ -36,6 +36,11 @@ void check(bool ok, std::source_location at = std::source_location::current()) {
|
||||
throw std::runtime_error("client remote session line " + std::to_string(at.line()));
|
||||
}
|
||||
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
||||
template <class T> const T& required(const std::optional<T>& value) {
|
||||
if (!value)
|
||||
throw std::runtime_error("missing remote client test value");
|
||||
return *value;
|
||||
}
|
||||
constexpr std::string_view name = "dev-region.evolution.test";
|
||||
constexpr world::WorldIdentity world_id{7, 3};
|
||||
constexpr std::uint64_t region = 12;
|
||||
@@ -97,7 +102,9 @@ client::EnvironmentCell cell(std::int64_t x, std::int64_t y, std::uint64_t quant
|
||||
|
||||
// A region on loopback with a 21 x 21 slice (x, y in -10..10 at z -7), one snapshot per tick.
|
||||
struct Region {
|
||||
explicit Region(const Files& f) : files{f} {
|
||||
explicit Region(const Files& f,
|
||||
const std::function<void(server::RegionSessionsConfig&)>& configure = {})
|
||||
: files{f} {
|
||||
server::RegionSessionsConfig c;
|
||||
c.transport.certificate_pem_file = f.certificate.string();
|
||||
c.transport.key_pem_file = f.key.string();
|
||||
@@ -107,13 +114,17 @@ struct Region {
|
||||
c.control.epoch = epoch;
|
||||
c.control.max_account_attempts = 16;
|
||||
c.issuer_keys.push_back({1, *key.public_key()});
|
||||
if (configure)
|
||||
configure(c);
|
||||
const bool cellular = c.accept_cellular_actions;
|
||||
auto made = server::RegionSessions::create(std::move(c));
|
||||
CHECK(made.has_value());
|
||||
sessions = std::move(*made);
|
||||
sessions->set_default_interest({3, 3, -7, 7});
|
||||
// Probe markers (ADR-0094) over the slice's cells, spawning in the middle of (3, 3).
|
||||
CHECK(sessions->set_motion_area({-10'000'000, -10'000'000, 10'999'999, 10'999'999, -7},
|
||||
3'500'000, 3'500'000));
|
||||
if (!cellular)
|
||||
CHECK(sessions->set_motion_area({-10'000'000, -10'000'000, 10'999'999, 10'999'999, -7},
|
||||
3'500'000, 3'500'000));
|
||||
}
|
||||
WireGrant grant(const AccountId& who, std::uint64_t serial,
|
||||
std::uint64_t in_region = region) const {
|
||||
@@ -153,11 +164,14 @@ struct Region {
|
||||
});
|
||||
}
|
||||
static_cast<void>(sessions->take_events());
|
||||
if (after_poll)
|
||||
after_poll();
|
||||
}
|
||||
const Files& files;
|
||||
GrantSigningKey key = *GrantSigningKey::import(DeploymentEnvironment::dev, 1, scalar());
|
||||
std::unique_ptr<server::RegionSessions> sessions;
|
||||
std::uint64_t epoch{3}, tick{100}, replicated{};
|
||||
std::function<void()> after_poll;
|
||||
};
|
||||
|
||||
struct Client {
|
||||
@@ -488,6 +502,145 @@ void crossing_regions(const Files& f) {
|
||||
CHECK(a.phase() == LaunchPhase::failed && world.probes.at(dana).owner == 2);
|
||||
CHECK(db1.claims == region1_claims && db2.claims == region2_claims + 1);
|
||||
}
|
||||
// Real RemoteSession over QUIC; the fixture records authority answers without simulating biology.
|
||||
void cellular_v10(const Files& files) {
|
||||
using namespace evo::client_app;
|
||||
struct Ledger final : ActionLedger {
|
||||
std::map<std::uint64_t, DurableActionRecord> records;
|
||||
std::expected<std::optional<ActionOutcome>, ActionLedgerError>
|
||||
find(const AccountId&, std::uint64_t id) override {
|
||||
return records.contains(id) ? std::optional{records.at(id).outcome} : std::nullopt;
|
||||
}
|
||||
std::expected<std::optional<DurableActionRecord>, ActionLedgerError>
|
||||
find_record(const AccountId&, std::uint64_t id) override {
|
||||
return records.contains(id) ? std::optional{records.at(id)} : std::nullopt;
|
||||
}
|
||||
} ledger;
|
||||
test::WorldDb world;
|
||||
test::RegionDb control{world, region};
|
||||
std::vector<CellularMutationAction> mutations;
|
||||
std::vector<std::uint64_t> births;
|
||||
std::uint64_t life = 0, next_life = 901;
|
||||
bool resolve_mutation = false;
|
||||
const auto owner = account(0xD0);
|
||||
Region r{files, [&](server::RegionSessionsConfig& config) {
|
||||
config.ledger = &control;
|
||||
config.actions = &ledger;
|
||||
config.accept_cellular_actions = true;
|
||||
config.create_primitive_life = [&](const AccountId& a, std::uint64_t generation,
|
||||
std::uint64_t id) {
|
||||
CHECK(a == owner && generation != 0);
|
||||
births.push_back(id);
|
||||
life = next_life;
|
||||
return PrimitiveLifeOutcome{id, PrimitiveLifeResult::born, life, 1};
|
||||
};
|
||||
config.query_primitive_life = config.create_primitive_life;
|
||||
config.select_cellular_mutation = [&](const AccountId& a, std::uint64_t generation,
|
||||
const CellularMutationAction& m) {
|
||||
CHECK(a == owner && generation != 0);
|
||||
mutations.push_back(m);
|
||||
return server::CellularMutationAnswer{
|
||||
resolve_mutation ? AdmitStatus::duplicate : AdmitStatus::admitted, 102,
|
||||
resolve_mutation ? std::optional{ActionOutcome{
|
||||
m.action_id, ActionResult::committed, 102, 3}}
|
||||
: std::nullopt};
|
||||
};
|
||||
}};
|
||||
std::uint64_t sent_view{}, view_session{}, sent_life{};
|
||||
bool offer = true;
|
||||
r.after_poll = [&] {
|
||||
const auto session = r.sessions->holder(owner);
|
||||
if (!session || (sent_view == r.tick && view_session == *session && sent_life == life))
|
||||
return;
|
||||
sent_view = r.tick;
|
||||
view_session = *session;
|
||||
sent_life = life;
|
||||
CHECK(r.sessions->send_cellular_perception(
|
||||
owner,
|
||||
{r.tick, life, {}, life ? std::optional{CellularLifeDiagnostics{}} : std::nullopt}));
|
||||
if (offer && life != 0)
|
||||
CHECK(r.sessions->send_mutation_offer(owner,
|
||||
{r.tick, life, 1, 99, {{3, 2, 0, 50, 20, 30}}}));
|
||||
};
|
||||
Client c;
|
||||
CHECK(c.host.connect(
|
||||
RemoteSession::open(r.material({r.grant(owner, 1), r.grant(owner, 2)}), true)));
|
||||
CHECK(c.until(r, [&] { return c.host.session()->cellular_play().offer().has_value(); }));
|
||||
auto& remote = *c.host.session();
|
||||
CHECK(!births.empty() && remote.cellular_play().life() == 901);
|
||||
CHECK(remote.request_cellular(CellAction::mutation, {901, 1, 99, 3}));
|
||||
CHECK(!remote.request_cellular(CellAction::mutation, {901, 1, 99, 3}));
|
||||
CHECK(c.until(r, [&] {
|
||||
return !mutations.empty() &&
|
||||
required(remote.cellular_play().pending()).state == CellActionState::admitted;
|
||||
}));
|
||||
const auto original = mutations.front();
|
||||
r.sessions->shutdown(Clock::now());
|
||||
CHECK(c.until(r, [&] { return remote.status().phase == "reconnecting"; }));
|
||||
CHECK(!remote.request_cellular(CellAction::bud));
|
||||
resolve_mutation = true;
|
||||
CHECK(c.until(r, [&] { return !remote.cellular_play().history().empty(); }, 20));
|
||||
CHECK(mutations.size() >= 2 && mutations.back().action_id == original.action_id &&
|
||||
mutations.back().life_identity == original.life_identity &&
|
||||
mutations.back().tick == original.tick &&
|
||||
mutations.back().operator_id == original.operator_id && births.size() == 1);
|
||||
CHECK(remote.cellular_play().history().back().state == CellActionState::committed);
|
||||
// No patch coordinates or intake accompany a bud; one request creates one carried action.
|
||||
remote.set_cellular_feed_target({{1000, 2000}});
|
||||
CHECK(remote.request_cellular(CellAction::bud));
|
||||
CHECK(!remote.cellular_feed_target());
|
||||
const auto bud_id = required(remote.cellular_play().pending()).id;
|
||||
std::optional<CarriedAction> bud;
|
||||
CHECK(c.until(
|
||||
r,
|
||||
[&] {
|
||||
for (const auto& carried : r.sessions->carry(r.tick + 1))
|
||||
if (carried.action_id == bud_id)
|
||||
bud = carried;
|
||||
return bud.has_value();
|
||||
},
|
||||
20));
|
||||
CHECK(required(bud).cellular_input);
|
||||
const auto input = decode_cellular_action_input(required(required(bud).cellular_input));
|
||||
CHECK(input && input->bud && !input->engulf && !input->has_intake_target);
|
||||
ledger.records.emplace(
|
||||
bud_id, DurableActionRecord{{bud_id, ActionResult::committed, required(bud).tick, 4},
|
||||
required(bud).cellular_input});
|
||||
r.sessions->committed(std::span{&required(bud), 1}, 4);
|
||||
CHECK(c.until(r, [&] { return !remote.cellular_play().pending(); }));
|
||||
CHECK(remote.cellular_play().history().back().id == bud_id);
|
||||
CHECK(remote.request_cellular(CellAction::engulf));
|
||||
const auto engulf_id = required(remote.cellular_play().pending()).id;
|
||||
std::optional<CarriedAction> engulf;
|
||||
CHECK(c.until(
|
||||
r,
|
||||
[&] {
|
||||
for (const auto& carried : r.sessions->carry(r.tick + 1))
|
||||
if (carried.action_id == engulf_id)
|
||||
engulf = carried;
|
||||
return engulf.has_value();
|
||||
},
|
||||
20));
|
||||
CHECK(required(engulf).cellular_input);
|
||||
const auto engulf_input =
|
||||
decode_cellular_action_input(required(required(engulf).cellular_input));
|
||||
CHECK(engulf_input && engulf_input->engulf && !engulf_input->bud &&
|
||||
!engulf_input->has_intake_target);
|
||||
r.sessions->dropped(std::span{&required(engulf), 1}, true);
|
||||
CHECK(c.until(r, [&] { return !remote.cellular_play().pending(); }));
|
||||
// Death and a fresh request on the same connection. Repeated UI clicks issue only one.
|
||||
offer = false;
|
||||
life = 0;
|
||||
++r.tick;
|
||||
CHECK(r.sessions->send_life_ended(owner, {r.tick, 901, CellularDeathReason::starved}));
|
||||
CHECK(c.until(r, [&] { return remote.cellular_play().can_restart(); }));
|
||||
CHECK(required(remote.cellular_play().ended()).cause == CellularDeathReason::starved);
|
||||
CHECK(remote.restart_cellular() && !remote.restart_cellular());
|
||||
next_life = 902;
|
||||
++r.tick;
|
||||
CHECK(c.until(r, [&] { return births.size() == 2 && remote.cellular_play().life() == 902; }));
|
||||
CHECK(births[0] != births[1] && !remote.cellular_play().ended());
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() try {
|
||||
@@ -526,6 +679,7 @@ int main() try {
|
||||
refusals(r);
|
||||
}
|
||||
crossing_regions(files);
|
||||
cellular_v10(files);
|
||||
std::filesystem::remove_all(files.dir);
|
||||
std::puts("client remote session tests passed");
|
||||
return 0;
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
// M9.8c toolkit-independent UI model: labels keep data states distinct, selection
|
||||
// follows presentations, the launcher bounds credentials and errors, and the outcome
|
||||
// log stays bounded.
|
||||
#include "cellular_controls.hpp"
|
||||
#include "cellular_play.hpp"
|
||||
#include "cellular_scene.hpp"
|
||||
#include "evo/client/labels.hpp"
|
||||
#include "evo/client/launcher.hpp"
|
||||
#include "evo/client/outcome_log.hpp"
|
||||
@@ -25,6 +28,11 @@ void check(bool ok, std::source_location at = std::source_location::current()) {
|
||||
throw std::runtime_error("client UI model line " + std::to_string(at.line()));
|
||||
}
|
||||
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
||||
template <class T> const T& required(const std::optional<T>& value) {
|
||||
if (!value)
|
||||
throw std::runtime_error("missing client model test value");
|
||||
return *value;
|
||||
}
|
||||
constexpr world::WorldIdentity identity{3, 9};
|
||||
|
||||
EnvironmentCell cell(std::int64_t x) {
|
||||
@@ -69,6 +77,56 @@ OrganismPresentation organisms(std::vector<OrganismCell> cells, std::uint64_t ti
|
||||
return std::move(*p);
|
||||
}
|
||||
|
||||
void cellular_assistance() {
|
||||
using namespace client_app;
|
||||
auto own = organism(42, 980);
|
||||
own.y = {2000};
|
||||
own.phenotype.movement_speed = 10000;
|
||||
auto population = organisms({own});
|
||||
network::CellularPerception view{2, 42, {{1000, 2000, 100, {}}}, {}};
|
||||
CellularControls controls;
|
||||
const Intention diagonal{1, 2, 707, -707};
|
||||
auto steering = steer_cellular(controls, diagonal, &view, &population, {});
|
||||
CHECK(steering.patch == std::pair<std::uint32_t, std::uint32_t>{1000, 2000});
|
||||
CHECK(steering.intention.move_x == 35 && steering.intention.move_y == -35);
|
||||
own.x = {979};
|
||||
population = organisms({own});
|
||||
CHECK(!steer_cellular(controls, diagonal, &view, &population, {}).patch);
|
||||
controls.slow_near_food = false;
|
||||
controls.precision = true;
|
||||
controls.speed_percent = 50;
|
||||
steering = steer_cellular(controls, diagonal, &view, &population, {});
|
||||
CHECK(steering.intention.move_x == 70 && steering.intention.move_y == -70);
|
||||
controls.auto_feed = false;
|
||||
CHECK(steer_cellular(controls, {}, &view, &population, {{9000, 9000}}).patch ==
|
||||
std::pair<std::uint32_t, std::uint32_t>{9000, 9000});
|
||||
controls.auto_feed = true;
|
||||
view.patches[0].energy_pj = 0;
|
||||
own.x = {1000};
|
||||
population = organisms({own});
|
||||
CHECK(!steer_cellular(controls, {}, &view, &population, {}).patch);
|
||||
view.patches[0].matter_fg[2] = 1;
|
||||
CHECK(steer_cellular(controls, {}, &view, &population, {}).patch);
|
||||
view.life_identity = 0;
|
||||
CHECK(!steer_cellular(controls, {}, &view, &population, {}).patch);
|
||||
network::CellularOfferedCandidate candidate;
|
||||
candidate.cost_energy_pj = 10;
|
||||
candidate.cost_matter_fg = {1, 2, 3, 4};
|
||||
network::CellularLifeDiagnostics reserve;
|
||||
reserve.reserve_energy_pj = 10;
|
||||
reserve.reserve_matter_fg = {1, 2, 3, 4};
|
||||
CHECK(can_fund(candidate, reserve));
|
||||
reserve.reserve_matter_fg[3] = 3;
|
||||
CHECK(!can_fund(candidate, reserve));
|
||||
reserve.reserve_matter_fg[3] = 4;
|
||||
reserve.reserve_energy_pj = 9;
|
||||
CHECK(!can_fund(candidate, reserve));
|
||||
std::vector<render::Rectangle> scene;
|
||||
patch_box(scene, {-10, 100}, {100, -10}, true, true, 80, 80);
|
||||
CHECK(scene.size() == patch_rectangles);
|
||||
for (const auto& r : scene)
|
||||
CHECK(r.x >= 0 && r.y >= 0 && r.x + r.width <= 80 && r.y + r.height <= 80);
|
||||
}
|
||||
void labels() {
|
||||
const auto c = cell(0);
|
||||
const auto water = describe_field(c, world::Field::water);
|
||||
@@ -332,6 +390,81 @@ void session_host() {
|
||||
CHECK(!host.connect(FakeSession{server}));
|
||||
CHECK(server.alive == 0 && host.session() == nullptr);
|
||||
}
|
||||
void cellular_play() {
|
||||
using namespace evo::client_app;
|
||||
using namespace evo::network;
|
||||
CellularPlay play;
|
||||
play.initialize(100);
|
||||
CHECK(play.birth_request() == 100 && play.birth_pending());
|
||||
play.connected();
|
||||
play.observe({101, 900, {}, CellularLifeDiagnostics{}});
|
||||
CHECK(play.can_act() && !play.can_restart());
|
||||
CellularLifeDiagnostics feedback;
|
||||
feedback.has_tick_effects = true;
|
||||
feedback.bud = CellularBudOutcome::insufficient_funding;
|
||||
play.observe({101, 900, {}, feedback});
|
||||
play.observe({102, 900, {}, CellularLifeDiagnostics{}});
|
||||
CHECK(play.bud_feedback() ==
|
||||
std::pair{std::uint64_t{101}, CellularBudOutcome::insufficient_funding});
|
||||
const CellularMutationOffer offer{101, 900, 1, 100, {{3, 2, 0, 50, 20, 30}}};
|
||||
play.observe_offer(offer);
|
||||
CHECK(!play.queue(CellAction::mutation, 102, {900, 2, 100, 3}));
|
||||
CHECK(!play.queue(CellAction::mutation, 100, {900, 1, 100, 3}));
|
||||
CHECK(!play.queue(CellAction::mutation, 102, {900, 1, 100, 8}));
|
||||
CHECK(play.queue(CellAction::mutation, 102, {900, 1, 100, 3}));
|
||||
const auto id = required(play.pending()).id;
|
||||
CHECK(!play.queue(CellAction::bud, 102)); // Double clicks cannot create another action.
|
||||
play.sent();
|
||||
play.receipt({id, AdmitStatus::not_ready, 101, 0});
|
||||
CHECK(required(play.pending()).state == CellActionState::unresolved);
|
||||
play.disconnected();
|
||||
CHECK(!play.can_act() && !play.offer());
|
||||
play.connected();
|
||||
CHECK(!play.can_act());
|
||||
play.observe({103, 900, {}, CellularLifeDiagnostics{}});
|
||||
play.receipt({id, AdmitStatus::invalid_action, 103, 0});
|
||||
CHECK(required(play.pending()).state ==
|
||||
CellActionState::unresolved); // Refused retry != failed original.
|
||||
play.outcome({id, ActionResult::committed, 102, 1});
|
||||
CHECK(!play.pending() && play.history().back().state == CellActionState::committed);
|
||||
CHECK(play.queue(CellAction::bud, 104));
|
||||
const auto bud = required(play.pending()).id;
|
||||
play.sent();
|
||||
play.observe_end({104, 900, CellularDeathReason::starved});
|
||||
play.observe({103, 900, {}, CellularLifeDiagnostics{}}); // Retained view is older than death.
|
||||
CHECK(play.life() == 0 && play.can_restart() && !play.can_act());
|
||||
CHECK(play.restart());
|
||||
const auto request = play.birth_request();
|
||||
CHECK(request != 100 && !play.restart());
|
||||
play.birth({100, PrimitiveLifeResult::born, 900, 1}); // Old request cannot finish this birth.
|
||||
CHECK(play.birth_pending());
|
||||
play.birth({request, PrimitiveLifeResult::born, 901, 3});
|
||||
CHECK(!play.can_restart()); // Birth reply may precede the first new-life view.
|
||||
play.observe({105, 901, {}, CellularLifeDiagnostics{}});
|
||||
play.observe_end({104, 900, CellularDeathReason::starved});
|
||||
CHECK(play.life() == 901 && !play.ended() && !play.pending());
|
||||
play.outcome({bud, ActionResult::not_committed, 0, 0});
|
||||
CHECK(play.history().back().state == CellActionState::refused);
|
||||
for (int i = 0; i < 20; ++i) {
|
||||
CHECK(play.queue(CellAction::engulf, 106));
|
||||
const auto action = required(play.pending()).id;
|
||||
play.sent();
|
||||
play.outcome({action, ActionResult::unknown, 0, 0});
|
||||
play.keep_unknown();
|
||||
}
|
||||
CHECK(play.history().size() == CellularPlay::history_limit);
|
||||
CHECK(play.history().back().state == CellActionState::unresolved);
|
||||
play.disconnected();
|
||||
CHECK(!play.queue(CellAction::engulf, 106) && !play.can_restart());
|
||||
play.connected();
|
||||
play.observe({106, 901, {}, CellularLifeDiagnostics{}});
|
||||
CHECK(play.queue(CellAction::bud, 107));
|
||||
play.disconnected();
|
||||
CHECK(!play.pending() && play.history().back().state == CellActionState::refused);
|
||||
CellularPlay exhausted;
|
||||
exhausted.initialize(std::numeric_limits<std::uint64_t>::max());
|
||||
CHECK(exhausted.allocate_id() == 0 && exhausted.allocate_id() == 0);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() try {
|
||||
@@ -340,6 +473,8 @@ int main() try {
|
||||
launcher();
|
||||
outcome_log();
|
||||
session_host();
|
||||
cellular_play();
|
||||
cellular_assistance();
|
||||
std::puts("client UI model tests passed");
|
||||
return 0;
|
||||
} catch (const std::exception& e) {
|
||||
|
||||
@@ -36,6 +36,25 @@ US-layout key positions. Changed controls are saved in
|
||||
%APPDATA%\Aeternalis Games\Evolution Engineering Client\controls-v1.txt.
|
||||
No other settings, logs or credentials are written by the client.
|
||||
|
||||
Cellular play (v10)
|
||||
------------------
|
||||
Check Cellular play (v10) before Connect, or add --cellular to the connection
|
||||
command. For the current dev playtest use fresh accounts and region 4 grants.
|
||||
Cell shows reserves and Engulf/Bud actions. Feeding is automatic when touching
|
||||
stocked food. Food offers manual targeting, a speed slider, precision steering,
|
||||
and optional slowing near food. Evolution explains earned mutation choices and
|
||||
shows their energy/matter cost; unaffordable choices are disabled. On a
|
||||
narrow window, Evolution is the Life tab. Log keeps recent discrete results and
|
||||
can reveal engineering panels. Ctrl+= and Ctrl+- adjust UI scale.
|
||||
|
||||
Engulf and Bud are single actions; automatic feeding resumes after their tick.
|
||||
A bud becomes wildlife; you keep your cell. Engulf and bud failures and death
|
||||
causes come from the server. Mutation funding is rechecked at commitment.
|
||||
Accepted actions await a committed result. An unknown result is
|
||||
not success or failure. Start new life creates a fresh primitive cell after death;
|
||||
old lives are never revived. Request history lasts only for this app connection
|
||||
flow, including automatic reconnects, and is not saved on exit.
|
||||
|
||||
Useful options: --version, --fixture, --renderer software, --controls FILE.
|
||||
Any unknown option prints the full usage.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user