kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

steam relay networking

Browse Source
This commit is contained in:
kotofyt
2026-03-01 23:06:28 +02:00
parent 03c560c2b7
commit 468d765aa1
16 changed files with 628 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
engine/engine.cpp
View File

@@ -12,6 +12,7 @@
#ifdef STEAM
#include "steam/steam_api.h"
#include "steam/steam_gameserver.h"
#endif
IRenderContext *g_pRenderContext;
@@ -21,17 +22,30 @@ IGameWindowManager *g_pWindowManager;
CServerGameDLL *g_pServerGame;
CClientGameDLL *g_pClientGame;
extern "C" void __cdecl SteamAPIDebug( ESteamNetworkingSocketsDebugOutputType nType, const char *pszMsg )
{
V_printf("STEAM: %s\n", pszMsg);
}
extern "C" void FunnyMain( int argc, char **argv )
{
CommandLine()->CreateCommandLine(argc, argv);
EngineConsts_t stConstants = {};
#ifdef STEAM
if(SteamAPI_RestartAppIfNecessary(480))
{
V_printf("Mshallah we are doing reboot\n");
Plat_Exit(0);
}
stConstants.m_bIsSteam = true;
if (!SteamAPI_Init())
Plat_FatalErrorFunc("SteamAPI_Init failed lol\n");
stConstants.LaunchServer = LaunchLocalBridge;
stConstants.LaunchServer = LaunchServerAtSteamRelay;
stConstants.ConnectSteamServer = ConnectBySteamID;
//SteamNetworkingUtils()->SetDebugOutputFunction(k_ESteamNetworkingSocketsDebugOutputType_Debug, SteamAPIDebug);
#endif
stConstants.m_bIsDedicated = CommandLine()->CheckParam("-dedicated");
stConstants.LaunchLocalBridge = LaunchLocalBridge;
@@ -75,9 +89,13 @@ extern "C" void FunnyMain( int argc, char **argv )
double fPrevious = Plat_GetTime();
for (;;) {
#ifdef STEAM
SteamAPI_RunCallbacks();
#endif
double fCurrent = Plat_GetTime();
double fDelta = fCurrent-fPrevious;
fPrevious = fCurrent;
g_pServerGame->m_pBridge->Frame(fDelta);
if (!stConstants.m_bIsDedicated)

42
engine/localnetwork.cpp
View File

@@ -12,13 +12,16 @@ public:
virtual ~CLocalNetworkServer() override;
virtual void NetThink() override;
virtual void SetCallback( NetCallbackFn fnCallback ) override;
virtual uint32_t BHasUpdates() override;
virtual NetPacket_t RecievePacket() override;
virtual NetPacket_t PeekPacket() override;
virtual NetPacket_t PeekPacket() override;
virtual void SendPacket( NetPacket_t stPacket ) override;
virtual bool BIsActive() override;
virtual uint64_t GetSteamID() override;
virtual const char *GetIP() override;
virtual uint16_t GetPort() override;
@@ -27,6 +30,7 @@ public:
CUtlVector<NetPacket_t> m_packets;
CUtlVector<NetPacket_t> m_clientPackets;
CUtlVector<void*> m_freedPackets;
NetCallbackFn m_fnCallback;
const uint16_t m_uPort;
};
@@ -41,16 +45,18 @@ CLocalNetworkServer::~CLocalNetworkServer()
}
void CLocalNetworkServer::SetCallback( NetCallbackFn fnCallback )
{
m_fnCallback = fnCallback;
}
void CLocalNetworkServer::NetThink()
{
m_lock.Lock();
for ( auto p: m_freedPackets)
{
V_free(p);
}
m_freedPackets = {};
m_lock.Unlock();
}
@@ -61,23 +67,19 @@ uint32_t CLocalNetworkServer::BHasUpdates()
NetPacket_t CLocalNetworkServer::RecievePacket()
{
m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_clientPackets[0];
m_clientPackets.RemoveHead(1);
m_freedPackets.AppendTail(p.pData);
m_lock.Unlock();
return p;
}
NetPacket_t CLocalNetworkServer::PeekPacket()
{
m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_clientPackets[0];
m_lock.Unlock();
return p;
}
@@ -86,14 +88,17 @@ void CLocalNetworkServer::SendPacket( NetPacket_t stPacket )
{
NetPacket_t stSavedPacked;
stSavedPacked.uSize = stPacket.uSize;
stSavedPacked.m_uOwner = 0;
stSavedPacked.pData = V_malloc(stPacket.uSize);
V_memcpy(stSavedPacked.pData, stPacket.pData, stPacket.uSize);
m_lock.Lock();
m_packets.AppendTail(stSavedPacked);
m_lock.Unlock();
}
bool CLocalNetworkServer::BIsActive()
{
return true;
}
uint64_t CLocalNetworkServer::GetSteamID()
{
@@ -117,12 +122,15 @@ public:
virtual ~CLocalNetworkClient() override;
virtual void NetThink() override;
virtual void SetCallback( NetCallbackFn fnCallback ) override;
virtual uint32_t BHasUpdates() override;
virtual NetPacket_t RecievePacket() override;
virtual NetPacket_t PeekPacket() override;
virtual void SendPacket( NetPacket_t stPacket ) override;
virtual bool BIsActive() override;
virtual uint64_t GetSteamID() override;
virtual const char *GetIP() override;
@@ -131,6 +139,11 @@ public:
CLocalNetworkServer *m_pServer;
};
bool CLocalNetworkClient::BIsActive()
{
return true;
}
CLocalNetworkClient::CLocalNetworkClient( uint16_t uPort )
{
m_pServer = s_pLocalServers[uPort];
@@ -154,23 +167,19 @@ uint32_t CLocalNetworkClient::BHasUpdates()
NetPacket_t CLocalNetworkClient::RecievePacket()
{
m_pServer->m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_pServer->m_packets[0];
m_pServer->m_packets.RemoveHead(1);
m_pServer->m_freedPackets.AppendTail(p.pData);
m_pServer->m_lock.Unlock();
return p;
}
NetPacket_t CLocalNetworkClient::PeekPacket()
{
m_pServer->m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_pServer->m_packets[0];
m_pServer->m_lock.Unlock();
return p;
}
@@ -179,12 +188,15 @@ void CLocalNetworkClient::SendPacket( NetPacket_t stPacket )
{
NetPacket_t stSavedPacked;
stSavedPacked.uSize = stPacket.uSize;
stSavedPacked.m_uOwner = 0;
stSavedPacked.pData = V_malloc(stPacket.uSize);
V_memcpy(stSavedPacked.pData, stPacket.pData, stPacket.uSize);
m_pServer->m_lock.Lock();
m_pServer->m_clientPackets.AppendTail(stSavedPacked);
m_pServer->m_lock.Unlock();
}
void CLocalNetworkClient::SetCallback( NetCallbackFn fnCallback )
{
}

240
engine/steamnetwork.cpp
View File

@@ -1,5 +1,11 @@
#include "inetworkserver.h"
#include "inetworkclient.h"
#include "tier0/lib.h"
#include "tier1/utlmutex.h"
#include "tier1/utlvector.h"
#ifdef STEAM
#include "steam/steam_gameserver.h"
#endif
#include "steam/isteamnetworkingsockets.h"
class CSteamNetworkServer: public INetworkBase
@@ -9,22 +15,37 @@ public:
virtual ~CSteamNetworkServer() override;
virtual void NetThink() override;
virtual void SetCallback( NetCallbackFn fnCallback ) override;
virtual uint32_t BHasUpdates() override;
virtual NetPacket_t PeekPacket() override;
virtual NetPacket_t RecievePacket() override;
virtual void SendPacket( NetPacket_t stPacket ) override;
virtual bool BIsActive() override;
virtual uint64_t GetSteamID() override;
virtual const char *GetIP() override;
virtual uint16_t GetPort() override;
ISteamNetworkingSockets *m_pInterface;
HSteamListenSocket m_hSocket;
NetCallbackFn m_fnCallback;
HSteamNetPollGroup m_hPollGroup;
uint64_t m_uSteamId;
CUtlVector<HSteamNetPollGroup> m_hConnections;
STEAM_GAMESERVER_CALLBACK(CSteamNetworkServer, ClientConnected, SteamNetConnectionStatusChangedCallback_t);
STEAM_GAMESERVER_CALLBACK(CSteamNetworkServer, SteamNetAuthenticated, SteamNetAuthenticationStatus_t);
};
CSteamNetworkServer::CSteamNetworkServer( uint16_t uPort )
{
m_hSocket = SteamNetworkingSockets()->CreateListenSocketP2P(uPort, 0, NULL);
m_pInterface = SteamGameServerNetworkingSockets();
m_hSocket = m_pInterface->CreateListenSocketP2P(0, 0, NULL);
m_hPollGroup = m_pInterface->CreatePollGroup();
}
CSteamNetworkServer::~CSteamNetworkServer()
@@ -37,8 +58,17 @@ void CSteamNetworkServer::NetThink()
{
}
void CSteamNetworkServer::SetCallback( NetCallbackFn fnCallback )
{
m_fnCallback = fnCallback;
}
uint32_t CSteamNetworkServer::BHasUpdates()
{
return 0;
}
NetPacket_t CSteamNetworkServer::PeekPacket()
{
}
@@ -51,6 +81,21 @@ NetPacket_t CSteamNetworkServer::RecievePacket()
void CSteamNetworkServer::SendPacket( NetPacket_t stPacket )
{
if ( stPacket.m_uOwner == 0 )
{
for ( auto c: m_hConnections )
{
if (stPacket.m_eArrival == PACKET_MAY_ARRIVE)
m_pInterface->SendMessageToConnection(c, stPacket.pData, stPacket.uSize, k_nSteamNetworkingSend_Unreliable, 0);
if (stPacket.m_eArrival == PACKET_MUST_ARRIVE)
m_pInterface->SendMessageToConnection(c, stPacket.pData, stPacket.uSize, k_nSteamNetworkingSend_Reliable, 0);
}
}
}
bool CSteamNetworkServer::BIsActive()
{
return true;
}
@@ -69,6 +114,189 @@ uint16_t CSteamNetworkServer::GetPort()
return 0;
}
void CSteamNetworkServer::ClientConnected( SteamNetConnectionStatusChangedCallback_t *pParam )
{
uint32_t uResult;
NetCallback_t callback = {};
switch (pParam->m_info.m_eState)
{
case k_ESteamNetworkingConnectionState_Connecting:
callback.m_eType = NET_TRYING_TO_CONNECT;
callback.m_ullUserID = pParam->m_info.m_identityRemote.GetSteamID64();
break;
case k_ESteamNetworkingConnectionState_Connected:
callback.m_eType = NET_CONNECTED;
callback.m_ullUserID = pParam->m_info.m_identityRemote.GetSteamID64();
m_pInterface->SetConnectionPollGroup(pParam->m_hConn, m_hPollGroup);
m_hConnections.AppendTail(pParam->m_hConn);
break;
default:
break;
}
V_printf("%p\n", m_fnCallback);
if (m_fnCallback)
uResult = m_fnCallback(&callback);
else
uResult = 0;
switch (pParam->m_info.m_eState)
{
case k_ESteamNetworkingConnectionState_Connecting:
if (uResult != 0)
m_pInterface->AcceptConnection(pParam->m_hConn);
else
m_pInterface->CloseConnection(pParam->m_hConn, 0, "Connection denied", 0);
break;
default:
break;
}
}
void CSteamNetworkServer::SteamNetAuthenticated( SteamNetAuthenticationStatus_t *pParam )
{
NetCallback_t callback = {};
callback.m_eType = NET_SERVER_READY_TO_USE;
if ( pParam->m_eAvail != k_ESteamNetworkingAvailability_Current )
return;
if (m_fnCallback)
m_fnCallback(&callback);
}
class CSteamNetworkClient: public INetworkBase
{
public:
CSteamNetworkClient( uint64_t uID, uint16_t uPort );
virtual ~CSteamNetworkClient() override;
virtual void NetThink() override;
virtual void SetCallback( NetCallbackFn fnCallback ) override;
virtual uint32_t BHasUpdates() override;
virtual NetPacket_t PeekPacket() override;
virtual NetPacket_t RecievePacket() override;
virtual void SendPacket( NetPacket_t stPacket ) override;
virtual bool BIsActive() override;
virtual uint64_t GetSteamID() override;
virtual const char *GetIP() override;
virtual uint16_t GetPort() override;
ISteamNetworkingSockets *m_pInterface;
HSteamNetConnection m_hConnection;
CUtlVector<NetPacket_t> m_incomingPackets = {};
CUtlVector<SteamNetworkingMessage_t*> m_incomingSteamPackets = {};
CUtlVector<SteamNetworkingMessage_t*> m_freeSteamPackets = {};
CUtlLock m_lock;
};
CSteamNetworkClient::CSteamNetworkClient( uint64_t uID, uint16_t uPort )
{
m_pInterface = SteamNetworkingSockets();
SteamNetworkingIdentity id = {};
id.Clear();
id.SetSteamID64(uID);
m_hConnection = m_pInterface->ConnectP2P(id, 0, 0, NULL);
}
CSteamNetworkClient::~CSteamNetworkClient()
{
}
void CSteamNetworkClient::NetThink()
{
int nReceived = 1;
for ( auto p: m_freeSteamPackets )
{
p->Release();
}
m_freeSteamPackets = {};
while (nReceived)
{
SteamNetworkingMessage_t *pMessages[64];
nReceived = m_pInterface->ReceiveMessagesOnConnection(m_hConnection, pMessages, 64);
for ( int i = 0; i < nReceived; i++ )
{
SteamNetConnectionInfo_t info = {};
m_pInterface->GetConnectionInfo(pMessages[i]->GetConnection(), &info);
m_incomingSteamPackets.AppendTail(pMessages[i]);
NetPacket_t packet = {};
packet.m_uOwner = info.m_identityRemote.GetSteamID64();
packet.uSize = pMessages[i]->GetSize();
packet.pData = (void*)pMessages[i]->GetData();
m_incomingPackets.AppendTail(packet);
}
}
}
void CSteamNetworkClient::SetCallback( NetCallbackFn fnCallback )
{
}
uint32_t CSteamNetworkClient::BHasUpdates()
{
return m_incomingPackets.GetSize();
}
NetPacket_t CSteamNetworkClient::PeekPacket()
{
m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_incomingPackets[0];
m_lock.Unlock();
return p;
}
NetPacket_t CSteamNetworkClient::RecievePacket()
{
m_lock.Lock();
if (!BHasUpdates())
return {};
NetPacket_t p = m_incomingPackets[0];
m_freeSteamPackets.AppendTail(m_incomingSteamPackets[0]);
m_incomingSteamPackets.RemoveHead(1);
m_incomingPackets.RemoveHead(1);
m_lock.Unlock();
return p;
}
void CSteamNetworkClient::SendPacket( NetPacket_t stPacket )
{
}
bool CSteamNetworkClient::BIsActive()
{
return true;
}
uint64_t CSteamNetworkClient::GetSteamID()
{
return 0;
}
const char *CSteamNetworkClient::GetIP()
{
return 0;
}
uint16_t CSteamNetworkClient::GetPort()
{
return 0;
}
INetworkBase *LaunchServerAtSteamRelay( uint16_t uPort )
{
@@ -78,5 +306,11 @@ INetworkBase *LaunchServerAtSteamRelay( uint16_t uPort )
INetworkBase *ConnectBySteamID( uint64_t uID, uint16_t uPort )
{
return NULL;
CSteamNetworkClient *pBase = new CSteamNetworkClient(uID, uPort);
if (pBase->m_hConnection == k_HSteamNetConnection_Invalid)
{
delete pBase;
return NULL;
}
return pBase;
}

0
engine/steamserver.cpp Normal file
View File