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/ManageTool/ManageLibrary/Db/ManageServerDB.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "SQLite.h"
+
+#include "ManageServerDB.h"
+#include <Log/ServerLog.h>
+
+#include <cstdio>
+
+const char* CManageServerDB::GetDefaultDBFileName()
+{
+	return "./ManageServerDB.dat";
+}
+
+
+CManageServerDB& CManageServerDB::GetInstance()
+{
+	static CManageServerDB manageServerDB;
+	return manageServerDB;
+}
+
+
+CManageServerDB::CManageServerDB()
+:	m_lpSQLite(new CSQLite)
+{
+
+
+}
+
+
+CManageServerDB::~CManageServerDB()
+{
+	if(0 != m_lpSQLite)
+	{
+		delete m_lpSQLite;
+		m_lpSQLite = 0;
+	}
+}
+
+bool CManageServerDB::Initialize(const char* szDBFileName)
+{
+	if(0 == m_lpSQLite || !m_lpSQLite->Open(szDBFileName))
+	{
+		ERRLOG1(g_Log, "Cannot open database : %s", szDBFileName);
+		return false;
+	}
+
+	// Create Tables - 이미 만들어져 있으면 에러가 난다.
+	const int MAX_QUERY_NUM = 5;
+	const char* szCreateTableQuery[MAX_QUERY_NUM] = 
+	{
+		"CREATE TABLE TblManageToolUser (ID char(16) PRIMARY KEY, PASS char(16), "
+			"NAME char(32), IP char(16), LEVEL INTEGER)",
+
+		"CREATE TABLE TblServerInfo (IP INTEGER PRIMARY KEY, ServerName char(64))",
+		"CREATE TABLE TblRunPath (PathID INTEGER PRIMARY KEY, RunPath char(260))",
+		"CREATE TABLE TblRunOptions (OptionID INTEGER PRIMARY KEY, RunOption char(260))",
+		"CREATE TABLE TblRunInfo (RunID INTEGER PRIMARY KEY, PathID INTEGER, OptionID INTEGER, ServerIP INTEGER)"
+	};
+
+    m_lpSQLite->SetErrorLog(false);
+
+	for(int nQuery = 0; nQuery < MAX_QUERY_NUM; ++nQuery)
+	{
+        CSQLite::Dataset createUserTable(*m_lpSQLite, szCreateTableQuery[nQuery]);
+		
+		if(!createUserTable.Compile() || !createUserTable.Execute())
+		{
+			if(0 != createUserTable.GetLastError())
+			{
+				// Table create failed. if already create failed?
+				char szTableName[MAX_PATH];
+				int nLength = sscanf(createUserTable.GetLastError(), "table %s already exists", szTableName);
+				if(EOF == nLength || 0 == nLength)
+				{
+                    m_lpSQLite->SetErrorLog(true);
+					return false;
+				}
+			}
+		}
+	}
+
+    m_lpSQLite->SetErrorLog(true);
+	return true;
+}

Server/ManageTool/ManageLibrary/Db/ManageServerDB.h

@@ -0,0 +1,24 @@
+#ifndef _MANAGE_SERVER_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+#define _MANAGE_SERVER_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+
+class CSQLite;
+
+class CManageServerDB
+{
+public:
+
+	static const char* GetDefaultDBFileName();
+	static CManageServerDB& GetInstance();
+
+	bool Initialize(const char* szDBFileName = CManageServerDB::GetDefaultDBFileName());
+	CSQLite& GetSQLite() { return *m_lpSQLite; }
+	
+private:
+
+	CManageServerDB();
+	~CManageServerDB();
+
+	CSQLite* m_lpSQLite;
+};
+
+#endif

Server/ManageTool/ManageLibrary/Db/SQLite.cpp

