#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 #include #include #include #include #include #include #include #include #include #include #include #include #include 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 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(pg, std::chrono::seconds{2}); const auto lease = [&host] { return host.authority(); }; bridge.control_ = std::make_unique(*bridge.slot_, key, lease); bridge.actions_ = std::make_unique(*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(bridge.sessions_->port())); return std::optional{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 carry(std::uint64_t tick) { return sessions_->carry(tick); } void committed(std::span actions, std::uint64_t sequence) { sessions_->committed(actions, sequence); } void dropped(std::span 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(event.session), event.account.c_str(), static_cast(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::numeric_limits::max()) || voxel_y > static_cast(std::numeric_limits::max())) continue; const world::VoxelAddress voxel{static_cast(voxel_x), static_cast(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); 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()); // ADR-0136 (rules 8): pools and bubbles go out as v11 deposits, the nearest 512 to // the cell, by ascending id; `drained` marks a stock that fell since last tick. std::vector> near; const auto centre_x = static_cast(life.position.x_um); const auto centre_y = static_cast(life.position.y_um); for (const auto& patch : *perceived) { if (patch.kind == biology::CellularDepositKind::patch) continue; network::CellularPerceivedDeposit deposit; deposit.id = patch.id; deposit.x_um = patch.address.x_um; deposit.y_um = patch.address.y_um; deposit.radius_um = static_cast(std::min(patch.radius_um, 65'535)); deposit.shape = patch.kind == biology::CellularDepositKind::pool ? network::CellularDepositShape::pool : network::CellularDepositShape::bubble; deposit.amount_codes[0] = network::deposit_amount_code(patch.available.energy.value); for (std::size_t c = 0; c < patch.available.matter.size(); ++c) deposit.amount_codes.at(c + 1) = network::deposit_amount_code(patch.available.matter[c].value); const auto before = deposit_stock_.find(patch.id); deposit.drained = before != deposit_stock_.end() && (patch.available.energy.value < before->second.energy.value || std::ranges::any_of( std::array{0, 1, 2, 3}, [&](int c) { const auto i = static_cast(c); return patch.available.matter.at(i).value < before->second.matter.at(i).value; })); seen_stock_[patch.id] = patch.available; const auto dx = std::int64_t{patch.address.x_um} - centre_x; const auto dy = std::int64_t{patch.address.y_um} - centre_y; near.emplace_back(static_cast(dx * dx + dy * dy), deposit); } if (near.size() > network::max_cellular_perceived_deposits) { std::ranges::nth_element( near, near.begin() + static_cast(network::max_cellular_perceived_deposits), [](const auto& a, const auto& b) { return std::pair{a.first, a.second.id} < std::pair{b.first, b.second.id}; }); near.resize(network::max_cellular_perceived_deposits); } for (const auto& [distance, deposit] : near) view.deposits.push_back(deposit); std::ranges::sort(view.deposits, {}, &network::CellularPerceivedDeposit::id); for (const auto& patch : *perceived) { if (patch.kind != biology::CellularDepositKind::patch) continue; 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); } // After every owner's view: clear only the sessions that got none this tick. sessions_->clear_cellular_perceptions(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); // What each deposit held when last seen, for next tick's `drained` flags. deposit_stock_ = std::move(seen_stock_); seen_stock_.clear(); 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(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 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::chrono::duration_cast( 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{file}, std::istreambuf_iterator{}}; } static std::optional fail(const char* message) { std::puts(message); return std::nullopt; } std::unique_ptr slot_; std::unique_ptr control_; std::unique_ptr actions_; std::unique_ptr sessions_; std::optional window_; std::optional 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 offers_; // Last offer view sent to each owner. std::map> bud_costs_; // By genome. // ADR-0136: deposit stocks seen at the last replicated tick, and this tick's. std::map deposit_stock_, seen_stock_; std::vector> owned_; // At last replication. bool shutdown_{}; }; } // namespace evo::server_app