NetworkManager Class Reference

#include <NetworkManager.h>

Inheritance diagram for NetworkManager:

Collaboration diagram for NetworkManager:

Public Member Functions
	NetworkManager (flecs::world ecs, std::shared_ptr< IdentityManager > identity_manager)
void	setup (std::weak_ptr< BoardManager > board_manager, std::weak_ptr< GameTableManager > gametable_manager)
	~NetworkManager ()
void	startServer (ConnectionType mode, unsigned short port, bool tryUpnp)
void	startServer (std::string internal_ip_address, unsigned short port)
void	closeServer ()
bool	isConnected ()
bool	isHosting () const
bool	hasAnyPeer () const
int	connectedPeerCount () const
void	allowPort (unsigned int port)
void	disallowPort (unsigned short port)
std::string	getNetworkInfo (ConnectionType type)
std::string	getLocalIPAddress ()
std::string	getExternalIPAddress ()
std::string	getLocalTunnelURL ()
void	parseConnectionString (std::string connection_string, std::string &server, unsigned short &port, std::string &password)
unsigned short	getPort () const
std::string	getNetworkPassword () const
void	setPort (unsigned int port)
void	setNetworkPassword (const char *password)
Role	getPeerRole () const
void	ShowPortForwardingHelpPopup (bool *p_open)
rtc::Configuration	getRTCConfig () const
bool	connectToPeer (const std::string &connectionString)
bool	disconectFromPeers ()
bool	removePeer (std::string peerId)
bool	clearPeers () const
bool	disconnectAllPeers ()
std::size_t	removeDisconnectedPeers ()
void	broadcastPeerDisconnect (const std::string &targetId)
void	onPeerLocalDescription (const std::string &peerId, const rtc::Description &desc)
void	onPeerLocalCandidate (const std::string &peerId, const rtc::Candidate &cand)
std::shared_ptr< PeerLink >	ensurePeerLink (const std::string &peerId)
std::string	displayNameForPeer (const std::string &peerId) const
std::string	getMyUsername () const
std::string	getMyUniqueId () const
const std::string &	getMyPeerId () const
void	setMyPeerId (std::string v)
const std::unordered_map< std::string, std::shared_ptr< PeerLink > > &	getPeers () const
std::shared_ptr< SignalingServer >	getSignalingServer () const
bool	tryPopReadyMessage (msg::ReadyMessage &out)
bool	tryPopRawMessage (msg::InboundRaw &out)
void	drainEvents ()
void	drainInboundRaw (int maxPerTick)
void	decodeRawChatBuffer (const std::string &fromPeer, const std::vector< uint8_t > &b)
void	decodeRawNotesBuffer (const std::string &fromPeer, const std::vector< uint8_t > &b)
void	startRawDrainWorker ()
void	stopRawDrainWorker ()
void	onPeerChannelOpen (const std::string &peerId, const std::string &label)
void	bootstrapPeerIfReady (const std::string &peerId)
void	broadcastGameTable (const flecs::entity &gameTable)
void	broadcastBoard (const flecs::entity &board)
void	broadcastFog (uint64_t boardId, const flecs::entity &fog)
void	broadcastFogUpdate (uint64_t boardId, const flecs::entity &fog)
void	broadcastFogDelete (uint64_t boardId, const flecs::entity &fog)
void	sendFogUpdate (uint64_t boardId, const flecs::entity &fog, const std::vector< std::string > &toPeerIds)
void	sendFogDelete (uint64_t boardId, const flecs::entity &fog, const std::vector< std::string > &toPeerIds)
void	sendGameTo (const std::string &peerId, const std::vector< unsigned char > &bytes)
void	broadcastGameFrame (const std::vector< unsigned char > &frame, const std::vector< std::string > &toPeerIds)
void	sendGameTable (const flecs::entity &gameTable, const std::vector< std::string > &toPeerIds)
void	sendBoard (const flecs::entity &board, const std::vector< std::string > &toPeerIds)
void	sendFog (uint64_t boardId, const flecs::entity &fog, const std::vector< std::string > &toPeerIds)
bool	sendImageChunks (msg::ImageOwnerKind kind, uint64_t id, const std::vector< unsigned char > &img, const std::vector< std::string > &toPeerIds)
void	setToaster (std::shared_ptr< ImGuiToaster > t)
void	pushStatusToast (const std::string &msg, ImGuiToaster::Level lvl, float durationSec=5.0f)
std::vector< std::string >	getConnectedPeerIds () const
std::vector< std::string >	getConnectedUsernames () const
void	setGMId (const std::string &id)
const std::string &	getGMId () const
void	decodeRawGameBuffer (const std::string &fromPeer, const std::vector< uint8_t > &b)
void	sendMarkerDelete (uint64_t boardId, const flecs::entity &marker, const std::vector< std::string > &toPeerIds)
void	broadcastMarkerDelete (uint64_t boardId, const flecs::entity &marker)
void	broadcastMarker (uint64_t boardId, const flecs::entity &marker)
void	sendMarker (uint64_t boardId, const flecs::entity &marker, const std::vector< std::string > &toPeerIds)
void	decodeRawMarkerMoveBuffer (const std::string &fromPeer, const std::vector< uint8_t > &b)
void	markDraggingLocal (uint64_t markerId, bool dragging)
bool	isMarkerBeingDragged (uint64_t markerId) const
bool	amIDragging (uint64_t markerId) const
void	forceCloseDrag (uint64_t markerId)
void	broadcastMarkerMove (uint64_t boardId, const flecs::entity &marker)
void	sendMarkerMove (uint64_t boardId, const flecs::entity &marker, const std::vector< std::string > &toPeerIds)
void	broadcastMarkerMoveState (uint64_t boardId, const flecs::entity &marker)
void	sendMarkerMoveState (uint64_t boardId, const flecs::entity &marker, const std::vector< std::string > &toPeerIds)
void	broadcastMarkerUpdate (uint64_t boardId, const flecs::entity &marker)
void	sendMarkerUpdate (uint64_t boardId, const flecs::entity &marker, const std::vector< std::string > &toPeerIds)
bool	shouldApplyMarkerMove (const msg::ReadyMessage &m)
bool	shouldApplyMarkerMoveStateStart (const msg::ReadyMessage &m)
bool	shouldApplyMarkerMoveStateFinal (const msg::ReadyMessage &m)
void	broadcastGridUpdate (uint64_t boardId, const flecs::entity &board)
void	sendGridUpdate (uint64_t boardId, const flecs::entity &board, const std::vector< std::string > &toPeerIds)
void	buildUserNameUpdate (std::vector< uint8_t > &out, uint64_t tableId, const std::string &userUniqueId, const std::string &oldUsername, const std::string &newUsername, bool reboundFlag) const
void	broadcastUserNameUpdate (const std::vector< uint8_t > &payload)
void	sendUserNameUpdateTo (const std::string &peerId, const std::vector< uint8_t > &payload)
void	upsertPeerIdentityWithUnique (const std::string &peerId, const std::string &uniqueId, const std::string &username)
bool	broadcastChatJson (const msg::Json &j)
bool	sendChatJsonTo (const std::string &peerId, const msg::Json &j)
bool	sendChatJsonTo (const std::set< std::string > &peers, const msg::Json &j)
std::shared_ptr< IdentityManager >	getIdentityManager ()
std::string	debugIdentitySnapshot () const
void	clearDragState (uint64_t markerId)
void	housekeepPeers ()
void	setCustomHost (const std::string &h)
const std::string &	getCustomHost () const

Public Attributes
MessageQueue< msg::NetEvent >	events_
MessageQueue< msg::InboundRaw >	inboundRaw_
std::unordered_map< uint64_t, DragState >	drag_

Private Member Functions
std::vector< unsigned char >	buildGridUpdateFrame (uint64_t boardId, const Grid &grid)
void	handleGridUpdate (const std::vector< uint8_t > &b, size_t &off)
uint32_t	getSendMoveMinPeriodMs () const
void	handleMarkerMove (const std::vector< uint8_t > &b, size_t &off)
void	handleMarkerUpdate (const std::vector< uint8_t > &b, size_t &off)
void	handleMarkerMoveState (const std::vector< uint8_t > &b, size_t &off)
std::vector< unsigned char >	buildMarkerMoveFrame (uint64_t boardId, const flecs::entity &marker, uint32_t seq)
std::vector< unsigned char >	buildMarkerMoveStateFrame (uint64_t boardId, const flecs::entity &marker)
std::vector< unsigned char >	buildMarkerUpdateFrame (uint64_t boardId, const flecs::entity &marker)
void	handleMarkerDelete (const std::vector< uint8_t > &b, size_t &off)
std::vector< unsigned char >	buildMarkerDeleteFrame (uint64_t boardId, uint64_t markerId)
std::vector< uint8_t >	buildCommitMarkerFrame (uint64_t boardId, uint64_t markerId)
std::vector< uint8_t >	buildCreateMarkerFrame (uint64_t boardId, const flecs::entity &marker, uint64_t imageBytesTotal)
void	handleMarkerMeta (const std::vector< uint8_t > &b, size_t &off)
void	handleGameTableSnapshot (const std::vector< uint8_t > &b, size_t &off)
void	handleBoardMeta (const std::vector< uint8_t > &b, size_t &off)
void	handleFogCreate (const std::vector< uint8_t > &b, size_t &off)
void	handleImageChunk (const std::vector< uint8_t > &b, size_t &off)
void	handleCommitBoard (const std::vector< uint8_t > &b, size_t &off)
void	handleCommitMarker (const std::vector< uint8_t > &b, size_t &off)
void	handleUserNameUpdate (const std::vector< uint8_t > &b, size_t &off)
void	handleFogUpdate (const std::vector< uint8_t > &b, size_t &off)
void	handleFogDelete (const std::vector< uint8_t > &b, size_t &off)
void	tryFinalizeImage (msg::ImageOwnerKind kind, uint64_t id)
std::vector< uint8_t >	buildSnapshotGameTableFrame (uint64_t gameTableId, const std::string &name)
std::vector< uint8_t >	buildSnapshotBoardFrame (const flecs::entity &board, uint64_t imageBytesTotal)
std::vector< uint8_t >	buildFogCreateFrame (uint64_t boardId, const flecs::entity &fog)
std::vector< uint8_t >	buildImageChunkFrame (uint8_t ownerKind, uint64_t id, uint64_t offset, const uint8_t *data, size_t len)
std::vector< uint8_t >	buildCommitBoardFrame (uint64_t boardId)
std::vector< unsigned char >	buildFogUpdateFrame (uint64_t boardId, const flecs::entity &fog)
std::vector< unsigned char >	buildFogDeleteFrame (uint64_t boardId, uint64_t fogId)
std::vector< unsigned char >	readFileBytes (const std::string &path)

Static Private Member Functions
static bool	tieBreakWins (const std::string &challengerPeerId, const std::string &currentOwnerPeerId)
static bool	hasUrlScheme (const std::string &s)
static bool	ensureRemaining (const std::vector< uint8_t > &b, size_t off, size_t need)
static uint64_t	nowMs ()

Private Attributes
std::string	customHost_
std::string	decodingFromPeer_
uint32_t	sendMoveMinPeriodMs_ {50}
std::unordered_map< uint64_t, PendingImage >	imagesRx_
MessageQueue< msg::ReadyMessage >	inboundGame_
std::atomic< bool >	rawWorkerRunning_ {false}
std::atomic< bool >	rawWorkerStop_ {false}
std::thread	rawWorker_
std::shared_ptr< IdentityManager >	identity_manager
std::shared_ptr< ImGuiToaster >	toaster_
std::string	myPeerId_
std::string	gmPeerId_
flecs::world	ecs
unsigned int	port = 8080
char	network_password [124] = "\0"
std::string	external_ip_address = ""
std::string	local_ip_address = ""
Role	peer_role
rtc::Configuration	rtcConfig
std::shared_ptr< SignalingServer >	signalingServer
std::shared_ptr< SignalingClient >	signalingClient
std::unordered_map< std::string, std::shared_ptr< PeerLink > >	peers
std::weak_ptr< BoardManager >	board_manager
std::weak_ptr< GameTableManager >	gametable_manager

Static Private Attributes
static constexpr size_t	kChunk = 8 * 1024
static constexpr int	kPaceEveryN = 48
static constexpr int	kPaceMillis = 2

Detailed Description

Definition at line 66 of file NetworkManager.h.

Constructor & Destructor Documentation

NetworkManager()

NetworkManager::NetworkManager	(	flecs::world	ecs,
		std::shared_ptr< IdentityManager >	identity_manager )

Definition at line 14 of file NetworkManager.cpp.

                                                                                              :
    ecs(ecs), identity_manager(identity_manager), peer_role(Role::NONE)
{
    getLocalIPAddress();
    getExternalIPAddress();
    rtc::InitLogger(rtc::LogLevel::Verbose);
    NetworkUtilities::setupTLS();
}

Here is the call graph for this function:

~NetworkManager()

NetworkManager::~NetworkManager

(

)

Definition at line 47 of file NetworkManager.cpp.

{
    closeServer();
    disconnectAllPeers();
}

Here is the call graph for this function:

Member Function Documentation

allowPort()

void NetworkManager::allowPort

(

unsigned int

port

)

amIDragging()

bool NetworkManager::amIDragging

(

uint64_t

markerId

)

const

Definition at line 1450 of file NetworkManager.cpp.