@@ -0,0 +1,220 @@
+#include "stdafx.h"
+#include "SQLite.h"
+
+#include <cstdlib>
+#include <sqlite-library/sqlite.h>
+#include <Log/ServerLog.h>
+
+#define SAFE_FREE_SQLITE_ERRMSG(p) if(p) { sqlite_freemem(p); (p) = 0; }
+
+CSQLite::CSQLite()
+:	m_sqlDB(0), m_szErrorMsg(0), m_bLogError(true)
+{
+
+}
+
+CSQLite::~CSQLite()
+{
+	SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+	Close();
+}
+
+
+bool CSQLite::Open(const char* szDBFileName)
+{
+	char* szErrMsg = 0;
+	m_sqlDB = sqlite_open(szDBFileName, 0, &szErrMsg);
+
+	if(0 == m_sqlDB)
+	{
+        if(m_bLogError)
+        {
+            ERRLOG2(g_Log, "Can't open database : %s(%d)", 
+                szDBFileName, GetLastError());
+        }
+		
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrMsg;
+		return false;
+	}
+	
+	return true;
+}
+
+void CSQLite::Close()
+{
+	if(0 != m_sqlDB)
+	{
+		sqlite_close(m_sqlDB);
+	}
+}
+
+int CSQLite::GetLastInsertRowID()
+{
+	return sqlite_last_insert_rowid(m_sqlDB);
+}
+
+
+bool CSQLite::ExecuteQuery(const char* szQuery, QueryCallBack fnCallBack, void* callBackArg)
+{
+	char* szErrorMsg = 0;
+	int nResult = sqlite_exec(m_sqlDB, szQuery, fnCallBack, callBackArg, &szErrorMsg);
+	if(SQLITE_OK != nResult)
+	{
+        if(m_bLogError)
+        {
+		    ERRLOG2(g_Log, "Execute Query failed : %s(Query:%s)", 
+			    szErrorMsg, szQuery);
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	return true;	
+}
+
+
+
+CSQLite::Dataset::Dataset(CSQLite& sqlite, const char* szQuery)
+:	m_SQLite(sqlite), 
+	m_sqlite_vm(0),
+	m_szQuery(szQuery), 
+	m_szErrorMsg(0),
+	m_nExecuteResult(SQLITE_ROW)
+{
+	
+}
+
+
+CSQLite::Dataset::~Dataset()
+{
+	Free();
+	SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+}
+
+
+bool CSQLite::Dataset::Compile()
+{
+	Free();	
+
+	const char* szNextQuery = 0;
+	char*		szErrorMsg  = 0;
+
+	if('\0' == *m_szQuery)
+	{
+		// 쿼리가 끝까지 완료되었으면 빠져나감.
+		return false;
+	}
+
+	int nResult = sqlite_compile(m_SQLite.GetHandle(), m_szQuery, 
+		&szNextQuery, &m_sqlite_vm, &szErrorMsg);
+
+	if(SQLITE_OK != nResult)
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+		    ERRLOG2(g_Log, "SQLite error : compile query error - %s(%d)", 
+			    szErrorMsg, GetLastError());
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	m_szQuery = szNextQuery;
+	return true;
+}
+
+bool CSQLite::Dataset::Execute(int* nColNum_Out, 
+							   const char *** pazValue, 
+							   const char *** pazColName)
+{
+	m_nExecuteResult = sqlite_step(m_sqlite_vm, nColNum_Out, pazValue, pazColName);
+
+	if(SQLITE_ROW == m_nExecuteResult || 
+		SQLITE_DONE == m_nExecuteResult)
+	{
+		return true;
+	}
+	else
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+		    ERRLOG1(g_Log, "SQLite error : Dataset - execute error :%s", 
+			    sqlite_error_string(m_nExecuteResult));
+        }
+	}
+
+	return false;
+}
+
+
+bool CSQLite::Dataset::IsExcuteDone()
+{ 
+	return (SQLITE_ROW != m_nExecuteResult); 
+}
+
+
+void CSQLite::Dataset::Free()
+{
+	if(0 != m_sqlite_vm)
+	{
+		char* szErrorMsg = 0;
+
+		if(SQLITE_OK != sqlite_finalize(m_sqlite_vm, &szErrorMsg))
+		{
+            if(m_SQLite.IsErrorLogging())
+            {
+			    ERRLOG2(g_Log, "SQLite error : finalize error - %s(%d)", 
+				    szErrorMsg, GetLastError());
+            }
+
+			SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+			m_szErrorMsg = szErrorMsg;
+		}
+
+		m_sqlite_vm = 0;
+	}
+}
+
+
+CSQLite::Tableset::Tableset(CSQLite& sqlite, const char* szQuery)
+:	m_SQLite(sqlite), m_szQuery(szQuery), m_nRow(0), m_nCol(0), 
+	m_szResult(0), m_szErrorMsg(0)
+{
+
+
+}
+
+CSQLite::Tableset::~Tableset()
+{
+	if(0 != m_szResult)
+	{
+		sqlite_free_table(m_szResult);
+		m_szResult = 0;
+	}
+}
+
+bool CSQLite::Tableset::Execute()
+{
+	char* szErrorMsg = 0;
+
+	if(SQLITE_OK != sqlite_get_table(m_SQLite.GetHandle(), m_szQuery, 
+		&m_szResult, &m_nRow, &m_nCol, &szErrorMsg))
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+        	ERRLOG2(g_Log, "SQLite error : get_table error - %s(%d)", 
+	    		szErrorMsg, GetLastError());
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	return true;
+}

