networking i guess

engine/build.cpp

@@ -3,6 +3,7 @@
 #include "ld.h"
 #include "tier1/utlstring.h"
 
+#define EXTERNAL "../external/"
 #define FUNNYSTDLIB "../external/funnystdlib/"
 ADD_DEPENDENCY_BUILD_FILE(cfg, "../buildcfg.cpp");
 ADD_DEPENDENCY_BUILD_FILE(MaterialSystem, "../materialsystem/build.cpp")
@@ -19,6 +20,9 @@ DECLARE_BUILD_STAGE(engine)
 	compileProject.files = {
 		"engine.cpp",
 		"cvar.cpp",
+		"localnetwork.cpp",
+		"socketnetwork.cpp",
+		"steamnetwork.cpp",
 		
 		"sv_dll.cpp",
 		"cl_dll.cpp",
@@ -29,7 +33,10 @@ DECLARE_BUILD_STAGE(engine)
 		"../external/SDL/include",
 		"../external/cglm/include",
 		FUNNYSTDLIB"public",
+		EXTERNAL"steamworks/public",
 	};
+	if ( GET_PROJECT_VALUE(config, "steam") == "true" )
+		compileProject.macros.AppendTail({"STEAM", "TRUE"});
 	compileProject.bFPIC = true;
 	ldProject = ccompiler->Compile(&compileProject);
 
@@ -39,6 +46,10 @@ DECLARE_BUILD_STAGE(engine)
 	}
 	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"),
@@ -49,7 +60,7 @@ DECLARE_BUILD_STAGE(engine)
 
 	if (ldProject.m_target.kernel & TARGET_KERNEL_WINDOWS_DEVICES)
 	{
-		ldProject.libraryDirectories = {"../external/windows"};
+		ldProject.libraryDirectories.AppendTail(EXTERNAL"windows");
 		ldProject.libraries.AppendTail("winpthread-1");
 		ldProject.libraries.AppendTail("winmm");
 		ldProject.libraries.AppendTail("ole32");

engine/cl_dll.cpp

@@ -21,6 +21,7 @@ void CClientGameDLL::Init()
 	pEngineBridge->ConnectInterface(RENDER_CONTEXT_INTERFACE_VERSION, m_pRenderContext);
 	pEngineBridge->ConnectInterface("MainWindow", m_pGameWindow);
 	pEngineBridge->ConnectInterface(FILESYSTEM_INTERFACE_VERSION, filesystem);
+	pEngineBridge->ConnectInterface("EngineConstants", m_pEngineConsts);
 	pEngineBridge->Init();
 	m_pBridge = pEngineBridge;
 }

engine/engine.cpp

@@ -7,6 +7,12 @@
 #include "tier0/mem.h"
 #include "sv_dll.h"
 #include "cl_dll.h"
+#include "inetworkserver.h"
+#include "inetworkclient.h"
+
+#ifdef STEAM
+#include "steam/steam_api.h"
+#endif
 
 IRenderContext *g_pRenderContext;
 IFileSystem *filesystem;
