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>

GameTools/GLOBALSCRIPT/Utility/Resource/EnsureCleanup.h

@@ -0,0 +1,225 @@
+/******************************************************************************
+Module:  EnsureCleanup.h
+Notices: Copyright (c) 2000 Jeffrey Richter
+Purpose: These classes ensure object cleanup when an object goes out of scope.
+         See Appendix B.
+******************************************************************************/
+
+#ifndef _ENSURE_CLEAN_UP_BY_JEFFERY_RICHTER
+#define _ENSURE_CLEAN_UP_BY_JEFFERY_RICHTER
+
+#pragma once   // Include this header file once per compilation unit
+
+#include <winsock2.h>
+#include <windows.h>
+
+// Data type representing the address of the object's cleanup function.
+// I used UINT_PTR so that this class works properly in 64-bit Windows.
+typedef VOID (WINAPI* PFNENSURECLEANUP)(UINT_PTR);
+
+
+
+// Each template instantiation requires a data type, address of cleanup 
+// function, and a value that indicates an invalid value.
+template<class TYPE, PFNENSURECLEANUP pfn, UINT_PTR tInvalid = NULL> 
+class CEnsureCleanup 
+{
+public:
+   
+    // Default constructor assumes an invalid value (nothing to cleanup)
+    CEnsureCleanup() { m_t = tInvalid; }
+
+    // This constructor sets the value to the specified value
+    CEnsureCleanup(TYPE t) : m_t((UINT_PTR) t) { }
+
+    // The destructor performs the cleanup.
+    ~CEnsureCleanup() { Cleanup(); }
+
+    // Helper methods to tell if the value represents a valid object or not..
+    BOOL IsValid() { return(m_t != tInvalid); }
+    BOOL IsInvalid() { return(!IsValid()); }
+
+    // Re-assigning the object forces the current object to be cleaned-up.
+    TYPE operator=(TYPE t) 
+    {
+        Cleanup(); 
+        m_t = (UINT_PTR) t;
+        return(*this);  
+    }
+
+    // Returns the value (supports both 32-bit and 64-bit Windows).
+    operator TYPE() 
+    { 
+        // If TYPE is a 32-bit value, cast m_t to 32-bit TYPE
+        // If TYPE is a 64-bit value, case m_t to 64-bit TYPE
+        return((sizeof(TYPE) == 4) ? (TYPE) PtrToUint(m_t) : (TYPE) m_t); 
+    }
+
+   // Cleanup the object if the value represents a valid object
+    void Cleanup() 
+    { 
+        if (IsValid()) 
+        {
+            // In 64-bit Windows, all parameters are 64-bits, 
+            // so no casting is required
+            pfn(m_t);         // Close the object.
+            m_t = tInvalid;   // We no longer represent a valid object.
+        }
+    }
+   
+private:
+
+    UINT_PTR m_t;           // The member representing the object
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+// Macros to make it easier to declare instances of the template 
+// class for specific data types.
+
+#define MakeCleanupClass(className, tData, pfnCleanup) \
+    typedef CEnsureCleanup<tData, (PFNENSURECLEANUP) pfnCleanup> className;
+
+#define MakeCleanupClassX(className, tData, pfnCleanup, tInvalid) \
+    typedef CEnsureCleanup<tData, (PFNENSURECLEANUP) pfnCleanup, \
+    (INT_PTR) tInvalid> className;
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+// Instances of the template C++ class for common data types.
+MakeCleanupClass(CEnsureCloseHandle,        HANDLE,    CloseHandle);
+MakeCleanupClassX(CEnsureCloseFile,         HANDLE,    CloseHandle,         INVALID_HANDLE_VALUE);
+MakeCleanupClass(CEnsureLocalFree,          HLOCAL,    LocalFree);
+MakeCleanupClass(CEnsureGlobalFree,         HGLOBAL,   GlobalFree);
+MakeCleanupClass(CEnsureRegCloseKey,        HKEY,      RegCloseKey);
+MakeCleanupClass(CEnsureCloseServiceHandle, SC_HANDLE, CloseServiceHandle);
+MakeCleanupClass(CEnsureCloseWindowStation, HWINSTA,   CloseWindowStation);
+MakeCleanupClass(CEnsureCloseDesktop,       HDESK,     CloseDesktop);
+MakeCleanupClass(CEnsureUnmapViewOfFile,    PVOID,     UnmapViewOfFile);
+MakeCleanupClass(CEnsureFreeLibrary,        HMODULE,   FreeLibrary);
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+// Special class for releasing a reserved region.
+// Special class is required because VirtualFree requires 3 parameters
+class CEnsureReleaseRegion 
+{
+public:
+    CEnsureReleaseRegion(PVOID pv = NULL) : m_pv(pv) { }
+    ~CEnsureReleaseRegion() { Cleanup(); }
+
+    PVOID operator=(PVOID pv)
+    { 
+        Cleanup(); 
+        m_pv = pv; 
+        return(m_pv); 
+    }
+
+    operator PVOID() { return(m_pv); }
+    void Cleanup() 
+    { 
+        if (m_pv != NULL) 
+        {
+            VirtualFree(m_pv, 0, MEM_RELEASE); 
+            m_pv = NULL; 
+        } 
+    }
+   
+private:
+    PVOID m_pv;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+// Special class for freeing a block from a heap
+// Special class is required because HeapFree requires 3 parameters
+class CEnsureHeapFree 
+{
+public:
+    CEnsureHeapFree(PVOID pv = NULL, HANDLE hHeap = GetProcessHeap()) 
+        :   m_pv(pv), m_hHeap(hHeap) { }
+
+    ~CEnsureHeapFree() { Cleanup(); }
+
+    PVOID operator=(PVOID pv)
+    { 
+        Cleanup(); 
+        m_pv = pv; 
+        return(m_pv); 
+    }
+
+    operator PVOID() { return(m_pv); }
+    void Cleanup() 
+    {
+        if (m_pv != NULL)
+        { 
+            HeapFree(m_hHeap, 0, m_pv); 
+            m_pv = NULL; 
+        } 
+    }
+
+private:
+    HANDLE  m_hHeap;
+    PVOID   m_pv;
+};
+
+
+template<typename T>
+class CEnsureDelete
+{
+public:
+    CEnsureDelete(T* ptr) : m_ptr(ptr) { } 
+    ~CEnsureDelete() { if(NULL != m_ptr) { delete m_ptr; } }
+private:
+    
+    // <20><><EFBFBD>縦 <20><> <20><> <20><><EFBFBD><EFBFBD> <20><>.
+    CEnsureDelete& operator =(const CEnsureDelete& ensureDelete);
+    CEnsureDelete(const CEnsureDelete& ensureDelete);   
+
+    T*   m_ptr;
+};
+
+
+template<typename T>
+class CEnsureDeleteArray
+{
+public:
+    CEnsureDeleteArray(T* ptrArray) : m_ptrArray(ptrArray) { }
+    ~CEnsureDeleteArray() { if(NULL != m_ptrArray) { delete [] m_ptrArray; } }
+private:
+
+    // <20><><EFBFBD>縦 <20><> <20><> <20><><EFBFBD><EFBFBD> <20><>.
+    CEnsureDeleteArray& operator =(const CEnsureDeleteArray& ensureDeleteArray);
+    CEnsureDeleteArray(const CEnsureDeleteArray& ensureDeleteArray);   
+
+    T*  m_ptrArray;
+};
+
+
+template<typename T>
+class CEnsureRelease
+{
+public:
+
+    CEnsureRelease(T& t) : m_t(&t) { }
+    CEnsureRelease(T* t) : m_t(t) { }
+    ~CEnsureRelease() { if(NULL != m_t) { m_t->Release(); } }
+
+private:
+
+    // <20><><EFBFBD>縦 <20><> <20><> <20><><EFBFBD><EFBFBD> <20><>.
+    CEnsureRelease& operator =(const CEnsureRelease& ensureRelease);
+    CEnsureRelease(const CEnsureRelease& ensureRelease);   
+
+    T* m_t;
+};
+
+#endif