Implement basic Interprocess logic.

src/SvenBXT.cpp

@@ -295,6 +295,8 @@ void SvenBXT_Shutdown()
 
 	SvenBXT_UnhookEngine();
 	SvenBXT_UnhookClient();
+
+	Interprocess::Shutdown();
 
 	g_bHasLoaded = false;
 }

src/SvenBXT.h

@@ -14,6 +14,26 @@
 #define SVENBXT_VERSION __DATE__ // maybe something else? :thinking:
 #define SVENBXT_GITHUB_URL "https://github.com/ScriptedSnark/SvenBXT"
 
+// INTERPROCESS & SVENSPLIT
+#define SVENSPLIT_PIPE_NAME "SvenBXT-SvenSplit"
+
+enum class MessageType : unsigned char
+{
+	TIME = 0x00,
+	EVENT = 0x01
+};
+
+enum class EventType : unsigned char
+{
+	GAMEEND = 0x00,
+	MAPCHANGE = 0x01,
+	TIMER_RESET = 0x02,
+	TIMER_START = 0x03,
+	SS_ALEAPOFFAITH = 0x04
+};
+
+#include "interprocess.h"
+
 // WINDOWS
 #ifdef PLATFORM_WINDOWS
 #include <windows.h>

src/cl_dll/cdll_int.cpp

@@ -90,6 +90,9 @@ void CL_Initialize()
 	CreateHook(Client, V_CalcRefdef);
 	CreateHook(Client, HUD_VidInit);
 	CreateHook(Client, HUD_Redraw);
+
+	TRACE("Initializing interprocesses...\n");
+	Interprocess::Initialize();
 
 	TRACE("Initializing HUD...\n");
 	gBXTHud.Init();

src/cl_dll/hud_timer.cpp

@@ -50,6 +50,7 @@ int __MsgFunc_BXTTimer(const char* pszName, int iSize, void* pbuf)
 	bool stop = READ_BYTE();
 
 	g_RTATimer.SyncTimer(time, stop);
+	Interprocess::WriteTime(Interprocess::GetTime());
 
 	return 0;
 }
@@ -65,6 +66,9 @@ int CHudTimer::Init()
 	hud_timer_anchor = CVAR_CREATE("sbxt_hud_timer_anchor", "0.0 0.5", 0);
 	hud_timer_offset = CVAR_CREATE("sbxt_hud_timer_offset", "", 0);
 
+	svensplit_time_update_frequency = CVAR_CREATE("_sbxt_svensplit_time_update_frequency", "41", 0);
+	interprocess_enable = CVAR_CREATE("sbxt_interprocess_enable", "0", 0);
+
 	HOOK_COMMAND("sbxt_timer_start", TimerStart);
 	HOOK_COMMAND("sbxt_timer_stop", TimerStop);
 	HOOK_COMMAND("sbxt_timer_reset", TimerReset);