@@ -19,38 +25,52 @@ extern "C" void FunnyMain( int argc, char **argv )
 {
 	CommandLine()->CreateCommandLine(argc, argv);
 
+	EngineConsts_t stConstants = {};
+#ifdef STEAM
+	stConstants.m_bIsSteam = true; 
+	if (!SteamAPI_Init())
+		Plat_FatalErrorFunc("SteamAPI_Init failed lol\n");
+	stConstants.LaunchServer = LaunchLocalBridge;	
+	stConstants.ConnectSteamServer = ConnectBySteamID;	
+#endif
+	stConstants.m_bIsDedicated = CommandLine()->CheckParam("-dedicated");
+	stConstants.LaunchLocalBridge = LaunchLocalBridge;	
+	stConstants.ConnectLocalBridge = ConnectByLocalBridge;	
 	CreateInterfaceFn pFilesystemFactory = Sys_GetFactory("filesystem_std");
 	CreateInterfaceFn pMaterialSystemFactory = Sys_GetFactory("MaterialSystem");
 	CreateInterfaceFn pRenderSystemFactory = Sys_GetFactory("RenderSystemVulkan");
+	IGameWindow *pWindow;
 
 	filesystem = (IFileSystem*)pFilesystemFactory(FILESYSTEM_INTERFACE_VERSION, NULL);
 	filesystem->Init();
 
-	g_pWindowManager = (IGameWindowManager*)pRenderSystemFactory(GAME_WINDOW_MANAGER_INTERFACE_VERSION, NULL);
-	V_printf("%s\n", GAME_WINDOW_MANAGER_INTERFACE_VERSION);
-	g_pWindowManager->Init();
+	if (!stConstants.m_bIsDedicated)
+	{
+		g_pWindowManager = (IGameWindowManager*)pRenderSystemFactory(GAME_WINDOW_MANAGER_INTERFACE_VERSION, NULL);
+		g_pWindowManager->Init();
 
-	IGameWindow *pWindow = g_pWindowManager->CreateWindow();
-	pWindow->Init();
-
-
-	g_pRenderContext = (IRenderContext*)pRenderSystemFactory(RENDER_CONTEXT_INTERFACE_VERSION, NULL);
-	g_pRenderContext->SetMainWindowManager(g_pWindowManager);
-	g_pRenderContext->Init();
-
-	g_pRenderContext->RegisterGameWindow(pWindow);
+		pWindow = g_pWindowManager->CreateWindow();
+		pWindow->Init();
 
+		g_pRenderContext = (IRenderContext*)pRenderSystemFactory(RENDER_CONTEXT_INTERFACE_VERSION, NULL);
+		g_pRenderContext->SetMainWindowManager(g_pWindowManager);
+		g_pRenderContext->Init();
 
+		g_pRenderContext->RegisterGameWindow(pWindow);
+	}
 
 	g_pServerGame = new CServerGameDLL;
-	g_pServerGame->m_pGameWindow = pWindow;
-	g_pServerGame->m_pRenderContext = g_pRenderContext;
+	g_pServerGame->m_pEngineConsts = &stConstants;
 	g_pServerGame->Init();
-
-	g_pClientGame = new CClientGameDLL;
-	g_pClientGame->m_pGameWindow = pWindow;
-	g_pClientGame->m_pRenderContext = g_pRenderContext;
-	g_pClientGame->Init();
+	
+	if (!stConstants.m_bIsDedicated)
+	{
+		g_pClientGame = new CClientGameDLL;
+		g_pClientGame->m_pGameWindow = pWindow;
+		g_pClientGame->m_pRenderContext = g_pRenderContext;
+		g_pClientGame->m_pEngineConsts = &stConstants;
+		g_pClientGame->Init();
+	}
 
 
 	double fPrevious = Plat_GetTime();
@@ -58,11 +78,15 @@ extern "C" void FunnyMain( int argc, char **argv )
 		double fCurrent = Plat_GetTime();
 		double fDelta = fCurrent-fPrevious;
 		fPrevious = fCurrent;
-		g_pWindowManager->Frame(fDelta);
 		g_pServerGame->m_pBridge->Frame(fDelta);
-		g_pClientGame->m_pBridge->Frame(fDelta);
 
-		g_pRenderContext->Frame(fDelta);
+		if (!stConstants.m_bIsDedicated)
+		{
+			g_pWindowManager->Frame(fDelta);
+			g_pClientGame->m_pBridge->Frame(fDelta);
+			g_pRenderContext->Frame(fDelta);
+		}
+
 	};
 
 };

engine/inetwork.cpp

@@ -0,0 +1,5 @@
+
+class CUnsecureNetworkManager
+{
+
+};

engine/localnetwork.cpp

@@ -0,0 +1,218 @@
+#include "inetworkserver.h"
+#include "tier1/utlmutex.h"
+#include "tier1/utlvector.h"
+
+class CLocalNetworkServer;
+static CLocalNetworkServer *s_pLocalServers[128];
+
+class CLocalNetworkServer: public INetworkBase
+{
+public:
+	CLocalNetworkServer( uint16_t uPort );
+	virtual ~CLocalNetworkServer() override;
+
+	virtual void NetThink() override;
+
+	virtual uint32_t BHasUpdates() override;
+	virtual NetPacket_t RecievePacket() override;
+	virtual NetPacket_t PeekPacket() override;
+
+	virtual void SendPacket( NetPacket_t stPacket ) override;
+
+	virtual uint64_t GetSteamID() override;
+	virtual const char *GetIP() override;
+	virtual uint16_t GetPort() override;
+
+	CUtlLock m_lock;
+	CUtlVector<NetPacket_t> m_packets;
+	CUtlVector<NetPacket_t> m_clientPackets;
+	CUtlVector<void*> m_freedPackets;
+	const uint16_t m_uPort;
+};
+
+CLocalNetworkServer::CLocalNetworkServer( uint16_t uPort ) : m_uPort(uPort)
+{
+	s_pLocalServers[uPort] = this;
+}
+
+CLocalNetworkServer::~CLocalNetworkServer()
+{
+	s_pLocalServers[m_uPort] = NULL;
+
+}
+
+
+void CLocalNetworkServer::NetThink()
+{
+	m_lock.Lock();
+	for ( auto p: m_freedPackets)
+	{
+		V_free(p);
+	}
+	m_freedPackets = {};
+	m_lock.Unlock();
+}
+
+
+uint32_t CLocalNetworkServer::BHasUpdates()
+{
+	return m_clientPackets.GetSize();
+}
+
+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;
+}
+
+
+void CLocalNetworkServer::SendPacket( NetPacket_t stPacket )
+{
+	NetPacket_t stSavedPacked;
+	stSavedPacked.uSize = stPacket.uSize;
+	stSavedPacked.pData = V_malloc(stPacket.uSize);
+	V_memcpy(stSavedPacked.pData, stPacket.pData, stPacket.uSize);
+
+	m_lock.Lock();
+	m_packets.AppendTail(stSavedPacked);
+	m_lock.Unlock();
+}
+
+
+uint64_t CLocalNetworkServer::GetSteamID()
+{
+	return 0;
+}
+
+const char *CLocalNetworkServer::GetIP()
+{
+	return NULL;
+}
+
+uint16_t CLocalNetworkServer::GetPort()
+{
+	return m_uPort;
+}
+
+class CLocalNetworkClient: public INetworkBase
+{
+public:
+	CLocalNetworkClient( uint16_t uPort );
+	virtual ~CLocalNetworkClient() override;
+
+	virtual void NetThink() override;
+
+	virtual uint32_t BHasUpdates() override;
+	virtual NetPacket_t RecievePacket() override;
+	virtual NetPacket_t PeekPacket() override;
+
+	virtual void SendPacket( NetPacket_t stPacket ) override;
+
+	virtual uint64_t GetSteamID() override;
+	virtual const char *GetIP() override;
+	virtual uint16_t GetPort() override;
+
+	CLocalNetworkServer *m_pServer;
+};
+
+CLocalNetworkClient::CLocalNetworkClient( uint16_t uPort )
+{
+	m_pServer = s_pLocalServers[uPort];
+}
+
+CLocalNetworkClient::~CLocalNetworkClient()
+{
+
+}
+
+
+void CLocalNetworkClient::NetThink()
+{
+}
+
+
+uint32_t CLocalNetworkClient::BHasUpdates()
+{
+	return m_pServer->m_packets.GetSize();
+}
+
+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;
+}
+
+
+void CLocalNetworkClient::SendPacket( NetPacket_t stPacket )
+{
+	NetPacket_t stSavedPacked;
+	stSavedPacked.uSize = stPacket.uSize;
+	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();
+}
+
+
+uint64_t CLocalNetworkClient::GetSteamID()
+{
+	return 0;
+}
+
+const char *CLocalNetworkClient::GetIP()
+{
+	return NULL;
+}
+
+uint16_t CLocalNetworkClient::GetPort()
+{
+	return m_pServer->m_uPort;
+}
+
+INetworkBase *LaunchLocalBridge( uint16_t uPort )
+{
+	INetworkBase *pBase = new CLocalNetworkServer(uPort);
+	return pBase;
+}
+INetworkBase *ConnectByLocalBridge( uint16_t uPort )
+{
+	if (s_pLocalServers[uPort] == 0)
+	{
+		return NULL;
+	}
+	return new CLocalNetworkClient(uPort); 
+}

