mitiru::network

Networking primitives: socket abstraction, RPC, replication, and the lockstep transport used by deterministic multiplayer.

Name	Kind	Items
INetworkTransport	class	9
TimestampedState	struct	1
LagCompensator	class	12
Lobby	class	7
RoomState	enum	4
LobbyEvent	enum	8
RoomInfo	struct	13
LobbyEventInfo	struct	4
LobbyConfig	struct	4
LobbySystem	class	25
LocalTransport	class	8
MessageType	enum	8
DeliveryMode	enum	8
GameMessage	struct	14
ReplicatedProperty	struct	3
ReplicatedEntity	struct	5
DeadReckoningState	struct	2
ReplicationManager	class	4
SessionMode	enum	4
PeerState	enum	4
SessionEvent	enum	5
PeerInfo	struct	7
SessionConfig	struct	6
SessionEventInfo	struct	3
NetworkSession	class	25
AuthorityMode	enum	4
SyncableComponent	class	9
StateDelta	struct	5
SyncSnapshot	struct	2
SyncManager	class	16
NetworkEvent	enum	6
PacketHeader	struct	3
NetworkMessage	struct	3
NetworkStats	struct	6
TestResult	struct	3
ValidationReport	struct	3
NetworkValidator	class	5
ConnectionStatus	enum	5
ReceivedPacket	struct	4
IReliableTransport	class	11
GnsReliableTransport	class	13
NullReliableTransport	class	19
WsaGuard	class	7
StateSync	class	6
TcpTransport	class	16
UdpTransport	class	16
WsOpcode	enum	6
WsFrameHeader	struct	5
WebSocketTransport	class	14

class INetworkTransport 9

virtual ~INetworkTransport() = default

virtual bool listen(std::uint16_t port) = 0

virtual bool connect(std::string_view host, std::uint16_t port) = 0

virtual void disconnect(ConnectionId id) = 0

virtual void send(ConnectionId id, const std::vector<std::uint8_t>& data) = 0

[[nodiscard]] virtual std::vector<NetworkMessage> poll() = 0

[[nodiscard]] virtual bool isConnected(ConnectionId id) const = 0

[[nodiscard]] virtual NetworkStats stats() const = 0

using Timestamp = std::uint64_t;

struct TimestampedState 1

Timestamp time = 0

class LagCompensator 12

using LerpFunc = std::function<State(const State&, const State&, float)>;

explicit LagCompensator(std::size_t capacity = kDefaultCapacity)

void setLerpFunction(LerpFunc func)

void recordState(Timestamp time, State state)

[[nodiscard]] std::optional<State> rewindTo(Timestamp time) const

[[nodiscard]] std::optional<State> interpolate( Timestamp t1, Timestamp t2, float alpha) const

[[nodiscard]] std::optional<State> interpolateAt(Timestamp time) const

[[nodiscard]] std::size_t stateCount() const noexcept

[[nodiscard]] std::size_t capacity() const noexcept

[[nodiscard]] Timestamp oldestTimestamp() const noexcept

[[nodiscard]] Timestamp newestTimestamp() const noexcept

void clear() noexcept

class Lobby 7

void addPlayer(ConnectionId id, std::string name)

void removePlayer(ConnectionId id)

void setReady(ConnectionId id, bool ready)

[[nodiscard]] bool allReady() const

[[nodiscard]] std::size_t playerCount() const noexcept

[[nodiscard]] const std::vector<Player>& players() const noexcept

[[nodiscard]] std::string toJson() const

enum RoomState : std::uint8_t 4

Waiting = 0

Starting = 1

InGame = 2

Closed = 3

enum LobbyEvent : std::uint8_t 8

RoomCreated = 0

RoomDestroyed = 1

PlayerJoined = 2

PlayerLeft = 3

PlayerReady = 4

AllReady = 5

GameStarting = 6

RoomDiscovered = 7

struct RoomInfo 13

std::uint32_t roomId = 0

std::string name

std::string hostAddress

std::uint16_t hostPort = 0

std::uint32_t currentPlayers = 0

std::uint32_t maxPlayers = 4

RoomState state = RoomState::Waiting

std::string gameMode

float lastSeenTime = 0.0f

[[nodiscard]] bool isFull() const noexcept

[[nodiscard]] bool isJoinable() const noexcept

[[nodiscard]] nlohmann::json toJson() const

[[nodiscard]] static std::optional<RoomInfo> fromJson(const nlohmann::json& j)

struct LobbyEventInfo 4

LobbyEvent event = LobbyEvent::RoomCreated