@@ -81,6 +85,8 @@ int CHudTimer::VidInit()
 
 int CHudTimer::Draw(float time)
 {
+	Interprocess::WriteTime(Interprocess::GetTime());
+
 	if (!hud_timer->value)
 		return 0;
 
@@ -91,7 +97,7 @@ int CHudTimer::Draw(float time)
 	int minutes = g_RTATimer.GetMinutes();
 	int seconds = g_RTATimer.GetSeconds();
 	int milliseconds = g_RTATimer.GetMilliseconds();
-
+	
 	if (hud_timer->value == 1)
 	{
 		char rta_timer[64];
@@ -135,6 +141,8 @@ void CHudTimer::TimerStart()
 	g_RTATimer.StartTimer();
 	//g_IGTTimer.StartTimer();
 
+	Interprocess::WriteTimerStart(Interprocess::GetTime());
+
 	if (UTIL_IsHost())
 	{
 		SV_SyncTimer();
@@ -157,6 +165,8 @@ void CHudTimer::TimerReset()
 	g_RTATimer.ResetTimer();
 	//g_IGTTimer.ResetTimer();
 
+	Interprocess::WriteTimerReset(Interprocess::GetTime());
+
 	if (UTIL_IsHost())
 	{
 		SV_SyncTimer();

src/cl_dll/hud_timer.h

@@ -27,6 +27,9 @@ class CHudTimer: public CBXTHudBase
 	bool ShouldSync() { return (hud_timer_serversync->value && !UTIL_IsHost()); }
 	bool IsInILMode() { return hud_timer_il_mode->value; };
 
+	cvar_t* svensplit_time_update_frequency;
+	cvar_t* interprocess_enable;
+
 private:
 	cvar_t* hud_timer_serversync;
 	cvar_t* hud_timer_il_mode;

src/dlls/server.cpp

@@ -11,6 +11,8 @@ void FASTCALL HOOKED_CNihilanth_DyingThink(void* thisptr)
 {
 	g_lpHUDTimer->TimerStop();
 
+	Interprocess::WriteGameEnd(Interprocess::GetTime());
+
 	ORIG_CNihilanth_DyingThink(thisptr);
 }
 

src/interprocess.cpp

@@ -0,0 +1,235 @@
+#include "interprocess.h"
+#include <windows.h>
+#include "Utils.h"
+#include "SvenBXT.h"
+#include "cl_dll/hud_timer.h"
+
+namespace Interprocess
+{
+	static HANDLE pipe_SvenSplit = INVALID_HANDLE_VALUE;
+	static OVERLAPPED overlapped;
+	static bool writing_to_pipe;
+
+	static void InitSvenSplitPipe()
+	{
+		pipe_SvenSplit = CreateNamedPipe(
+			"\\\\.\\pipe\\" SVENSPLIT_PIPE_NAME,
+			PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
+			PIPE_TYPE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS,
+			1,
+			256 * 1000,
+			0,
+			0,
+			NULL);
+		if (pipe_SvenSplit == INVALID_HANDLE_VALUE)
+		{
+			Sys_Printf("Error opening the SvenSplit pipe: %d\n", GetLastError());
+			Sys_Printf("SvenSplit integration is not available.\n");
+			return;
+		}
+		Sys_Printf("Opened the SvenSplit pipe.\n");
+
+		std::memset(&overlapped, 0, sizeof(overlapped));
+		overlapped.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
+		if (overlapped.hEvent == NULL)
+		{
+			Sys_Printf("Error creating an event for overlapped: %d. Closing the SvenSplit pipe.\n", GetLastError());
+			Sys_Printf("SvenSplit integration is not available.\n");
+			CloseHandle(pipe_SvenSplit);
+			pipe_SvenSplit = INVALID_HANDLE_VALUE;
+		}
+	}
+
+	void Initialize()
+	{
+		InitSvenSplitPipe();
+	}
+
+	static void ShutdownSvenSplitPipe()
+	{
+		if (pipe_SvenSplit != INVALID_HANDLE_VALUE)
+		{
+			CloseHandle(pipe_SvenSplit);
+			Sys_Printf("Closed the SvenSplit pipe.\n");
+		}
+		pipe_SvenSplit = INVALID_HANDLE_VALUE;
+
+		CloseHandle(overlapped.hEvent);
+		std::memset(&overlapped, 0, sizeof(overlapped));
+	}
+
+	void Shutdown()
+	{
+		ShutdownSvenSplitPipe();
+	}
+
+	static void WriteSvenSplit(const std::vector<char>& data)
+	{
+		if (pipe_SvenSplit == INVALID_HANDLE_VALUE)
+			return;
+
+		if (writing_to_pipe)
+		{
+			if (WaitForSingleObject(overlapped.hEvent, INFINITE) != WAIT_OBJECT_0)
+			{
+				// Some weird error?
+				Sys_Printf("WaitForSingleObject failed with %d.\n", GetLastError());
+				DisconnectNamedPipe(pipe_SvenSplit);
+				return WriteSvenSplit(data);
+			}
+			writing_to_pipe = false;
+		}
+
+		if (!ConnectNamedPipe(pipe_SvenSplit, &overlapped))
+		{
+			auto err = GetLastError();
+			if (err == ERROR_NO_DATA)
+			{
+				// Client has disconnected.
+				DisconnectNamedPipe(pipe_SvenSplit);
+				return WriteSvenSplit(data);
+			}
+			else if (err == ERROR_IO_PENDING)
+			{
+				// Waiting for someone to connect.
+				return;
+			}
+			else if (err != ERROR_PIPE_CONNECTED)
+			{
+				// Some weird error with pipe?
+				// Try remaking it.
+				Sys_Printf("ConnectNamedPipe failed with %d.\n", err);
+				ShutdownSvenSplitPipe();
+				InitSvenSplitPipe();
+				return WriteSvenSplit(data);
+			}
+		}
+
+		if (!WriteFile(pipe_SvenSplit, data.data(), data.size(), NULL, &overlapped))
+		{
+			auto err = GetLastError();
+			if (err == ERROR_IO_PENDING)
+			{
+				// Started writing.
+				writing_to_pipe = true;
+				return;
+			}
+			else
+			{
+				Sys_Printf("WriteFile failed with %d.\n", err);
+				DisconnectNamedPipe(pipe_SvenSplit);
+				return;
+			}
+		}
+	}
+
+	static size_t AddTimeToBuffer(char* buf, const Time& time)
+	{
+		std::memcpy(buf, &time.hours, sizeof(time.hours));
+		std::memcpy(buf + sizeof(time.hours), &time.minutes, sizeof(time.minutes));
+		std::memcpy(buf + sizeof(time.hours) + sizeof(time.minutes), &time.seconds, sizeof(time.seconds));
+		std::memcpy(buf + sizeof(time.hours) + sizeof(time.minutes) + sizeof(time.seconds), &time.milliseconds, sizeof(time.milliseconds));
+		return sizeof(time.hours) + sizeof(time.minutes) + sizeof(time.seconds) + sizeof(time.milliseconds);
+	}
+
+	void WriteTime(const Time& time)
+	{
+		if (!g_lpHUDTimer->interprocess_enable->value)
+			return;
+
+		std::vector<char> buf(10);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::TIME);
+		AddTimeToBuffer(buf.data() + 2, time);
+
+		if (g_lpHUDTimer->svensplit_time_update_frequency->value > 0.0f)
+		{
+			static auto last_time = std::chrono::steady_clock::now() - std::chrono::milliseconds(static_cast<long long>(1000 / g_lpHUDTimer->svensplit_time_update_frequency->value) + 1);
+			auto now = std::chrono::steady_clock::now();
+			if (now >= last_time + std::chrono::milliseconds(static_cast<long long>(1000 / g_lpHUDTimer->svensplit_time_update_frequency->value)))
+			{
+				WriteSvenSplit(buf);
+				last_time = now;
+			}
+		}
+		else
+		{
+			WriteSvenSplit(buf);
+		}
+	}
+
+	void WriteGameEnd(const Time& time)
+	{
+		std::vector<char> buf(11);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::EVENT);
+		buf[2] = static_cast<char>(EventType::GAMEEND);
+		AddTimeToBuffer(buf.data() + 3, time);
+
+		WriteSvenSplit(buf);
+	}
+
+	void WriteMapChange(const Time& time, const std::string& map)
+	{
+		int32_t size = static_cast<int32_t>(map.size());
+
+		std::vector<char> buf(15 + size);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::EVENT);
+		buf[2] = static_cast<char>(EventType::MAPCHANGE);
+		auto time_size = AddTimeToBuffer(buf.data() + 3, time);
+
+		std::memcpy(buf.data() + 3 + time_size, &size, sizeof(size));
+		std::memcpy(buf.data() + 3 + time_size + 4, map.data(), size);
+
+		WriteSvenSplit(buf);
+	}
+
+	void WriteTimerReset(const Time& time)
+	{
+		std::vector<char> buf(11);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::EVENT);
+		buf[2] = static_cast<char>(EventType::TIMER_RESET);
+		AddTimeToBuffer(buf.data() + 3, time);
+
+		WriteSvenSplit(buf);
+	}
+
+	void WriteTimerStart(const Time& time)
+	{
+		std::vector<char> buf(11);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::EVENT);
+		buf[2] = static_cast<char>(EventType::TIMER_START);
+		AddTimeToBuffer(buf.data() + 3, time);
+
+		WriteSvenSplit(buf);
+	}
+
+	void WriteSSALeapOfFaith(const Time& time)
+	{
+		std::vector<char> buf(11);
+		buf[0] = static_cast<char>(buf.size());
+		buf[1] = static_cast<char>(MessageType::EVENT);
+		buf[2] = static_cast<char>(EventType::SS_ALEAPOFFAITH);
+		AddTimeToBuffer(buf.data() + 3, time);
+
+		WriteSvenSplit(buf);
+	}
+
+	Interprocess::Time GetTime()
+	{
+		int hours = g_RTATimer.GetHours();
+		int minutes = g_RTATimer.GetMinutes();
+		int seconds = g_RTATimer.GetSeconds();
+		int milliseconds = g_RTATimer.GetMilliseconds();
+
+		return Interprocess::Time{
+			static_cast<uint32_t>(hours),
+			static_cast<uint8_t>(minutes),
+			static_cast<uint8_t>(seconds),
+			static_cast<uint16_t>(milliseconds)
+		};
+	}
+}

src/interprocess.h

@@ -0,0 +1,30 @@
+#ifndef INTERPROCESS_H_INCLUDED
+#define INTERPROCESS_H_INCLUDED
+
+#include <vector>
+#include <string>
+
+namespace Interprocess
+{
+	struct Time
+	{
+		uint32_t hours;
+		uint8_t minutes;
+		uint8_t seconds;
+		uint16_t milliseconds;
+	};
+
+	void Initialize();
+	void Shutdown();
+
+	void WriteTime(const Time& time);
+
+	void WriteGameEnd(const Time& time);
+	void WriteMapChange(const Time& time, const std::string& map);
+	void WriteTimerReset(const Time& time);
+	void WriteTimerStart(const Time& time);
+	void WriteSSALeapOfFaith(const Time& time);
+	Time GetTime();
+}
+
+#endif // INTERPROCESS_H_INCLUDED