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,6 +122,7 @@ public:
virtual ~CLocalNetworkClient() override;
virtual void NetThink() override;
virtual void SetCallback( NetCallbackFn fnCallback ) override;
virtual uint32_t BHasUpdates() override;
virtual NetPacket_t RecievePacket() override;
@@ -124,6 +130,8 @@ public:
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;
@@ -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 )
{
}

238
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 )
{
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

4
game/client/baseentity.cpp
View File

@@ -128,7 +128,9 @@ BEGIN_DATADESC_NOBASE(C_BaseEntity)
END_DATADESC()
IMPLEMENT_RECV_DT_NOBASE(C_BaseEntity)
NetPropFloat3(m_vPosition)
NetPropFloat3(m_vPosition),
NetPropQuaternion(m_vRotation),
NetPropFloat3(m_vScale)
END_RECV_DT()
IMPLEMENT_EMPTY_SEND_DT_NOBASE(C_BaseEntity)

9
game/client/build.cpp
View File

@@ -33,9 +33,12 @@ DECLARE_BUILD_STAGE(Client)
"../shared",
"../../public",
FUNNYSTDLIB"public",
EXTERNAL"cglm/include"
EXTERNAL"cglm/include",
EXTERNAL"steamworks/public",
};
compileProject.bFPIC = true;
if ( GET_PROJECT_VALUE(config, "steam") == "true" )
compileProject.macros.AppendTail({"STEAM", "TRUE"});
ldProject = ccompiler->Compile(&compileProject);
if ( GET_PROJECT_VALUE(config, "static") == "true" )
@@ -44,6 +47,10 @@ DECLARE_BUILD_STAGE(Client)
}
else
{
if ( GET_PROJECT_VALUE(config, "steam") == "true" ) {
ldProject.libraryDirectories.AppendTail(EXTERNAL"steamworks/redistributable_bin/linux64");
ldProject.libraries.AppendTail("steam_api");
}
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
ldProject.libraryObjects = {
GET_PROJECT_LIBRARY(tier0, "tier0"),

88
game/client/game.cpp
View File

@@ -1,4 +1,5 @@
#include "tier2/ifilesystem.h"
#include "tier0/commandline.h"
#include "materialsystem/imaterialsystem.h"
#include "enginebridge.h"
#include "worldrender.h"
@@ -9,6 +10,10 @@
#include "cglm/cglm.h"
#include "inetworkclient.h"
#include "netprotocol.h"
#ifdef STEAM
#include "steam/isteamgameserver.h"
#include "steam/steam_gameserver.h"
#endif
IFileSystem *filesystem;
IRenderContext *g_pRenderContext;
@@ -16,7 +21,9 @@ IGameWindow *g_pMainWindow;
static CEngineVars s_vars;
CEngineVars *g_pEngineVars = &s_vars;
EngineConsts_t *g_pEngineConstants;
INetworkBase *g_pServerBridge;
INetworkBase *g_pServerConnection;
class CFunnyGameBridge: public IEngineBridge
{
@@ -25,6 +32,11 @@ class CFunnyGameBridge: public IEngineBridge
virtual void Frame( float fDelta ) override;
virtual void Shutdown() override;
virtual void ConnectInterface( const char *psz, void *pInterface ) override;
void TryToConnectToServer();
bool m_bIsConnectedToSteamRelay;
bool m_bIsConnectedToServer;
};
IEngineBridge *EngineBridge()
@@ -35,17 +47,30 @@ IEngineBridge *EngineBridge()
EXPOSE_INTERFACE_FN(EngineBridge, IEngineBridge, ENGINE_BRIDGE_INTERFACE_VERSION)
void CFunnyGameBridge::Init()
{
g_pWorldRenderer->Init();
g_pServerBridge = g_pEngineConstants->ConnectLocalBridge(0);
#ifdef STEAM
if (g_pEngineConstants->m_bIsSteam)
{
SteamErrMsg err = { 0 };
m_bIsConnectedToSteamRelay = 0;
SteamNetworkingUtils()->InitRelayNetworkAccess();
}
#endif
m_bIsConnectedToServer = false;
g_pServerBridge = g_pEngineConstants->ConnectLocalBridge(0);
if (g_pServerBridge)
{
PlayerJoined_t join = {
MESSAGE_PLAYER_JOINED,
"LocalPlayer"
};
g_pServerBridge->SendPacket({&join, sizeof(join)});
}
}
void CFunnyGameBridge::Tick( float fDelta )
{
@@ -70,15 +95,53 @@ searchIndex:
return (char*)pEntity+pCurrentMap->m_pFields[uCurrentIndex].m_uOffset;
}
void CFunnyGameBridge::TryToConnectToServer()
{
#ifdef STEAM
if (g_pEngineConstants->m_bIsSteam)
{
if (m_bIsConnectedToSteamRelay != 0 )
return;
if ( SteamNetworkingUtils()->GetRelayNetworkStatus(NULL) == k_ESteamNetworkingAvailability_Current)
{
m_bIsConnectedToSteamRelay = 1;
V_printf("%llu\n", SteamUser()->GetSteamID().ConvertToUint64());
if (CommandLine()->ParamValue("-steam-connect"))
{
char *pEnd = NULL;
uint64_t uValue = strtoull(CommandLine()->ParamValue("-steam-connect"), &pEnd, 10);
g_pServerConnection = g_pEngineConstants->ConnectSteamServer(uValue, FUNNY_SECURE_PORT);
if (g_pServerConnection)
{
m_bIsConnectedToServer = true;
}
return;
}
}
}
#endif
}
void CFunnyGameBridge::Frame( float fDelta )
{
g_pEngineVars->m_fTime += fDelta;
g_pEngineVars->m_fDeltaTime = fDelta;
g_pServerBridge->NetThink();
while ( g_pServerBridge->BHasUpdates() )
TryToConnectToServer();
INetworkBase *pCurrentServer = g_pServerBridge;
pCurrentServer = g_pServerBridge;
if (m_bIsConnectedToServer)
if (g_pServerConnection->BIsActive())
pCurrentServer = g_pServerConnection;
if (pCurrentServer)
{
NetPacket_t packet = g_pServerBridge->PeekPacket();
pCurrentServer->NetThink();
while ( pCurrentServer->BHasUpdates() )
{
NetPacket_t packet = pCurrentServer->PeekPacket();
// discard it
if (packet.uSize < sizeof (EMessageType))
continue;
@@ -90,11 +153,21 @@ void CFunnyGameBridge::Frame( float fDelta )
pEntity = EntitySystem()->CreateByClassnameWithIndex(
(char*)pPacket->m_entityClass.m_szEntityName, pPacket->m_entityClass.m_uIndex
);
if (pEntity == NULL)
{
pCurrentServer->RecievePacket();
continue;
}
pEntity->Spawn();
g_pServerBridge->RecievePacket();
pCurrentServer->RecievePacket();
break;
case MESSAGE_ENTITY_DATA_SYNC:
pEntity = EntitySystem()->GetEntities()[pPacket->m_entityData.m_uIndex];
if (pEntity == NULL)
{
pCurrentServer->RecievePacket();
continue;
}
union {
void *pData;
char *pcCurrentData;
@@ -115,12 +188,15 @@ void CFunnyGameBridge::Frame( float fDelta )
V_memcpy(pValueData, pcCurrentData, uVariableSize);
pcCurrentData += (uVariableSize+7) & ~7;
}
g_pServerBridge->RecievePacket();
pCurrentServer->RecievePacket();
break;
default:
pCurrentServer->RecievePacket();
V_printf("worng packet\n");
continue;
}
}
}
EntitySystem()->Think();
g_pWorldRenderer->Frame(fDelta);

11
game/server/baseentity.cpp
View File

@@ -25,6 +25,12 @@ void CBaseEntity::Spawn()
void CBaseEntity::SetAbsAngles( float fPitch, float fYaw, float fRoll )
{
versor q;
glm_euler_yzx_quat((vec3){fPitch, fYaw, fRoll}, q);
m_vRotation.x = q[0];
m_vRotation.y = q[1];
m_vRotation.z = q[2];
m_vRotation.w = q[3];
}
void CBaseEntity::SetAbsOrigin( Vector origin )
@@ -42,7 +48,6 @@ void CBaseEntity::SetScale( float fScale )
QAngle CBaseEntity::GetAbsQAngles( void )
{
}
Quat CBaseEntity::GetAbsAngles( void )
{
@@ -119,7 +124,9 @@ BEGIN_DATADESC_NOBASE(CBaseEntity)
END_DATADESC()
IMPLEMENT_SEND_DT_NOBASE(CBaseEntity)
NetPropFloat3(m_vPosition)
NetPropFloat3(m_vPosition),
NetPropQuaternion(m_vRotation),
NetPropFloat3(m_vScale),
END_SEND_DT()
IMPLEMENT_EMPTY_RECV_DT_NOBASE(CBaseEntity)

9
game/server/build.cpp
View File

@@ -27,9 +27,12 @@ DECLARE_BUILD_STAGE(Server)
".",
"../shared",
FUNNYSTDLIB"public",
EXTERNAL"cglm/include"
EXTERNAL"cglm/include",
EXTERNAL"steamworks/public",
};
compileProject.bFPIC = true;
if ( GET_PROJECT_VALUE(config, "steam") == "true" )
compileProject.macros.AppendTail({"STEAM", "TRUE"});
ldProject = ccompiler->Compile(&compileProject);
if ( GET_PROJECT_VALUE(config, "static") == "true" )
{
@@ -37,6 +40,10 @@ DECLARE_BUILD_STAGE(Server)
}
else
{
if ( GET_PROJECT_VALUE(config, "steam") == "true" ) {
ldProject.libraryDirectories.AppendTail(EXTERNAL"steamworks/redistributable_bin/linux64");
ldProject.libraries.AppendTail("steam_api");
}
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
ldProject.libraryObjects = {
GET_PROJECT_LIBRARY(tier0, "tier0"),

29
game/server/entitysystem.cpp
View File

@@ -92,7 +92,8 @@ CBaseEntity *CEntitySystem::CreateByClassname( const char *szName )
iSelectedSlot,
};
V_strncpy((char*)stClassSync.m_szEntityName, szName, 256);
g_pClientBridge->SendPacket({&stClassSync, sizeof(stClassSync)});
if (g_pCurrentConnection)
g_pCurrentConnection->SendPacket({&stClassSync, sizeof(stClassSync)});
return pEntity;
}
IEntityFactory *CEntitySystem::GetFactoryByClassname( const char *szName )
@@ -113,6 +114,25 @@ void CEntitySystem::Think()
CBaseEntity *pEntity;
int i;
for ( i = 0; i < MAX_EDICTS; i++ )
{
pEntity = m_pEntities[i];
if ( pEntity == NULL )
continue;
if ( !pEntity->m_pfnThink )
continue;
(pEntity->*pEntity->m_pfnThink)(0);
}
}
void CEntitySystem::NetThink( INetworkBase *pBase )
{
CBaseEntity *pEntity;
int i;
uint32_t u;
uint32_t x;
uint32_t uSize;
@@ -125,10 +145,8 @@ void CEntitySystem::Think()
EntityDataSyncValue_t *pValue;
};
for ( i = 0; i < MAX_EDICTS; i++ )
{
pEntity = m_pEntities[i];
if ( pEntity == NULL )
continue;
@@ -136,8 +154,6 @@ void CEntitySystem::Think()
if ( !pEntity->m_pfnThink )
continue;
(pEntity->*pEntity->m_pfnThink)(0);
pNetMap = pEntity->GetSendMap();
uSize = sizeof(EntityDataSyncValue_t);
x = 0;
@@ -177,7 +193,8 @@ void CEntitySystem::Think()
}
pNetMap = pNetMap->m_pBase;
}
g_pClientBridge->SendPacket({pData, uSize});
if (g_pCurrentConnection)
g_pCurrentConnection->SendPacket({pData, uSize});
V_free(pData);
}