std::uint32_t roomId = 0

ConnectionId playerId = INVALID_CONNECTION

std::string detail

struct LobbyConfig 4

std::uint16_t discoveryPort = 27016

float broadcastIntervalSec = 2.0f

float roomTimeoutSec = 10.0f

std::string discoveryMagic = "MITIRU_LOBBY_V1"

class LobbySystem 25

using EventCallback = std::function<void(const LobbyEventInfo&)>;

using GameStartCallback = std::function<void(const RoomInfo&, const Lobby&)>;

std::uint32_t createRoom(std::string_view name, std::uint32_t maxPlayers = 4, std::string_view gameMode = "")

void destroyRoom(std::uint32_t roomId)

bool joinRoom(std::uint32_t roomId, ConnectionId playerId, std::string_view playerName)

void leaveRoom(std::uint32_t roomId, ConnectionId playerId)

void setReady(std::uint32_t roomId, ConnectionId playerId, bool ready)

bool tryStartGame(std::uint32_t roomId)

bool startDiscovery()

void stopDiscovery()

void update(float deltaTimeSec)

[[nodiscard]] std::vector<RoomInfo> discoveredRooms() const

[[nodiscard]] const RoomInfo* getRoom(std::uint32_t roomId) const

[[nodiscard]] const Lobby* getLobby(std::uint32_t roomId) const

[[nodiscard]] std::size_t hostedRoomCount() const noexcept

[[nodiscard]] LobbyConfig& config() noexcept

[[nodiscard]] const LobbyConfig& config() const noexcept

void setEventCallback(EventCallback callback)

void setGameStartCallback(GameStartCallback callback)

~LobbySystem()

LobbySystem() = default

LobbySystem(const LobbySystem&) = delete

LobbySystem& operator=(const LobbySystem&) = delete

LobbySystem(LobbySystem&&) = delete

LobbySystem& operator=(LobbySystem&&) = delete

class LocalTransport : public INetworkTransport 8

static void pair(LocalTransport& a, LocalTransport& b)

bool listen(std::uint16_t ) override

bool connect(std::string_view , std::uint16_t ) override

void disconnect(ConnectionId ) override

void send(ConnectionId id, const std::vector<std::uint8_t>& data) override

[[nodiscard]] std::vector<NetworkMessage> poll() override

[[nodiscard]] bool isConnected(ConnectionId ) const override

[[nodiscard]] NetworkStats stats() const override

enum MessageType : std::uint8_t 8

Connect = 0

Disconnect = 1

Heartbeat = 2

GameState = 3

Input = 4

RPC = 5

LobbyAction = 6

Custom = 255

enum DeliveryMode : std::uint8_t 8

Unreliable = 0

Reliable = 1

ReliableOrdered = 2

[[nodiscard]] inline GameMessage heartbeat(ConnectionId senderId)

[[nodiscard]] inline GameMessage connectRequest(std::string_view playerName)

[[nodiscard]] inline GameMessage disconnectNotice( ConnectionId senderId, std::string_view reason = "")

[[nodiscard]] inline GameMessage gameState( ConnectionId senderId, const nlohmann::json& stateJson)

[[nodiscard]] inline GameMessage input( ConnectionId senderId, const nlohmann::json& inputJson)

struct GameMessage 14

MessageType type = MessageType::Custom

ConnectionId senderId = INVALID_CONNECTION

std::uint32_t sequenceNumber = 0

std::uint64_t timestampMs = 0

DeliveryMode delivery = DeliveryMode::Reliable

std::uint8_t channel = 0

std::vector<std::uint8_t> payload

void stampNow() noexcept

void setJsonPayload(const nlohmann::json& j)

[[nodiscard]] std::optional<nlohmann::json> jsonPayload() const

void setTextPayload(std::string_view text)

[[nodiscard]] std::string textPayload() const

[[nodiscard]] std::vector<std::uint8_t> toBytes() const

[[nodiscard]] static std::optional<GameMessage> fromBytes( const std::vector<std::uint8_t>& data)

struct ReplicatedProperty 3

std::string name

int numValues = 3

uint32_t lastUpdateFrame = 0

struct ReplicatedEntity 5

int nodeId = -1

uint32_t networkId = 0

uint8_t ownerPeerId = 0

std::vector<ReplicatedProperty> properties

bool dirty = false

struct DeadReckoningState 2

double timestamp = 0.0

void predict(double t, float outPos[3]) const noexcept

class ReplicationManager 4

void registerEntity(int nodeId, uint8_t ownerPeerId)

