Add OrganismPresentation cells derived via biology::derive_phenotype with no controller, owner or level fields (pinned by test), so identical biology renders identically for players and NPCs. OrganismLayer reuses the ADR-0080 ordering/freshness semantics; death is a remnant state and removal is absence. Rendering takes an explicit rectangle budget, falls back to body-only detail and marks truncation instead of dropping data. An opt-in rectangle-only hover inspector shows phenotype gauges; ImGui is not adopted. ADR-0081 records the decision; evidence in VALIDATION.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
322 lines
16 KiB
C++
322 lines
16 KiB
C++
#include "evo/client/application.hpp"
|
|
#include "evo/client/organism_inspector.hpp"
|
|
#include "evo/render/environment.hpp"
|
|
#include "evo/render/organism.hpp"
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <charconv>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <exception>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string_view>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using evo::world::Field;
|
|
constexpr evo::world::WorldIdentity fixture_identity{1, 1};
|
|
constexpr std::int64_t fixture_z = -16000;
|
|
// Water, nitrogen (never opened: missing), phosphorus (present zero), organic and
|
|
// incident energy (never opened: missing). Unrequested fields draw hollow outlines.
|
|
constexpr std::uint32_t fixture_mask = (1U << 0) | (1U << 1) | (1U << 2) | (1U << 7) | (1U << 8);
|
|
constexpr unsigned frames_per_authority_tick = 60;
|
|
// Frame composition: environment bound + organisms + inspector + 3 host UI rectangles.
|
|
constexpr std::size_t organism_budget = evo::render::max_rectangles -
|
|
evo::render::max_environment_rectangles -
|
|
evo::client::inspector_rectangles - 3;
|
|
// Local in-memory stand-in for authoritative region views until M9.7. It is never
|
|
// persisted or published; the client presentation only copies its read-only views.
|
|
struct FixtureAuthority {
|
|
std::unique_ptr<evo::world::FieldStore> fields;
|
|
std::unique_ptr<evo::world::ChunkStore> terrain;
|
|
std::vector<evo::world::VoxelAddress> footprint;
|
|
// Static presentation population: phenotypes derive from real genomes, but no
|
|
// ecology runs here. Two remnants show the dead encoding.
|
|
std::vector<evo::client::OrganismCell> organisms;
|
|
std::uint64_t tick{1};
|
|
};
|
|
bool add_organism(FixtureAuthority& authority, std::uint64_t id, evo::world::VoxelAddress voxel,
|
|
std::uint64_t x_um, std::uint64_t y_um) {
|
|
using evo::biology::Capability;
|
|
const auto k = static_cast<std::uint32_t>(id);
|
|
evo::biology::GenomeDraft draft{
|
|
id,
|
|
1,
|
|
1,
|
|
{},
|
|
{{Capability::energy_conversion, 200 + 100 * (k % 7), 0}, {Capability::membrane, 10, 0}}};
|
|
if (k % 3 == 0)
|
|
draft.capabilities.push_back({Capability::movement, 50, 0});
|
|
if (k % 2 == 0)
|
|
draft.capabilities.push_back({Capability::ingestion, 2000, 0});
|
|
draft.capabilities.push_back({Capability::target_size, 8'000'000, 0});
|
|
const auto genome = evo::biology::Genome::create(draft);
|
|
if (!genome)
|
|
return false;
|
|
constexpr evo::biology::EnvironmentState temperate{
|
|
293'150, {{1'000'000'000}, {evo::accounting::Femtograms{1'000'000'000}, {}, {}, {}}}};
|
|
const auto cell = evo::client::present_organism(
|
|
id, voxel, {x_um}, {y_um}, *genome, {400 + 100 * (k % 7), k % 5 == 0 ? 300U : 0U},
|
|
temperate,
|
|
k == 5 || k == 23 ? evo::client::OrganismState::dead : evo::client::OrganismState::alive);
|
|
if (!cell)
|
|
return false;
|
|
authority.organisms.push_back(*cell);
|
|
return true;
|
|
}
|
|
std::optional<FixtureAuthority> make_authority() {
|
|
FixtureAuthority authority;
|
|
std::vector<evo::world::FieldSite> sites;
|
|
std::vector<std::uint64_t> water, energy;
|
|
for (std::int64_t x = -8; x < 8; ++x)
|
|
for (std::int64_t y = -4; y < 4; ++y) {
|
|
const auto ux = static_cast<std::uint64_t>(x + 8);
|
|
const auto uy = static_cast<std::uint64_t>(y + 4);
|
|
authority.footprint.push_back({x, y, fixture_z});
|
|
// Habitat boxes vary to show their boundaries inside each 1 m voxel.
|
|
const evo::world::HabitatBox box{{50000 * (ux % 4)}, {40000 * uy}, {0},
|
|
{800000 - 30000 * uy}, {500000 + 10000 * ux}, {100}};
|
|
sites.push_back({authority.footprint.back(), box, {1}});
|
|
const auto volume = box.width.value * box.height.value * box.depth.value;
|
|
water.push_back(volume >> (2 * ux / 3 + uy));
|
|
energy.push_back((ux + 1) * (uy + 1) * (volume >> 4));
|
|
}
|
|
const std::uint64_t zero = 0;
|
|
const evo::world::FieldOpening opening[]{
|
|
{Field::water, water}, {Field::phosphorus, {&zero, 1}}, {Field::organic_energy, energy}};
|
|
const evo::world::FieldDefaults defaults{{evo::accounting::Femtograms{0},
|
|
evo::accounting::Femtograms{1ULL << 50},
|
|
evo::accounting::Femtograms{0}}};
|
|
constexpr std::size_t budget = 4'000'000;
|
|
auto fields =
|
|
evo::world::FieldStore::create(fixture_identity, 1, defaults, sites, opening, budget);
|
|
auto terrain = evo::world::ChunkStore::create({}, 32, budget);
|
|
if (!fields || !terrain)
|
|
return std::nullopt;
|
|
authority.fields = std::move(*fields);
|
|
authority.terrain = std::move(*terrain);
|
|
for (const auto voxel : authority.footprint)
|
|
if (!authority.terrain->load(evo::world::split(voxel, evo::world::base_chunk_edge)->chunk))
|
|
return std::nullopt;
|
|
// A 4x4 cluster 60 um apart in voxel (0, 0) for zoomed inspection, then one
|
|
// organism in every other voxel of the fixture.
|
|
std::uint64_t id = 1;
|
|
for (std::uint64_t i = 0; i < 16; ++i)
|
|
if (!add_organism(authority, id++, {0, 0, fixture_z}, 410000 + 60 * (i % 4),
|
|
480000 + 60 * (i / 4)))
|
|
return std::nullopt;
|
|
for (std::int64_t x = -8; x < 8; x += 2)
|
|
for (std::int64_t y = -4; y < 4; y += 2)
|
|
if (!add_organism(authority, id++, {x, y, fixture_z}, 500000, 500000))
|
|
return std::nullopt;
|
|
return authority;
|
|
}
|
|
// One conserved same-channel water move per authority tick (finite fixture stock).
|
|
bool advance(FixtureAuthority& authority) {
|
|
const auto sites = authority.fields->sites().size();
|
|
const auto from = static_cast<std::size_t>(authority.tick * 7 % sites);
|
|
const auto amount = authority.fields->read(from, Field::water);
|
|
if (!amount)
|
|
return false;
|
|
++authority.tick;
|
|
if (*amount < 8)
|
|
return true;
|
|
const auto moved = authority.fields->transfer(authority.tick, Field::water, from,
|
|
(from + 1) % sites, *amount / 8);
|
|
return moved || moved.error() == evo::world::FieldError::capacity;
|
|
}
|
|
std::optional<evo::client::EnvironmentPresentation> query(const FixtureAuthority& authority) {
|
|
const auto view = evo::world::query_environment(
|
|
*authority.fields, *authority.terrain, authority.tick, authority.footprint, fixture_mask);
|
|
if (!view)
|
|
return std::nullopt;
|
|
auto presentation = evo::client::present_environment(*view, fixture_z);
|
|
if (!presentation)
|
|
return std::nullopt;
|
|
return std::move(*presentation);
|
|
}
|
|
std::optional<evo::client::OrganismPresentation> organisms(const FixtureAuthority& authority) {
|
|
auto presentation = evo::client::OrganismPresentation::create(
|
|
{fixture_identity, authority.tick, 1}, fixture_z, authority.organisms);
|
|
if (!presentation)
|
|
return std::nullopt;
|
|
return std::move(*presentation);
|
|
}
|
|
std::optional<evo::render::EnvironmentDisplay> parse_layer(std::string_view name) {
|
|
using Mode = evo::render::EnvironmentDisplay::Mode;
|
|
constexpr std::array<std::string_view, evo::world::field_count> names{"water",
|
|
"nitrogen",
|
|
"phosphorus",
|
|
"organic-carbon",
|
|
"organic-nitrogen",
|
|
"organic-phosphorus",
|
|
"organic-other",
|
|
"organic-energy",
|
|
"incident-energy",
|
|
"heat"};
|
|
if (name == "moisture")
|
|
return evo::render::EnvironmentDisplay{Mode::moisture};
|
|
for (std::size_t i = 0; i < names.size(); ++i)
|
|
if (name == names.at(i))
|
|
return evo::render::EnvironmentDisplay{Mode::field, static_cast<Field>(i)};
|
|
return std::nullopt;
|
|
}
|
|
bool parse_count(std::string_view value, unsigned limit, unsigned& out) {
|
|
const auto [end, error] = std::from_chars(value.data(), value.data() + value.size(), out);
|
|
return error == std::errc{} && end == value.data() + value.size() && out != 0 && out <= limit;
|
|
}
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) try {
|
|
evo::client::Config config;
|
|
unsigned frames = 0, refresh_every = 1;
|
|
bool inspect = false;
|
|
evo::render::EnvironmentDisplay display;
|
|
for (int i = 1; i < argc; ++i) {
|
|
const std::string_view arg{argv[i]};
|
|
if (arg == "--hidden")
|
|
config.hidden = true;
|
|
else if (arg == "--inspect")
|
|
inspect = true;
|
|
else if (arg == "--renderer" && i + 1 < argc)
|
|
config.renderer = argv[++i];
|
|
else if (arg == "--frames" && i + 1 < argc) {
|
|
if (!parse_count(argv[++i], 100000, frames))
|
|
return 2;
|
|
} else if (arg == "--refresh-every" && i + 1 < argc) {
|
|
if (!parse_count(argv[++i], 1000, refresh_every))
|
|
return 2;
|
|
} else if (arg == "--layer" && i + 1 < argc) {
|
|
const auto layer = parse_layer(argv[++i]);
|
|
if (!layer)
|
|
return 2;
|
|
display = *layer;
|
|
} else {
|
|
std::fputs("usage: evo-client [--renderer NAME] [--hidden] [--frames 1..100000]\n"
|
|
" [--layer water|nitrogen|...|heat|moisture]\n"
|
|
" [--refresh-every 1..1000] [--inspect]\n",
|
|
stderr);
|
|
return 2;
|
|
}
|
|
}
|
|
auto authority = make_authority();
|
|
if (!authority) {
|
|
std::fputs("client environment fixture error\n", stderr);
|
|
return 1;
|
|
}
|
|
evo::client::EnvironmentLayer environment;
|
|
evo::client::OrganismLayer population;
|
|
auto app = evo::client::Application::open(config);
|
|
if (!app) {
|
|
std::fprintf(stderr, "client initialization error=%d\n", static_cast<int>(app.error()));
|
|
return 1;
|
|
}
|
|
// A minimized native window may start with no drawable area. Adopt the
|
|
// native viewport before projecting; until then use the requested size.
|
|
auto camera = evo::client::Camera::create(
|
|
{config.width, config.height, config.width, config.height}, {}, 0.05);
|
|
if (!camera)
|
|
return 1;
|
|
std::puts("Arrows: pan | wheel: zoom | WASD: intention indicator | Tab: UI capture (orange)");
|
|
std::puts("Status chips (environment, organisms): green current | amber stale | red none;"
|
|
" magenta marker: organisms truncated");
|
|
std::vector<evo::render::Rectangle> boxes;
|
|
std::uint64_t count = 0;
|
|
auto previous = std::chrono::steady_clock::now();
|
|
while (frames == 0 || count < frames) {
|
|
if (auto result = (*app)->poll_events(); !result) {
|
|
std::fprintf(stderr, "client event error=%d\n", static_cast<int>(result.error()));
|
|
return 1;
|
|
}
|
|
const auto state = (*app)->state();
|
|
if (state.closed)
|
|
break;
|
|
const auto now = std::chrono::steady_clock::now();
|
|
const double seconds =
|
|
std::clamp(std::chrono::duration<double>(now - previous).count(), 0.0, 0.1);
|
|
previous = now;
|
|
const auto navigation = (*app)->take_navigation();
|
|
// Fixture ticks only. No server session or simulation clock exists here.
|
|
const auto intention = (*app)->sample_intention(count);
|
|
if (!intention)
|
|
return 1;
|
|
// The fixture authority advances at its own cadence. Presentations refresh
|
|
// every N authority ticks; in between the advanced watermark shows as stale.
|
|
if (count % frames_per_authority_tick == 0) {
|
|
if (count != 0 && !advance(*authority))
|
|
return 1;
|
|
if ((authority->tick - 1) % refresh_every == 0) {
|
|
auto next = query(*authority);
|
|
auto cells = organisms(*authority);
|
|
if (!next || !cells || !environment.accept(std::move(*next)) ||
|
|
!population.accept(std::move(*cells)))
|
|
return 1;
|
|
}
|
|
if (!environment.observe(
|
|
{fixture_identity, authority->tick, authority->fields->last_command()}) ||
|
|
!population.observe({fixture_identity, authority->tick, 1}))
|
|
return 1;
|
|
}
|
|
boxes.clear();
|
|
if (state.logical_width > 0 && state.logical_height > 0 && state.pixel_width > 0 &&
|
|
state.pixel_height > 0) {
|
|
if (!camera->resize({state.logical_width, state.logical_height, state.pixel_width,
|
|
state.pixel_height}))
|
|
return 1;
|
|
if (auto result =
|
|
camera->pan({navigation.x * 400 * seconds, navigation.y * 400 * seconds});
|
|
!result && result.error() != evo::client::CameraError::out_of_range)
|
|
return 1;
|
|
const evo::client::ScreenPoint anchor{
|
|
std::clamp(navigation.pointer.x, 0.0, static_cast<double>(state.logical_width)),
|
|
std::clamp(navigation.pointer.y, 0.0, static_cast<double>(state.logical_height))};
|
|
if (auto result = camera->zoom(std::exp2(navigation.wheel / 4), anchor);
|
|
!result && result.error() != evo::client::CameraError::out_of_range)
|
|
return 1;
|
|
// Copied presentation only; clipped to the viewport before float conversion.
|
|
if (!evo::render::build_environment(boxes, environment.current(),
|
|
environment.freshness(), *camera, display) ||
|
|
!evo::render::append_organisms(boxes, organism_budget, population.current(),
|
|
population.freshness(), *camera))
|
|
return 1;
|
|
// Engineering inspector: biology gauges for the hovered organism only.
|
|
if (const auto* shown = population.current(); inspect && shown != nullptr)
|
|
if (const auto index =
|
|
evo::client::pick_organism(*shown, *camera, navigation.pointer))
|
|
if (!evo::client::append_inspector(boxes, evo::client::inspector_rectangles,
|
|
shown->cells()[*index], *camera))
|
|
return 1;
|
|
}
|
|
boxes.push_back({8, 8, 64, 8,
|
|
(*app)->ui_captured() ? evo::render::Color{240, 140, 32, 255}
|
|
: evo::render::Color{64, 180, 140, 255}});
|
|
boxes.push_back({36 + static_cast<float>(intention->move_x) / 50,
|
|
48 - static_cast<float>(intention->move_y) / 50,
|
|
8,
|
|
8,
|
|
{240, 240, 240, 255}});
|
|
const auto frame = evo::render::Frame::create(boxes, {16, 20, 28, 255});
|
|
if (!frame)
|
|
return 1;
|
|
const auto result = (*app)->present(*frame);
|
|
if (!result) {
|
|
std::fprintf(stderr, "client frame error=%d\n", static_cast<int>(result.error()));
|
|
return 1;
|
|
}
|
|
if (*result == evo::client::Step::closed)
|
|
break;
|
|
++count;
|
|
std::this_thread::sleep_for(std::chrono::milliseconds{16});
|
|
}
|
|
return 0;
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "client exception: %.200s\n", e.what());
|
|
return 1;
|
|
} catch (...) {
|
|
std::fputs("client exception\n", stderr);
|
|
return 1;
|
|
}
|