#pragma once #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 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; 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; 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); }; 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()) { 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); sessions_->clear_cellular_perceptions(tick); for (const auto& life : state.lives()) { 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; 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; } } 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); } replicated_tick_ = tick; } void shutdown() { sessions_->shutdown(std::chrono::steady_clock::now()); } private: 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_; bool shutdown_{}; }; } // namespace evo::server_app