void updateProperty(uint32_t networkId, const std::string& propName, const float* values, int numValues)

[[nodiscard]] std::vector<uint8_t> serializeDirty()

[[nodiscard]] size_t entityCount() const noexcept

enum SessionMode : std::uint8_t 4

None = 0

Server = 1

Client = 2

P2P = 3

enum PeerState : std::uint8_t 4

Connecting = 0

Connected = 1

Disconnecting = 2

Disconnected = 3

enum SessionEvent : std::uint8_t 5

PeerConnected = 0

PeerDisconnected = 1

PeerTimedOut = 2

SessionStarted = 3

SessionEnded = 4

struct PeerInfo 7

ConnectionId connectionId = INVALID_CONNECTION

std::string name

PeerState state = PeerState::Disconnected

float latencyMs = 0.0f

float lastHeartbeatTime = 0.0f

float connectedSince = 0.0f

std::uint32_t nextSequence = 0

struct SessionConfig 6

float heartbeatIntervalSec = 1.0f

float timeoutSec = 10.0f

float reconnectDelaySec = 3.0f

std::uint32_t maxPeers = 16

bool autoReconnect = true

std::string playerName = "Player"

struct SessionEventInfo 3

SessionEvent event = SessionEvent::PeerConnected

ConnectionId peerId = INVALID_CONNECTION

std::string detail

class NetworkSession 25

using EventCallback = std::function<void(const SessionEventInfo&)>;

using MessageHandler = std::function<void(const GameMessage&)>;

bool hostAsServer(std::uint16_t port, std::shared_ptr<INetworkTransport> transport)

bool joinAsClient(std::string_view host, std::uint16_t port, std::shared_ptr<INetworkTransport> transport)

bool startP2P(std::uint16_t port, std::shared_ptr<INetworkTransport> transport)

void shutdown()

void update(float deltaTimeSec)

void sendTo(ConnectionId peerId, GameMessage msg)

void broadcast(GameMessage msg)

void broadcastGameState(const nlohmann::json& stateJson)

void sendInput(const nlohmann::json& inputJson)

[[nodiscard]] std::vector<GameMessage> receive()

[[nodiscard]] const PeerInfo* getPeer(ConnectionId peerId) const

[[nodiscard]] const std::unordered_map<ConnectionId, PeerInfo>& peers() const noexcept

[[nodiscard]] std::size_t connectedPeerCount() const noexcept

void disconnectPeer(ConnectionId peerId, std::string_view reason = "")

[[nodiscard]] SessionConfig& config() noexcept

[[nodiscard]] const SessionConfig& config() const noexcept

[[nodiscard]] SessionMode mode() const noexcept

void setLocalId(ConnectionId id) noexcept

[[nodiscard]] ConnectionId localId() const noexcept

void setEventCallback(EventCallback callback)

void onMessage(MessageType type, MessageHandler handler)

[[nodiscard]] bool isActive() const noexcept

[[nodiscard]] float elapsedTime() const noexcept

enum AuthorityMode : std::uint8_t 4

HostAuthoritative = 0

OwnerAuthoritative = 1

Shared = 2

[[nodiscard]] inline nlohmann::json lerpJsonNumeric( const nlohmann::json& a, const nlohmann::json& b, float alpha)

class SyncableComponent 9

virtual ~SyncableComponent() = default

[[nodiscard]] virtual std::uint32_t syncId() const = 0

[[nodiscard]] virtual nlohmann::json serialize() const = 0

virtual void deserialize(const nlohmann::json& j) = 0

[[nodiscard]] virtual bool isDirty() const

virtual void clearDirty()

void markDirty()

[[nodiscard]] ConnectionId ownerId() const noexcept

void setOwnerId(ConnectionId id) noexcept

struct StateDelta 5

std::uint64_t version = 0

std::uint64_t timestampMs = 0

nlohmann::json states

[[nodiscard]] nlohmann::json toJson() const

[[nodiscard]] static std::optional<StateDelta> fromJson(const nlohmann::json& j)

struct SyncSnapshot 2

std::uint64_t timestampMs = 0

nlohmann::json state

class SyncManager 16

`using InterpolateFunc = std::function<nlohmann::json( const nlohmann::json&, const nlohmann::json&, float)>;`

void registerComponent(SyncableComponent* component)

void unregisterComponent(std::uint32_t syncId)

void setAuthorityMode(AuthorityMode mode) noexcept

void setLocalPeerId(ConnectionId id) noexcept