{
    auto it = drag_.find(markerId);
    if (it == drag_.end())
        return false;
    const auto& s = it->second;
 
    // If we started the drag locally, trust the local flag.
    if (!s.closed && s.locallyDragging)
        return true;
 
    // Otherwise fall back to peer-id ownership (remote handoff cases).
    return !s.closed && s.ownerPeerId == getMyPeerId();
}

Here is the call graph for this function:

bootstrapPeerIfReady()

void NetworkManager::bootstrapPeerIfReady

(

const std::string &

peerId

)

Definition at line 2550 of file NetworkManager.cpp.

{
    Logger::instance().log("localtunnel", Logger::Level::Info, "BeginBoostrap");
    auto gm = gametable_manager.lock();
    auto bm = board_manager.lock();
    if (!gm)
    {
        throw std::exception("[NetworkManager] GametableManager Expired!!");
    }
    if (!bm)
    {
        throw std::exception("[NetworkManager] BoardManager Expired!!");
    }
 
    auto it = peers.find(peerId);
    if (it == peers.end() || !it->second)
        return;
    auto& link = it->second;
    if (link->bootstrapSent())
        return; // one-shot per connection
    if (gm->active_game_table.is_valid() && gm->active_game_table.has<GameTable>())
    {
        sendGameTable(gm->active_game_table, {peerId});
        Logger::instance().log("localtunnel", Logger::Level::Info, "SentGameTable");
    }
 
    if (bm->isBoardActive())
    {
        auto boardEnt = bm->getActiveBoard();
        if (boardEnt.is_valid() && boardEnt.has<Board>())
        {
            sendBoard(boardEnt, {peerId}); // this sends meta + image chunks + commit
            Logger::instance().log("localtunnel", Logger::Level::Info, "SentBoard");
        }
    }
 
    link->markBootstrapSent();
}

Here is the call graph for this function:

Here is the caller graph for this function:

broadcastBoard()

void NetworkManager::broadcastBoard

(

const flecs::entity &

board

)

Definition at line 979 of file NetworkManager.cpp.

{ //{check}--USE THIS METHOD
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
    {
        sendBoard(board, ids);
    }
}

Here is the call graph for this function:

broadcastChatJson()

bool NetworkManager::broadcastChatJson

(

const msg::Json &

j

)

Definition at line 1074 of file NetworkManager.cpp.

{
    const std::string text = j.dump(); // UTF-8 JSON
    bool any = false;
    for (auto& [pid, link] : peers)
    {
        if (link->sendOn(msg::dc::name::Chat, std::string_view(text)))
            any = true;
    }
    return any;
}

broadcastFog()

void NetworkManager::broadcastFog	(	uint64_t	boardId,
		const flecs::entity &	fog )

Definition at line 997 of file NetworkManager.cpp.

{ //{check}--USE THIS METHOD
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
    {
        sendFog(boardId, fog, ids);
    }
}

Here is the call graph for this function:

broadcastFogDelete()

void NetworkManager::broadcastFogDelete	(	uint64_t	boardId,
		const flecs::entity &	fog )

Definition at line 1024 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendFogDelete(boardId, fog, ids);
}

Here is the call graph for this function:

broadcastFogUpdate()

void NetworkManager::broadcastFogUpdate	(	uint64_t	boardId,
		const flecs::entity &	fog )

Definition at line 1017 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendFogUpdate(boardId, fog, ids);
}

Here is the call graph for this function:

broadcastGameFrame()

void NetworkManager::broadcastGameFrame	(	const std::vector< unsigned char > &	frame,
		const std::vector< std::string > &	toPeerIds )

Definition at line 2791 of file NetworkManager.cpp.

{
    for (auto& pid : toPeerIds)
    {
        sendGameTo(pid, frame);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

broadcastGameTable()

void NetworkManager::broadcastGameTable

(

const flecs::entity &

gameTable

)

Definition at line 970 of file NetworkManager.cpp.

{ //{check}--USE THIS METHOD
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
    {
        sendGameTable(gameTable, ids);
    }
}

Here is the call graph for this function:

broadcastGridUpdate()

void NetworkManager::broadcastGridUpdate	(	uint64_t	boardId,
		const flecs::entity &	board )

Definition at line 1893 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendGridUpdate(boardId, board, ids);
}

Here is the call graph for this function:

broadcastMarker()

void NetworkManager::broadcastMarker	(	uint64_t	boardId,
		const flecs::entity &	marker )

Definition at line 988 of file NetworkManager.cpp.

{ //{check}--USE THIS METHOD
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
    {
        sendMarker(boardId, marker, ids);
    }
}

Here is the call graph for this function:

broadcastMarkerDelete()

void NetworkManager::broadcastMarkerDelete	(	uint64_t	boardId,
		const flecs::entity &	marker )

Definition at line 1010 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendMarkerDelete(boardId, marker, ids);
}

Here is the call graph for this function:

broadcastMarkerMove()

void NetworkManager::broadcastMarkerMove	(	uint64_t	boardId,
		const flecs::entity &	marker )

Definition at line 1387 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendMarkerMove(boardId, marker, ids);
}

Here is the call graph for this function:

broadcastMarkerMoveState()

void NetworkManager::broadcastMarkerMoveState	(	uint64_t	boardId,
		const flecs::entity &	marker )

Definition at line 1421 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendMarkerMoveState(boardId, marker, ids);
}

Here is the call graph for this function:

broadcastMarkerUpdate()

void NetworkManager::broadcastMarkerUpdate	(	uint64_t	boardId,
		const flecs::entity &	marker )

Definition at line 1380 of file NetworkManager.cpp.

{
    auto ids = getConnectedPeerIds();
    if (!ids.empty())
        sendMarkerUpdate(boardId, marker, ids);
}

Here is the call graph for this function:

broadcastPeerDisconnect()

void NetworkManager::broadcastPeerDisconnect

(

const std::string &

targetId

)

Definition at line 869 of file NetworkManager.cpp.

{
    if (!signalingClient)
        return; // GM might be loopbacked as a client; else send via server
    auto j = msg::makePeerDisconnect(targetId, /*broadcast*/ true);
    signalingClient->send(j.dump());
}

Here is the call graph for this function:

broadcastUserNameUpdate()

void NetworkManager::broadcastUserNameUpdate

(

const std::vector< uint8_t > &

payload

)

Definition at line 1048 of file NetworkManager.cpp.

{
    for (auto& [pid, link] : peers)
    {
        if (!link)
            continue;
        sendUserNameUpdateTo(pid, payload);
    }
}

Here is the call graph for this function:

buildCommitBoardFrame()

std::vector< unsigned char > NetworkManager::buildCommitBoardFrame ( uint64_t boardId )

private

Definition at line 2766 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::CommitBoard));
    Serializer::serializeUInt64(b, boardId);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildCommitMarkerFrame()

std::vector< unsigned char > NetworkManager::buildCommitMarkerFrame ( uint64_t boardId, uint64_t markerId )

private

Definition at line 2774 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::CommitMarker));
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeUInt64(b, markerId);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildCreateMarkerFrame()

std::vector< unsigned char > NetworkManager::buildCreateMarkerFrame ( uint64_t boardId, const flecs::entity & marker, uint64_t imageBytesTotal )

private

Definition at line 2709 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::MarkerCreate));
 
    auto mid = marker.get<Identifier>()->id;
    auto pos = *marker.get<Position>();
    auto sz = *marker.get<Size>();
    auto vis = *marker.get<Visibility>();
    auto mov = *marker.get<Moving>();
 
    std::string name = "marker_" + std::to_string(mid);
 
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeUInt64(b, mid);
    Serializer::serializeString(b, name);
 
    Serializer::serializePosition(b, &pos);
    Serializer::serializeSize(b, &sz);
    Serializer::serializeVisibility(b, &vis);
    Serializer::serializeMoving(b, &mov);
 
    Serializer::serializeUInt64(b, imageBytesTotal);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildFogCreateFrame()

std::vector< unsigned char > NetworkManager::buildFogCreateFrame ( uint64_t boardId, const flecs::entity & fog )

private

Definition at line 2735 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::FogCreate));
 
    auto fid = fog.get<Identifier>()->id;
    auto pos = *fog.get<Position>();
    auto sz = *fog.get<Size>();
    auto vis = *fog.get<Visibility>();
 
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeUInt64(b, fid);
    Serializer::serializePosition(b, &pos);
    Serializer::serializeSize(b, &sz);
    Serializer::serializeVisibility(b, &vis);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildFogDeleteFrame()

std::vector< unsigned char > NetworkManager::buildFogDeleteFrame ( uint64_t boardId, uint64_t fogId )

private

Definition at line 2656 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::FogDelete));
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeUInt64(b, fogId);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildFogUpdateFrame()

std::vector< unsigned char > NetworkManager::buildFogUpdateFrame ( uint64_t boardId, const flecs::entity & fog )

private

Definition at line 2638 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::FogUpdate));
    Serializer::serializeUInt64(b, boardId);
 
    const auto id = fog.get<Identifier>()->id;
    const auto pos = *fog.get<Position>();
    const auto siz = *fog.get<Size>();
    const auto vis = *fog.get<Visibility>();
 
    Serializer::serializeUInt64(b, id);
    Serializer::serializePosition(b, &pos);
    Serializer::serializeSize(b, &siz);
    Serializer::serializeVisibility(b, &vis);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildGridUpdateFrame()

std::vector< unsigned char > NetworkManager::buildGridUpdateFrame ( uint64_t boardId, const Grid & grid )

private

Definition at line 1911 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::GridUpdate));
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeGrid(b, &grid);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildImageChunkFrame()

std::vector< unsigned char > NetworkManager::buildImageChunkFrame ( uint8_t ownerKind, uint64_t id, uint64_t offset, const uint8_t * data, size_t len )

private

Definition at line 2753 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::ImageChunk));
    Serializer::serializeUInt8(b, ownerKind);
    Serializer::serializeUInt64(b, id);
    Serializer::serializeUInt64(b, offset);
    // len as int32
    Serializer::serializeInt(b, static_cast<int>(len));
    b.insert(b.end(), data, data + len);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildMarkerDeleteFrame()

std::vector< unsigned char > NetworkManager::buildMarkerDeleteFrame ( uint64_t boardId, uint64_t markerId )

private

Definition at line 2628 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::MarkerDelete));
    Serializer::serializeUInt64(b, boardId);
    Serializer::serializeUInt64(b, markerId);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildMarkerMoveFrame()

std::vector< unsigned char > NetworkManager::buildMarkerMoveFrame ( uint64_t boardId, const flecs::entity & marker, uint32_t seq )

private

Definition at line 1299 of file NetworkManager.cpp.

{
    std::vector<unsigned char> out;
    const auto* id = marker.get<Identifier>();
    const auto* pos = marker.get<Position>();
    if (!id || !pos)
        return out;
 
    // epoch from drag_ state
    auto& s = drag_[id->id];
    if (s.locallyProposedEpoch == 0 && s.epoch == 0)
    {
        s.locallyProposedEpoch = s.epoch + 1;
        s.epoch = s.locallyProposedEpoch;
    }
    const uint32_t epoch = (s.locallyProposedEpoch ? s.locallyProposedEpoch : s.epoch);
    const uint64_t ts = nowMs();
 
    Serializer::serializeUInt8(out, static_cast<uint8_t>(msg::DCType::MarkerMove));
    Serializer::serializeUInt64(out, boardId);
    Serializer::serializeUInt64(out, id->id);
    Serializer::serializeUInt32(out, epoch);
    Serializer::serializeUInt32(out, seq);
    Serializer::serializeUInt64(out, ts);
    Serializer::serializePosition(out, pos);
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildMarkerMoveStateFrame()

std::vector< unsigned char > NetworkManager::buildMarkerMoveStateFrame ( uint64_t boardId, const flecs::entity & marker )

private

Definition at line 1326 of file NetworkManager.cpp.

{
    std::vector<unsigned char> out;
    const auto* id = marker.get<Identifier>();
    const auto* mv = marker.get<Moving>();
    if (!id || !mv)
        return out;
 
    auto& s = drag_[id->id];
    if (s.locallyProposedEpoch == 0 && s.epoch == 0)
    {
        s.locallyProposedEpoch = s.epoch + 1;
        s.epoch = s.locallyProposedEpoch;
    }
    const uint32_t epoch = (s.locallyProposedEpoch ? s.locallyProposedEpoch : s.epoch);
    const uint32_t seq = ++s.localSeq;
    const uint64_t ts = nowMs();
    s.lastTxMs = ts;
 
    Serializer::serializeUInt8(out, static_cast<uint8_t>(msg::DCType::MarkerMoveState));
    Serializer::serializeUInt64(out, boardId);
    Serializer::serializeUInt64(out, id->id);
    Serializer::serializeUInt32(out, epoch);
    Serializer::serializeUInt32(out, seq);
    Serializer::serializeUInt64(out, ts);
    Serializer::serializeMoving(out, mv); // isDragging
 
    if (!mv->isDragging && marker.has<Position>())
    {
        const auto* pos = marker.get<Position>(); // final pos at end
        Serializer::serializePosition(out, pos);
    }
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildMarkerUpdateFrame()

std::vector< unsigned char > NetworkManager::buildMarkerUpdateFrame ( uint64_t boardId, const flecs::entity & marker )

private

Definition at line 1362 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::MarkerUpdate));
    Serializer::serializeUInt64(b, boardId);
 
    const auto id = marker.get<Identifier>()->id;
    const auto siz = *marker.get<Size>();
    const auto vis = *marker.get<Visibility>();
    const auto mc = *marker.get<MarkerComponent>();
 
    Serializer::serializeUInt64(b, id);
    Serializer::serializeSize(b, &siz);
    Serializer::serializeVisibility(b, &vis);
    Serializer::serializeMarkerComponent(b, &mc);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildSnapshotBoardFrame()

