Martin Slachta
79 lines
2.5 KiB
C++
79 lines
2.5 KiB
C++
#pragma once
|
|
|
|
#include "PeerLink.hpp"
|
|
#include "WorldStepProcessor.hpp"
|
|
#include "Peer.pb.h"
|
|
#include "world/World.hpp"
|
|
|
|
#include <chrono>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace tw::p2p {
|
|
|
|
// Encapsulates the peer-to-peer networking layer and lock-step simulation.
|
|
//
|
|
// Owns the PeerLink (transport), WorldStepProcessor (simulation), peer
|
|
// registry, action history, and ack tracking. The caller (TestPeerNode)
|
|
// only needs to supply a World and forward a few lifecycle calls.
|
|
class PeerWorldController {
|
|
public:
|
|
PeerWorldController(uint32_t self_id, uint16_t port,
|
|
std::unique_ptr<PeerLink> link,
|
|
const std::string& registry_path,
|
|
World* world);
|
|
|
|
// Write this node's entry into the shared registry.
|
|
void register_self();
|
|
|
|
// Block until at least expected_count entries appear in the registry.
|
|
bool wait_until_peers_registered(
|
|
uint32_t expected_count,
|
|
std::chrono::milliseconds timeout = std::chrono::milliseconds(30000));
|
|
|
|
// Initiate outgoing connections to all higher-ID peers in the registry.
|
|
void discover_and_connect();
|
|
|
|
// Accept expected_count incoming connections via the PeerLink listener.
|
|
void wait_for_connections(
|
|
uint32_t expected_count,
|
|
std::chrono::milliseconds timeout = std::chrono::milliseconds(2000));
|
|
|
|
// One simulation tick. Returns true if the world stepped forward.
|
|
bool tick();
|
|
|
|
uint32_t self_id() const { return m_self_id; }
|
|
uint32_t current_frame() const { return m_processor.current_frame(); }
|
|
uint64_t rollbacks() const { return m_processor.rollbacks(); }
|
|
uint64_t stepped_frames() const { return m_processor.stepped_frames(); }
|
|
|
|
glm::vec3 peer_position(uint32_t peer_id) const {
|
|
return m_processor.peer_position(peer_id);
|
|
}
|
|
|
|
const std::vector<uint32_t>& peer_ids() const { return m_peer_ids; }
|
|
|
|
uint32_t get_peer_latest_snapshot_frame(uint32_t peer_id) {
|
|
}
|
|
|
|
private:
|
|
uint32_t m_self_id;
|
|
uint16_t m_port;
|
|
std::string m_registry_path;
|
|
|
|
std::unique_ptr<PeerLink> m_link;
|
|
WorldStepProcessor m_processor;
|
|
|
|
std::vector<uint32_t> m_peer_ids;
|
|
std::map<uint32_t, mmo::peer::PeerAction> m_self_history;
|
|
std::unordered_map<uint32_t, uint32_t> m_peer_acks;
|
|
|
|
mmo::peer::PeerAction build_local_action(uint32_t frame) const;
|
|
void send_history_to(uint32_t peer_id);
|
|
};
|
|
|
|
} // namespace tw::p2p
|