[[nodiscard]] bool hasAuthority(std::uint32_t syncId) const

void setIsHost(bool isHost) noexcept

[[nodiscard]] StateDelta collectDirtyStates()

void applyRemoteDelta(const StateDelta& delta)

void interpolate(std::uint64_t renderTimeMs)

void extrapolate(std::uint64_t currentTimeMs, std::uint64_t maxExtrapolateMs = 200)

void setInterpolateFunc(InterpolateFunc func)

[[nodiscard]] std::size_t componentCount() const noexcept

[[nodiscard]] nlohmann::json fullSnapshot() const

void applyFullSnapshot(const nlohmann::json& snapshot)

void clearSnapshots()

enum NetworkEvent 6

Connected

Disconnected

DataReceived

Error

using ConnectionId = std::uint32_t;

constexpr ConnectionId INVALID_CONNECTION = 0

struct PacketHeader 3

std::uint32_t size = 0

std::uint32_t type = 0

std::uint32_t sequence = 0

struct NetworkMessage 3

ConnectionId sender = INVALID_CONNECTION

PacketHeader header

std::vector<std::uint8_t> payload

struct NetworkStats 6

std::uint64_t bytesSent = 0

std::uint64_t bytesReceived = 0

std::uint64_t packetsSent = 0

std::uint64_t packetsReceived = 0

float latencyMs = 0.0f

float packetLoss = 0.0f

struct TestResult 3

std::string name

bool passed = false

std::string detail

struct ValidationReport 3

bool allPassed = false

std::vector<TestResult> results

[[nodiscard]] std::string toJson() const

class NetworkValidator 5

[[nodiscard]] bool testLocalTransport() const

[[nodiscard]] bool testTcpLoopback() const

[[nodiscard]] bool testStateSync() const

[[nodiscard]] bool testLobby() const

[[nodiscard]] ValidationReport runAll() const

enum ConnectionStatus : std::uint8_t 5

Connecting = 0

Connected

Disconnected

Failed

[[nodiscard]] inline std::unique_ptr<IReliableTransport> createReliableTransport()

struct ReceivedPacket 4

ConnectionId connectionId = INVALID_CONNECTION

std::vector<std::uint8_t> data

std::uint32_t size = 0

bool reliable = true

class IReliableTransport 11

virtual ~IReliableTransport() = default

virtual bool listen(std::uint16_t port) = 0

virtual ConnectionId connect(std::string_view address, std::uint16_t port) = 0

virtual void disconnect(ConnectionId connId) = 0

virtual void send(ConnectionId connId, const void* data, std::uint32_t size, bool reliable = true) = 0

[[nodiscard]] virtual std::vector<ReceivedPacket> receive() = 0

virtual void poll() = 0

[[nodiscard]] virtual ConnectionStatus getConnectionStatus( ConnectionId connId) const = 0

void setOnConnected(std::function<void(ConnectionId)> callback)

void setOnDisconnected(std::function<void(ConnectionId)> callback)

void setOnData(std::function<void(const ReceivedPacket&)> callback)

class GnsReliableTransport : public IReliableTransport 13

GnsReliableTransport()

~GnsReliableTransport() override

GnsReliableTransport(const GnsReliableTransport&) = delete

GnsReliableTransport& operator=(const GnsReliableTransport&) = delete

GnsReliableTransport(GnsReliableTransport&&) = delete

GnsReliableTransport& operator=(GnsReliableTransport&&) = delete

bool listen(std::uint16_t port) override

ConnectionId connect(std::string_view address, std::uint16_t port) override

void disconnect(ConnectionId connId) override

void send(ConnectionId connId, const void* data, std::uint32_t size, bool reliable) override

[[nodiscard]] std::vector<ReceivedPacket> receive() override

void poll() override

[[nodiscard]] ConnectionStatus getConnectionStatus( ConnectionId connId) const override

class NullReliableTransport : public IReliableTransport 19

bool listen([[maybe_unused]] std::uint16_t port) override

ConnectionId connect([[maybe_unused]] std::string_view address, [[maybe_unused]] std::uint16_t port) override

void disconnect([[maybe_unused]] ConnectionId connId) override

void send([[maybe_unused]] ConnectionId connId, [[maybe_unused]] const void* data, [[maybe_unused]] std::uint32_t size, [[maybe_unused]] bool reliable) override

[[nodiscard]] std::vector<ReceivedPacket> receive() override

void poll() override

[[nodiscard]] ConnectionStatus getConnectionStatus( [[maybe_unused]] ConnectionId connId) const override