std::vector< unsigned char > NetworkManager::buildSnapshotBoardFrame ( const flecs::entity & board, uint64_t imageBytesTotal )

private

Definition at line 2674 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::Snapshot_Board));
 
    // Required components
    auto id = board.get<Identifier>()->id;
    auto bd = *board.get<Board>();
    auto pan = *board.get<Panning>();
    auto grid = *board.get<Grid>();
    auto size = *board.get<Size>();
 
    Serializer::serializeUInt64(b, id);
    Serializer::serializeString(b, bd.board_name);
 
    // Panning
    Serializer::serializeBool(b, pan.isPanning);
 
    // Grid
    Serializer::serializeVec2(b, grid.offset);
    Serializer::serializeFloat(b, grid.cell_size);
    Serializer::serializeBool(b, grid.is_hex);
    Serializer::serializeBool(b, grid.snap_to_grid);
    Serializer::serializeBool(b, grid.visible);
    Serializer::serializeFloat(b, grid.opacity);
 
    // Size
    Serializer::serializeFloat(b, size.width);
    Serializer::serializeFloat(b, size.height);
 
    // Image total size in bytes (u64)
    Serializer::serializeUInt64(b, imageBytesTotal);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildSnapshotGameTableFrame()

std::vector< unsigned char > NetworkManager::buildSnapshotGameTableFrame ( uint64_t gameTableId, const std::string & name )

private

Definition at line 2665 of file NetworkManager.cpp.

