Restructure repository to include all source folders

Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Server/RylServerProject/RylServerLibrary/Utility/ServerAppFramework/MsgProc/MsgProc.cpp

@@ -0,0 +1,48 @@
+#include "stdafx.h"
+#include "MsgProc.h"
+
+CMsgProcessMgr::CMsgProcessMgr()
+{
+
+}
+
+CMsgProcessMgr::~CMsgProcessMgr()
+{
+	Clear();
+}
+
+
+bool CMsgProcessMgr::Register(UINT uMsg, CMsgProc* lpMsgProcessProc)
+{
+	return m_MessageProcessMap.insert(
+		MessageProcessMap::value_type(uMsg, lpMsgProcessProc)).second;	
+}
+
+
+bool CMsgProcessMgr::Remove(UINT uMsg)
+{
+	return (0 != m_MessageProcessMap.erase(uMsg));
+}
+
+
+CMsgProc* CMsgProcessMgr::FindMsgProc(UINT uMsg)
+{
+	MessageProcessMap::iterator find = m_MessageProcessMap.find(uMsg);
+	MessageProcessMap::iterator end  = m_MessageProcessMap.end();
+
+	return (find != end) ? find->second : 0;
+}
+
+
+void CMsgProcessMgr::Clear()
+{
+	MessageProcessMap::iterator pos = m_MessageProcessMap.begin();
+	MessageProcessMap::iterator end = m_MessageProcessMap.end();
+
+	for(; pos != end; ++pos)
+	{
+		delete pos->second;
+	}
+
+	m_MessageProcessMap.clear();
+}

Server/RylServerProject/RylServerLibrary/Utility/ServerAppFramework/MsgProc/MsgProc.h