using SocketHandle = SOCKET;

using SocketHandle = int;

inline constexpr SocketHandle INVALID_SOCK = INVALID_SOCKET

inline constexpr SocketHandle INVALID_SOCK = -1

inline constexpr int SOCK_ERR = SOCKET_ERROR

inline constexpr int SOCK_ERR = -1

inline constexpr int WOULD_BLOCK_ERR = WSAEWOULDBLOCK

inline constexpr int WOULD_BLOCK_ERR = EWOULDBLOCK

[[nodiscard]] inline int lastSocketError() noexcept

[[nodiscard]] inline bool isWouldBlock(int err) noexcept

inline void closeSocket(SocketHandle sock) noexcept

[[nodiscard]] inline bool setNonBlocking(SocketHandle sock) noexcept

class WsaGuard 7

WsaGuard() noexcept

~WsaGuard() noexcept

[[nodiscard]] bool isInitialized() const noexcept

WsaGuard(const WsaGuard&) = delete

WsaGuard& operator=(const WsaGuard&) = delete

WsaGuard(WsaGuard&&) = delete

WsaGuard& operator=(WsaGuard&&) = delete

class StateSync 6

void setAuthority(bool isServer) noexcept

void pushState(std::string stateJson)

[[nodiscard]] std::string latestState() const

[[nodiscard]] std::uint64_t stateVersion() const noexcept

void acknowledgeVersion(std::uint64_t version)

[[nodiscard]] std::size_t pendingCount() const noexcept

class TcpTransport : public INetworkTransport 16

TcpTransport() = default

~TcpTransport() override

TcpTransport(const TcpTransport&) = delete

TcpTransport& operator=(const TcpTransport&) = delete

TcpTransport(TcpTransport&&) = delete

TcpTransport& operator=(TcpTransport&&) = delete

[[nodiscard]] bool isWsaInitialized() const noexcept

[[nodiscard]] uint16_t getLocalPort() const noexcept

bool listen(std::uint16_t port) override

bool connect(std::string_view host, std::uint16_t port) override

void disconnect(ConnectionId id) override

void send(ConnectionId id, const std::vector<std::uint8_t>& data) override

[[nodiscard]] std::vector<NetworkMessage> poll() override

[[nodiscard]] bool isConnected(ConnectionId id) const override

[[nodiscard]] NetworkStats stats() const override

[[nodiscard]] bool isListening() const noexcept

class UdpTransport : public INetworkTransport 16

UdpTransport() = default

~UdpTransport() override

UdpTransport(const UdpTransport&) = delete

UdpTransport& operator=(const UdpTransport&) = delete

UdpTransport(UdpTransport&&) = delete

UdpTransport& operator=(UdpTransport&&) = delete

[[nodiscard]] bool isInitialized() const noexcept

[[nodiscard]] uint16_t getLocalPort() const noexcept

bool listen(std::uint16_t port) override

bool connect(std::string_view host, std::uint16_t port) override

void disconnect(ConnectionId id) override

void send(ConnectionId id, const std::vector<std::uint8_t>& data) override

[[nodiscard]] std::vector<NetworkMessage> poll() override

[[nodiscard]] bool isConnected(ConnectionId id) const override

[[nodiscard]] NetworkStats stats() const override

[[nodiscard]] bool isServerMode() const noexcept

enum WsOpcode : std::uint8_t 6

Continuation = 0x0

Text = 0x1

Binary = 0x2

Close = 0x8

Ping = 0x9

Pong = 0xA

struct WsFrameHeader 5

bool fin = false

WsOpcode opcode = WsOpcode::Binary

bool masked = false

std::uint64_t payloadLen = 0

std::size_t headerSize = 0

class WebSocketTransport : public INetworkTransport 14

WebSocketTransport() = default

~WebSocketTransport() override

WebSocketTransport(const WebSocketTransport&) = delete

WebSocketTransport& operator=(const WebSocketTransport&) = delete

WebSocketTransport(WebSocketTransport&&) = delete

WebSocketTransport& operator=(WebSocketTransport&&) = delete

bool listen(std::uint16_t port) override

bool connect(std::string_view host, std::uint16_t port) override

void disconnect(ConnectionId id) override

void send(ConnectionId id, const std::vector<std::uint8_t>& data) override

[[nodiscard]] std::vector<NetworkMessage> poll() override

[[nodiscard]] bool isConnected(ConnectionId id) const override

[[nodiscard]] NetworkStats stats() const override

[[nodiscard]] uint16_t getLocalPort() const noexcept

---

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.