3
game/server/entitysystem.h
View File

@@ -7,6 +7,8 @@
#ifndef ENTITIES_H
#define ENTITIES_H
#include "networkbase.h"
class IEntityFactory;
class CBaseEntity;
@@ -23,6 +25,7 @@ public:
virtual IEntityFactory *GetFactoryByClassname( const char *szName );
virtual void Think();
virtual void NetThink( INetworkBase *pBase );
virtual CBaseEntity **GetEntities();
private:
CBaseEntity *m_pEntities[MAX_EDICTS];

127
game/server/game.cpp
View File

@@ -5,6 +5,11 @@
#include "game.h"
#include "inetworkserver.h"
#include "netprotocol.h"
#ifdef STEAM
#include "steam/isteamgameserver.h"
#include "steam/steam_gameserver.h"
#endif
IFileSystem *filesystem;
IRenderContext *g_pRenderContext;
@@ -13,6 +18,8 @@ static CEngineVars s_vars;
CEngineVars *g_pEngineVars = &s_vars;
EngineConsts_t *g_pEngineConstants;
INetworkBase *g_pClientBridge;
INetworkBase *g_pPublicConnection;
INetworkBase *g_pCurrentConnection;
class CFunnyGameBridge: public IEngineBridge
{
@@ -22,6 +29,9 @@ class CFunnyGameBridge: public IEngineBridge
virtual void Shutdown() override;
virtual void ConnectInterface( const char *psz, void *pInterface ) override;
bool m_bIsConnectedToSteamRelay;
float m_fNetUpdateTimer;
};
IEngineBridge *EngineBridge()
@@ -32,9 +42,64 @@ IEngineBridge *EngineBridge()
EXPOSE_INTERFACE_FN(EngineBridge, IEngineBridge, ENGINE_BRIDGE_INTERFACE_VERSION)
uint32_t NET_ServerCallback( NetCallback_t *pCallback )
{
V_printf("hi %u\n", pCallback->m_eType);
if (pCallback->m_eType == NET_SERVER_READY_TO_USE)
{
V_printf("//--- LAUNCHED SERVER AT ---\n");
V_printf("// %llu\n", SteamGameServer()->GetSteamID().ConvertToUint64());
return 0;
}
if (pCallback->m_eType == NET_TRYING_TO_CONNECT)
{
V_printf("user %llu is trying to connect\n", pCallback->m_ullUserID);
return 1;
}
if (pCallback->m_eType == NET_CONNECTED)
{
V_printf("user %llu has connected, hi!\n", pCallback->m_ullUserID);
CBaseEntity *pEntity;
pEntity = EntitySystem()->CreateByClassname("player");
pEntity->Spawn();
return 1;
}
return 0;
}
void CFunnyGameBridge::Init()
{
if (g_pEngineConstants->m_bIsDedicated == false)
g_pClientBridge = g_pEngineConstants->LaunchLocalBridge(0);
g_pPublicConnection = NULL;
g_pCurrentConnection = g_pClientBridge;
#ifdef STEAM
if (g_pEngineConstants->m_bIsSteam)
{
SteamErrMsg err = { 0 };
if (SteamGameServer_InitEx(INADDR_ANY, FUNNY_SECURE_PORT, FUNNY_QUERY_PORT, eServerModeAuthentication, "0.0.0.0", &err));
{
V_printf("SteamGameServer_InitEx: %s", err);
}
SteamNetworkingUtils()->InitRelayNetworkAccess();
}
if (g_pEngineConstants->m_bIsDedicated && g_pEngineConstants->m_bIsSteam)
{
SteamGameServer()->SetModDir("funnygame");
SteamGameServer()->SetProduct("funnygame");
SteamGameServer()->SetGameDescription("not that funny but ok");
SteamGameServer()->LogOnAnonymous();
SteamNetworkingUtils()->InitRelayNetworkAccess();
SteamGameServer()->SetDedicatedServer(true);
SteamGameServer()->SetMaxPlayerCount(128);
SteamGameServer()->SetAdvertiseServerActive(true);
}
if (g_pEngineConstants->m_bIsSteam)
{
}
#endif
m_fNetUpdateTimer = 0;
}
void CFunnyGameBridge::Tick( float fDelta )
@@ -42,34 +107,74 @@ void CFunnyGameBridge::Tick( float fDelta )
}
void CFunnyGameBridge::Frame( float fDelta )
void NET_ProcessPacket( INetworkBase *pBase )
{
g_pEngineVars->m_fTime += fDelta;
g_pEngineVars->m_fDeltaTime = fDelta;
g_pClientBridge->NetThink();
while (g_pClientBridge->BHasUpdates())
{
NetPacket_t packet = g_pClientBridge->PeekPacket();
NetPacket_t packet = pBase->PeekPacket();
// discard it
if (packet.uSize < sizeof (EMessageType))
continue;
{
pBase->RecievePacket();
return;
}
PlayerPacket_t *pPacket = (PlayerPacket_t*)packet.pData;
CBaseEntity *pEntity;
switch (pPacket->m_eType)
{
case MESSAGE_PLAYER_JOINED:
g_pClientBridge->RecievePacket();
// online packets don't generate these
if (g_pEngineConstants->m_bIsDedicated)
break;
pBase->RecievePacket();
V_printf("Hi %s\n",pPacket->m_playerJoined.m_szPlayerName);
pEntity = EntitySystem()->CreateByClassname("player");
pEntity->Spawn();
break;
default:
continue;
break;
}
pBase->RecievePacket();
}
void CFunnyGameBridge::Frame( float fDelta )
{
g_pEngineVars->m_fTime += fDelta;
g_pEngineVars->m_fDeltaTime = fDelta;
#ifdef STEAM
if (g_pEngineConstants->m_bIsSteam && g_pEngineConstants->m_bIsDedicated)
{
SteamGameServer_RunCallbacks();
if (m_bIsConnectedToSteamRelay == 0 && SteamNetworkingUtils()->GetRelayNetworkStatus(NULL) == k_ESteamNetworkingAvailability_Current)
{
m_bIsConnectedToSteamRelay = 1;
g_pPublicConnection = g_pEngineConstants->LaunchServer( FUNNY_SECURE_PORT );
g_pPublicConnection->SetCallback(NET_ServerCallback);
g_pCurrentConnection = g_pPublicConnection;
return;
}
}
#endif
if (g_pCurrentConnection)
{
g_pCurrentConnection->NetThink();
while (g_pCurrentConnection->BHasUpdates())
NET_ProcessPacket(g_pCurrentConnection);
}
float fTickRate = 1.0/60.0;
m_fNetUpdateTimer += fDelta;
while (m_fNetUpdateTimer >= fTickRate)
{
m_fNetUpdateTimer-=fTickRate;
EntitySystem()->Think();
if (g_pCurrentConnection)
{
EntitySystem()->NetThink(g_pCurrentConnection);
}
}
EntitySystem()->Think();
}

4
game/server/milmoba/player.cpp
View File

@@ -10,8 +10,10 @@ void CMOBAPlayer::Spawn()
void CMOBAPlayer::Think( float fDelta )
{
m_fTimer = g_pEngineVars->m_fTime;
m_fTimer += 1.0/60.0;
SetAbsOrigin({m_fTimer, 0, 0});
SetAbsAngles(glm_rad(90), m_fTimer, 0);
SetScale(1);
};
LINK_ENTITY_TO_CLASS(player, CMOBAPlayer)

2
game/shared/engine.h
View File

@@ -22,5 +22,7 @@ extern IGameWindow *g_pMainWindow;
extern EngineConsts_t *g_pEngineConstants;
extern INetworkBase *g_pServerBridge;
extern INetworkBase *g_pClientBridge;
extern INetworkBase *g_pPublicConnection;
extern INetworkBase *g_pCurrentConnection;
#endif

4
game/shared/game.h
View File

@@ -14,4 +14,8 @@ public:
};
extern CEngineVars *g_pEngineVars;
#define FUNNY_SECURE_PORT 27015
#define FUNNY_QUERY_PORT 27016
#endif