@@ -0,0 +1,38 @@
+#ifndef _GM_NETWORK_MSG_PROC_
+#define _GM_NETWORK_MSG_PROC_
+
+#include <winsock2.h>
+#include <windows.h>
+#include <map>
+
+class CMsgProc
+{
+public:
+	virtual ~CMsgProc() = 0;
+	virtual LRESULT operator () (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
+};
+
+inline CMsgProc::~CMsgProc() { }
+
+class CMsgProcessMgr
+{
+public:
+
+	CMsgProcessMgr();
+	~CMsgProcessMgr();
+
+	bool Register(UINT uMsg, CMsgProc* lpMsgProcessProc);
+	bool Remove(UINT uMsg);
+
+	CMsgProc* FindMsgProc(UINT uMsg);
+
+	void Clear();
+
+private:
+
+	typedef std::map<UINT, CMsgProc*> MessageProcessMap;
+
+	MessageProcessMap	m_MessageProcessMap;
+};
+
+#endif

Server/RylServerProject/RylServerLibrary/Utility/ServerAppFramework/MsgProc/TimerProc.cpp

@@ -0,0 +1,213 @@
+#include "stdafx.h"
+#include "TimerProc.h"
+
+const TCHAR* CTimerProcMgr::ms_this = TEXT("CTimerProcMgr");
+
+const CTimerProcMgr::TIMER_ID	CTimerProcMgr::INVALID_TIMER_ID = 0xFFFFFFFF;
+const CTimerProcMgr::PROC_ID	CTimerProcMgr::INVALID_PROC_ID  = 0xFFFFFFFF;
+
+
+CTimerProcMgr::CTimerProcMgr()
+:	m_nProcIDCounter(1),
+	m_nTimerIDCounter(1)
+{
+
+
+}
+
+CTimerProcMgr::~CTimerProcMgr()
+{
+	ClearAll();
+}
+
+
+CTimerProcMgr::TIMER_ID CTimerProcMgr::CreateTimer(HWND hOwnerWnd, unsigned long dwInterval)
+{
+	TIMER_ID nTimerID = GetTimerID(hOwnerWnd, dwInterval);
+
+	if(INVALID_TIMER_ID == nTimerID)
+	{
+		std::pair<TimerMap::iterator, bool> result_pair; 
+		result_pair.second = false;
+
+		do
+		{
+			nTimerID = m_nTimerIDCounter++;
+
+			result_pair = m_TimerMap.insert(
+				TimerMap::value_type(nTimerID, InternalTimerData(hOwnerWnd, dwInterval)));
+
+			if(result_pair.second)
+			{
+				if(0 == SetTimer(hOwnerWnd, nTimerID, dwInterval, CTimerProcMgr::TimerProc))
+				{					
+					nTimerID = INVALID_TIMER_ID;
+					m_TimerMap.erase(result_pair.first);
+					break;
+				}
+				else
+				{
+					SetProp(hOwnerWnd, ms_this, this);
+				}
+			}
+
+		} while(!result_pair.second);
+	}
+
+	return nTimerID;
+}
+
+bool CTimerProcMgr::RemoveTimer(TIMER_ID nTimerID)
+{
+	TimerMap::iterator find = m_TimerMap.find(nTimerID);
+	TimerMap::iterator end = m_TimerMap.end();
+
+	if(find != end)
+	{
+		InternalTimerData& timerData = find->second;
+		KillTimer(timerData.m_hOwnerWnd, find->first);
+
+		TimerProcessList::iterator process_pos = timerData.m_timerProcessList.begin();
+		TimerProcessList::iterator process_end = timerData.m_timerProcessList.end();
+
+		for(;process_pos != process_end; ++process_pos)
+		{
+			delete process_pos->m_lpTimerProc;
+		}
+
+		timerData.m_timerProcessList.clear();
+
+		m_TimerMap.erase(find);
+		return true;
+	}
+
+	return false;
+}
+
+
+CTimerProcMgr::TIMER_ID CTimerProcMgr::GetTimerID(HWND hOwnerWnd, unsigned long dwInterval)
+{
+	TimerMap::iterator pos = m_TimerMap.begin();
+	TimerMap::iterator end = m_TimerMap.end();
+
+	for(; pos != end; ++pos)
+	{
+		InternalTimerData& timerData = pos->second;
+
+		if(timerData.m_hOwnerWnd == hOwnerWnd &&
+			timerData.m_dwInterval == dwInterval)
+		{
+			return pos->first;
+		}
+	}
+
+	return INVALID_TIMER_ID;
+}
+
+
+CTimerProcMgr::PROC_ID CTimerProcMgr::AddProc(TIMER_ID nTimerID, CTimerProc* lpTimerProc)
+{
+	TimerMap::iterator find = m_TimerMap.find(nTimerID);
+	TimerMap::iterator end = m_TimerMap.end();
+
+	if(find != end)
+	{
+		InternalTimerData& timerData = find->second;
+
+		PROC_ID nProcID = m_nProcIDCounter++;
+		timerData.m_timerProcessList.push_back(InternalProcessData(nProcID, lpTimerProc));
+
+		return nProcID;
+	}
+
+	return INVALID_PROC_ID;
+}
+
+
+bool CTimerProcMgr::RemoveProc(PROC_ID nProcID)
+{
+	TimerMap::iterator pos = m_TimerMap.begin();
+	TimerMap::iterator end = m_TimerMap.end();
+
+	TimerProcessList::iterator process_pos;
+	TimerProcessList::iterator process_end;
+
+	for(; pos != end; ++pos)
+	{
+		InternalTimerData& timerData = pos->second;
+
+		process_pos = timerData.m_timerProcessList.begin();
+		process_end = timerData.m_timerProcessList.end();
+
+		for(; process_pos != process_end; ++process_pos)
+		{
+			InternalProcessData& processData = *process_pos;
+
+			if(processData.m_nProcessID == nProcID)
+			{
+				delete processData.m_lpTimerProc;
+				timerData.m_timerProcessList.erase(process_pos);
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+void CTimerProcMgr::ClearAll()
+{
+	TimerMap::iterator pos = m_TimerMap.begin();
+	TimerMap::iterator end = m_TimerMap.end();
+
+	for(;pos != end; ++pos)
+	{
+		InternalTimerData& timerData = pos->second;
+		KillTimer(timerData.m_hOwnerWnd, pos->first);
+        
+		TimerProcessList::iterator process_pos = timerData.m_timerProcessList.begin();
+		TimerProcessList::iterator process_end = timerData.m_timerProcessList.end();
+
+		for(;process_pos != process_end; ++process_pos)
+		{
+			delete process_pos->m_lpTimerProc;
+		}
+
+		timerData.m_timerProcessList.clear();
+	}
+
+	m_TimerMap.clear();
+}
+
+
+VOID CALLBACK CTimerProcMgr::TimerProc(HWND hWnd, UINT uMsg, 
+									   UINT_PTR nTimerID, DWORD dwTime)
+{
+	CTimerProcMgr* lpTimerProcMgr = 
+		reinterpret_cast<CTimerProcMgr*>(GetProp(hWnd, ms_this));
+
+	if(0 != lpTimerProcMgr && uMsg == WM_TIMER)
+	{
+		TimerMap::iterator find = lpTimerProcMgr->m_TimerMap.find(nTimerID);
+		TimerMap::iterator end = lpTimerProcMgr->m_TimerMap.end();
+
+		if(find != end)
+		{
+			InternalTimerData& timerData = find->second;
+
+			TimerProcessList::iterator process_pos = timerData.m_timerProcessList.begin();
+			TimerProcessList::iterator process_end = timerData.m_timerProcessList.end();
+
+			for(; process_pos != process_end; ++process_pos)
+			{
+				InternalProcessData& processData = *process_pos;
+
+				if(0 != processData.m_lpTimerProc)
+				{
+					(*processData.m_lpTimerProc)(hWnd, uMsg, nTimerID, dwTime);
+				}
+			}
+		}
+	}
+}

Server/RylServerProject/RylServerLibrary/Utility/ServerAppFramework/MsgProc/TimerProc.h

@@ -0,0 +1,81 @@
+#ifndef _GM_NETWORK_TIMER_PROC_
+#define _GM_NETWORK_TIMER_PROC_
+
+#include <winsock2.h>
+#include <windows.h>
+#include <list>
+#include <map>
+
+class CTimerProc
+{
+public:
+	virtual ~CTimerProc() { }
+	virtual VOID operator () (HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) = 0;
+};
+
+
+class CTimerProcMgr
+{
+public:
+
+	CTimerProcMgr();
+	~CTimerProcMgr();
+
+	typedef unsigned int TIMER_ID;
+	typedef unsigned int PROC_ID;
+
+	static const TIMER_ID	INVALID_TIMER_ID;
+	static const PROC_ID	INVALID_PROC_ID;
+
+	TIMER_ID CreateTimer(HWND hOwnerWnd, unsigned long dwInterval);
+	bool RemoveTimer(TIMER_ID nTimerID);
+
+	TIMER_ID GetTimerID(HWND hOwnerWnd, unsigned long dwInterval);
+
+	PROC_ID AddProc(TIMER_ID nTimerID, CTimerProc* lpTimerProc);
+	bool RemoveProc(PROC_ID nProcID);
+
+	void ClearAll();
+
+private:
+
+	static VOID CALLBACK TimerProc(HWND hWnd, UINT uMsg, UINT_PTR nTimerID, DWORD dwTime);
+
+	struct InternalProcessData
+	{
+		PROC_ID		m_nProcessID;
+        CTimerProc*	m_lpTimerProc;
+
+		InternalProcessData(PROC_ID nProcessID, CTimerProc* lpTimerProc)
+			:	m_nProcessID(nProcessID), m_lpTimerProc(lpTimerProc)
+		{
+
+		}
+	};
+
+	typedef std::list<InternalProcessData>	TimerProcessList;
+	
+	struct InternalTimerData
+	{
+		HWND				m_hOwnerWnd;
+		unsigned long		m_dwInterval;
+		TimerProcessList	m_timerProcessList;
+
+		InternalTimerData(HWND hOwnerWnd, unsigned long dwInterval)
+			:	m_hOwnerWnd(hOwnerWnd), m_dwInterval(dwInterval)
+		{
+
+		}
+	};
+
+	// Key : TimerID
+	typedef std::map<TIMER_ID, InternalTimerData>	TimerMap;
+	
+	static const TCHAR* ms_this;
+	
+	TimerMap	m_TimerMap;
+	PROC_ID		m_nProcIDCounter;
+	TIMER_ID	m_nTimerIDCounter;
+};
+
+#endif