Foundation / checks (ecs) (push) Successful in 2m20s
Foundation / checks (deploy) (push) Successful in 4m4s
Foundation / checks (tsan) (push) Successful in 9m59s
Foundation / checks (client) (push) Successful in 19m19s
Foundation / checks (network) (push) Successful in 19m24s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 32m13s
Foundation / checks (checks) (push) Canceled after 32m19s
The v10 cellular perception carries the bud cost after the diagnostics block: the energy (construction plus the bud's provision) and matter per channel one bud takes from a fully grown cell's reserve. biology::bud_cost reads it from fund_bud itself, so the shown cost is exactly the charge; the server caches it per genome. The client shows it and names the channels the reserve is short on. v10 clients must be rebuilt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
411 lines
21 KiB
C++
411 lines
21 KiB
C++
#pragma once
|
|
|
|
#include "evo/biology/budding.hpp"
|
|
#include "evo/client/organism_view.hpp"
|
|
#include "evo/network/session_grant.hpp"
|
|
#include "evo/server/cellular_region_host.hpp"
|
|
#include "evo/server/pg_slot.hpp"
|
|
#include "evo/server/postgres_action_ledger.hpp"
|
|
#include "evo/server/postgres_control_ledger.hpp"
|
|
#include "evo/server/region_sessions.hpp"
|
|
#include "evo/server/session_window.hpp"
|
|
#include "m10_bridge.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <charconv>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <fstream>
|
|
#include <iterator>
|
|
#include <limits>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace evo::server_app {
|
|
// Profile-4 network boundary. Biology and persistence remain owned by the cellular host;
|
|
// this bridge handles admission, v7-v9 action receipts, public cell replication and
|
|
// owner-filtered v8/v9 perception.
|
|
class CellularBridge {
|
|
public:
|
|
static std::optional<CellularBridge> open(const M10Options& options,
|
|
server::CellularRegionHost& host,
|
|
persistence::RegionKey key, std::uint64_t frame,
|
|
const persistence::PgOptions& pg) {
|
|
if (!options.complete())
|
|
return fail("error cellular-session-config");
|
|
CellularBridge bridge;
|
|
const auto window = server::SessionWindow::open(options.session_window, wall_seconds());
|
|
if (!window)
|
|
return fail("error cellular-session-window");
|
|
const auto colon = options.listen.rfind(':');
|
|
std::uint16_t port{};
|
|
if (colon == std::string::npos ||
|
|
std::from_chars(options.listen.data() + colon + 1,
|
|
options.listen.data() + options.listen.size(), port)
|
|
.ec != std::errc{})
|
|
return fail("error cellular-session-listen");
|
|
const auto issuer = read(options.issuer);
|
|
if (issuer.size() != network::grant_public_key_bytes)
|
|
return fail("error cellular-session-issuer");
|
|
|
|
server::RegionSessionsConfig config;
|
|
config.transport.listen_address = options.listen.substr(0, colon);
|
|
config.transport.port = port;
|
|
config.transport.certificate_pem_file = options.certificate;
|
|
config.transport.key_pem_file = options.key;
|
|
config.control.environment =
|
|
options.environment == "dev" ? network::DeploymentEnvironment::dev
|
|
: options.environment == "stage" ? network::DeploymentEnvironment::stage
|
|
: network::DeploymentEnvironment::world0;
|
|
config.control.world = {key.world, frame};
|
|
config.control.region = key.region;
|
|
config.control.epoch = 1;
|
|
config.control.max_sessions = 512;
|
|
config.transport.limits.max_connections = 576;
|
|
if (options.max_grant_lifetime != 0) {
|
|
// As for lineage (M10.5c): a longer DEV ceiling lets a playtest outlive the 300 s
|
|
// default; never outside dev.
|
|
if (config.control.environment != network::DeploymentEnvironment::dev)
|
|
return fail("error m10-grant-lifetime");
|
|
config.control.max_grant_lifetime = options.max_grant_lifetime;
|
|
}
|
|
const auto life_routes = parse_life_owner_routes(options);
|
|
if (!life_routes || life_routes->empty())
|
|
return fail("error cellular-life-routes");
|
|
config.life_owner_routes = *life_routes;
|
|
network::GrantPublicKey public_key{};
|
|
std::copy(issuer.begin(), issuer.end(), public_key.begin());
|
|
config.issuer_keys.push_back({1, public_key});
|
|
|
|
bridge.window_ = *window;
|
|
bridge.slot_ = std::make_unique<server::PgSlot>(pg, std::chrono::seconds{2});
|
|
const auto lease = [&host] { return host.authority(); };
|
|
bridge.control_ =
|
|
std::make_unique<server::PostgresControlLedger>(*bridge.slot_, key, lease);
|
|
bridge.actions_ = std::make_unique<server::PostgresActionLedger>(*bridge.slot_, key, lease);
|
|
config.ledger = bridge.control_.get();
|
|
config.actions = bridge.actions_.get();
|
|
config.accept_cellular_actions = true;
|
|
// A cellular action carries one tick's movement and intake; a tick without one is
|
|
// idle, so a steering or feeding player sends one every tick. The probe default
|
|
// (4 per 8-tick window) refused every other one; allow one per tick with headroom
|
|
// for arrival jitter across window edges.
|
|
config.intents.max_actions_per_window = 2 * config.intents.window_ticks;
|
|
config.create_primitive_life = [&host](const network::AccountId& account,
|
|
std::uint64_t generation, std::uint64_t request) {
|
|
return host.create_primitive_life(account.bytes, generation, request);
|
|
};
|
|
config.query_primitive_life = [&host](const network::AccountId& account,
|
|
std::uint64_t generation, std::uint64_t request) {
|
|
return host.query_primitive_life(account.bytes, generation, request);
|
|
};
|
|
config.select_cellular_mutation = [&host](const network::AccountId& account,
|
|
std::uint64_t generation,
|
|
const network::CellularMutationAction& m) {
|
|
const auto reply =
|
|
host.select_mutation(account.bytes, generation, m.action_id,
|
|
{m.life_identity, m.event_index, m.offer_tick, m.operator_id});
|
|
server::CellularMutationAnswer answer{
|
|
server::admit_status(reply.status), reply.tick, {}};
|
|
if (reply.outcome)
|
|
answer.outcome = server::action_outcome(*reply.outcome);
|
|
return answer;
|
|
};
|
|
auto sessions = server::RegionSessions::create(std::move(config));
|
|
if (!sessions)
|
|
return fail(sessions.error() == server::RegionSessionsError::transport
|
|
? "error cellular-session-listen"
|
|
: "error cellular-session-config");
|
|
bridge.sessions_ = std::move(*sessions);
|
|
bridge.sessions_->set_default_interest({0, 0, 0, 7});
|
|
std::printf("cellular listening %u\n", static_cast<unsigned>(bridge.sessions_->port()));
|
|
return std::optional<CellularBridge>{std::move(bridge)};
|
|
}
|
|
|
|
[[nodiscard]] bool accepting(std::uint64_t now_seconds) {
|
|
const bool open = window_ && window_->accepting(now_seconds);
|
|
if (!open && !shutdown_) {
|
|
sessions_->shutdown(std::chrono::steady_clock::now());
|
|
shutdown_ = true;
|
|
}
|
|
return open;
|
|
}
|
|
[[nodiscard]] server::RegionSessions& sessions() noexcept {
|
|
return *sessions_;
|
|
}
|
|
[[nodiscard]] std::vector<network::CarriedAction> carry(std::uint64_t tick) {
|
|
return sessions_->carry(tick);
|
|
}
|
|
void committed(std::span<const network::CarriedAction> actions, std::uint64_t sequence) {
|
|
sessions_->committed(actions, sequence);
|
|
}
|
|
void dropped(std::span<const network::CarriedAction> actions, bool final) {
|
|
sessions_->dropped(actions, final);
|
|
}
|
|
void poll(const server::HostStatus& status, std::uint64_t now_seconds) {
|
|
sessions_->poll({status.ready, status.epoch, status.simulated_tick}, now_seconds,
|
|
std::chrono::steady_clock::now());
|
|
for (const auto& event : sessions_->take_events())
|
|
std::printf("cellular %s session=%llu account=%s reason=%u\n",
|
|
event.kind == server::RegionSessionEvent::Kind::opened ? "opened"
|
|
: event.kind == server::RegionSessionEvent::Kind::closed ? "closed"
|
|
: "refused",
|
|
static_cast<unsigned long long>(event.session), event.account.c_str(),
|
|
static_cast<unsigned>(event.reason));
|
|
}
|
|
void replicate(const server::CellularLives& state) {
|
|
const auto tick = state.tick();
|
|
if (replicated_tick_ == tick)
|
|
return;
|
|
const auto source = [&](const network::SessionInterest& interest) {
|
|
network::ReplicationSource result;
|
|
result.identity = {state.world(), state.frame()};
|
|
result.organism_revision = tick;
|
|
for (const auto& life : state.lives()) {
|
|
if (life.presence == server::CellularPresence::suspended)
|
|
continue; // Out of the world (ADR-0128).
|
|
const auto voxel_x = life.position.x_um / 1'000'000;
|
|
const auto voxel_y = life.position.y_um / 1'000'000;
|
|
if (voxel_x >
|
|
static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()) ||
|
|
voxel_y > static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()))
|
|
continue;
|
|
const world::VoxelAddress voxel{static_cast<std::int64_t>(voxel_x),
|
|
static_cast<std::int64_t>(voxel_y), 0};
|
|
if (voxel.x < interest.x - interest.radius ||
|
|
voxel.x > interest.x + interest.radius ||
|
|
voxel.y < interest.y - interest.radius ||
|
|
voxel.y > interest.y + interest.radius)
|
|
continue;
|
|
const auto genome = state.archive().find(life.identity.genome);
|
|
if (!genome)
|
|
continue;
|
|
const biology::EnvironmentState environment{state.ambient_temperature_millikelvin(),
|
|
life.reserve};
|
|
auto cell = client::present_organism(
|
|
life.identity.organism, voxel, {life.position.x_um % 1'000'000},
|
|
{life.position.y_um % 1'000'000}, *genome, life.growth, environment,
|
|
client::OrganismState::alive);
|
|
if (cell)
|
|
result.organisms.push_back(*cell);
|
|
}
|
|
std::ranges::sort(result.organisms, {}, &client::OrganismCell::id);
|
|
return result;
|
|
};
|
|
sessions_->replicate(tick, source);
|
|
sessions_->clear_cellular_perceptions(tick);
|
|
for (const auto& life : state.lives()) {
|
|
if (life.presence == server::CellularPresence::suspended)
|
|
continue;
|
|
const auto perceived = state.perceive(life.identity.life);
|
|
if (!perceived)
|
|
continue;
|
|
network::CellularPerception view;
|
|
view.tick = tick;
|
|
view.life_identity = life.identity.life;
|
|
network::CellularLifeDiagnostics diagnostics;
|
|
diagnostics.reserve_energy_pj = life.reserve.energy.value;
|
|
for (std::size_t i = 0; i < diagnostics.reserve_matter_fg.size(); ++i)
|
|
diagnostics.reserve_matter_fg[i] = life.reserve.matter[i].value;
|
|
if (const auto cost = bud_cost_for(state, life.identity.genome)) {
|
|
diagnostics.bud_cost_energy_pj = cost->energy.value;
|
|
for (std::size_t i = 0; i < diagnostics.bud_cost_matter_fg.size(); ++i)
|
|
diagnostics.bud_cost_matter_fg[i] = cost->matter[i].value;
|
|
}
|
|
const auto feedback =
|
|
std::ranges::lower_bound(state.last_tick_feedback(), life.identity.life, {},
|
|
&server::CellularLifeTickFeedback::life_id);
|
|
if (feedback != state.last_tick_feedback().end() &&
|
|
feedback->life_id == life.identity.life && feedback->tick == tick) {
|
|
diagnostics.has_tick_effects = true;
|
|
diagnostics.maintenance_cost_pj = feedback->maintenance_cost.value;
|
|
diagnostics.movement_cost_pj = feedback->movement_cost.value;
|
|
switch (feedback->movement) {
|
|
case biology::CellularMovementStatus::not_requested:
|
|
diagnostics.movement = network::CellularMovementResult::no_movement;
|
|
break;
|
|
case biology::CellularMovementStatus::moved:
|
|
diagnostics.movement = network::CellularMovementResult::moved;
|
|
break;
|
|
case biology::CellularMovementStatus::blocked:
|
|
diagnostics.movement = network::CellularMovementResult::blocked;
|
|
break;
|
|
case biology::CellularMovementStatus::insufficient_reserve:
|
|
diagnostics.movement = network::CellularMovementResult::insufficient_energy;
|
|
break;
|
|
}
|
|
switch (feedback->intake) {
|
|
case biology::CellularIntakeStatus::not_requested:
|
|
diagnostics.intake = network::CellularIntakeResult::not_requested;
|
|
break;
|
|
case biology::CellularIntakeStatus::acquired:
|
|
diagnostics.intake = network::CellularIntakeResult::acquired;
|
|
break;
|
|
case biology::CellularIntakeStatus::missing:
|
|
diagnostics.intake = network::CellularIntakeResult::missing_patch;
|
|
break;
|
|
case biology::CellularIntakeStatus::out_of_contact:
|
|
diagnostics.intake = network::CellularIntakeResult::out_of_contact;
|
|
break;
|
|
}
|
|
// ADR-0129 (v10): what an engulf or bud intention did this tick.
|
|
diagnostics.engulf = engulf_result(feedback->engulf);
|
|
diagnostics.bud = feedback->bud ? bud_outcome(*feedback->bud)
|
|
: network::CellularBudOutcome::not_requested;
|
|
}
|
|
view.diagnostics = diagnostics;
|
|
view.patches.reserve(perceived->size());
|
|
for (const auto& patch : *perceived) {
|
|
network::CellularPerceivedPatch visible;
|
|
visible.x_um = patch.address.x_um;
|
|
visible.y_um = patch.address.y_um;
|
|
visible.energy_pj = patch.available.energy.value;
|
|
for (std::size_t i = 0; i < visible.matter_fg.size(); ++i)
|
|
visible.matter_fg[i] = patch.available.matter[i].value;
|
|
view.patches.push_back(visible);
|
|
}
|
|
(void)sessions_->send_cellular_perception(network::AccountId{life.account}, view);
|
|
send_offer(state, life, tick);
|
|
}
|
|
std::erase_if(offers_, [&](const SentOffer& sent) {
|
|
return std::ranges::find(state.lives(), sent.account,
|
|
&server::CellularOwnedLife::account) == state.lives().end();
|
|
});
|
|
announce_endings(state);
|
|
replicated_tick_ = tick;
|
|
}
|
|
// ADR-0129: an owned life seen at the last replication and now a corpse is announced to
|
|
// its owner once, with its recorded cause.
|
|
void announce_endings(const server::CellularLives& state) {
|
|
for (const auto& [account, life_id] : owned_) {
|
|
if (std::ranges::find(state.lives(), life_id, [](const server::CellularOwnedLife& l) {
|
|
return l.identity.life;
|
|
}) != state.lives().end())
|
|
continue;
|
|
const auto corpse =
|
|
std::ranges::find(state.corpses(), life_id, &server::CellularOwnedCorpse::life_id);
|
|
if (corpse == state.corpses().end())
|
|
continue;
|
|
const auto cause = corpse->cause == biology::CellularDeathCause::starved
|
|
? network::CellularDeathReason::starved
|
|
: corpse->cause == biology::CellularDeathCause::engulfed
|
|
? network::CellularDeathReason::engulfed
|
|
: network::CellularDeathReason::unrecorded;
|
|
static_cast<void>(sessions_->send_life_ended(network::AccountId{account},
|
|
{corpse->died_tick, life_id, cause}));
|
|
}
|
|
owned_.clear();
|
|
for (const auto& life : state.lives())
|
|
if (life.account != server::LifeAccount{})
|
|
owned_.emplace_back(life.account, life.identity.life);
|
|
}
|
|
static network::CellularEngulfResult engulf_result(biology::CellularEngulfStatus status) {
|
|
switch (status) {
|
|
case biology::CellularEngulfStatus::not_requested:
|
|
return network::CellularEngulfResult::not_requested;
|
|
case biology::CellularEngulfStatus::engulfed:
|
|
return network::CellularEngulfResult::engulfed;
|
|
case biology::CellularEngulfStatus::no_eligible_prey:
|
|
return network::CellularEngulfResult::no_eligible_prey;
|
|
case biology::CellularEngulfStatus::unsupported:
|
|
return network::CellularEngulfResult::unsupported;
|
|
case biology::CellularEngulfStatus::no_contact:
|
|
return network::CellularEngulfResult::no_contact;
|
|
case biology::CellularEngulfStatus::prey_too_large:
|
|
return network::CellularEngulfResult::prey_too_large;
|
|
case biology::CellularEngulfStatus::membrane_too_thick:
|
|
return network::CellularEngulfResult::membrane_too_thick;
|
|
}
|
|
return network::CellularEngulfResult::not_reported;
|
|
}
|
|
static network::CellularBudOutcome bud_outcome(server::CellularBudResult result) {
|
|
switch (result) {
|
|
case server::CellularBudResult::budded:
|
|
return network::CellularBudOutcome::budded;
|
|
case server::CellularBudResult::life_died:
|
|
case server::CellularBudResult::not_able:
|
|
return network::CellularBudOutcome::not_able;
|
|
case server::CellularBudResult::insufficient_funding:
|
|
return network::CellularBudOutcome::insufficient_funding;
|
|
case server::CellularBudResult::no_placement:
|
|
return network::CellularBudOutcome::no_placement;
|
|
}
|
|
return network::CellularBudOutcome::not_reported;
|
|
}
|
|
// 11.4d: the owner's outstanding offer is sent reliably when it changes or the owner's
|
|
// session changes; an empty view clears an offer that was consumed.
|
|
void send_offer(const server::CellularLives& state, const server::CellularOwnedLife& life,
|
|
std::uint64_t tick) {
|
|
const network::AccountId account{life.account};
|
|
const auto session = sessions_->holder(account);
|
|
const auto& progress = life.mutation;
|
|
const SentOffer current{life.account, session.value_or(0), life.identity.life,
|
|
progress.offer ? progress.event_index : 0,
|
|
progress.offer ? progress.offer_tick : 0};
|
|
auto sent = std::ranges::find(offers_, life.account, &SentOffer::account);
|
|
if (sent != offers_.end() && *sent == current)
|
|
return;
|
|
if (!session || (!progress.offer && sent == offers_.end()))
|
|
return; // Nothing to show, or no one to show it to.
|
|
if (!sessions_->send_mutation_offer(account, server::offer_view(state, life, tick)))
|
|
return; // Not a v10 owner (or the stream refused): retried on a later tick.
|
|
if (sent != offers_.end())
|
|
*sent = current;
|
|
else
|
|
offers_.push_back(current);
|
|
}
|
|
void shutdown() {
|
|
sessions_->shutdown(std::chrono::steady_clock::now());
|
|
}
|
|
|
|
private:
|
|
// ADR-0129 amendment: a genome's bud cost is pure for this region's temperature, and
|
|
// deriving it scans up to a thousand bodies, so it is computed once per genome.
|
|
std::optional<accounting::Inventory> bud_cost_for(const server::CellularLives& state,
|
|
std::uint64_t genome_id) {
|
|
if (const auto known = bud_costs_.find(genome_id); known != bud_costs_.end())
|
|
return known->second;
|
|
const auto genome = state.archive().find(genome_id);
|
|
if (!genome)
|
|
return std::nullopt;
|
|
if (bud_costs_.size() >= 4096)
|
|
bud_costs_.clear(); // Bounded: recomputing is only slower.
|
|
return bud_costs_[genome_id] =
|
|
biology::bud_cost(*genome, state.ambient_temperature_millikelvin());
|
|
}
|
|
static std::uint64_t wall_seconds() {
|
|
return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(
|
|
std::chrono::system_clock::now().time_since_epoch())
|
|
.count());
|
|
}
|
|
static std::string read(const std::string& path) {
|
|
std::ifstream file{path, std::ios::binary};
|
|
return {std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
|
|
}
|
|
static std::optional<CellularBridge> fail(const char* message) {
|
|
std::puts(message);
|
|
return std::nullopt;
|
|
}
|
|
|
|
std::unique_ptr<server::PgSlot> slot_;
|
|
std::unique_ptr<server::PostgresControlLedger> control_;
|
|
std::unique_ptr<server::PostgresActionLedger> actions_;
|
|
std::unique_ptr<server::RegionSessions> sessions_;
|
|
std::optional<server::SessionWindow> window_;
|
|
std::optional<std::uint64_t> replicated_tick_;
|
|
struct SentOffer {
|
|
server::LifeAccount account{};
|
|
std::uint64_t session{}, life{}, event_index{}, offer_tick{};
|
|
friend bool operator==(const SentOffer&, const SentOffer&) = default;
|
|
};
|
|
std::vector<SentOffer> offers_; // Last offer view sent to each owner.
|
|
std::map<std::uint64_t, std::optional<accounting::Inventory>> bud_costs_; // By genome.
|
|
std::vector<std::pair<server::LifeAccount, std::uint64_t>> owned_; // At last replication.
|
|
bool shutdown_{};
|
|
};
|
|
} // namespace evo::server_app
|