31
public/networkbase.h
View File

@@ -3,18 +3,45 @@
#define NETWORK_BASE_H
#include "tier1/interface.h"
enum EPacketArrival
{
PACKET_MAY_ARRIVE,
PACKET_MUST_ARRIVE
};
struct NetPacket_t
{
void *pData;
uint32_t uSize;
uint64_t m_uOwner;
EPacketArrival m_eArrival;
};
enum ENetCallbackType
{
NET_NONE = 0,
NET_TRYING_TO_CONNECT,
NET_CONNECTED,
NET_DISCONNECTED,
NET_SERVER_READY_TO_USE,
};
struct NetCallback_t
{
ENetCallbackType m_eType;
uint64_t m_ullUserID;
};
typedef uint32_t (*NetCallbackFn)( NetCallback_t *pUser );
abstract_class INetworkBase
{
public:
virtual ~INetworkBase() = default;
virtual void NetThink() = 0;
virtual void SetCallback( NetCallbackFn fnCallback ) = 0;
virtual uint32_t BHasUpdates() = 0;
virtual NetPacket_t RecievePacket() = 0;
@@ -22,9 +49,13 @@ public:
virtual void SendPacket( NetPacket_t stPacket ) = 0;
virtual bool BIsActive() = 0;
virtual uint64_t GetSteamID() = 0;
virtual const char *GetIP() = 0;
virtual uint16_t GetPort() = 0;
};
#define GAME_PORT
#endif