engine/steamnetwork.cpp

@@ -0,0 +1,82 @@
+#include "inetworkserver.h"
+#include "inetworkclient.h"
+#include "steam/isteamnetworkingsockets.h"
+
+class CSteamNetworkServer: public INetworkBase
+{
+public:
+	CSteamNetworkServer( uint16_t uPort );
+	virtual ~CSteamNetworkServer() override;
+
+	virtual void NetThink() override;
+
+	virtual uint32_t BHasUpdates() override;
+	virtual NetPacket_t RecievePacket() override;
+
+	virtual void SendPacket( NetPacket_t stPacket ) override;
+
+	virtual uint64_t GetSteamID() override;
+	virtual const char *GetIP() override;
+	virtual uint16_t GetPort() override;
+	HSteamListenSocket m_hSocket;
+};
+
+CSteamNetworkServer::CSteamNetworkServer( uint16_t uPort )
+{
+	m_hSocket = SteamNetworkingSockets()->CreateListenSocketP2P(uPort, 0, NULL);
+	
+}
+
+CSteamNetworkServer::~CSteamNetworkServer()
+{
+
+}
+
+
+void CSteamNetworkServer::NetThink()
+{
+}
+
+
+uint32_t CSteamNetworkServer::BHasUpdates()
+{
+
+}
+
+NetPacket_t CSteamNetworkServer::RecievePacket()
+{
+
+}
+
+
+void CSteamNetworkServer::SendPacket( NetPacket_t stPacket )
+{
+}
+
+
+uint64_t CSteamNetworkServer::GetSteamID()
+{
+	return 0;
+}
+
+const char *CSteamNetworkServer::GetIP()
+{
+	return NULL;
+}
+
+uint16_t CSteamNetworkServer::GetPort()
+{
+	return 0;
+}
+
+
+INetworkBase *LaunchServerAtSteamRelay( uint16_t uPort )
+{
+	INetworkBase *pBase = new CSteamNetworkServer(uPort);
+	return pBase;
+}
+
+INetworkBase *ConnectBySteamID( uint64_t uID, uint16_t uPort )
+{
+	return NULL;
+}

engine/sv_dll.cpp

@@ -16,7 +16,7 @@ void CServerGameDLL::Init()
 
 	CreateInterfaceFn pfnServerFactory = Sys_GetFactory(pLib);
 	IEngineBridge *pEngineBridge = (IEngineBridge*)pfnServerFactory(ENGINE_BRIDGE_INTERFACE_VERSION, NULL);
-
+	pEngineBridge->ConnectInterface("EngineConstants", m_pEngineConsts);
 	pEngineBridge->Init();
 	m_pBridge = pEngineBridge;
 }