Server/ManageTool/ManageLibrary/Db/SQLite.h

@@ -0,0 +1,93 @@
+#ifndef _MANAGE_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+#define _MANAGE_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+
+// forward decl;
+typedef struct sqlite_vm sqlite_vm;
+typedef struct sqlite sqlite;
+
+class CSQLite
+{
+public:
+
+	typedef int (*QueryCallBack)(void *callBackArg, int nColumnNum, 
+		char **szColumnValues, char **szColumnNames);
+
+	CSQLite();
+	virtual ~CSQLite();
+
+	bool Open(const char* szFileName);
+	void Close();
+
+	int GetLastInsertRowID();
+	bool ExecuteQuery(const char* szQuery, QueryCallBack callBack, void* callBackArg);
+	const char* GetLastError() const { return m_szErrorMsg; }
+
+    void SetErrorLog(bool bLogError) { m_bLogError = bLogError; }
+    bool IsErrorLogging() { return m_bLogError; }
+
+	class Dataset
+	{
+	public:
+
+		Dataset(CSQLite& sqlite, const char* szQuery);
+		~Dataset();
+
+		// 쿼리를 컴파일해서 처리 준비를 한다.
+		bool Compile();
+
+		// 쿼리를 실행하고 결과를 얻어온다.
+		bool Execute(int* nColNum_Out = 0, 
+			const char ***pazValue = 0, 
+			const char *** pazColName = 0);
+		
+		bool IsExcuteDone();
+
+		const char* GetLastError() const { return m_szErrorMsg; }
+		void Free();
+
+	private:
+	    
+		CSQLite&	m_SQLite;
+		sqlite_vm*	m_sqlite_vm;
+		const char*	m_szQuery;
+		char*		m_szErrorMsg;
+		int			m_nExecuteResult;
+	};
+
+	class Tableset
+	{
+	public:
+
+		Tableset(CSQLite& sqlite, const char* szQuery);
+		~Tableset();
+
+        bool Execute();
+
+		char** GetResult() { return m_szResult; }
+		int GetMaxRow() { return m_nRow; }
+		int GetMaxCol() { return m_nCol; }
+
+		const char* GetLastError() const { return m_szErrorMsg; }
+
+	private:
+
+		CSQLite&	m_SQLite;
+		const char*	m_szQuery;
+		char**		m_szResult;
+		int			m_nRow;
+		int			m_nCol;		
+		char*		m_szErrorMsg;
+	};
+
+private:
+
+	sqlite* GetHandle() { return m_sqlDB; }
+	sqlite*	m_sqlDB;
+	char*	m_szErrorMsg;
+    bool    m_bLogError;
+
+	friend class Dataset;
+	friend class Tableset;
+};
+
+#endif