{
    std::vector<unsigned char> b;
    Serializer::serializeUInt8(b, static_cast<uint8_t>(msg::DCType::Snapshot_GameTable));
    Serializer::serializeUInt64(b, gameTableId);
    Serializer::serializeString(b, name);
    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildUserNameUpdate()

void NetworkManager::buildUserNameUpdate	(	std::vector< uint8_t > &	out,
		uint64_t	tableId,
		const std::string &	userUniqueId,
		const std::string &	oldUsername,
		const std::string &	newUsername,
		bool	reboundFlag ) const

Definition at line 1033 of file NetworkManager.cpp.

{
    out.clear();
    Serializer::serializeUInt64(out, tableId);
    Serializer::serializeString(out, userUniqueId); // <— uniqueId
    Serializer::serializeString(out, oldUsername);
    Serializer::serializeString(out, newUsername);
    Serializer::serializeUInt8(out, reboundFlag ? 1 : 0);
}

Here is the call graph for this function:

clearDragState()

void NetworkManager::clearDragState

(

uint64_t

markerId

)

Definition at line 963 of file NetworkManager.cpp.

{
    drag_.erase(markerId);
}

clearPeers()

bool NetworkManager::clearPeers ( ) const

inline

Definition at line 121 of file NetworkManager.h.

    {
        for (auto [id, peer] : peers)
        {
            peer->close();
        }
        return peers.empty();
    }

closeServer()

void NetworkManager::closeServer

(

)

Definition at line 307 of file NetworkManager.cpp.

{
    if (signalingServer.get() != nullptr)
    {
        peer_role = Role::NONE;
        signalingServer->stop();
    }
    //stopRawDrainWorker();
    NetworkUtilities::stopLocalTunnel();
}

Here is the call graph for this function:

Here is the caller graph for this function:

connectedPeerCount()

int NetworkManager::connectedPeerCount

(

)

const

Definition at line 335 of file NetworkManager.cpp.

{
    int n = 0;
    for (auto& [id, link] : peers)
        if (link && link->isConnected())
            ++n;
    return n;
}

connectToPeer()

bool NetworkManager::connectToPeer

(

const std::string &

connectionString

)

Definition at line 344 of file NetworkManager.cpp.

{
    std::string server;
    unsigned short port = 0;
    std::string password;
    parseConnectionString(connectionString, server, port, password);
 
    if (!password.empty())
        setNetworkPassword(password.c_str());
    peer_role = Role::PLAYER;
 
    if (hasUrlScheme(server))
    {
        return signalingClient->connectUrl(server); // NEW method (see below)
    }
    return signalingClient->connect(server, port); // your old method
}

Here is the call graph for this function:

debugIdentitySnapshot()

std::string NetworkManager::debugIdentitySnapshot

(

)

const

Definition at line 906 of file NetworkManager.cpp.

{
    std::ostringstream os;
    os << "[Identity Snapshot]\n";
 
    os << "self.peerId=" << (getMyPeerId().empty() ? "(none)" : getMyPeerId()) << "\n";
    if (identity_manager)
    {
        os << "self.uniqueId=" << identity_manager->myUniqueId()
           << "  username=\"" << identity_manager->myUsername() << "\"\n";
    }
    // GM (if tracked)
    if (!getGMId().empty())
    {
        os << "gm.uniqueId=" << getGMId()
           << "  username=\"" << (identity_manager ? identity_manager->usernameForUnique(getGMId()) : std::string{}) << "\"\n";
    }
 
    os << "\n[Peers]\n";
    for (const auto& [peerId, link] : peers)
    {
        os << "- peerId=" << peerId;
 
        std::string uid, uname;
        if (identity_manager)
        {
            if (auto u = identity_manager->uniqueForPeer(peerId))
                uid = *u;
            if (!uid.empty())
                uname = identity_manager->usernameForUnique(uid);
        }
 
        if (!uid.empty())
            os << "  uniqueId=" << uid;
        if (!uname.empty())
            os << "  username=\"" << uname << "\"";
 
        if (link)
            os << "  link.display=\"" << link->displayName() << "\"";
 
        os << "\n";
    }
 
    // Optionally: dump address-book keys too
    if (identity_manager)
    {
        os << "\n[Peer→Unique map]\n";
        // If you don’t expose an accessor, add one that returns a copy or iterate via a friend.
        for (const auto& pid : getConnectedPeerIds())
        {
            if (auto u = identity_manager->uniqueForPeer(pid))
                os << "  " << pid << " -> " << *u << "\n";
        }
    }
 
    return os.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRawChatBuffer()

void NetworkManager::decodeRawChatBuffer	(	const std::string &	fromPeer,
		const std::vector< uint8_t > &	b )

Definition at line 2390 of file NetworkManager.cpp.

{
    // ---- JSON branch ----
    auto first_non_ws = std::find_if(b.begin(), b.end(), [](uint8_t c)
                                     { return !std::isspace((unsigned char)c); });
    if (first_non_ws != b.end() && *first_non_ws == '{')
    {
        try
        {
            std::string s(b.begin(), b.end()); // UTF-8
            msg::Json j = msg::Json::parse(s);
 
            msg::ReadyMessage r;
            r.fromPeerId = fromPeer;
 
            // type
            msg::DCType t;
            if (!msg::DCTypeFromJson(msg::getString(j, "type"), t))
            {
                Logger::instance().log("chat", Logger::Level::Warn, "JSON chat: unknown type");
                return;
            }
            r.kind = t;
 
            // common fields
            if (j.contains("tableId"))
                r.tableId = (uint64_t)j["tableId"].get<uint64_t>();
            if (j.contains("groupId"))
                r.threadId = (uint64_t)j["groupId"].get<uint64_t>();
 
            switch (t)
            {
                case msg::DCType::ChatGroupCreate:
                case msg::DCType::ChatGroupUpdate:
                {
                    if (j.contains("name"))
                        r.name = j["name"].get<std::string>();
                    if (j.contains("participants") && j["participants"].is_array())
                    {
                        std::set<std::string> parts;
                        for (auto& e : j["participants"])
                            parts.insert(e.get<std::string>());
                        r.participants = std::move(parts);
                    }
                    break;
                }
                case msg::DCType::ChatGroupDelete:
                {
                    // nothing extra
                    break;
                }
                case msg::DCType::ChatMessage:
                {
                    if (j.contains("ts"))
                        r.ts = (uint64_t)j["ts"].get<uint64_t>();
                    if (j.contains("username"))
                        r.name = j["username"].get<std::string>();
                    if (j.contains("text"))
                        r.text = j["text"].get<std::string>();
                    break;
                }
                default:
                    return; // ignore non-chat types here
            }
 
            inboundGame_.push(std::move(r));
            return; // handled JSON
        }
        catch (const std::exception& e)
        {
            Logger::instance().log("chat", Logger::Level::Warn, std::string("JSON parse error: ") + e.what());
            // fall through to legacy-binary branch if you still support it
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRawGameBuffer()

void NetworkManager::decodeRawGameBuffer	(	const std::string &	fromPeer,
		const std::vector< uint8_t > &	b )

Definition at line 1113 of file NetworkManager.cpp.

{
    decodingFromPeer_ = fromPeer;
    size_t off = 0;
    while (off < b.size())
    {
        if (!ensureRemaining(b, off, 1))
            break;
 
        auto type = static_cast<msg::DCType>(b[off]);
        off += 1;
 
        Logger::instance().log("localtunnel", Logger::Level::Info, msg::DCtypeString(type) + " Received!!");
        switch (type)
        {
            case msg::DCType::Snapshot_GameTable:
                handleGameTableSnapshot(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "Snapshot_GameTable Handled!!");
                break;
 
            case msg::DCType::Snapshot_Board:
                handleBoardMeta(b, off); // fills imagesRx_
                Logger::instance().log("localtunnel", Logger::Level::Info, "Snapshot_Board Handled!!");
                break;
 
            case msg::DCType::MarkerCreate:
                handleMarkerMeta(b, off); // fills imagesRx_
                //Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerCreate Handled!!");
                break;
 
            case msg::DCType::FogCreate:
                handleFogCreate(b, off);
                //Logger::instance().log("localtunnel", Logger::Level::Info, "FogCreate Handled!!");
                break;
 
            case msg::DCType::ImageChunk:
                handleImageChunk(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "ImageChunk Handled!!");
                break;
 
            case msg::DCType::CommitBoard:
                handleCommitBoard(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "CommitBoard Handled!!");
                break;
 
            case msg::DCType::CommitMarker:
                handleCommitMarker(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "CommitMarker Handled!!");
                break;
 
            case msg::DCType::MarkerUpdate:
                handleMarkerUpdate(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerUpdate Handled!!");
                break;
 
            case msg::DCType::MarkerMoveState:
                handleMarkerMoveState(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerUpdate Handled!!");
                break;
 
            case msg::DCType::FogUpdate:
                handleFogUpdate(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "FogUpdate Handled!!");
                break;
 
            case msg::DCType::MarkerDelete:
                handleMarkerDelete(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerDelete Handled!!");
                break;
 
            case msg::DCType::FogDelete:
                handleFogDelete(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerDelete FogDelete!!");
                break;
 
            case msg::DCType::GridUpdate:
                handleGridUpdate(b, off);
                Logger::instance().log("localtunnel", Logger::Level::Info, "GridUpdate Handled!!");
                break;
 
            case msg::DCType::UserNameUpdate:
            {
                handleUserNameUpdate(b, off);
                break;
            }
            default:
                Logger::instance().log("localtunnel", Logger::Level::Warn, "Unkown Message Type not Handled!!");
                break;
        }
    }
    decodingFromPeer_.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRawMarkerMoveBuffer()

void NetworkManager::decodeRawMarkerMoveBuffer	(	const std::string &	fromPeer,
		const std::vector< uint8_t > &	b )

Definition at line 1207 of file NetworkManager.cpp.

{
    decodingFromPeer_ = fromPeer;
    size_t off = 0;
    while (off < b.size())
    {
        if (!ensureRemaining(b, off, 1))
            break;
 
        auto type = static_cast<msg::DCType>(b[off]);
        off += 1;
        Logger::instance().log("localtunnel", Logger::Level::Info, msg::DCtypeString(type) + " Received!! MarkerMove");
        if (type != msg::DCType::MarkerMove)
        {
            // If the sender packed something else on this DC, bail
            return;
        }
 
        handleMarkerMove(b, off); // parses one frame and updates coalescer
        Logger::instance().log("localtunnel", Logger::Level::Info, "MarkerMove Handled!!");
    }
    decodingFromPeer_.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

decodeRawNotesBuffer()

void NetworkManager::decodeRawNotesBuffer	(	const std::string &	fromPeer,
		const std::vector< uint8_t > &	b )

Definition at line 2467 of file NetworkManager.cpp.

{
    size_t off = 0;
    while (off < b.size())
    {
        if (!ensureRemaining(b, off, 1))
            break;
 
        auto type = static_cast<msg::DCType>(b[off]);
        off += 1;
 
        Logger::instance().log("localtunnel", Logger::Level::Info, msg::DCtypeString(type) + " Received!!");
        switch (type)
        {
            case msg::DCType::NoteCreate:
                //handleGameTableSnapshot(b, off); // pushes ReadyMessage internally
                Logger::instance().log("localtunnel", Logger::Level::Info, "NoteCreate Handled!!");
                break;
 
            case msg::DCType::NoteUpdate:
                //handleBoardMeta(b, off); // fills imagesRx_
                Logger::instance().log("localtunnel", Logger::Level::Info, "NoteUpdate Handled!!");
                break;
 
            case msg::DCType::NoteDelete:
                //handleMarkerMeta(b, off); // fills imagesRx_
                Logger::instance().log("localtunnel", Logger::Level::Info, "NoteDelete Handled!!");
                break;
            default:
                // unknown / out-of-sync: stop this buffer
                Logger::instance().log("localtunnel", Logger::Level::Warn, "Unkown Message Type not Handled!! onNotes");
                return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

disallowPort()

void NetworkManager::disallowPort

(

unsigned short

port

)

disconectFromPeers()

bool NetworkManager::disconectFromPeers

(

)

Definition at line 781 of file NetworkManager.cpp.

{
    // Move out to avoid mutation during destruction
    std::unordered_map<std::string, std::shared_ptr<PeerLink>> moved = std::move(peers);
    peers.clear();
 
    for (auto& [pid, link] : moved)
    {
        if (!link)
            continue;
        try
        {
            link->close();
        }
        catch (const std::exception& e)
        {
            Logger::instance().log("main", Logger::Level::Error, std::string("[disconnectFromPeers] ") + e.what());
            pushStatusToast("Peer disconnect error", ImGuiToaster::Level::Error, 5.0f);
        }
        catch (...)
        {
            Logger::instance().log("main", Logger::Level::Error, "[disconnectFromPeers] unknown");
            pushStatusToast("Peer disconnect error (unknown)", ImGuiToaster::Level::Error, 5.0f);
        }
    }
    moved.clear();
 
    if (signalingClient)
    {
        signalingClient->close();
    }
 
    peer_role = Role::NONE;
    return true;
}

Here is the call graph for this function:

disconnectAllPeers()

bool NetworkManager::disconnectAllPeers

(

)

Definition at line 817 of file NetworkManager.cpp.

{
    if (signalingServer)
    {
        signalingServer->broadcastShutdown();
    }
 
    std::unordered_map<std::string, std::shared_ptr<PeerLink>> moved = std::move(peers);
    peers.clear();
 
    for (auto& [pid, link] : moved)
    {
        if (!link)
            continue;
        try
        {
            link->close();
        }
        catch (const std::exception& e)
        {
            Logger::instance().log("main", Logger::Level::Error, std::string("[disconnectAllPeers] ") + e.what());
            pushStatusToast("Peer disconnect error", ImGuiToaster::Level::Error, 5.0f);
        }
        catch (...)
        {
            Logger::instance().log("main", Logger::Level::Error, "[disconnectAllPeers] unknown");
            pushStatusToast("Peer disconnect error (unknown)", ImGuiToaster::Level::Error, 5.0f);
        }
    }
    moved.clear();
 
    if (signalingServer)
    {
        signalingServer->disconnectAllClients();
        try
        {
            signalingServer->stop();
        }
        catch (...)
        {
        }
    }
 
    if (signalingClient)
    {
        signalingClient->close();
    }
 
    peer_role = Role::NONE;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

displayNameForPeer()

std::string NetworkManager::displayNameForPeer

(

const std::string &

peerId

)

const

Definition at line 773 of file NetworkManager.cpp.

{
    if (!identity_manager)
        return peerId;
    auto u = identity_manager->usernameForPeer(peerId);
    return u.value_or(peerId);
}

Here is the caller graph for this function:

drainEvents()

void NetworkManager::drainEvents

(

)

Definition at line 2173 of file NetworkManager.cpp.

{
    msg::NetEvent ev;
    while (events_.try_pop(ev))
    {
        if (ev.type == msg::NetEvent::Type::DcOpen)
        {
            auto it = peers.find(ev.peerId);
            if (it != peers.end() && it->second)
            {
                it->second->setOpen(ev.label, true);
            }
        }
        else if (ev.type == msg::NetEvent::Type::DcClosed)
        {
            auto it = peers.find(ev.peerId);
            if (it != peers.end() && it->second)
            {
                it->second->setOpen(ev.label, false);
                it->second->markBootstrapReset();
                //reconnectPeer(ev.peerId);
            }
        }
        else if (ev.type == msg::NetEvent::Type::PcClosed)
        {
            auto it = peers.find(ev.peerId);
            if (it != peers.end() && it->second)
            {
                //reconnectPeer(ev.peerId);
            }
        }
        else if (ev.type == msg::NetEvent::Type::PcOpen)
        {
            pushStatusToast(std::string("[Peer] ") + ev.peerId + " Connected", ImGuiToaster::Level::Good);
        }
    }
 
    // If GM: check if any peer is now fully open → bootstrap once
    if (peer_role == Role::GAMEMASTER)
    {
        for (auto& [pid, link] : peers)
        {
            if (link && link->allRequiredOpen() && !link->bootstrapSent())
            {
                try
                {
                    bootstrapPeerIfReady(pid);
                }
                catch (const std::exception& e)
                {
                    const std::string msg = std::string("Error bootstrapping peer: ") + e.what();
                    Logger::instance().log("main", Logger::Level::Error, msg);
                    toaster_->Push(ImGuiToaster::Level::Error, msg, 5.0f);
                }
                catch (...)
                {
                    const char* msg = "Error bootstrapping peer: unknown exception";
                    Logger::instance().log("main", Logger::Level::Error, msg);
                    toaster_->Push(ImGuiToaster::Level::Error, msg, 5.0f);
                }
            }
        }
    }
}

Here is the call graph for this function:

drainInboundRaw()

void NetworkManager::drainInboundRaw

(

int

maxPerTick

)

Definition at line 2238 of file NetworkManager.cpp.

{
    using clock = std::chrono::steady_clock;
    int processed = 0;
 
    msg::InboundRaw r;
    while (processed < maxPerTick && inboundRaw_.try_pop(r))
    {
        try
        {
            if (r.label == msg::dc::name::Game)
            {
                decodeRawGameBuffer(r.fromPeer, r.bytes);
            }
            else if (r.label == msg::dc::name::Chat)
            {
                decodeRawChatBuffer(r.fromPeer, r.bytes);
            }
            else if (r.label == msg::dc::name::Notes)
            {
                decodeRawNotesBuffer(r.fromPeer, r.bytes);
            }
            else if (r.label == msg::dc::name::MarkerMove)
            {
                decodeRawMarkerMoveBuffer(r.fromPeer, r.bytes); // coalesce into moveLatest_
            }
        }
        catch (...)
        {
            // swallow/log
        }
        ++processed;
    }
}

Here is the call graph for this function:

ensurePeerLink()

std::shared_ptr< PeerLink > NetworkManager::ensurePeerLink

(

const std::string &

peerId

)

Definition at line 632 of file NetworkManager.cpp.

{
    if (auto it = peers.find(peerId); it != peers.end())
        return it->second;
    auto link = std::make_shared<PeerLink>(peerId, weak_from_this());
    peers.emplace(peerId, link);
    return link;
}

ensureRemaining()

static bool NetworkManager::ensureRemaining ( const std::vector< uint8_t > & b, size_t off, size_t need )

inlinestaticprivate

Definition at line 409 of file NetworkManager.h.

    {
        return off + need <= b.size();
    }

Here is the caller graph for this function:

forceCloseDrag()

void NetworkManager::forceCloseDrag

(

uint64_t

markerId

)

Definition at line 1492 of file NetworkManager.cpp.

{
    auto it = drag_.find(markerId);
    if (it == drag_.end())
        return;
    auto& s = it->second;
    s.closed = true;
    s.locallyDragging = false;
    s.localSeq = 0;
}

getConnectedPeerIds()

std::vector< std::string > NetworkManager::getConnectedPeerIds

(

)

const

Definition at line 877 of file NetworkManager.cpp.

{
    std::vector<std::string> ids;
    ids.reserve(peers.size());
    for (auto& [pid, link] : peers)
    {
        if (link && link->isConnected())
        {
            ids.push_back(pid);
        }
    }
    return ids;
}

Here is the caller graph for this function:

getConnectedUsernames()

std::vector< std::string > NetworkManager::getConnectedUsernames

(

)

const

Definition at line 891 of file NetworkManager.cpp.

{
    std::vector<std::string> user_names;
    user_names.reserve(peers.size());
    for (auto& [pid, link] : peers)
    {
        if (link && link->isConnected())
        {
            user_names.push_back(displayNameForPeer(pid));
        }
    }
    return user_names;
}

Here is the call graph for this function:

getCustomHost()

const std::string & NetworkManager::getCustomHost ( ) const

inline

Definition at line 300 of file NetworkManager.h.

{ return customHost_; }

Here is the caller graph for this function:

getExternalIPAddress()

std::string NetworkManager::getExternalIPAddress

(

)

Definition at line 374 of file NetworkManager.cpp.

{
    if (external_ip_address == "")
    {
        //auto external_ip = UPnPManager::getExternalIPv4Address();
        std::string external_ip = NetworkUtilities::httpGet(L"loca.lt", L"/mytunnelpassword");
        external_ip_address = external_ip;
        return external_ip;
    }
    return external_ip_address;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGMId()

const std::string & NetworkManager::getGMId ( ) const

inline

Definition at line 229 of file NetworkManager.h.

    {
        return gmPeerId_;
    }

Here is the caller graph for this function:

getIdentityManager()

std::shared_ptr< IdentityManager > NetworkManager::getIdentityManager ( )

inline

Definition at line 288 of file NetworkManager.h.

    {
        return identity_manager;
    }

getLocalIPAddress()

std::string NetworkManager::getLocalIPAddress

(

)

Definition at line 363 of file NetworkManager.cpp.

{
    if (local_ip_address == "")
    {
        auto local_ip = NetworkUtilities::getLocalIPv4Address();
        local_ip_address = local_ip;
        return local_ip;
    }
    return local_ip_address;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLocalTunnelURL()

std::string NetworkManager::getLocalTunnelURL

(

)

Definition at line 414 of file NetworkManager.cpp.

{
    return NetworkUtilities::getLocalTunnelUrl();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getMyPeerId()

const std::string & NetworkManager::getMyPeerId ( ) const

inline

Definition at line 149 of file NetworkManager.h.

    {
        return myPeerId_;
    }

Here is the caller graph for this function:

getMyUniqueId()

std::string NetworkManager::getMyUniqueId ( ) const

inline

Definition at line 144 of file NetworkManager.h.

    {
        return identity_manager->myUniqueId();
    }

Here is the caller graph for this function:

getMyUsername()

std::string NetworkManager::getMyUsername ( ) const

inline

Definition at line 140 of file NetworkManager.h.

    {
        return identity_manager->myUsername();
    }

Here is the caller graph for this function:

getNetworkInfo()

std::string NetworkManager::getNetworkInfo

(

ConnectionType

type

)

Definition at line 386 of file NetworkManager.cpp.

{
    const auto port = getPort();
    const auto pwd = getNetworkPassword();
 
    if (type == ConnectionType::LOCAL)
    { // LAN (192.168.x.y)
        const auto ip = getLocalIPAddress();
        return "runic:" + ip + ":" + std::to_string(port) + "?" + pwd;
    }
    else if (type == ConnectionType::EXTERNAL)
    { // public IP
        const auto ip = getExternalIPAddress();
        return "runic:" + ip + ":" + std::to_string(port) + "?" + pwd;
    }
    else if (type == ConnectionType::LOCALTUNNEL)
    {
        const auto url = getLocalTunnelURL(); // e.g., https://sub.loca.lt
        return url + "?" + pwd;               // no port needed (LT handles it)
    }
    else if (type == ConnectionType::CUSTOM)
    { // public IP
        const auto customHost = getCustomHost();
        return "runic:" + customHost  + ":" + std::to_string(port) + "?" + pwd;
    }
    return {};
}

Here is the call graph for this function:

getNetworkPassword()

std::string NetworkManager::getNetworkPassword ( ) const

inline

Definition at line 99 of file NetworkManager.h.

    {
        return std::string(network_password);
    };

Here is the caller graph for this function:

getPeerRole()

Role NetworkManager::getPeerRole ( ) const

inline

Definition at line 108 of file NetworkManager.h.

    {
        return peer_role;
    }

getPeers()

const std::unordered_map< std::string, std::shared_ptr< PeerLink > > & NetworkManager::getPeers ( ) const

inline

Definition at line 158 of file NetworkManager.h.

    {
        return peers;
    }

getPort()

unsigned short NetworkManager::getPort ( ) const

inline

Definition at line 95 of file NetworkManager.h.

    {
        return port;
    };

Here is the caller graph for this function:

getRTCConfig()

rtc::Configuration NetworkManager::getRTCConfig ( ) const

inline

Definition at line 113 of file NetworkManager.h.

    {
        return rtcConfig;
    }

getSendMoveMinPeriodMs()

uint32_t NetworkManager::getSendMoveMinPeriodMs ( ) const

inlineprivate

Definition at line 312 of file NetworkManager.h.

    {
        return sendMoveMinPeriodMs_;
    }

getSignalingServer()

std::shared_ptr< SignalingServer > NetworkManager::getSignalingServer ( ) const

inline

Definition at line 162 of file NetworkManager.h.

    {
        return signalingServer;
    }

handleBoardMeta()

void NetworkManager::handleBoardMeta ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1945 of file NetworkManager.cpp.

{
    msg::BoardMeta bm;
    bm.boardId = Serializer::deserializeUInt64(b, off);
    bm.boardName = Serializer::deserializeString(b, off);
    bm.pan = Serializer::deserializePanning(b, off);
    bm.grid = Serializer::deserializeGrid(b, off);
    bm.size = Serializer::deserializeSize(b, off);
    uint64_t total = Serializer::deserializeUInt64(b, off); // 0 if no image
 
    auto& p = imagesRx_[bm.boardId];
    p.kind = msg::ImageOwnerKind::Board;
    p.id = bm.boardId;
    p.boardId = bm.boardId;
    p.boardMeta = bm;
    p.total = total;
    p.received = 0;
    p.buf.clear();
    if (total)
        p.buf.resize(static_cast<size_t>(total));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleCommitBoard()

void NetworkManager::handleCommitBoard ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2005 of file NetworkManager.cpp.

{
    uint64_t boardId = Serializer::deserializeUInt64(b, off);
 
    auto it = imagesRx_.find(boardId);
    if (it == imagesRx_.end())
    {
        // Late/meta-less commit? Create a placeholder so tryFinalize can run if chunks arrive later.
        PendingImage p;
        p.kind = msg::ImageOwnerKind::Board;
        p.id = boardId;
        imagesRx_.emplace(boardId, std::move(p));
        it = imagesRx_.find(boardId);
    }
 
    it->second.commitRequested = true;
    tryFinalizeImage(msg::ImageOwnerKind::Board, boardId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleCommitMarker()

void NetworkManager::handleCommitMarker ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2091 of file NetworkManager.cpp.

{
    uint64_t boardId = Serializer::deserializeUInt64(b, off);
    uint64_t markerId = Serializer::deserializeUInt64(b, off);
 
    auto it = imagesRx_.find(markerId);
    if (it == imagesRx_.end())
    {
        PendingImage p;
        p.kind = msg::ImageOwnerKind::Marker;
        p.id = markerId;
        p.boardId = boardId;
        imagesRx_.emplace(markerId, std::move(p));
        it = imagesRx_.find(markerId);
    }
    else
    {
        it->second.boardId = boardId; // ensure it's set
    }
 
    it->second.commitRequested = true;
    tryFinalizeImage(msg::ImageOwnerKind::Marker, markerId);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleFogCreate()

void NetworkManager::handleFogCreate ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1993 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::FogCreate;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.fogId = Serializer::deserializeUInt64(b, off);
    m.pos = Serializer::deserializePosition(b, off);
    m.size = Serializer::deserializeSize(b, off);
    m.vis = Serializer::deserializeVisibility(b, off);
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleFogDelete()

void NetworkManager::handleFogDelete ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2164 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::FogDelete;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.fogId = Serializer::deserializeUInt64(b, off);
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleFogUpdate()

void NetworkManager::handleFogUpdate ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2151 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::FogUpdate;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.fogId = Serializer::deserializeUInt64(b, off);
    m.pos = Serializer::deserializePosition(b, off);
    m.size = Serializer::deserializeSize(b, off);
    m.vis = Serializer::deserializeVisibility(b, off);
    m.mov = Serializer::deserializeMoving(b, off); // remove if you don’t use Moving on fog
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleGameTableSnapshot()

void NetworkManager::handleGameTableSnapshot ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1935 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::Snapshot_GameTable;
    m.tableId = Serializer::deserializeUInt64(b, off);
    m.name = Serializer::deserializeString(b, off);
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleGridUpdate()

void NetworkManager::handleGridUpdate ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1920 of file NetworkManager.cpp.

{
    // type byte already consumed by the caller switch
    if (!ensureRemaining(b, off, 8))
        return;
 
    msg::ReadyMessage m;
    m.kind = msg::DCType::GridUpdate;
    m.boardId = Serializer::deserializeUInt64(b, off);
    Grid g = Serializer::deserializeGrid(b, off);
    m.grid = g;
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleImageChunk()

void NetworkManager::handleImageChunk ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2024 of file NetworkManager.cpp.

{
    if (off + 1 > b.size())
    {
        Logger::instance().log("localtunnel", Logger::Level::Error, "ImageChunk: underrun(kind)");
        return;
    }
    auto kind = static_cast<msg::ImageOwnerKind>(b[off]);
    off += 1;
 
    if (off + 8 + 8 + 4 > b.size())
    {
        Logger::instance().log("localtunnel", Logger::Level::Error, "ImageChunk: underrun(headers)");
        return;
    }
    uint64_t id = Serializer::deserializeUInt64(b, off);
    uint64_t off64 = Serializer::deserializeUInt64(b, off);
    int len = Serializer::deserializeInt(b, off);
 
    if (len < 0 || off + static_cast<size_t>(len) > b.size())
    {
        Logger::instance().log("localtunnel", Logger::Level::Error,
                               "ImageChunk: invalid len id=" + std::to_string(id) + " len=" + std::to_string(len));
        return;
    }
 
    auto it = imagesRx_.find(id);
    if (it == imagesRx_.end())
    {
        Logger::instance().log("localtunnel", Logger::Level::Warn,
                               "ImageChunk: unknown id=" + std::to_string(id));
        off += static_cast<size_t>(len);
        return;
    }
 
    auto& p = it->second;
    if (p.kind != kind || p.total == 0)
    {
        Logger::instance().log("localtunnel", Logger::Level::Warn,
                               "ImageChunk: kind/total mismatch id=" + std::to_string(id));
        off += static_cast<size_t>(len);
        return;
    }
 
    if (off64 + static_cast<uint64_t>(len) > p.total)
    {
        Logger::instance().log("localtunnel", Logger::Level::Error,
                               "ImageChunk: out-of-bounds id=" + std::to_string(id) +
                                   " off=" + std::to_string(off64) + " len=" + std::to_string(len) +
                                   " total=" + std::to_string(p.total));
        off += static_cast<size_t>(len);
        return;
    }
 
    std::memcpy(p.buf.data() + off64, b.data() + off, static_cast<size_t>(len));
    off += static_cast<size_t>(len);
    p.received += static_cast<uint64_t>(len);
 
    // Occasional progress log (e.g., every ~1MB)
    if ((p.received % (1u << 20)) < static_cast<uint64_t>(len))
    {
        Logger::instance().log("localtunnel", Logger::Level::Info,
                               "ImageChunk: id=" + std::to_string(id) + " " +
                                   std::to_string(p.received) + "/" + std::to_string(p.total));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleMarkerDelete()

void NetworkManager::handleMarkerDelete ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2141 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::MarkerDelete;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.markerId = Serializer::deserializeUInt64(b, off);
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleMarkerMeta()

void NetworkManager::handleMarkerMeta ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1968 of file NetworkManager.cpp.

{
    msg::MarkerMeta mm;
    mm.boardId = Serializer::deserializeUInt64(b, off);
    mm.markerId = Serializer::deserializeUInt64(b, off);
    mm.name = Serializer::deserializeString(b, off);
    mm.pos = Serializer::deserializePosition(b, off);
    mm.size = Serializer::deserializeSize(b, off);
    mm.vis = Serializer::deserializeVisibility(b, off);
    mm.mov = Serializer::deserializeMoving(b, off);
    uint64_t total = Serializer::deserializeUInt64(b, off); // 0 if no image
 
    auto& p = imagesRx_[mm.markerId];
    p.kind = msg::ImageOwnerKind::Marker;
    p.id = mm.markerId;
    p.boardId = mm.boardId;
    p.markerMeta = mm;
    p.total = total;
    p.received = 0;
    p.buf.clear();
    if (total)
        p.buf.resize(static_cast<size_t>(total));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleMarkerMove()

void NetworkManager::handleMarkerMove ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1231 of file NetworkManager.cpp.

{
    if (!ensureRemaining(raw, off, 8 + 8 + 4 + 4 + 8 + 8)) // 8 bytes Position (2x int32)
        return;
 
    const auto& b = reinterpret_cast<const std::vector<unsigned char>&>(raw);
 
    msg::ReadyMessage m;
    m.kind = msg::DCType::MarkerMove;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.markerId = Serializer::deserializeUInt64(b, off);
    m.dragEpoch = Serializer::deserializeUInt32(b, off);
    m.seq = Serializer::deserializeUInt32(b, off);
    m.ts = Serializer::deserializeUInt64(b, off);
    Position p = Serializer::deserializePosition(b, off);
    m.pos = p;
    m.mov = Moving{true};
 
    m.fromPeerId = decodingFromPeer_;
 
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleMarkerMoveState()

void NetworkManager::handleMarkerMoveState ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1269 of file NetworkManager.cpp.

{
    // Expect (after type):
    // [boardId:u64][markerId:u64][epoch:u32][seq:u32][ts:u64][Moving][(Position if final)]
    if (!ensureRemaining(raw, off, 8 + 8 + 4 + 4 + 8 + 1))
        return;
 
    const auto& b = reinterpret_cast<const std::vector<unsigned char>&>(raw);
 
    msg::ReadyMessage m;
    m.kind = msg::DCType::MarkerMoveState;
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.markerId = Serializer::deserializeUInt64(b, off);
    m.dragEpoch = Serializer::deserializeUInt32(b, off);
    m.seq = Serializer::deserializeUInt32(b, off);
    m.ts = Serializer::deserializeUInt64(b, off);
    Moving mv = Serializer::deserializeMoving(b, off);
    m.mov = mv;
 
    if (!mv.isDragging)
    {
        if (!ensureRemaining(raw, off, 8))
            return; // Position (2x int)
        Position p = Serializer::deserializePosition(b, off);
        m.pos = p;
    }
    m.fromPeerId = decodingFromPeer_;
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleMarkerUpdate()

void NetworkManager::handleMarkerUpdate ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 1255 of file NetworkManager.cpp.

{
    msg::ReadyMessage m;
    m.kind = msg::DCType::MarkerUpdate;
 
    m.boardId = Serializer::deserializeUInt64(b, off);
    m.markerId = Serializer::deserializeUInt64(b, off);
    m.size = Serializer::deserializeSize(b, off);
    m.vis = Serializer::deserializeVisibility(b, off);
    m.markerComp = Serializer::deserializeMarkerComponent(b, off);
 
    m.fromPeerId = decodingFromPeer_;
    inboundGame_.push(std::move(m));
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleUserNameUpdate()

void NetworkManager::handleUserNameUpdate ( const std::vector< uint8_t > & b, size_t & off )

private

Definition at line 2115 of file NetworkManager.cpp.

{
    msg::ReadyMessage r;
    r.kind = msg::DCType::UserNameUpdate;
    r.fromPeerId = decodingFromPeer_;
    r.tableId = Serializer::deserializeUInt64(b, off);
 
    // This is UNIQUE ID now:
    const std::string uniqueId = Serializer::deserializeString(b, off);
    const std::string oldU = Serializer::deserializeString(b, off);
    const std::string newU = Serializer::deserializeString(b, off);
    const uint8_t rebound = Serializer::deserializeUInt8(b, off);
 
    // Keep old ReadyMessage fields for upstream handlers (uses userPeerId/name/text in your codebase):
    r.userUniqueId = uniqueId; // NOTE: field name is legacy; carries uniqueId now.
    r.text = oldU;
    r.name = newU;
    r.rebound = rebound;
 
    Logger::instance().log("chat", Logger::Level::Info,
                           "UserNameUpdate: tbl=" + std::to_string(r.tableId.value_or(0)) +
                               " uid=" + uniqueId + " old=" + oldU + " new=" + newU);
 
    inboundGame_.push(std::move(r));
}

Here is the call graph for this function:

Here is the caller graph for this function:

hasAnyPeer()

bool NetworkManager::hasAnyPeer

(

)

const

Definition at line 331 of file NetworkManager.cpp.

{
    return !peers.empty();
}

hasUrlScheme()

static bool NetworkManager::hasUrlScheme ( const std::string & s )

inlinestaticprivate

Definition at line 402 of file NetworkManager.h.

    {
        auto starts = [&](const char* p)
        { return s.rfind(p, 0) == 0; };
        return starts("https://") || starts("http://") || starts("wss://") || starts("ws://");
    }

Here is the caller graph for this function:

housekeepPeers()

void NetworkManager::housekeepPeers

(

)

Definition at line 678 of file NetworkManager.cpp.

{
    const uint64_t now = nowMs();
    const uint64_t kGraceMs = 10'000; // disconnect grace period
 
    static std::unordered_map<std::string, uint64_t> firstDiscPeerAt;
    static std::unordered_map<std::string, uint64_t> firstDiscWsAt;
 
    // ---- PeerLink cleanup ----
    for (auto it = peers.begin(); it != peers.end();)
    {
        const std::string& pid = it->first;
        auto& link = it->second;
 
        const bool connected = (link && link->isConnected());
        if (connected)
        {
            firstDiscPeerAt.erase(pid);
            ++it;
            continue;
        }
 
        uint64_t& t0 = firstDiscPeerAt[pid];
        if (t0 == 0)
            t0 = now;
 
        if (now - t0 >= kGraceMs)
        {
            try
            {
                if (link)
                    link->close();
            }
            catch (...)
            {
            }
            it = peers.erase(it);
            firstDiscPeerAt.erase(pid);
        }
        else
        {
            ++it;
        }
    }
 
    // ---- WebSocket cleanup (server side) ----
    auto wsClients = signalingServer->authClients();
    for (auto it = wsClients.begin(); it != wsClients.end();)
    {
        const std::string& cid = it->first;
        auto& ws = it->second;
 
        const bool open = (ws && ws->isOpen()); // if your API is different, change this check
        if (open)
        {
            firstDiscWsAt.erase(cid);
            ++it;
            continue;
        }
 
        uint64_t& t0 = firstDiscWsAt[cid];
        if (t0 == 0)
            t0 = now;
 
        if (now - t0 >= kGraceMs)
        {
            try
            {
                NetworkUtilities::safeCloseWebSocket(ws);
            }
            catch (...)
            {
            }
            it = wsClients.erase(it);
            firstDiscWsAt.erase(cid);
        }
        else
        {
            ++it;
        }
    }
}

Here is the call graph for this function:

isConnected()

bool NetworkManager::isConnected

(

)

Definition at line 318 of file NetworkManager.cpp.

{
    for (auto& [peerId, link] : peers)
    {
        if (link && link->isConnected())
            return true;
    }
    return false;
}

isHosting()

bool NetworkManager::isHosting

(

)

const

Definition at line 327 of file NetworkManager.cpp.

{
    return signalingServer && signalingServer->isRunning(); // if you expose isRunning()
}

isMarkerBeingDragged()

bool NetworkManager::isMarkerBeingDragged

(

uint64_t

markerId

)

const

Definition at line 1486 of file NetworkManager.cpp.

{
    auto it = drag_.find(markerId);
    return (it != drag_.end() && !it->second.closed);
}

markDraggingLocal()

void NetworkManager::markDraggingLocal	(	uint64_t	markerId,
		bool	dragging )

Definition at line 1466 of file NetworkManager.cpp.

{
    auto& s = drag_[markerId];
    if (dragging)
    {
        s.locallyDragging = true;
        s.locallyProposedEpoch = (s.closed ? (s.epoch + 1) : s.epoch);
        s.localSeq = 0;
        s.ownerPeerId = getMyPeerId();
        s.epochOpenedMs = nowMs();
        s.closed = false;
        if (s.locallyProposedEpoch > s.epoch)
            s.epoch = s.locallyProposedEpoch;
    }
    else
    {
        s.locallyDragging = false; // we close epoch on final frame or forceCloseDrag
    }
}

Here is the call graph for this function:

nowMs()

static uint64_t NetworkManager::nowMs ( )

inlinestaticprivate

Definition at line 433 of file NetworkManager.h.

    {
        using Clock = std::chrono::steady_clock;
        using namespace std::chrono;
        return duration_cast<milliseconds>(Clock::now().time_since_epoch()).count();
    }

Here is the caller graph for this function:

onPeerChannelOpen()

void NetworkManager::onPeerChannelOpen	(	const std::string &	peerId,
		const std::string &	label )

onPeerLocalCandidate()

void NetworkManager::onPeerLocalCandidate	(	const std::string &	peerId,
		const rtc::Candidate &	cand )

Definition at line 670 of file NetworkManager.cpp.

{
    auto j = msg::makeCandidate("", peerId, cand.candidate());
    if (signalingClient)
        signalingClient->send(j.dump());
}

Here is the call graph for this function:

onPeerLocalDescription()

void NetworkManager::onPeerLocalDescription	(	const std::string &	peerId,
		const rtc::Description &	desc )

Definition at line 643 of file NetworkManager.cpp.

{
    nlohmann::json j;
    const std::string sdp = std::string(desc);
 
    // Always pull identity from IdentityManager
    const std::string username = getMyUsername(); // forwards to IdentityManager
    const std::string uniqueId = getMyUniqueId(); // forwards to IdentityManager
 
    if (desc.type() == rtc::Description::Type::Offer)
    {
        // server will overwrite "from", so "" is fine
        j = msg::makeOffer(/*from*/ "", /*to*/ peerId, sdp, username, uniqueId);
    }
    else if (desc.type() == rtc::Description::Type::Answer)
    {
        j = msg::makeAnswer(/*from*/ "", /*to*/ peerId, sdp, username, uniqueId);
    }
    else
    {
        return;
    }
 
    if (signalingClient)
        signalingClient->send(j.dump());
}

Here is the call graph for this function:

parseConnectionString()

void NetworkManager::parseConnectionString	(	std::string	connection_string,
		std::string &	server,
		unsigned short &	port,
		std::string &	password )

Definition at line 419 of file NetworkManager.cpp.

{
    server.clear();
    password.clear();
    port = 0;
 
    const std::string prefix = "runic:";
    if (connection_string.rfind(prefix, 0) == 0)
        connection_string.erase(0, prefix.size());
 
    // split pass
    std::string left = connection_string;
    if (auto q = connection_string.find('?'); q != std::string::npos)
    {
        left = connection_string.substr(0, q);
        password = connection_string.substr(q + 1);
    }
 
    if (hasUrlScheme(left))
    { // URL path
        server = left;
        return;
    }
 
    // host[:port]
    if (auto colon = left.find(':'); colon != std::string::npos)
    {
        server = left.substr(0, colon);
        try
        {
            port = static_cast<unsigned short>(std::stoi(left.substr(colon + 1)));
        }
        catch (...)
        {
            port = 0;
        }
    }
    else
    {
        server = left; // no port
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pushStatusToast()

void NetworkManager::pushStatusToast ( const std::string & msg, ImGuiToaster::Level lvl, float durationSec = 5.0f )

inline

Definition at line 213 of file NetworkManager.h.

    {
        if (toaster_)
            toaster_->Push(lvl, msg, durationSec);
    }

Here is the caller graph for this function:

readFileBytes()

std::vector< unsigned char > NetworkManager::readFileBytes ( const std::string & path )

inlineprivate

Definition at line 414 of file NetworkManager.h.

    {
        std::ifstream file(path, std::ios::binary);
        if (!file)
        {
            return {}; // return empty if file not found
        }
        file.seekg(0, std::ios::end);
        size_t size = file.tellg();
        file.seekg(0, std::ios::beg);
 
        std::vector<unsigned char> buffer(size);
        if (size > 0)
        {
            file.read(reinterpret_cast<char*>(buffer.data()), size);
        }
        return buffer;
    }

Here is the caller graph for this function:

removeDisconnectedPeers()

std::size_t NetworkManager::removeDisconnectedPeers

(

)

Definition at line 551 of file NetworkManager.cpp.

{
    std::vector<std::string> toErase;
    std::vector<std::shared_ptr<PeerLink>> toClose;
    toErase.reserve(peers.size());
    toClose.reserve(peers.size());
 
    // 1) Decide who to remove; DO NOT mutate the map yet.
    for (auto const& [pid, link] : peers)
    {
        const bool shouldRemove = (!link) || link->isClosedOrFailed();
        if (shouldRemove)
        {
            toErase.push_back(pid);
            if (link)
                toClose.emplace_back(link);
        }
    }
 
    // 2) Erase all selected entries from the map (no destructors called yet for links we retained).
    for (auto const& pid : toErase)
        peers.erase(pid);
 
    // 3) Close outside the map to avoid re-entrancy/races.
    for (auto& link : toClose)
    {
        try
        {
            link->close(); // should be idempotent and NOT call back into NM
        }
        catch (const std::exception& e)
        {
            Logger::instance().log("main", Logger::Level::Error, std::string("[removeDisconnectedPeers] ") + e.what());
            //pushStatusToast("Peer close error", ImGuiToaster::Level::Error, 4.0f);
        }
        catch (...)
        {
            Logger::instance().log("main", Logger::Level::Error, "[removeDisconnectedPeers] unknown exception");
            //pushStatusToast("Peer close error (unknown)", ImGuiToaster::Level::Error, 4.0f);
        }
    }
 
    return toErase.size();
}

Here is the call graph for this function:

removePeer()

bool NetworkManager::removePeer

(

std::string

peerId

)

Definition at line 596 of file NetworkManager.cpp.

{
    // 1) Find, move the link out, erase entry first.
    std::shared_ptr<PeerLink> link;
    if (auto it = peers.find(peerId); it != peers.end())
    {
        link = std::move(it->second);
        peers.erase(it);
    }
    else
    {
        return false;
    }
 
    // 2) Close outside the map.
    if (link)
    {
        try
        {
            link->close(); // safe: detach callbacks first, idempotent
        }
        catch (const std::exception& e)
        {
            Logger::instance().log("main", Logger::Level::Error, std::string("[removePeer] ") + e.what());
            //pushStatusToast("Peer close error", ImGuiToaster::Level::Error, 4.0f);
        }
        catch (...)
        {
            Logger::instance().log("main", Logger::Level::Error, "[removePeer] unknown exception");
            //pushStatusToast("Peer close error (unknown)", ImGuiToaster::Level::Error, 4.0f);
        }
    }
    return true;
}

Here is the call graph for this function:

sendBoard()

void NetworkManager::sendBoard	(	const flecs::entity &	board,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1697 of file NetworkManager.cpp.

{
    // read board image (from TextureComponent.image_path)
    auto tex = board.get<TextureComponent>();
    auto image_path = tex->image_path;
    Logger::instance().log("localtunnel", Logger::Level::Info, "Board Texture Path: " + image_path);
    auto is_file_only = PathManager::isFilenameOnly(tex->image_path);
    auto is_path_like = PathManager::isPathLike(tex->image_path);
    if (is_file_only || !is_path_like)
    {
        Logger::instance().log("localtunnel", Logger::Level::Info, "Board Texture Path is FILE ONLY");
        auto map_folder = PathManager::getMapsPath();
        auto image_path_ = map_folder / tex->image_path;
        image_path = image_path_.string();
    }
    Logger::instance().log("localtunnel", Logger::Level::Info, "Board Texture Path AGAIN: " + image_path);
    std::vector<unsigned char> img = tex ? readFileBytes(image_path) : std::vector<unsigned char>{};
 
    // 1) meta
    auto meta = buildSnapshotBoardFrame(board, static_cast<uint64_t>(img.size()));
    broadcastGameFrame(meta, toPeerIds);
 
    uint64_t bid = board.get<Identifier>()->id;
    sendImageChunks(msg::ImageOwnerKind::Board, bid, img, toPeerIds);
 
    // 3) commit
    auto commit = buildCommitBoardFrame(bid);
    broadcastGameFrame(commit, toPeerIds);
 
    board.children([&](flecs::entity child)
                   {
            if (child.has<MarkerComponent>()) {
                uint64_t bid = board.get<Identifier>()->id;
                sendMarker(bid, child, toPeerIds);
                Logger::instance().log("localtunnel", Logger::Level::Info, "SentMarker");
            }
            else if (child.has<FogOfWar>()) {
                uint64_t bid = board.get<Identifier>()->id;
                sendFog(bid, child, toPeerIds);
                Logger::instance().log("localtunnel", Logger::Level::Info, "SentFog");
            } });
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendChatJsonTo() [1/2]

bool NetworkManager::sendChatJsonTo	(	const std::set< std::string > &	peers,
		const msg::Json &	j )

Definition at line 1095 of file NetworkManager.cpp.

{
    const std::string text = j.dump();
    bool any = false;
    for (auto& pid : targets)
    {
        auto it = peers.find(pid);
        if (it == peers.end() || !it->second)
            continue;
        auto& link = it->second;
        if (!link->isConnected())
            continue;
        if (link->sendOn(msg::dc::name::Chat, std::string_view(text)))
            any = true;
    }
    return any;
}

sendChatJsonTo() [2/2]

bool NetworkManager::sendChatJsonTo	(	const std::string &	peerId,
		const msg::Json &	j )

Definition at line 1085 of file NetworkManager.cpp.

{
    auto it = peers.find(peerId);
    if (it == peers.end() || !it->second)
        return false;
    auto& link = it->second;
    if (!link->isConnected())
        return false;
    return link->sendOn(msg::dc::name::Chat, std::string_view(j.dump()));
}

sendFog()

void NetworkManager::sendFog	(	uint64_t	boardId,
		const flecs::entity &	fog,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1780 of file NetworkManager.cpp.

{
    auto frame = buildFogCreateFrame(boardId, fog);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendFogDelete()

void NetworkManager::sendFogDelete	(	uint64_t	boardId,
		const flecs::entity &	fog,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1677 of file NetworkManager.cpp.

{
    if (!fog.is_valid() || !fog.has<Identifier>())
        return;
 
    const uint64_t fid = fog.get<Identifier>()->id;
    auto frame = buildFogDeleteFrame(boardId, fid);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendFogUpdate()

void NetworkManager::sendFogUpdate	(	uint64_t	boardId,
		const flecs::entity &	fog,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1667 of file NetworkManager.cpp.

{
    if (!fog.is_valid() || !fog.has<Identifier>())
        return;
 
    auto frame = buildFogUpdateFrame(boardId, fog);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendGameTable()

void NetworkManager::sendGameTable	(	const flecs::entity &	gameTable,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1689 of file NetworkManager.cpp.

{
    auto gtId = gameTable.get<Identifier>()->id;
    auto gt = *gameTable.get<GameTable>();
    auto frame = buildSnapshotGameTableFrame(gtId, gt.gameTableName);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendGameTo()

void NetworkManager::sendGameTo	(	const std::string &	peerId,
		const std::vector< unsigned char > &	bytes )

Definition at line 2783 of file NetworkManager.cpp.

{
    auto it = peers.find(peerId);
    if (it == peers.end() || !it->second)
        return;
    it->second->sendGame(bytes);
}

Here is the caller graph for this function:

sendGridUpdate()

void NetworkManager::sendGridUpdate	(	uint64_t	boardId,
		const flecs::entity &	board,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1900 of file NetworkManager.cpp.

{
    if (!board.is_valid() || !board.has<Grid>())
        return;
 
    const auto* g = board.get<Grid>();
    auto frame = buildGridUpdateFrame(boardId, *g);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendImageChunks()

bool NetworkManager::sendImageChunks	(	msg::ImageOwnerKind	kind,
		uint64_t	id,
		const std::vector< unsigned char > &	img,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1792 of file NetworkManager.cpp.

{
    Logger::instance().log("localtunnel", Logger::Level::Info,
                           std::string("sendImageChunks: kind=") + (kind == msg::ImageOwnerKind::Board ? "Board" : "Marker") +
                               " id=" + std::to_string(id) + " bytes=" + std::to_string(img.size()));
 
    size_t sent = 0;
    int paced = 0;
    while (sent < img.size())
    {
        const size_t chunk = std::min(kChunk, img.size() - sent);
        const auto frame = buildImageChunkFrame(static_cast<uint8_t>(kind), id, sent, img.data() + sent, chunk);
 
        // If you have per-peer send that returns bool, check and log
        bool allOk = true;
        for (auto& pid : toPeerIds)
        {
            sendGameTo(pid, frame); // if your API is void, keep it; otherwise log ok
        }
 
        // Fallback pacing (keeps buffers happy)
        if ((++paced % kPaceEveryN) == 0)
            std::this_thread::sleep_for(std::chrono::milliseconds(kPaceMillis));
 
        sent += chunk;
    }
 
    Logger::instance().log("localtunnel", Logger::Level::Info,
                           "sendImageChunks: done kind=" + std::string(kind == msg::ImageOwnerKind::Board ? "Board" : "Marker") +
                               " id=" + std::to_string(id) + " total=" + std::to_string(img.size()));
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendMarker()

void NetworkManager::sendMarker	(	uint64_t	boardId,
		const flecs::entity &	marker,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1741 of file NetworkManager.cpp.

{
    const TextureComponent* tex = marker.get<TextureComponent>();
    auto image_path = tex->image_path;
    Logger::instance().log("localtunnel", Logger::Level::Info, "Marker Path: " + image_path);
    auto is_file_only = PathManager::isFilenameOnly(tex->image_path);
    auto is_path_like = PathManager::isPathLike(tex->image_path);
    if (is_file_only || !is_path_like)
    {
        Logger::instance().log("localtunnel", Logger::Level::Info, "Marker Path is FILE ONLY");
        auto marker_folder = PathManager::getMarkersPath();
        auto image_path_ = marker_folder / tex->image_path;
        image_path = image_path_.string();
    }
    Logger::instance().log("localtunnel", Logger::Level::Info, "Marker Path Again: " + image_path);
    std::vector<unsigned char> img = tex ? readFileBytes(image_path) : std::vector<unsigned char>{};
    Logger::instance().log("localtunnel", Logger::Level::Info, "Marker Texture Byte Size: " + std::to_string(img.size()));
    // 1) meta
    auto meta = buildCreateMarkerFrame(boardId, marker, static_cast<uint64_t>(img.size()));
    broadcastGameFrame(meta, toPeerIds);
 
    // 2) image chunks (ownerKind=1 for marker)
    uint64_t mid = marker.get<Identifier>()->id;
    sendImageChunks(msg::ImageOwnerKind::Marker, mid, img, toPeerIds);
    //uint64_t off = 0;
    //while (off < img.size())
    //{
    //    size_t chunk = std::min<size_t>(kChunk, img.size() - off);
    //    auto frame = buildImageChunkFrame(/*ownerKind=*/1, mid, off, img.data() + off, chunk);
    //    Logger::instance().log("localtunnel", Logger::Level::Info, "Marker Texture Byte Size: " + img.size());
    //    broadcastGameFrame(frame, toPeerIds);
    //    off += chunk;
    //}
 
    // 3) commit
    auto commit = buildCommitMarkerFrame(boardId, mid);
    broadcastGameFrame(commit, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendMarkerDelete()

void NetworkManager::sendMarkerDelete	(	uint64_t	boardId,
		const flecs::entity &	marker,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1656 of file NetworkManager.cpp.

{
    if (!marker.is_valid() || !marker.has<Identifier>())
        return;
 
    const uint64_t mid = marker.get<Identifier>()->id;
    auto frame = buildMarkerDeleteFrame(boardId, mid);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendMarkerMove()

void NetworkManager::sendMarkerMove	(	uint64_t	boardId,
		const flecs::entity &	marker,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1393 of file NetworkManager.cpp.

{
    if (!marker.is_valid() || !marker.has<Identifier>() || !marker.has<Position>())
        return;
 
    const uint64_t markerId = marker.get<Identifier>()->id;
 
    // per-drag local seq in DragState
    auto& s = drag_[markerId];
    if (s.locallyProposedEpoch == 0 && s.epoch == 0)
    {
        s.locallyProposedEpoch = s.epoch + 1;
        s.epoch = s.locallyProposedEpoch;
    }
    const uint32_t seq = ++s.localSeq;
    s.lastTxMs = nowMs();
 
    auto frame = buildMarkerMoveFrame(boardId, marker, seq);
    if (frame.empty())
        return;
 
    for (auto& pid : toPeerIds)
    {
        if (auto it = peers.find(pid); it != peers.end() && it->second)
            it->second->sendMarkerMove(frame);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendMarkerMoveState()

void NetworkManager::sendMarkerMoveState	(	uint64_t	boardId,
		const flecs::entity &	marker,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1428 of file NetworkManager.cpp.

{
    if (!marker.is_valid() || !marker.has<Identifier>() || !marker.has<Moving>())
        return;
 
    auto frame = buildMarkerMoveStateFrame(boardId, marker);
    if (frame.empty())
        return;
 
    // Reliable: use your game channel
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendMarkerUpdate()

void NetworkManager::sendMarkerUpdate	(	uint64_t	boardId,
		const flecs::entity &	marker,
		const std::vector< std::string > &	toPeerIds )

Definition at line 1503 of file NetworkManager.cpp.

{
    if (!marker.is_valid() || !marker.has<Identifier>())
        return;
 
    auto frame = buildMarkerUpdateFrame(boardId, marker);
    broadcastGameFrame(frame, toPeerIds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendUserNameUpdateTo()

void NetworkManager::sendUserNameUpdateTo	(	const std::string &	peerId,
		const std::vector< uint8_t > &	payload )

Definition at line 1058 of file NetworkManager.cpp.

{
    auto it = peers.find(peerId);
    if (it == peers.end() || !it->second)
        return;
 
    std::vector<uint8_t> frame;
    frame.reserve(1 + payload.size());
    frame.push_back((uint8_t)msg::DCType::UserNameUpdate);
    frame.insert(frame.end(), payload.begin(), payload.end());
 
    it->second->sendOn(msg::dc::name::Game, frame);
}

Here is the caller graph for this function:

setCustomHost()

void NetworkManager::setCustomHost ( const std::string & h )

inline

Definition at line 299 of file NetworkManager.h.

{ customHost_ = h; }

setGMId()

void NetworkManager::setGMId ( const std::string & id )

inline

Definition at line 225 of file NetworkManager.h.

    {
        gmPeerId_ = id;
    }

setMyPeerId()

void NetworkManager::setMyPeerId ( std::string v )

inline

Definition at line 153 of file NetworkManager.h.

    {
        myPeerId_ = std::move(v);
    }

setNetworkPassword()

void NetworkManager::setNetworkPassword

(

const char *

password

)

Definition at line 462 of file NetworkManager.cpp.

{
    strncpy(network_password, password, sizeof(network_password) - 1);
    network_password[sizeof(network_password) - 1] = '\0';
}

Here is the caller graph for this function:

setPort()

void NetworkManager::setPort ( unsigned int port )

inline

Definition at line 103 of file NetworkManager.h.

    {
        this->port = port;
    }

Here is the caller graph for this function:

setToaster()

void NetworkManager::setToaster ( std::shared_ptr< ImGuiToaster > t )

inline

Definition at line 208 of file NetworkManager.h.

    {
        toaster_ = t;
    }

setup()

void NetworkManager::setup	(	std::weak_ptr< BoardManager >	board_manager,
		std::weak_ptr< GameTableManager >	gametable_manager )

Definition at line 23 of file NetworkManager.cpp.

{
    this->board_manager = board_manager;
    this->gametable_manager = gametable_manager;
 
    signalingClient = std::make_shared<SignalingClient>(weak_from_this());
    signalingServer = std::make_shared<SignalingServer>(weak_from_this());
 
    DebugConsole::setLocalTunnelHandlers(
        [this]() -> std::string
        {
            auto ip = NetworkUtilities::getLocalIPv4Address();
            Logger::instance().log("localtunnel", Logger::Level::Debug, "Starting with runic-" + ip + ":" + std::to_string(port));
            return NetworkUtilities::startLocalTunnel("runic-" + ip, port);
        },
        [this]()
        {
            NetworkUtilities::stopLocalTunnel();
            Logger::instance().log("localtunnel", Logger::Level::Info, "Stop requested");
        });
    DebugConsole::setIdentityLogger([this]() -> std::string
                                    { return debugIdentitySnapshot(); });
}

Here is the call graph for this function:

shouldApplyMarkerMove()

bool NetworkManager::shouldApplyMarkerMove

(

const msg::ReadyMessage &

m

)

Definition at line 1513 of file NetworkManager.cpp.

{
    if (!m.markerId || !m.dragEpoch)
        return false;
    auto& s = drag_[*m.markerId];
 
    // Epoch
    if (*m.dragEpoch < s.epoch)
        return false;
    if (*m.dragEpoch > s.epoch)
    {
        s.epoch = *m.dragEpoch;
        s.closed = false;
        s.lastSeq = 0;
        s.ownerPeerId = m.fromPeerId;
    }
    else
    {
        if (s.closed)
            return false;
        if (!s.ownerPeerId.empty() && s.ownerPeerId != m.fromPeerId)
        {
            if (!tieBreakWins(m.fromPeerId, s.ownerPeerId))
                return false;
            s.ownerPeerId = m.fromPeerId;
            if (s.locallyDragging)
            {
                s.locallyDragging = false;
                s.localSeq = 0;
            }
        }
        else
        {
            s.ownerPeerId = m.fromPeerId; // first owner for this epoch
        }
    }
 
    // Seq
    if (m.seq && *m.seq <= s.lastSeq)
        return false;
    if (m.seq)
        s.lastSeq = *m.seq;
 
    // Local echo suppression while we drag
    if (s.locallyDragging)
        return false;
 
    return true;
}

Here is the call graph for this function:

shouldApplyMarkerMoveStateFinal()

bool NetworkManager::shouldApplyMarkerMoveStateFinal

(

const msg::ReadyMessage &

m

)

Definition at line 1607 of file NetworkManager.cpp.

{
    if (!m.markerId || !m.dragEpoch || !m.mov || m.mov->isDragging)
        return false;
    auto& s = drag_[*m.markerId];
 
    if (*m.dragEpoch < s.epoch)
        return false;
    if (*m.dragEpoch > s.epoch)
    {
        s.epoch = *m.dragEpoch;
        s.closed = false;
        s.lastSeq = 0;
        s.ownerPeerId = m.fromPeerId;
    }
    else
    {
        if (s.closed)
            return false;
        if (!s.ownerPeerId.empty() && s.ownerPeerId != m.fromPeerId)
        {
            if (!tieBreakWins(m.fromPeerId, s.ownerPeerId))
                return false;
            s.ownerPeerId = m.fromPeerId;
            if (s.locallyDragging)
            {
                s.locallyDragging = false;
                s.localSeq = 0;
            }
        }
        else
        {
            s.ownerPeerId = m.fromPeerId;
        }
        if (m.seq && *m.seq < s.lastSeq)
            return false;
        if (m.seq && *m.seq >= s.lastSeq)
            s.lastSeq = *m.seq;
    }
 
    // finalize epoch
    s.closed = true;
    s.locallyDragging = false;
    s.localSeq = 0;
 
    return true;
}

Here is the call graph for this function:

shouldApplyMarkerMoveStateStart()

bool NetworkManager::shouldApplyMarkerMoveStateStart

(

const msg::ReadyMessage &

m

)

Definition at line 1563 of file NetworkManager.cpp.

{
    if (!m.markerId || !m.dragEpoch || !m.mov || !m.mov->isDragging)
        return false;
    auto& s = drag_[*m.markerId];
 
    if (*m.dragEpoch < s.epoch)
        return false;
    if (*m.dragEpoch > s.epoch)
    {
        s.epoch = *m.dragEpoch;
        s.closed = false;
        s.lastSeq = 0;
        s.ownerPeerId = m.fromPeerId;
    }
    else
    {
        if (s.closed)
            return false;
        if (!s.ownerPeerId.empty() && s.ownerPeerId != m.fromPeerId)
        {
            if (!tieBreakWins(m.fromPeerId, s.ownerPeerId))
                return false;
            s.ownerPeerId = m.fromPeerId;
            if (s.locallyDragging)
            {
                s.locallyDragging = false;
                s.localSeq = 0;
            }
        }
        else
        {
            s.ownerPeerId = m.fromPeerId;
        }
    }
 
    if (m.seq && *m.seq <= s.lastSeq)
        return false;
    if (m.seq)
        s.lastSeq = *m.seq;
 
    return true;
}

Here is the call graph for this function:

ShowPortForwardingHelpPopup()

void NetworkManager::ShowPortForwardingHelpPopup

(

bool *

p_open

)

Definition at line 469 of file NetworkManager.cpp.

{
    if (*p_open)
    {
        ImGui::OpenPopup("Port Forwarding Failed");
    }
 
    if (ImGui::BeginPopupModal("Port Forwarding Failed", p_open, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::Text("Automatic port forwarding failed. This is likely because your router does not\n"
                    "support UPnP or it is disabled. You can still host by choosing one of the\n"
                    "following three options:");
 
        ImGui::Separator();
 
        if (ImGui::BeginTabBar("PortOptions"))
        {
 
            // Tab 1: Enable UPnP
            if (ImGui::BeginTabItem("Enable UPnP"))
            {
                ImGui::Text("This is the easiest solution and will allow automatic port forwarding to work.");
                ImGui::Spacing();
                ImGui::BulletText("Access your router's administration page. This is usually done by\n"
                                  "typing its IP address (e.g., 192.168.1.1) in your browser.");
                ImGui::BulletText("Log in with your router's credentials.");
                ImGui::BulletText("Look for a setting named 'UPnP' or 'Universal Plug and Play' and enable it.");
                ImGui::BulletText("Save the settings and restart your router if necessary.");
                ImGui::BulletText("Try hosting again. The application should now automatically forward the port.");
                ImGui::EndTabItem();
            }
 
            // Tab 2: Manual Port Forwarding
            if (ImGui::BeginTabItem("Manual Port Forwarding"))
            {
                ImGui::Text("This method always works but requires you to configure your router manually.");
                ImGui::Spacing();
                ImGui::BulletText("Find your local IP address. Open Command Prompt and type 'ipconfig' to find it\n"
                                  "(e.g., 192.168.1.100).");
                ImGui::BulletText("Access your router's administration page.");
                ImGui::BulletText("Look for a setting named 'Port Forwarding', 'Virtual Server', or 'NAT'.");
                ImGui::BulletText("Create a new rule with the following details:");
                ImGui::Indent();
                ImGui::BulletText("Protocol: TCP");
                ImGui::BulletText("Internal Port: [Your application's port, e.g., 8080]");
                ImGui::BulletText("External Port: [The same port]");
                ImGui::BulletText("Internal IP: [Your local IP from step 1]");
                ImGui::Unindent();
                ImGui::BulletText("Save the rule and try hosting again.");
                ImGui::EndTabItem();
            }
 
            // Tab 3: Use a VPN (Hamachi)
            if (ImGui::BeginTabItem("Use a VPN (Hamachi)"))
            {
                ImGui::Text("A VPN creates a virtual local network, bypassing the need for port forwarding.");
                ImGui::Spacing();
                ImGui::BulletText("Download and install a VPN client like Hamachi.");
                ImGui::BulletText("Create a new network within the VPN client.");
                ImGui::BulletText("Share the network name and password with your friends.");
                ImGui::BulletText("Instruct your friends to join your network.");
                ImGui::BulletText("On the host screen, you should be able to see your VPN IP address.\n"
                                  "Use this IP to host your session.");
                ImGui::EndTabItem();
            }
 
            ImGui::EndTabBar();
        }
 
        if (ImGui::Button("Close"))
        {
            *p_open = false;
            ImGui::CloseCurrentPopup();
        }
 
        ImGui::EndPopup();
    }
}

startRawDrainWorker()

void NetworkManager::startRawDrainWorker

(

)

Definition at line 2502 of file NetworkManager.cpp.

{
    bool expected = false;
    if (!rawWorkerRunning_.compare_exchange_strong(expected, true))
        return; // already running
 
    rawWorkerStop_.store(false);
    rawWorker_ = std::thread([this]()
                             {
        using clock = std::chrono::steady_clock;
        auto lastFlush = clock::now();
        for (;;) {
            if (rawWorkerStop_.load())
                break;
 
            bool didWork = false;
 
            msg::InboundRaw r;
            if (inboundRaw_.try_pop(r)) {
                try {
                    if (r.label == msg::dc::name::Game) {
                        decodeRawGameBuffer(r.fromPeer, r.bytes);
                    } else if (r.label == msg::dc::name::Chat) {
                        decodeRawChatBuffer(r.fromPeer, r.bytes);
                    } else if (r.label == msg::dc::name::Notes) {
                        decodeRawNotesBuffer(r.fromPeer, r.bytes);
                    } else if (r.label == msg::dc::name::MarkerMove) {
                        decodeRawMarkerMoveBuffer(r.fromPeer, r.bytes);
                    }
                } catch (...) {
                    // swallow
                }
                didWork = true;
            }
            
        } });
}

Here is the call graph for this function:

startServer() [1/2]

void NetworkManager::startServer	(	ConnectionType	mode,
		unsigned short	port,
		bool	tryUpnp )

Definition at line 123 of file NetworkManager.cpp.

{
    peer_role = Role::GAMEMASTER;
 
    if (!signalingServer)
        signalingServer = std::make_shared<SignalingServer>(shared_from_this());
    if (!signalingClient)
        signalingClient = std::make_shared<SignalingClient>(shared_from_this());
 
    // Bind WS to all interfaces (overlay/LAN/etc.)
    signalingServer->start(port);
    setPort(port);
 
    const std::string localIp = getLocalIPAddress();
 
    // Mode-specific side effects (no client connect here)
    switch (mode)
    {
        case ConnectionType::LOCALTUNNEL:
        {
            // Expose to the world; GM still connects locally below
            try {
                (void)NetworkUtilities::startLocalTunnel("runic-" + localIp, static_cast<int>(port));
            } catch (...) {
                pushStatusToast("LocalTunnel failed to start.", ImGuiToaster::Level::Error, 4);
            }
            break;
        }
 
        case ConnectionType::EXTERNAL:
        {
            if (tryUpnp)
            {
                try
                {
                    (void)UPnPManager::addPortMapping(localIp, port, port, "TCP", "RunicVTT");
                }
                catch (...)
                {
                    pushStatusToast("UPnP port mapping failed — check router config.", ImGuiToaster::Level::Error, 4);
                }
            }
            // Players will connect via public IP:port; GM still connects locally below
            break;
        }
 
        case ConnectionType::LOCAL:
        case ConnectionType::CUSTOM:
        default:
            // No special side-effect needed; GM still connects locally below
            break;
    }
 
    // GM always connects locally to the server it just started.
    signalingClient->connect("127.0.0.1", port);
 
    pushStatusToast("Signalling Server Started!!", ImGuiToaster::Level::Good, 4);
    // startRawDrainWorker(); // if/when you want it
}

Here is the call graph for this function:

Here is the caller graph for this function:

startServer() [2/2]

void NetworkManager::startServer	(	std::string	internal_ip_address,
		unsigned short	port )

Definition at line 301 of file NetworkManager.cpp.

{
    // Old default used LocalTunnel; keep that behavior
    startServer(ConnectionType::LOCALTUNNEL, port, /*tryUpnp=*/false);
}

Here is the call graph for this function:

stopRawDrainWorker()

void NetworkManager::stopRawDrainWorker

(

)

Definition at line 2540 of file NetworkManager.cpp.

{
    if (!rawWorkerRunning_.load())
        return;
    rawWorkerStop_.store(true);
    if (rawWorker_.joinable())
        rawWorker_.join();
    rawWorkerRunning_.store(false);
}

tieBreakWins()

static bool NetworkManager::tieBreakWins ( const std::string & challengerPeerId, const std::string & currentOwnerPeerId )

inlinestaticprivate

Definition at line 327 of file NetworkManager.h.

    {
        return challengerPeerId < currentOwnerPeerId;
    }

Here is the caller graph for this function:

tryFinalizeImage()

void NetworkManager::tryFinalizeImage ( msg::ImageOwnerKind kind, uint64_t id )

private

Definition at line 2589 of file NetworkManager.cpp.

{
    auto it = imagesRx_.find(id);
    if (it == imagesRx_.end())
        return;
    auto& p = it->second;
    if (!p.commitRequested || !p.isComplete())
        return;
 
    msg::ReadyMessage m;
    if (kind == msg::ImageOwnerKind::Board)
    {
        if (!p.boardMeta)
            return; // need meta
        m.kind = msg::DCType::CommitBoard;
        m.boardId = p.boardMeta->boardId;
        m.boardMeta = p.boardMeta;
    }
    else
    {
        if (!p.markerMeta)
            return; // need meta
        m.kind = msg::DCType::CommitMarker;
        m.boardId = p.boardId; // for markers we also stored the boardId
        m.markerMeta = p.markerMeta;
    }
    m.bytes = std::move(p.buf);
    inboundGame_.push(std::move(m));
 
    Logger::instance().log("localtunnel", Logger::Level::Info,
                           std::string("tryFinalizeImage: finalized ") +
                               (kind == msg::ImageOwnerKind::Board ? "Board" : "Marker") +
                               " id=" + std::to_string(id));
 
    imagesRx_.erase(it);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tryPopRawMessage()

bool NetworkManager::tryPopRawMessage ( msg::InboundRaw & out )

inline

Definition at line 172 of file NetworkManager.h.

    {
        return inboundRaw_.try_pop(out);
    }

Here is the call graph for this function:

tryPopReadyMessage()

bool NetworkManager::tryPopReadyMessage ( msg::ReadyMessage & out )

inline

Definition at line 167 of file NetworkManager.h.

    {
        return inboundGame_.try_pop(out);
    }

Here is the call graph for this function:

upsertPeerIdentityWithUnique()

void NetworkManager::upsertPeerIdentityWithUnique	(	const std::string &	peerId,
		const std::string &	uniqueId,
		const std::string &	username )

Definition at line 761 of file NetworkManager.cpp.

{
    identity_manager->bindPeer(/*peerId=*/peerId,
                               /*uniqueId=*/uniqueId,
                               /*username=*/username);
 
    if (auto it = peers.find(peerId); it != peers.end() && it->second)
        it->second->setDisplayName(username);
}

Member Data Documentation

board_manager

std::weak_ptr<BoardManager> NetworkManager::board_manager

private

Definition at line 399 of file NetworkManager.h.

customHost_

std::string NetworkManager::customHost_

private

Definition at line 303 of file NetworkManager.h.

decodingFromPeer_

std::string NetworkManager::decodingFromPeer_

private

Definition at line 310 of file NetworkManager.h.

drag_

std::unordered_map<uint64_t , DragState> NetworkManager::drag_

Definition at line 293 of file NetworkManager.h.

ecs

flecs::world NetworkManager::ecs

private

Definition at line 388 of file NetworkManager.h.

events_

MessageQueue<msg::NetEvent> NetworkManager::events_

Definition at line 219 of file NetworkManager.h.

external_ip_address

std::string NetworkManager::external_ip_address = ""

private

Definition at line 391 of file NetworkManager.h.

gametable_manager

std::weak_ptr<GameTableManager> NetworkManager::gametable_manager

private

Definition at line 400 of file NetworkManager.h.

gmPeerId_

std::string NetworkManager::gmPeerId_

private

Definition at line 386 of file NetworkManager.h.

identity_manager

std::shared_ptr<IdentityManager> NetworkManager::identity_manager

private

Definition at line 347 of file NetworkManager.h.

imagesRx_

std::unordered_map<uint64_t, PendingImage> NetworkManager::imagesRx_

private

Definition at line 340 of file NetworkManager.h.

inboundGame_

MessageQueue<msg::ReadyMessage> NetworkManager::inboundGame_

private

Definition at line 341 of file NetworkManager.h.

inboundRaw_

MessageQueue<msg::InboundRaw> NetworkManager::inboundRaw_

Definition at line 220 of file NetworkManager.h.

kChunk

constexpr size_t NetworkManager::kChunk = 8 * 1024

staticconstexprprivate

Definition at line 349 of file NetworkManager.h.

kPaceEveryN

constexpr int NetworkManager::kPaceEveryN = 48

staticconstexprprivate

Definition at line 352 of file NetworkManager.h.

kPaceMillis

constexpr int NetworkManager::kPaceMillis = 2

staticconstexprprivate

Definition at line 353 of file NetworkManager.h.

local_ip_address

std::string NetworkManager::local_ip_address = ""

private

Definition at line 392 of file NetworkManager.h.

myPeerId_

std::string NetworkManager::myPeerId_

private

Definition at line 385 of file NetworkManager.h.

network_password

char NetworkManager::network_password[124] = "\0"

private

Definition at line 390 of file NetworkManager.h.

peer_role

Role NetworkManager::peer_role

private

Definition at line 393 of file NetworkManager.h.

peers

std::unordered_map<std::string, std::shared_ptr<PeerLink> > NetworkManager::peers

private

Definition at line 398 of file NetworkManager.h.

port

unsigned int NetworkManager::port = 8080

private

Definition at line 389 of file NetworkManager.h.

rawWorker_

std::thread NetworkManager::rawWorker_

private

Definition at line 345 of file NetworkManager.h.

rawWorkerRunning_

std::atomic<bool> NetworkManager::rawWorkerRunning_ {false}

private

Definition at line 343 of file NetworkManager.h.

{false};

rawWorkerStop_

std::atomic<bool> NetworkManager::rawWorkerStop_ {false}

private

Definition at line 344 of file NetworkManager.h.

{false};

rtcConfig

rtc::Configuration NetworkManager::rtcConfig

private

Definition at line 395 of file NetworkManager.h.

sendMoveMinPeriodMs_

uint32_t NetworkManager::sendMoveMinPeriodMs_ {50}

private

Definition at line 311 of file NetworkManager.h.

{50}; // pacing target (~20Hz)

signalingClient

std::shared_ptr<SignalingClient> NetworkManager::signalingClient

private

Definition at line 397 of file NetworkManager.h.

signalingServer

std::shared_ptr<SignalingServer> NetworkManager::signalingServer

private

Definition at line 396 of file NetworkManager.h.

toaster_

std::shared_ptr<ImGuiToaster> NetworkManager::toaster_

private

Definition at line 348 of file NetworkManager.h.

---

The documentation for this class was generated from the following files:

• include/network/NetworkManager.h
• src/network/NetworkManager.cpp