Merge branch 'main' into physicsSimplification

remove copy pasted logic
tested that the ninjago platforms and fire still works, tested that point of interest work as well Update PhantomPhysicsComponent.cpp
2025-12-17 03:37:08 -06:00 · 2024-02-08 03:55:30 -08:00 · 2024-02-04 03:38:11 -08:00
652 changed files with 13448 additions and 17493 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -73,4 +73,4 @@ cpp_space_around_assignment_operator=insert
 cpp_space_pointer_reference_alignment=left
 cpp_space_around_ternary_operator=insert
 cpp_wrap_preserve_blocks=one_liners
-cpp_indent_comment=false
+cpp_indent_comment=fasle
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -16,12 +16,12 @@ jobs:
        os: [ windows-2022, ubuntu-22.04, macos-13 ]

    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
      with:
        submodules: true
    - name: Add msbuild to PATH (Windows only)
      if: ${{ matrix.os == 'windows-2022' }}
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v1.1
      with:
        vs-version: '[17,18)'
        msbuild-architecture: x64
@@ -33,19 +33,21 @@ jobs:
    - name: cmake
      uses: lukka/run-cmake@v10
      with:
-        workflowPreset: "ci-${{matrix.os}}"
+        configurePreset: "ci-${{matrix.os}}"
+        buildPreset: "ci-${{matrix.os}}"
+        testPreset: "ci-${{matrix.os}}"
    - name: artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      with:
        name: build-${{matrix.os}}
        path: |
-          build/*/*Server*
-          build/*/*.ini
-          build/*/*.so
-          build/*/*.dll
-          build/*/vanity/
-          build/*/navmeshes/
-          build/*/migrations/
-          build/*/*.dcf
-          !build/*/*.pdb
-          !build/*/d*/
+          build/*Server*
+          build/*.ini
+          build/*.so
+          build/*.dll
+          build/vanity/
+          build/navmeshes/
+          build/migrations/
+          build/*.dcf
+          !build/*.pdb
+          !build/d*/
--- a/.gitignore
+++ b/.gitignore
@@ -112,8 +112,6 @@ CMakeFiles/TargetDirectories.txt
 *.sln
 *.recipe

-CMakeUserPresets.json
-
 # clangd
 .cache
 thirdparty/zlib-1.2.11/
@@ -124,7 +122,4 @@ docker/__pycache__
 docker-compose.override.yml

 !*Test.bin
-
-# CMake scripts
 !cmake/*
-!cmake/toolchains/*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,27 +1,10 @@
-cmake_minimum_required(VERSION 3.25)
-project(Darkflame
-	HOMEPAGE_URL "https://github.com/DarkflameUniverse/DarkflameServer"
-	LANGUAGES C CXX
-)
-
-# check if the path to the source directory contains a space
-if("${CMAKE_SOURCE_DIR}" MATCHES " ")
-	message(FATAL_ERROR "The server cannot build in the path (" ${CMAKE_SOURCE_DIR} ") because it contains a space. Please move the server to a path without spaces.")
-endif()
-
+cmake_minimum_required(VERSION 3.18)
+project(Darkflame)
 include(CTest)

-set(CMAKE_C_STANDARD 99)
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 	# Export the compile commands for debugging
-set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) 	# Set CMAKE visibility policy to NEW on project and subprojects
-set(CMAKE_VISIBILITY_INLINES_HIDDEN ON) # Set C and C++ symbol visibility to hide inlined functions
+set(CXX_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
-  
-set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build, options are: Debug, Release, RelWithDebInfo, MinSizeRel")
-set(DLU_CONFIG_DIR ${CMAKE_SOURCE_DIR}/build CACHE PATH "The directory where the server configuration files are stored")

 # Read variables from file
 FILE(READ "${CMAKE_SOURCE_DIR}/CMakeVariables.txt" variables)
@@ -69,37 +52,33 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
-	add_compile_options("-fPIC")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wuninitialized -fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)

-	# For all except Clang and Apple Clang
-	if(NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-		add_compile_options("-static-libgcc" "-lstdc++fs" "-Wno-error=implicit-function-declaration" "-Wno-error=int-conversion")
+	if(NOT APPLE)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -lstdc++fs")
 	endif()

 	if(${DYNAMIC} AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-		add_link_options("-export-dynamic")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -rdynamic")
 	endif()

 	if(${GGDB})
-		add_compile_options("-ggdb")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb")
 	endif()
+
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -O2 -fPIC")
 elseif(MSVC)
 	# Skip warning for invalid conversion from size_t to uint32_t for all targets below for now
-	# Also disable non-portable MSVC volatile behavior
-	add_compile_options("/wd4267" "/utf-8" "/volatile:iso" "/Zc:inline")
+	add_compile_options("/wd4267" "/utf-8")
 elseif(WIN32)
 	add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()

-# Set the output directories
-# ./build/<platform + architecture (x64, x86, aarch64)>/<compiler>/<build_mode>/
+# Our output dir
+set(CMAKE_BINARY_DIR ${PROJECT_BINARY_DIR})

-set(CMAKE_BINARY_DIR ${CMAKE_BINARY_DIR}/${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}/${CMAKE_CXX_COMPILER_ID}/${CMAKE_BUILD_TYPE})
-
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
+# TODO make this not have to override the build type directories
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR})
@@ -111,17 +90,6 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

-# Get DLU config directory
-if(DEFINED ENV{DLU_CONFIG_DIR})
-	set(DLU_CONFIG_DIR $ENV{DLU_CONFIG_DIR})
-else()
-	set(DLU_CONFIG_DIR ${CMAKE_BINARY_DIR})
-endif()
-
-message(STATUS "Configuration Directory is ${DLU_CONFIG_DIR}, and the build directory is ${CMAKE_BINARY_DIR}")
-
-find_package(MariaDB)
-
 # Create a /resServer directory
 make_directory(${CMAKE_BINARY_DIR}/resServer)

@@ -129,31 +97,30 @@ make_directory(${CMAKE_BINARY_DIR}/resServer)
 make_directory(${CMAKE_BINARY_DIR}/logs)

 # Copy resource files on first build
-set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
+set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blacklist.dcf")
 message(STATUS "Checking resource file integrity")

-
 include(Utils)
-UpdateConfigOption(${DLU_CONFIG_DIR}/authconfig.ini "port" "auth_server_port")
-UpdateConfigOption(${DLU_CONFIG_DIR}/chatconfig.ini "port" "chat_server_port")
-UpdateConfigOption(${DLU_CONFIG_DIR}/masterconfig.ini "port" "master_server_port")
+UpdateConfigOption(${PROJECT_BINARY_DIR}/authconfig.ini "port" "auth_server_port")
+UpdateConfigOption(${PROJECT_BINARY_DIR}/chatconfig.ini "port" "chat_server_port")
+UpdateConfigOption(${PROJECT_BINARY_DIR}/masterconfig.ini "port" "master_server_port")

 foreach(resource_file ${RESOURCE_FILES})
 	set(file_size 0)

-	if(EXISTS ${DLU_CONFIG_DIR}/${resource_file})
-		file(SIZE ${DLU_CONFIG_DIR}/${resource_file} file_size)
+	if(EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
+		file(SIZE ${PROJECT_BINARY_DIR}/${resource_file} file_size)
 	endif()

 	if(${file_size} EQUAL 0)
 		configure_file(
-			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${DLU_CONFIG_DIR}/${resource_file}
+			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${PROJECT_BINARY_DIR}/${resource_file}
 			COPYONLY
 		)
-		message(STATUS "Moved " ${resource_file} " to DLU config directory")
+		message(STATUS "Moved " ${resource_file} " to project binary directory")
 	elseif(resource_file MATCHES ".ini")
 		message(STATUS "Checking " ${resource_file} " for missing config options")
-		file(READ ${DLU_CONFIG_DIR}/${resource_file} current_file_contents)
+		file(READ ${PROJECT_BINARY_DIR}/${resource_file} current_file_contents)
 		string(REPLACE "\\\n" "" current_file_contents ${current_file_contents})
 		string(REPLACE "\n" ";" current_file_contents ${current_file_contents})
 		set(parsed_current_file_contents "")
@@ -184,10 +151,10 @@ foreach(resource_file ${RESOURCE_FILES})
 					set(line_to_add ${line_to_add} ${line})

 					foreach(line_to_append ${line_to_add})
-						file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
+						file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n" ${line_to_append})
 					endforeach()

-					file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n")
+					file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n")
 				endif()

 				set(line_to_add "")
@@ -212,7 +179,7 @@ file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip DESTINATION ${PRO
 file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)

 # Copy vanity files on first build
-set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "root.xml" "dev-tribute.xml" "atm.xml" "demo.xml")
+set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "NPC.xml")

 foreach(file ${VANITY_FILES})
 	configure_file("${CMAKE_SOURCE_DIR}/vanity/${file}" "${CMAKE_BINARY_DIR}/vanity/${file}" COPYONLY)
@@ -235,28 +202,42 @@ foreach(file ${SQL_FILES})
 	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${PROJECT_BINARY_DIR}/migrations/cdserver/${file})
 endforeach()

-# Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
-if (APPLE)
-	include_directories("/usr/local/include/")
-endif()
-
-# Load all of our third party directories
-add_subdirectory(thirdparty SYSTEM)
-
 # Create our list of include directories
-include_directories(
+set(INCLUDED_DIRECTORIES
+	"dCommon"
+	"dCommon/dClient"
+	"dCommon/dEnums"
+
+	"dChatFilter"
+
+	"dGame"
+	"dGame/dBehaviors"
+	"dGame/dComponents"
+	"dGame/dGameMessages"
+	"dGame/dInventory"
+	"dGame/dMission"
+	"dGame/dEntity"
+	"dGame/dPropertyBehaviors"
+	"dGame/dPropertyBehaviors/ControlBehaviorMessages"
+	"dGame/dUtilities"
+
 	"dPhysics"

 	"dNavigation"
+	"dNavigation/dTerrain"
+
+	"dZoneManager"
+
+	"dDatabase"
+	"dDatabase/CDClientDatabase"
+	"dDatabase/CDClientDatabase/CDClientTables"
+	"dDatabase/GameDatabase"
+	"dDatabase/GameDatabase/ITables"
+	"dDatabase/GameDatabase/MySQL"
+	"dDatabase/GameDatabase/MySQL/Tables"

 	"dNet"

-	"tests"
-	"tests/dCommonTests"
-	"tests/dGameTests"
-	"tests/dGameTests/dComponentsTests"
-
-	SYSTEM
 	"thirdparty/magic_enum/include/magic_enum"
 	"thirdparty/raknet/Source"
 	"thirdparty/tinyxml2"
@@ -264,26 +245,47 @@ include_directories(
 	"thirdparty/SQLite"
 	"thirdparty/cpplinq"
 	"thirdparty/cpp-httplib"
-	"thirdparty/MD5"
+
+	"tests"
+	"tests/dCommonTests"
+	"tests/dGameTests"
+	"tests/dGameTests/dComponentsTests"
 )

 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
-# TODO: Should probably not do this.
 if(APPLE)
 	include_directories("/usr/local/include/")
 endif()

-# Set warning flags
-if(MSVC)
-	# add_compile_options("/W4")
-	# Want to enable warnings eventually, but WAY too much noise right now
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
-	add_compile_options("-Wuninitialized" "-Wold-style-cast")
-else()
-	message(WARNING "Unknown compiler: '${CMAKE_CXX_COMPILER_ID}' - No warning flags enabled.")
+# Actually include the directories from our list
+foreach(dir ${INCLUDED_DIRECTORIES})
+	include_directories(${PROJECT_SOURCE_DIR}/${dir})
+endforeach()
+
+if(NOT WIN32)
+	include_directories("${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include/bcrypt")
 endif()

+include_directories("${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include")
+
 # Add linking directories:
+link_directories(${PROJECT_BINARY_DIR})
+
+# Load all of our third party directories
+add_subdirectory(thirdparty)
+if (UNIX)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+endif()
+# Glob together all headers that need to be precompiled
+file(
+	GLOB HEADERS_DDATABASE
+	LIST_DIRECTORIES false
+	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/*.h
+	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables/*.h
+	${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables/*.h
+	${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.h
+)
+
 file(
 	GLOB HEADERS_DZONEMANAGER
 	LIST_DIRECTORIES false
@@ -318,7 +320,7 @@ add_subdirectory(dPhysics)
 add_subdirectory(dServer)

 # Create a list of common libraries shared between all binaries
-set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "MariaDB::ConnCpp" "magic_enum")
+set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "mariadbConnCpp" "magic_enum")

 # Add platform specific common libraries
 if(UNIX)
@@ -340,6 +342,12 @@ target_precompile_headers(
 	${HEADERS_DZONEMANAGER}
 )

+# Need to specify to use the CXX compiler language here or else we get errors including <string>.
+target_precompile_headers(
+	dDatabase PRIVATE
+	"$<$<COMPILE_LANGUAGE:CXX>:${HEADERS_DDATABASE}>"
+)
+
 target_precompile_headers(
 	dCommon PRIVATE
 	${HEADERS_DCOMMON}
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -1,191 +1,128 @@
 {
-    "version": 6,
+    "version": 3,
    "cmakeMinimumRequired": {
-        "major": 3,
-        "minor": 25,
-        "patch": 0
+      "major": 3,
+      "minor": 14,
+      "patch": 0
    },
    "configurePresets": [
-        {
-            "name": "default",
-            "displayName": "Default configure step",
-            "description": "Use 'build' dir and Unix makefiles",
-            "binaryDir": "${sourceDir}/build",
-            "generator": "Unix Makefiles",
-            "hidden": true
+      {
+        "name": "default",
+        "displayName": "Default configure step",
+        "description": "Use 'build' dir and Unix makefiles",
+        "binaryDir": "${sourceDir}/build",
+        "generator": "Unix Makefiles"
+      },
+      {
+        "name": "ci-ubuntu-22.04",
+        "displayName": "CI configure step for Ubuntu",
+        "description": "Same as default, Used in GitHub actions workflow",
+        "inherits": "default"
+      },
+      {
+        "name": "ci-macos-13",
+        "displayName": "CI configure step for MacOS",
+        "description": "Same as default, Used in GitHub actions workflow",
+        "inherits": "default"
+      },
+      {
+        "name": "ci-windows-2022",
+        "displayName": "CI configure step for Windows",
+        "description": "Set architecture to 64-bit (b/c RakNet)",
+        "inherits": "default",
+        "generator": "Visual Studio 17 2022",
+        "architecture": {
+          "value": "x64"
        },
-        {
-            "name": "windows-default",
-            "inherits": "default",
-            "displayName": "Windows Default Configure Settings",
-            "description": "Sets build and install directories",
-            "generator": "Visual Studio 17 2022",
-            "condition": {
-                "type": "equals",
-                "lhs": "${hostSystemName}",
-                "rhs": "Windows"
-            },
-            "hidden": true
-        },
-        {
-            "name": "windows-msvc",
-            "inherits": "windows-default",
-            "displayName": "Windows (MSVC)",
-            "description": "Create a build using MSVC"
-        },
-        {
-            "name": "windows-clang",
-            "inherits": "windows-default",
-            "displayName": "EXPERIMENTAL - Windows (Clang)",
-            "description": "Create a build using Clang",
-            "toolset": "ClangCL"
-        },
-        {
-            "name": "linux-default",
-            "inherits": "default",
-            "hidden": true,
-            "condition": {
-                "type": "equals",
-                "lhs": "${hostSystemName}",
-                "rhs": "Linux"
-            }
-        },
-        {
-            "name": "linux-clang",
-            "inherits": "linux-default",
-            "toolchainFile": "${sourceDir}/cmake/toolchains/linux-clang.cmake",
-            "displayName": "Linux (Clang)",
-            "description": "Create a build using the Clang toolchain for Linux"
-        },
-        {
-            "name": "linux-gnu",
-            "inherits": "linux-default",
-            "toolchainFile": "${sourceDir}/cmake/toolchains/linux-gnu.cmake",
-            "displayName": "Linux (GNU)",
-            "description": "Create a build using the GNU toolchain for Linux"
-        },
-        {
-            "name": "macos",
-            "inherits": "default",
-            "displayName": "MacOS",
-            "description": "Create a build for MacOS",
-            "condition": {
-                "type": "equals",
-                "lhs": "${hostSystemName}",
-                "rhs": "Darwin"
-            }
+        "cacheVariables": {
+          "CMAKE_BUILD_TYPE": "RelWithDebInfo"
        }
+      },
+      {
+        "name": "windows-default",
+        "inherits": "ci-windows-2022",
+        "displayName": "Windows only Configure Settings",
+        "description": "Sets build and install directories",
+        "generator": "Ninja",
+        "architecture": {
+          "value": "x64",
+          "strategy": "external"
+        }
+      }
    ],
    "buildPresets": [
-        {
-            "name": "default",
-            "configurePreset": "default",
-            "displayName": "Default Build",
-            "description": "Default Build",
-            "jobs": 2
-        }
+      {
+        "name": "default",
+        "configurePreset": "default",
+        "displayName": "Default Build",
+        "description": "Default Build",
+        "jobs": 2
+      },
+      {
+        "name": "ci-windows-2022",
+        "configurePreset": "ci-windows-2022",
+        "displayName": "Windows CI Build",
+        "description": "This preset is used by the CI build on windows",
+        "configuration": "RelWithDebInfo",
+        "jobs": 2
+      },
+      {
+        "name": "ci-ubuntu-22.04",
+        "configurePreset": "ci-ubuntu-22.04",
+        "displayName": "Linux CI Build",
+        "description": "This preset is used by the CI build on linux",
+        "jobs": 2
+      },
+      {
+        "name": "ci-macos-13",
+        "configurePreset": "ci-macos-13",
+        "displayName": "MacOS CI Build",
+        "description": "This preset is used by the CI build on MacOS",
+        "jobs": 2
+      }
    ],
    "testPresets": [
-        {
-            "name": "ci-ubuntu-22.04",
-            "configurePreset": "ci-ubuntu-22.04",
-            "displayName": "CI Tests on Linux",
-            "description": "Runs all tests on a linux configuration",
-            "execution": {
-                "jobs": 2
-            },
-            "output": {
-                "outputOnFailure": true
-            }
-        },
-        {
-            "name": "ci-macos-13",
-            "configurePreset": "ci-macos-13",
-            "displayName": "CI Tests on MacOS",
-            "description": "Runs all tests on a Mac configuration",
-            "execution": {
-                "jobs": 2
-            },
-            "output": {
-                "outputOnFailure": true
-            }
-        },
-        {
-            "name": "ci-windows-2022",
-            "configurePreset": "ci-windows-2022",
-            "displayName": "CI Tests on windows",
-            "description": "Runs all tests on a windows configuration",
-            "configuration": "RelWithDebInfo",
-            "execution": {
-                "jobs": 2
-            },
-            "output": {
-                "outputOnFailure": true
-            },
-            "filter": {
-                "exclude": {
-                    "name": "((example)|(minigzip))+"
-                }
-            }
+      {
+        "name": "ci-ubuntu-22.04",
+        "configurePreset": "ci-ubuntu-22.04",
+        "displayName": "CI Tests on Linux",
+        "description": "Runs all tests on a linux configuration",
+		"execution": {
+			"jobs": 2
+		},
+        "output": {
+          "outputOnFailure": true
        }
-    ],
-    "workflowPresets": [
-        {
-            "name": "ci-windows-2022",
-            "displayName": "[Release] Windows (MSVC)",
-            "description": "CI workflow preset for Windows",
-            "steps": [
-                {
-                    "type": "configure",
-                    "name": "windows-msvc"
-                },
-                {
-                    "type": "build",
-                    "name": "default"
-                },
-                {
-                    "type": "test",
-                    "name": "default"
-                }
-            ]
-        },
-        {
-            "name": "ci-ubuntu-22.04",
-            "displayName": "[Release] Linux (GNU)",
-            "description": "CI workflow preset for Ubuntu",
-            "steps": [
-                {
-                    "type": "configure",
-                    "name": "linux-gnu"
-                },
-                {
-                    "type": "build",
-                    "name": "default"
-                },
-                {
-                    "type": "test",
-                    "name": "ci-ubuntu-22.04"
-                }
-            ]
-        },
-        {
-            "name": "ci-macos-13",
-            "displayName": "[Release] MacOS",
-            "description": "CI workflow preset for MacOS",
-            "steps": [
-                {
-                    "type": "configure",
-                    "name": "macos"
-                },
-                {
-                    "type": "build",
-                    "name": "default"
-                },
-                {
-                    "type": "test",
-                    "name": "default"
-                }
-            ]
+      },
+      {
+        "name": "ci-macos-13",
+        "configurePreset": "ci-macos-13",
+        "displayName": "CI Tests on MacOS",
+        "description": "Runs all tests on a Mac configuration",
+		"execution": {
+			"jobs": 2
+		},
+        "output": {
+          "outputOnFailure": true
        }
+      },
+      {
+        "name": "ci-windows-2022",
+        "configurePreset": "ci-windows-2022",
+        "displayName": "CI Tests on windows",
+        "description": "Runs all tests on a windows configuration",
+		"configuration": "RelWithDebInfo",
+		"execution": {
+			"jobs": 2
+		},
+        "output": {
+          "outputOnFailure": true
+        },
+		"filter": {
+			"exclude": {
+				"name": "((example)|(minigzip))+"
+			}
+		}
+      }
    ]
-}
+  }
--- a/CMakeVariables.txt
+++ b/CMakeVariables.txt
@@ -1,6 +1,6 @@
-PROJECT_VERSION_MAJOR=2
-PROJECT_VERSION_MINOR=3
-PROJECT_VERSION_PATCH=0
+PROJECT_VERSION_MAJOR=1
+PROJECT_VERSION_MINOR=1
+PROJECT_VERSION_PATCH=1

 # Debugging
 # Set DYNAMIC to 1 to enable the -rdynamic flag for the linker, yielding some symbols in crashlogs.
--- a/7
+++ b/7
@@ -23,7 +23,8 @@ RUN --mount=type=cache,id=build-apt-cache,target=/var/cache/apt \
    rm -rf /var/lib/apt/lists/*

 # Grab libraries and load them
-COPY --from=build /app/build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
+COPY --from=build /app/build/mariadbcpp/src/mariadb_connector_cpp-build/libmariadbcpp.so /usr/local/lib/
+COPY --from=build /app/build/mariadbcpp/src/mariadb_connector_cpp-build/libmariadb/libmariadb/libmariadb.so.3 /usr/local/lib
 RUN ldconfig

 # Server bins
@@ -31,7 +32,7 @@ COPY --from=build /app/build/*Server /app/

 # Necessary suplimentary files
 COPY --from=build /app/build/*.ini /app/configs/
-COPY --from=build /app/build/vanity/*.* /app/vanity/
+COPY --from=build /app/build/vanity/*.* /app/vanity/*
 COPY --from=build /app/build/navmeshes /app/navmeshes
 COPY --from=build /app/build/migrations /app/migrations
 COPY --from=build /app/build/*.dcf /app/
@@ -39,7 +40,7 @@ COPY --from=build /app/build/*.dcf /app/
 # backup of config and vanity files to copy to the host incase 
 # of a mount clobbering the copy from above
 COPY --from=build /app/build/*.ini /app/default-configs/ 
-COPY --from=build /app/build/vanity/*.* /app/default-vanity/
+COPY --from=build /app/build/vanity/*.* /app/default-vanity/*

 # needed as the container runs with the root user
 # and therefore sudo doesn't exist
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer

 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.18**</font> or later!).

 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.
@@ -73,7 +73,7 @@ sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-serve
 ```

 #### Required CMake version
-This project uses <font size="4">**CMake version 3.25**</font> or higher and as such you will need to ensure you have this version installed.
+This project uses <font size="4">**CMake version 3.18**</font> or higher and as such you will need to ensure you have this version installed.
 You can check your CMake version by using the following command in a terminal.
 ```bash
 cmake --version
--- a/build.sh
+++ b/build.sh
@@ -6,7 +6,8 @@ mkdir -p build
 cd build

 # Run cmake to generate make files
-cmake -DCMAKE_BUILD_TYPE="Release" ..
+cmake ..

 # To build utilizing multiple cores, append `-j` and the amount of cores to utilize, for example `cmake --build . --config Release -j8'
 cmake --build . --config Release $1
+
--- a/cmake/FindGoogleTest.cmake
+++ b/cmake/FindGoogleTest.cmake
@@ -1,17 +0,0 @@
-include(FetchContent)
-
-message(STATUS "Fetching gtest...")
-
-FetchContent_Declare(
-	googletest
-	GIT_REPOSITORY https://github.com/google/googletest.git
-	GIT_TAG release-1.12.1
-)
-
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-FetchContent_MakeAvailable(GoogleTest)
-
-message(STATUS "gtest fetched and is now ready.")
-set(GoogleTest_FOUND TRUE)
--- a/cmake/toolchains/linux-clang.cmake
+++ b/cmake/toolchains/linux-clang.cmake
@@ -1,14 +0,0 @@
-# Try and find a clang-16 install, falling back to a generic clang install otherwise
-find_program(CLANG_C_COMPILER clang-16 | clang REQUIRED)
-find_program(CLANG_CXX_COMPILER clang++-16 | clang++ REQUIRED)
-
-# Debug messages
-message(DEBUG "CLANG_C_COMPILER = ${CLANG_C_COMPILER}")
-message(DEBUG "CLANG_CXX_COMPILER = ${CLANG_CXX_COMPILER}")
-
-# Set compilers to clang (need to cache for VSCode tools to work correctly)
-set(CMAKE_C_COMPILER ${CLANG_C_COMPILER} CACHE STRING "Set C compiler")
-set(CMAKE_CXX_COMPILER ${CLANG_CXX_COMPILER} CACHE STRING "Set C++ compiler")
-
-# Set linker to lld
-add_link_options("-fuse-ld=lld")
--- a/cmake/toolchains/linux-gnu.cmake
+++ b/cmake/toolchains/linux-gnu.cmake
@@ -1,11 +0,0 @@
-# Try and find a gcc/g++ install
-find_program(GNU_C_COMPILER cc | gcc REQUIRED)
-find_program(GNU_CXX_COMPILER c++ | g++ REQUIRED)
-
-# Debug messages
-message(DEBUG "GNU_C_COMPILER = ${GNU_C_COMPILER}")
-message(DEBUG "GNU_CXX_COMPILER = ${GNU_CXX_COMPILER}")
-
-# Set compilers to GNU (need to cache for VSCode tools to work correctly)
-set(CMAKE_C_COMPILER ${GNU_C_COMPILER} CACHE STRING "Set C compiler")
-set(CMAKE_CXX_COMPILER ${GNU_CXX_COMPILER} CACHE STRING "Set C++ compiler")
--- a/dAuthServer/AuthServer.cpp
+++ b/dAuthServer/AuthServer.cpp
@@ -21,8 +21,8 @@
 //Auth includes:
 #include "AuthPackets.h"
 #include "eConnectionType.h"
-#include "MessageType/Server.h"
-#include "MessageType/Auth.h"
+#include "eServerMessageType.h"
+#include "eAuthMessageType.h"

 #include "Game.h"
 #include "Server.h"
@@ -82,11 +82,11 @@ int main(int argc, char** argv) {
 	Game::randomEngine = std::mt19937(time(0));

 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
+	uint32_t maxClients = 999;
+	uint32_t ourPort = 1001; //LU client is hardcoded to use this for auth port, so I'm making it the default.
 	std::string ourIP = "localhost";
-	const uint32_t maxClients = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_clients")).value_or(999);
-
-	//LU client is hardcoded to use this for auth port, so I'm making it the default.
-	const uint32_t ourPort = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("auth_server_port")).value_or(1001);
+	GeneralUtils::TryParse(Game::config->GetValue("max_clients"), maxClients);
+	GeneralUtils::TryParse(Game::config->GetValue("auth_server_port"), ourPort);
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;

@@ -102,7 +102,7 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceLastSQLPing = 0;

 	AuthPackets::LoadClaimCodes();
-
+	
 	Game::logger->Flush(); // once immediately before main loop
 	while (!Game::ShouldShutdown()) {
 		//Check if we're still connected to master:
@@ -166,11 +166,11 @@ void HandlePacket(Packet* packet) {

 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
 		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
-			if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) {
+			if (static_cast<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
 		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
-			if (static_cast<MessageType::Auth>(packet->data[3]) == MessageType::Auth::LOGIN_REQUEST) {
+			if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}
 		}
--- a/dChatFilter/dChatFilter.cpp
+++ b/dChatFilter/dChatFilter.cpp
@@ -27,8 +27,8 @@ dChatFilter::dChatFilter(const std::string& filepath, bool dontGenerateDCF) {
 		ExportWordlistToDCF(filepath + ".dcf", true);
 	}

-	if (BinaryIO::DoesFileExist("blocklist.dcf")) {
-		ReadWordlistDCF("blocklist.dcf", false);
+	if (BinaryIO::DoesFileExist("blacklist.dcf")) {
+		ReadWordlistDCF("blacklist.dcf", false);
 	}

 	//Read player names that are ok as well:
@@ -44,20 +44,20 @@ dChatFilter::~dChatFilter() {
 	m_DeniedWords.clear();
 }

-void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool allowList) {
+void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool whiteList) {
 	std::ifstream file(filepath);
 	if (file) {
 		std::string line;
 		while (std::getline(file, line)) {
 			line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
 			std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
-			if (allowList) m_ApprovedWords.push_back(CalculateHash(line));
+			if (whiteList) m_ApprovedWords.push_back(CalculateHash(line));
 			else m_DeniedWords.push_back(CalculateHash(line));
 		}
 	}
 }

-bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool allowList) {
+bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
 	std::ifstream file(filepath, std::ios::binary);
 	if (file) {
 		fileHeader hdr;
@@ -70,13 +70,13 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool allowList) {
 		if (hdr.formatVersion == formatVersion) {
 			size_t wordsToRead = 0;
 			BinaryIO::BinaryRead(file, wordsToRead);
-			if (allowList) m_ApprovedWords.reserve(wordsToRead);
+			if (whiteList) m_ApprovedWords.reserve(wordsToRead);
 			else m_DeniedWords.reserve(wordsToRead);

 			size_t word = 0;
 			for (size_t i = 0; i < wordsToRead; ++i) {
 				BinaryIO::BinaryRead(file, word);
-				if (allowList) m_ApprovedWords.push_back(word);
+				if (whiteList) m_ApprovedWords.push_back(word);
 				else m_DeniedWords.push_back(word);
 			}

@@ -90,14 +90,14 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool allowList) {
 	return false;
 }

-void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowList) {
+void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteList) {
 	std::ofstream file(filepath, std::ios::binary | std::ios_base::out);
 	if (file) {
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::header));
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::formatVersion));
-		BinaryIO::BinaryWrite(file, size_t(allowList ? m_ApprovedWords.size() : m_DeniedWords.size()));
+		BinaryIO::BinaryWrite(file, size_t(whiteList ? m_ApprovedWords.size() : m_DeniedWords.size()));

-		for (size_t word : allowList ? m_ApprovedWords : m_DeniedWords) {
+		for (size_t word : whiteList ? m_ApprovedWords : m_DeniedWords) {
 			BinaryIO::BinaryWrite(file, word);
 		}

@@ -105,10 +105,10 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowLis
 	}
 }

-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList) {
 	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
-	if (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
+	if (!whiteList && m_DeniedWords.empty()) return { { 0, message.length() } };

 	std::stringstream sMessage(message);
 	std::string segment;
@@ -126,16 +126,16 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::

 		size_t hash = CalculateHash(segment);

-		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
+		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && whiteList) {
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}

-		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
+		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && whiteList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}

-		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
+		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !whiteList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
--- a/dChatFilter/dChatFilter.h
+++ b/dChatFilter/dChatFilter.h
@@ -21,10 +21,10 @@ public:
 	dChatFilter(const std::string& filepath, bool dontGenerateDCF);
 	~dChatFilter();

-	void ReadWordlistPlaintext(const std::string& filepath, bool allowList);
-	bool ReadWordlistDCF(const std::string& filepath, bool allowList);
-	void ExportWordlistToDCF(const std::string& filepath, bool allowList);
-	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
+	void ReadWordlistPlaintext(const std::string& filepath, bool whiteList);
+	bool ReadWordlistDCF(const std::string& filepath, bool whiteList);
+	void ExportWordlistToDCF(const std::string& filepath, bool whiteList);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList = true);

 private:
 	bool m_DontGenerateDCF;
--- a/dChatServer/CMakeLists.txt
+++ b/dChatServer/CMakeLists.txt
@@ -5,11 +5,9 @@ set(DCHATSERVER_SOURCES
 )

 add_executable(ChatServer "ChatServer.cpp")
-target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
-add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
-
 add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
+target_include_directories(dChatServer PRIVATE ${PROJECT_SOURCE_DIR}/dServer)
+add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")

 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
 target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
--- a/dChatServer/ChatIgnoreList.cpp
+++ b/dChatServer/ChatIgnoreList.cpp
@@ -1,6 +1,6 @@
 #include "ChatIgnoreList.h"
 #include "PlayerContainer.h"
-#include "MessageType/Chat.h"
+#include "eChatInternalMessageType.h"
 #include "BitStreamUtils.h"
 #include "Game.h"
 #include "Logger.h"
@@ -13,7 +13,7 @@
 // The only thing not auto-handled is instance activities force joining the team on the server.

 void WriteOutgoingReplyHeader(RakNet::BitStream& bitStream, const LWOOBJID& receivingPlayer, const ChatIgnoreList::Response type) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT,  MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receivingPlayer);

 	//portion that will get routed:
@@ -59,7 +59,7 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 		bitStream.Write(LUWString(ignoredPlayer.playerName, 36));
 	}

-	Game::server->Send(bitStream, packet->systemAddress, false);
+	Game::server->Send(&bitStream, packet->systemAddress, false);
 }

 void ChatIgnoreList::AddIgnore(Packet* packet) {
@@ -131,7 +131,7 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 	bitStream.Write(playerNameSend);
 	bitStream.Write(ignoredPlayerId);

-	Game::server->Send(bitStream, packet->systemAddress, false);
+	Game::server->Send(&bitStream, packet->systemAddress, false);
 }

 void ChatIgnoreList::RemoveIgnore(Packet* packet) {
@@ -167,5 +167,5 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 	LUWString playerNameSend(removedIgnoreStr, 33);
 	bitStream.Write(playerNameSend);

-	Game::server->Send(bitStream, packet->systemAddress, false);
+	Game::server->Send(&bitStream, packet->systemAddress, false);
 }
--- a/dChatServer/ChatPacketHandler.cpp
+++ b/dChatServer/ChatPacketHandler.cpp
@@ -13,12 +13,12 @@
 #include "dConfig.h"
 #include "eObjectBits.h"
 #include "eConnectionType.h"
-#include "MessageType/Chat.h"
-#include "MessageType/Client.h"
-#include "MessageType/Game.h"
+#include "eChatMessageType.h"
+#include "eChatInternalMessageType.h"
+#include "eClientMessageType.h"
+#include "eGameMessageType.h"
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
-#include "ChatPackets.h"

 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
@@ -60,11 +60,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {

 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);

 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::GET_FRIENDS_LIST_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
 	bitStream.Write<uint16_t>(player.friends.size());
@@ -355,68 +355,7 @@ void ChatPacketHandler::HandleGMLevelUpdate(Packet* packet) {
 	inStream.Read(player.gmLevel);
 }

-
-void ChatPacketHandler::HandleWho(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	FindPlayerRequest request;
-	request.Deserialize(inStream);
-
-	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
-	if (!sender) return;
-
-	const auto& player = Game::playerContainer.GetPlayerData(request.playerName.GetAsString());
-	bool online = player;
-
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(request.requestor);
-
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::WHO_RESPONSE);
-	bitStream.Write<uint8_t>(online);
-	bitStream.Write(player.zoneID.GetMapID());
-	bitStream.Write(player.zoneID.GetInstanceID());
-	bitStream.Write(player.zoneID.GetCloneID());
-	bitStream.Write(request.playerName);
-
-	SystemAddress sysAddr = sender.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::HandleShowAll(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	ShowAllRequest request;
-	request.Deserialize(inStream);
-
-	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
-	if (!sender) return;
-
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(request.requestor);
-
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::SHOW_ALL_RESPONSE);
-	bitStream.Write<uint8_t>(!request.displayZoneData && !request.displayIndividualPlayers);
-	bitStream.Write(Game::playerContainer.GetPlayerCount());
-	bitStream.Write(Game::playerContainer.GetSimCount());
-	bitStream.Write<uint8_t>(request.displayIndividualPlayers);
-	bitStream.Write<uint8_t>(request.displayZoneData);
-	if (request.displayZoneData || request.displayIndividualPlayers){
-		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
-			if (!playerData) continue;
-			bitStream.Write<uint8_t>(0); // structure packing
-			if (request.displayIndividualPlayers) bitStream.Write(LUWString(playerData.playerName));
-			if (request.displayZoneData) {
-				bitStream.Write(playerData.zoneID.GetMapID());
-				bitStream.Write(playerData.zoneID.GetInstanceID());
-				bitStream.Write(playerData.zoneID.GetCloneID());
-			}
-		}
-	}
-	SystemAddress sysAddr = sender.sysAddr;
-	SEND_PACKET;
-}
-
-// the structure the client uses to send this packet is shared in many chat messages
+// the structure the client uses to send this packet is shared in many chat messages 
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
@@ -428,7 +367,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {

 	eChatChannel channel;
 	uint32_t size;
-
+	
 	inStream.IgnoreBytes(4);
 	inStream.Read(channel);
 	inStream.Read(size);
@@ -436,7 +375,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {

 	LUWString message(size);
 	inStream.Read(message);
-
+	
 	LOG("Got a message from (%s) via [%s]: %s", sender.playerName.c_str(), StringifiedEnum::ToString(channel).data(), message.GetAsString().c_str());

 	switch (channel) {
@@ -457,7 +396,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	}
 }

-// the structure the client uses to send this packet is shared in many chat messages
+// the structure the client uses to send this packet is shared in many chat messages 
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
@@ -484,7 +423,7 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {

 	LUWString message(size);
 	inStream.Read(message);
-
+	
 	LOG("Got a message from (%s) via [%s]: %s to %s", sender.playerName.c_str(), StringifiedEnum::ToString(channel).data(), message.GetAsString().c_str(), receiverName.c_str());

 	const auto& receiver = Game::playerContainer.GetPlayerData(receiverName);
@@ -515,10 +454,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {

 void ChatPacketHandler::SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(routeTo.playerID);

-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::PRIVATE_CHAT_MESSAGE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 	bitStream.Write(sender.playerID);
 	bitStream.Write(channel);
 	bitStream.Write<uint32_t>(0); // not used
@@ -757,11 +696,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {

 void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::TEAM_INVITE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);

 	bitStream.Write(LUWString(sender.playerName.c_str()));
 	bitStream.Write(sender.playerID);
@@ -772,14 +711,14 @@ void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerD

 void ChatPacketHandler::SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_INVITE_CONFIRM);
+	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);

 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -799,14 +738,14 @@ void ChatPacketHandler::SendTeamInviteConfirm(const PlayerData& receiver, bool b

 void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);

 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -824,14 +763,14 @@ void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64L

 void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_SET_LEADER);
+	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);

 	bitStream.Write(i64PlayerID);

@@ -841,14 +780,14 @@ void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i

 void ChatPacketHandler::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_ADD_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);

 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -870,14 +809,14 @@ void ChatPacketHandler::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFr

 void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_REMOVE_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);

 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -896,14 +835,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bD

 void ChatPacketHandler::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
 	CMSGHEADER;

 	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);

 	bitStream.Write(i64PlayerID);
 	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -930,11 +869,11 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 		[bool] - is FTP*/

 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(friendData.playerID);

 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::UPDATE_FRIEND_NOTIFY);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);

 	std::string playerName = playerData.playerName.c_str();
@@ -967,11 +906,11 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 	}

 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::ADD_FRIEND_REQUEST);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
 	bitStream.Write(LUWString(sender.playerName));
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.

@@ -981,11 +920,11 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play

 void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	// Portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::ADD_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
 	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender.sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
@@ -1004,11 +943,11 @@ void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const Pla

 void ChatPacketHandler::SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver.playerID);

 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::REMOVE_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	bitStream.Write(LUWString(personToRemove));

--- a/dChatServer/ChatPacketHandler.h
+++ b/dChatServer/ChatPacketHandler.h
@@ -50,8 +50,6 @@ namespace ChatPacketHandler {
 	void HandleFriendResponse(Packet* packet);
 	void HandleRemoveFriend(Packet* packet);
 	void HandleGMLevelUpdate(Packet* packet);
-	void HandleWho(Packet* packet);
-	void HandleShowAll(Packet* packet);

 	void HandleChatMessage(Packet* packet);
 	void HandlePrivateChatMessage(Packet* packet);
--- a/dChatServer/ChatServer.cpp
+++ b/dChatServer/ChatServer.cpp
@@ -16,8 +16,9 @@
 #include "eConnectionType.h"
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
-#include "MessageType/Chat.h"
-#include "MessageType/World.h"
+#include "eChatMessageType.h"
+#include "eChatInternalMessageType.h"
+#include "eWorldMessageType.h"
 #include "ChatIgnoreList.h"
 #include "StringifiedEnum.h"

@@ -98,17 +99,20 @@ int main(int argc, char** argv) {
 		masterPort = masterInfo->port;
 	}
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
+	uint32_t maxClients = 999;
+	uint32_t ourPort = 1501;
 	std::string ourIP = "localhost";
-	const uint32_t maxClients = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_clients")).value_or(999);
-	const uint32_t ourPort = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("chat_server_port")).value_or(2005);
+	GeneralUtils::TryParse(Game::config->GetValue("max_clients"), maxClients);
+	GeneralUtils::TryParse(Game::config->GetValue("chat_server_port"), ourPort);
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;

 	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::lastSignal);

-	const bool dontGenerateDCF = GeneralUtils::TryParse<bool>(Game::config->GetValue("dont_generate_dcf")).value_or(false);
+	bool dontGenerateDCF = false;
+	GeneralUtils::TryParse(Game::config->GetValue("dont_generate_dcf"), dontGenerateDCF);
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", dontGenerateDCF);
-
+	
 	Game::randomEngine = std::mt19937(time(0));

 	Game::playerContainer.Initialize();
@@ -179,168 +183,185 @@ int main(int argc, char** argv) {
 }

 void HandlePacket(Packet* packet) {
-	if (packet->length < 1) return;
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
 		LOG("A server has disconnected, erasing their connected players from the list.");
-	} else if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
+	}
+
+	if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
 		LOG("A server is connecting, awaiting user list.");
-	} else if (packet->length < 4 || packet->data[0] != ID_USER_PACKET_ENUM) return; // Nothing left to process or not the right packet type
+	}

-	CINSTREAM;
-	inStream.SetReadOffset(BYTES_TO_BITS(1));
+	if (packet->length < 4) return; // Nothing left to process.  Need 4 bytes to continue.

-	eConnectionType connection;
-	MessageType::Chat chatMessageID;
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
+		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
+		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
+			Game::playerContainer.InsertPlayer(packet);
+			break;

-	inStream.Read(connection);
-	if (connection != eConnectionType::CHAT) return;
-	inStream.Read(chatMessageID);
+		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
+			Game::playerContainer.RemovePlayer(packet);
+			break;

-	switch (chatMessageID) {
-		case MessageType::Chat::GM_MUTE:
+		case eChatInternalMessageType::MUTE_UPDATE:
 			Game::playerContainer.MuteUpdate(packet);
 			break;

-		case MessageType::Chat::CREATE_TEAM:
+		case eChatInternalMessageType::CREATE_TEAM:
 			Game::playerContainer.CreateTeamServer(packet);
 			break;

-		case MessageType::Chat::GET_FRIENDS_LIST:
+		case eChatInternalMessageType::ANNOUNCEMENT: {
+			//we just forward this packet to every connected server
+			CINSTREAM;
+			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
+			break;
+		}
+
+		default:
+			LOG("Unknown CHAT_INTERNAL id: %i", int(packet->data[3]));
+		}
+	}
+
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
+		eChatMessageType chat_message_type = static_cast<eChatMessageType>(packet->data[3]);
+		switch (chat_message_type) {
+		case eChatMessageType::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;

-		case MessageType::Chat::GET_IGNORE_LIST:
+		case eChatMessageType::GET_IGNORE_LIST:
 			ChatIgnoreList::GetIgnoreList(packet);
 			break;

-		case MessageType::Chat::ADD_IGNORE:
+		case eChatMessageType::ADD_IGNORE:
 			ChatIgnoreList::AddIgnore(packet);
 			break;

-		case MessageType::Chat::REMOVE_IGNORE:
+		case eChatMessageType::REMOVE_IGNORE:
 			ChatIgnoreList::RemoveIgnore(packet);
 			break;

-		case MessageType::Chat::TEAM_GET_STATUS:
+		case eChatMessageType::TEAM_GET_STATUS:
 			ChatPacketHandler::HandleTeamStatusRequest(packet);
 			break;

-		case MessageType::Chat::ADD_FRIEND_REQUEST:
+		case eChatMessageType::ADD_FRIEND_REQUEST:
 			//this involves someone sending the initial request, the response is below, response as in from the other player.
 			//We basically just check to see if this player is online or not and route the packet.
 			ChatPacketHandler::HandleFriendRequest(packet);
 			break;

-		case MessageType::Chat::ADD_FRIEND_RESPONSE:
+		case eChatMessageType::ADD_FRIEND_RESPONSE:
 			//This isn't the response a server sent, rather it is a player's response to a received request.
 			//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
 			ChatPacketHandler::HandleFriendResponse(packet);
 			break;

-		case MessageType::Chat::REMOVE_FRIEND:
+		case eChatMessageType::REMOVE_FRIEND:
 			ChatPacketHandler::HandleRemoveFriend(packet);
 			break;

-		case MessageType::Chat::GENERAL_CHAT_MESSAGE:
+		case eChatMessageType::GENERAL_CHAT_MESSAGE:
 			ChatPacketHandler::HandleChatMessage(packet);
 			break;

-		case MessageType::Chat::PRIVATE_CHAT_MESSAGE:
+		case eChatMessageType::PRIVATE_CHAT_MESSAGE:
 			//This message is supposed to be echo'd to both the sender and the receiver
 			//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
 			ChatPacketHandler::HandlePrivateChatMessage(packet);
 			break;

-		case MessageType::Chat::TEAM_INVITE:
+		case eChatMessageType::TEAM_INVITE:
 			ChatPacketHandler::HandleTeamInvite(packet);
 			break;

-		case MessageType::Chat::TEAM_INVITE_RESPONSE:
+		case eChatMessageType::TEAM_INVITE_RESPONSE:
 			ChatPacketHandler::HandleTeamInviteResponse(packet);
 			break;

-		case MessageType::Chat::TEAM_LEAVE:
+		case eChatMessageType::TEAM_LEAVE:
 			ChatPacketHandler::HandleTeamLeave(packet);
 			break;

-		case MessageType::Chat::TEAM_SET_LEADER:
+		case eChatMessageType::TEAM_SET_LEADER:
 			ChatPacketHandler::HandleTeamPromote(packet);
 			break;

-		case MessageType::Chat::TEAM_KICK:
+		case eChatMessageType::TEAM_KICK:
 			ChatPacketHandler::HandleTeamKick(packet);
 			break;

-		case MessageType::Chat::TEAM_SET_LOOT:
+		case eChatMessageType::TEAM_SET_LOOT:
 			ChatPacketHandler::HandleTeamLootOption(packet);
 			break;
-		case MessageType::Chat::GMLEVEL_UPDATE:
+		case eChatMessageType::GMLEVEL_UPDATE:
 			ChatPacketHandler::HandleGMLevelUpdate(packet);
 			break;
-		case MessageType::Chat::LOGIN_SESSION_NOTIFY:
-			Game::playerContainer.InsertPlayer(packet);
-			break;
-		case MessageType::Chat::GM_ANNOUNCE:{
-			// we just forward this packet to every connected server
-			inStream.ResetReadPointer();
-			Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
-			}
-			break;
-		case MessageType::Chat::UNEXPECTED_DISCONNECT:
-			Game::playerContainer.RemovePlayer(packet);
-			break;
-		case MessageType::Chat::WHO:
-			ChatPacketHandler::HandleWho(packet);
-			break;
-		case MessageType::Chat::SHOW_ALL:
-			ChatPacketHandler::HandleShowAll(packet);
-			break;
-		case MessageType::Chat::USER_CHANNEL_CHAT_MESSAGE:
-		case MessageType::Chat::WORLD_DISCONNECT_REQUEST:
-		case MessageType::Chat::WORLD_PROXIMITY_RESPONSE:
-		case MessageType::Chat::WORLD_PARCEL_RESPONSE:
-		case MessageType::Chat::TEAM_MISSED_INVITE_CHECK:
-		case MessageType::Chat::GUILD_CREATE:
-		case MessageType::Chat::GUILD_INVITE:
-		case MessageType::Chat::GUILD_INVITE_RESPONSE:
-		case MessageType::Chat::GUILD_LEAVE:
-		case MessageType::Chat::GUILD_KICK:
-		case MessageType::Chat::GUILD_GET_STATUS:
-		case MessageType::Chat::GUILD_GET_ALL:
-		case MessageType::Chat::BLUEPRINT_MODERATED:
-		case MessageType::Chat::BLUEPRINT_MODEL_READY:
-		case MessageType::Chat::PROPERTY_READY_FOR_APPROVAL:
-		case MessageType::Chat::PROPERTY_MODERATION_CHANGED:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED_REPORT:
-		case MessageType::Chat::MAIL:
-		case MessageType::Chat::WORLD_INSTANCE_LOCATION_REQUEST:
-		case MessageType::Chat::REPUTATION_UPDATE:
-		case MessageType::Chat::SEND_CANNED_TEXT:
-		case MessageType::Chat::CHARACTER_NAME_CHANGE_REQUEST:
-		case MessageType::Chat::CSR_REQUEST:
-		case MessageType::Chat::CSR_REPLY:
-		case MessageType::Chat::GM_KICK:
-		case MessageType::Chat::WORLD_ROUTE_PACKET:
-		case MessageType::Chat::GET_ZONE_POPULATIONS:
-		case MessageType::Chat::REQUEST_MINIMUM_CHAT_MODE:
-		case MessageType::Chat::MATCH_REQUEST:
-		case MessageType::Chat::UGCMANIFEST_REPORT_MISSING_FILE:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_FILE:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
-		case MessageType::Chat::UGCC_REQUEST:
-		case MessageType::Chat::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
-		case MessageType::Chat::ACHIEVEMENT_NOTIFY:
-		case MessageType::Chat::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		case MessageType::Chat::PLAYER_READY:
-		case MessageType::Chat::GET_DONATION_TOTAL:
-		case MessageType::Chat::UPDATE_DONATION:
-		case MessageType::Chat::PRG_CSR_COMMAND:
-		case MessageType::Chat::HEARTBEAT_REQUEST_FROM_WORLD:
-		case MessageType::Chat::UPDATE_FREE_TRIAL_STATUS:
-			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
+		case eChatMessageType::LOGIN_SESSION_NOTIFY:
+		case eChatMessageType::USER_CHANNEL_CHAT_MESSAGE:
+		case eChatMessageType::WORLD_DISCONNECT_REQUEST:
+		case eChatMessageType::WORLD_PROXIMITY_RESPONSE:
+		case eChatMessageType::WORLD_PARCEL_RESPONSE:
+		case eChatMessageType::TEAM_MISSED_INVITE_CHECK:
+		case eChatMessageType::GUILD_CREATE:
+		case eChatMessageType::GUILD_INVITE:
+		case eChatMessageType::GUILD_INVITE_RESPONSE:
+		case eChatMessageType::GUILD_LEAVE:
+		case eChatMessageType::GUILD_KICK:
+		case eChatMessageType::GUILD_GET_STATUS:
+		case eChatMessageType::GUILD_GET_ALL:
+		case eChatMessageType::SHOW_ALL:
+		case eChatMessageType::BLUEPRINT_MODERATED:
+		case eChatMessageType::BLUEPRINT_MODEL_READY:
+		case eChatMessageType::PROPERTY_READY_FOR_APPROVAL:
+		case eChatMessageType::PROPERTY_MODERATION_CHANGED:
+		case eChatMessageType::PROPERTY_BUILDMODE_CHANGED:
+		case eChatMessageType::PROPERTY_BUILDMODE_CHANGED_REPORT:
+		case eChatMessageType::MAIL:
+		case eChatMessageType::WORLD_INSTANCE_LOCATION_REQUEST:
+		case eChatMessageType::REPUTATION_UPDATE:
+		case eChatMessageType::SEND_CANNED_TEXT:
+		case eChatMessageType::CHARACTER_NAME_CHANGE_REQUEST:
+		case eChatMessageType::CSR_REQUEST:
+		case eChatMessageType::CSR_REPLY:
+		case eChatMessageType::GM_KICK:
+		case eChatMessageType::GM_ANNOUNCE:
+		case eChatMessageType::WORLD_ROUTE_PACKET:
+		case eChatMessageType::GET_ZONE_POPULATIONS:
+		case eChatMessageType::REQUEST_MINIMUM_CHAT_MODE:
+		case eChatMessageType::MATCH_REQUEST:
+		case eChatMessageType::UGCMANIFEST_REPORT_MISSING_FILE:
+		case eChatMessageType::UGCMANIFEST_REPORT_DONE_FILE:
+		case eChatMessageType::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
+		case eChatMessageType::UGCC_REQUEST:
+		case eChatMessageType::WHO:
+		case eChatMessageType::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
+		case eChatMessageType::ACHIEVEMENT_NOTIFY:
+		case eChatMessageType::GM_CLOSE_PRIVATE_CHAT_WINDOW:
+		case eChatMessageType::UNEXPECTED_DISCONNECT:
+		case eChatMessageType::PLAYER_READY:
+		case eChatMessageType::GET_DONATION_TOTAL:
+		case eChatMessageType::UPDATE_DONATION:
+		case eChatMessageType::PRG_CSR_COMMAND:
+		case eChatMessageType::HEARTBEAT_REQUEST_FROM_WORLD:
+		case eChatMessageType::UPDATE_FREE_TRIAL_STATUS:
+			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chat_message_type).data(), chat_message_type);
 			break;
 		default:
-			LOG("Unknown CHAT Message id: %i", chatMessageID);
+			LOG("Unknown CHAT Message id: %i", chat_message_type);
+		}
+	}
+
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
+		switch (static_cast<eWorldMessageType>(packet->data[3])) {
+		case eWorldMessageType::ROUTE_PACKET: {
+			LOG("Routing packet from world");
+			break;
+		}
+
+		default:
+			LOG("Unknown World id: %i", int(packet->data[3]));
+		}
 	}
 }
--- a/dChatServer/PlayerContainer.cpp
+++ b/dChatServer/PlayerContainer.cpp
@@ -9,15 +9,22 @@
 #include "BitStreamUtils.h"
 #include "Database.h"
 #include "eConnectionType.h"
+#include "eChatInternalMessageType.h"
+#include "eGameMasterLevel.h"
 #include "ChatPackets.h"
 #include "dConfig.h"
-#include "MessageType/Chat.h"

 void PlayerContainer::Initialize() {
-	m_MaxNumberOfBestFriends =
-		GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_best_friends")).value_or(m_MaxNumberOfBestFriends);
-	m_MaxNumberOfFriends =
-		GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_friends")).value_or(m_MaxNumberOfFriends);
+	GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_best_friends"), m_MaxNumberOfBestFriends);
+	GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_friends"), m_MaxNumberOfFriends);
+}
+
+PlayerContainer::~PlayerContainer() {
+	m_Players.clear();
+}
+
+PlayerData::PlayerData() {
+	gmLevel = eGameMasterLevel::CIVILIAN;
 }

 TeamData::TeamData() {
@@ -36,23 +43,19 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	data.playerID = playerId;

 	uint32_t len;
-	if (!inStream.Read<uint32_t>(len)) return;
+	inStream.Read<uint32_t>(len);

-	if (len > 33) {
-		LOG("Received a really long player name, probably a fake packet %i.", len);
-		return;
+	for (int i = 0; i < len; i++) {
+		char character; inStream.Read<char>(character);
+		data.playerName += character;
 	}

-	data.playerName.resize(len);
-	inStream.ReadAlignedBytes(reinterpret_cast<unsigned char*>(data.playerName.data()), len);
-
-	if (!inStream.Read(data.zoneID)) return;
-	if (!inStream.Read(data.muteExpire)) return;
-	if (!inStream.Read(data.gmLevel)) return;
+	inStream.Read(data.zoneID);
+	inStream.Read(data.muteExpire);
+	inStream.Read(data.gmLevel);
 	data.sysAddr = packet->systemAddress;

 	m_Names[data.playerID] = GeneralUtils::UTF8ToUTF16(data.playerName);
-	m_PlayerCount++;

 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());

@@ -91,7 +94,6 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		}
 	}

-	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);

@@ -125,11 +127,6 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 	size_t membersSize = 0;
 	inStream.Read(membersSize);

-	if (membersSize >= 4) {
-		LOG("Tried to create a team with more than 4 players");
-		return;
-	}
-
 	std::vector<LWOOBJID> members;

 	members.reserve(membersSize);
@@ -148,18 +145,19 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {

 	if (team != nullptr) {
 		team->zoneId = zoneId;
-		UpdateTeamsOnWorld(team, false);
 	}
+
+	UpdateTeamsOnWorld(team, false);
 }

 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_MUTE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);

 	bitStream.Write(player);
 	bitStream.Write(time);

-	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 }

 TeamData* PlayerContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
@@ -361,7 +359,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {

 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::TEAM_GET_STATUS);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);

 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);
@@ -374,7 +372,7 @@ void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 		}
 	}

-	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 }

 std::u16string PlayerContainer::GetName(LWOOBJID playerID) {
@@ -399,7 +397,7 @@ LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
 }

 PlayerData& PlayerContainer::GetPlayerDataMutable(const LWOOBJID& playerID) {
-	return m_Players.contains(playerID) ? m_Players[playerID] : m_Players[LWOOBJID_EMPTY];
+	return m_Players[playerID];
 }

 PlayerData& PlayerContainer::GetPlayerDataMutable(const std::string& playerName) {
--- a/dChatServer/PlayerContainer.h
+++ b/dChatServer/PlayerContainer.h
@@ -10,7 +10,7 @@
 enum class eGameMasterLevel : uint8_t;

 struct IgnoreData {
-	IgnoreData(const std::string& name, const LWOOBJID& id) : playerName{ name }, playerId{ id } {}
+	IgnoreData(const std::string& name, const LWOOBJID& id) : playerName(name), playerId(id) {}
 	inline bool operator==(const std::string& other) const noexcept {
 		return playerName == other;
 	}
@@ -24,6 +24,7 @@ struct IgnoreData {
 };

 struct PlayerData {
+	PlayerData();
 	operator bool() const noexcept {
 		return playerID != LWOOBJID_EMPTY;
 	}
@@ -44,7 +45,7 @@ struct PlayerData {
 	std::string playerName;
 	std::vector<FriendData> friends;
 	std::vector<IgnoreData> ignoredPlayers;
-	eGameMasterLevel gmLevel = static_cast<eGameMasterLevel>(0); // CIVILLIAN
+	eGameMasterLevel gmLevel;
 	bool isFTP = false;
 };

@@ -60,6 +61,8 @@ struct TeamData {

 class PlayerContainer {
 public:
+	~PlayerContainer();
+
 	void Initialize();
 	void InsertPlayer(Packet* packet);
 	void RemovePlayer(Packet* packet);
@@ -71,9 +74,6 @@ public:
 	const PlayerData& GetPlayerData(const std::string& playerName);
 	PlayerData& GetPlayerDataMutable(const LWOOBJID& playerID);
 	PlayerData& GetPlayerDataMutable(const std::string& playerName);
-	uint32_t GetPlayerCount() { return m_PlayerCount; };
-	uint32_t GetSimCount() { return m_SimCount; };
-	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() { return m_Players; };

 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -96,7 +96,5 @@ private:
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
 	uint32_t m_MaxNumberOfBestFriends = 5;
 	uint32_t m_MaxNumberOfFriends = 50;
-	uint32_t m_PlayerCount = 0;
-	uint32_t m_SimCount = 0;
 };

--- a/dCommon/AMFDeserialize.cpp
+++ b/dCommon/AMFDeserialize.cpp
@@ -9,63 +9,83 @@
 * AMF3 Deserializer written by EmosewaMC
 */

-std::unique_ptr<AMFBaseValue> AMFDeserialize::Read(RakNet::BitStream& inStream) {
+AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
+	if (!inStream) return nullptr;
+	AMFBaseValue* returnValue = nullptr;
 	// Read in the value type from the bitStream
 	eAmf marker;
-	inStream.Read(marker);
+	inStream->Read(marker);
 	// Based on the typing, create the value associated with that and return the base value class
 	switch (marker) {
-	case eAmf::Undefined:
-		return std::make_unique<AMFBaseValue>();
-	case eAmf::Null:
-		return std::make_unique<AMFNullValue>();
-	case eAmf::False:
-		return std::make_unique<AMFBoolValue>(false);
-	case eAmf::True:
-		return std::make_unique<AMFBoolValue>(true);
-	case eAmf::Integer:
-		return ReadAmfInteger(inStream);
-	case eAmf::Double:
-		return ReadAmfDouble(inStream);
-	case eAmf::String:
-		return ReadAmfString(inStream);
-	case eAmf::Array:
-		return ReadAmfArray(inStream);
+	case eAmf::Undefined: {
+		returnValue = new AMFBaseValue();
+		break;
+	}
+
+	case eAmf::Null: {
+		returnValue = new AMFNullValue();
+		break;
+	}
+
+	case eAmf::False: {
+		returnValue = new AMFBoolValue(false);
+		break;
+	}
+
+	case eAmf::True: {
+		returnValue = new AMFBoolValue(true);
+		break;
+	}
+
+	case eAmf::Integer: {
+		returnValue = ReadAmfInteger(inStream);
+		break;
+	}
+
+	case eAmf::Double: {
+		returnValue = ReadAmfDouble(inStream);
+		break;
+	}
+
+	case eAmf::String: {
+		returnValue = ReadAmfString(inStream);
+		break;
+	}
+
+	case eAmf::Array: {
+		returnValue = ReadAmfArray(inStream);
+		break;
+	}

 	// These values are unimplemented in the live client and will remain unimplemented
 	// unless someone modifies the client to allow serializing of these values.
 	case eAmf::XMLDoc:
-		[[fallthrough]];
 	case eAmf::Date:
-		[[fallthrough]];
 	case eAmf::Object:
-		[[fallthrough]];
 	case eAmf::XML:
-		[[fallthrough]];
 	case eAmf::ByteArray:
-		[[fallthrough]];
 	case eAmf::VectorInt:
-		[[fallthrough]];
 	case eAmf::VectorUInt:
-		[[fallthrough]];
 	case eAmf::VectorDouble:
-		[[fallthrough]];
 	case eAmf::VectorObject:
-		[[fallthrough]];
-	case eAmf::Dictionary:
+	case eAmf::Dictionary: {
 		throw marker;
+		break;
+	}
 	default:
 		throw std::invalid_argument("Invalid AMF3 marker" + std::to_string(static_cast<int32_t>(marker)));
+		break;
 	}
+	return returnValue;
 }

-uint32_t AMFDeserialize::ReadU29(RakNet::BitStream& inStream) {
+uint32_t AMFDeserialize::ReadU29(RakNet::BitStream* inStream) {
 	bool byteFlag = true;
 	uint32_t actualNumber{};
 	uint8_t numberOfBytesRead{};
 	while (byteFlag && numberOfBytesRead < 4) {
 		uint8_t byte{};
-		inStream.Read(byte);
+		inStream->Read(byte);
 		// Parse the byte
 		if (numberOfBytesRead < 3) {
 			byteFlag = byte & static_cast<uint8_t>(1 << 7);
@@ -81,7 +101,7 @@ uint32_t AMFDeserialize::ReadU29(RakNet::BitStream& inStream) {
 	return actualNumber;
 }

-const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
+const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 	auto length = ReadU29(inStream);
 	// Check if this is a reference
 	bool isReference = length % 2 == 1;
@@ -89,7 +109,7 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
 	length = length >> 1;
 	if (isReference) {
 		std::string value(length, 0);
-		inStream.Read(&value[0], length);
+		inStream->Read(&value[0], length);
 		// Empty strings are never sent by reference
 		if (!value.empty()) accessedElements.push_back(value);
 		return value;
@@ -99,20 +119,20 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
 	}
 }

-std::unique_ptr<AMFDoubleValue> AMFDeserialize::ReadAmfDouble(RakNet::BitStream& inStream) {
+AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
 	double value;
-	inStream.Read<double>(value);
-	return std::make_unique<AMFDoubleValue>(value);
+	inStream->Read<double>(value);
+	return new AMFDoubleValue(value);
 }

-std::unique_ptr<AMFArrayValue> AMFDeserialize::ReadAmfArray(RakNet::BitStream& inStream) {
-	auto arrayValue = std::make_unique<AMFArrayValue>();
+AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
+	auto arrayValue = new AMFArrayValue();

 	// Read size of dense array
-	const auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
+	auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
 	// Then read associative portion
 	while (true) {
-		const auto key = ReadString(inStream);
+		auto key = ReadString(inStream);
 		// No more associative values when we encounter an empty string key
 		if (key.size() == 0) break;
 		arrayValue->Insert(key, Read(inStream));
@@ -124,10 +144,10 @@ std::unique_ptr<AMFArrayValue> AMFDeserialize::ReadAmfArray(RakNet::BitStream& i
 	return arrayValue;
 }

-std::unique_ptr<AMFStringValue> AMFDeserialize::ReadAmfString(RakNet::BitStream& inStream) {
-	return std::make_unique<AMFStringValue>(ReadString(inStream));
+AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
+	return new AMFStringValue(ReadString(inStream));
 }

-std::unique_ptr<AMFIntValue> AMFDeserialize::ReadAmfInteger(RakNet::BitStream& inStream) {
-	return std::make_unique<AMFIntValue>(ReadU29(inStream)); // NOTE: NARROWING CONVERSION FROM UINT TO INT. IS THIS INTENDED?
+AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
+	return new AMFIntValue(ReadU29(inStream));
 }
--- a/dCommon/AMFDeserialize.h
+++ b/dCommon/AMFDeserialize.h
@@ -1,12 +1,12 @@
 #pragma once

-#include "Amf3.h"
 #include "BitStream.h"

-#include <memory>
 #include <vector>
 #include <string>

+class AMFBaseValue;
+
 class AMFDeserialize {
 public:
 	/**
@@ -15,7 +15,7 @@ public:
 	 * @param inStream inStream to read value from.
 	 * @return Returns an AMFValue with all the information from the bitStream in it.
 	 */
-	std::unique_ptr<AMFBaseValue> Read(RakNet::BitStream& inStream);
+	AMFBaseValue* Read(RakNet::BitStream* inStream);
 private:
 	/**
 	 * @brief Private method to read a U29 integer from a bitstream
@@ -23,7 +23,7 @@ private:
 	 * @param inStream bitstream to read data from
 	 * @return The number as an unsigned 29 bit integer
 	 */
-	static uint32_t ReadU29(RakNet::BitStream& inStream);
+	uint32_t ReadU29(RakNet::BitStream* inStream);

 	/**
 	 * @brief Reads a string from a bitstream
@@ -31,7 +31,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return The read string
 	 */
-	const std::string ReadString(RakNet::BitStream& inStream);
+	const std::string ReadString(RakNet::BitStream* inStream);

 	/**
 	 * @brief Read an AMFDouble value from a bitStream
@@ -39,7 +39,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Double value represented as an AMFValue
 	 */
-	static std::unique_ptr<AMFDoubleValue> ReadAmfDouble(RakNet::BitStream& inStream);
+	AMFBaseValue* ReadAmfDouble(RakNet::BitStream* inStream);

 	/**
 	 * @brief Read an AMFArray from a bitStream
@@ -47,7 +47,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Array value represented as an AMFValue
 	 */
-	std::unique_ptr<AMFArrayValue> ReadAmfArray(RakNet::BitStream& inStream);
+	AMFBaseValue* ReadAmfArray(RakNet::BitStream* inStream);

 	/**
 	 * @brief Read an AMFString from a bitStream
@@ -55,7 +55,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return String value represented as an AMFValue
 	 */
-	std::unique_ptr<AMFStringValue> ReadAmfString(RakNet::BitStream& inStream);
+	AMFBaseValue* ReadAmfString(RakNet::BitStream* inStream);

 	/**
 	 * @brief Read an AMFInteger from a bitStream
@@ -63,7 +63,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Integer value represented as an AMFValue
 	 */
-	static std::unique_ptr<AMFIntValue> ReadAmfInteger(RakNet::BitStream& inStream);
+	AMFBaseValue* ReadAmfInteger(RakNet::BitStream* inStream);

 	/**
 	 * List of strings read so far saved to be read by reference.
--- a/dCommon/Amf3.h
+++ b/dCommon/Amf3.h
@@ -31,70 +31,54 @@ enum class eAmf : uint8_t {

 class AMFBaseValue {
 public:
-	[[nodiscard]] constexpr virtual eAmf GetValueType() const noexcept { return eAmf::Undefined; }
-	constexpr AMFBaseValue() noexcept = default;
-	constexpr virtual ~AMFBaseValue() noexcept = default;
+	virtual eAmf GetValueType() { return eAmf::Undefined; };
+	AMFBaseValue() {};
+	virtual ~AMFBaseValue() {};
 };

-// AMFValue template class instantiations
-template <typename ValueType>
+template<typename ValueType>
 class AMFValue : public AMFBaseValue {
 public:
-	AMFValue() = default;
-	AMFValue(const ValueType value) : m_Data{ value } {}
+	AMFValue() {};
+	AMFValue(ValueType value) { SetValue(value); };
+	virtual ~AMFValue() override {};

-	virtual ~AMFValue() override = default;
-
-	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override;
-
-	[[nodiscard]] const ValueType& GetValue() const { return m_Data; }
-
-	void SetValue(const ValueType value) { m_Data = value; }
+	eAmf GetValueType() override { return eAmf::Undefined; };

+	const ValueType& GetValue() { return data; };
+	void SetValue(ValueType value) { data = value; };
 protected:
-	ValueType m_Data;
+	ValueType data;
 };

-// Explicit template class instantiations
-template class AMFValue<std::nullptr_t>;
-template class AMFValue<bool>;
-template class AMFValue<int32_t>;
-template class AMFValue<uint32_t>;
-template class AMFValue<std::string>;
-template class AMFValue<double>;
-
-// AMFValue template class member function instantiations
-template <> [[nodiscard]] constexpr eAmf AMFValue<std::nullptr_t>::GetValueType() const noexcept { return eAmf::Null; }
-template <> [[nodiscard]] constexpr eAmf AMFValue<bool>::GetValueType() const noexcept { return m_Data ? eAmf::True : eAmf::False; }
-template <> [[nodiscard]] constexpr eAmf AMFValue<int32_t>::GetValueType() const noexcept { return eAmf::Integer; }
-template <> [[nodiscard]] constexpr eAmf AMFValue<uint32_t>::GetValueType() const noexcept { return eAmf::Integer; }
-template <> [[nodiscard]] constexpr eAmf AMFValue<std::string>::GetValueType() const noexcept { return eAmf::String; }
-template <> [[nodiscard]] constexpr eAmf AMFValue<double>::GetValueType() const noexcept { return eAmf::Double; }
-
-template <typename ValueType>
-[[nodiscard]] constexpr eAmf AMFValue<ValueType>::GetValueType() const noexcept { return eAmf::Undefined; }
-
 // As a string this is much easier to write and read from a BitStream.
-template <>
+template<>
 class AMFValue<const char*> : public AMFBaseValue {
 public:
-	AMFValue() = default;
-	AMFValue(const char* value) { m_Data = value; }
-	virtual ~AMFValue() override = default;
+	AMFValue() {};
+	AMFValue(const char* value) { SetValue(std::string(value)); };
+	virtual ~AMFValue() override {};

-	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override { return eAmf::String; }
+	eAmf GetValueType() override { return eAmf::String; };

-	[[nodiscard]] const std::string& GetValue() const { return m_Data; }
-	void SetValue(const std::string& value) { m_Data = value; }
+	const std::string& GetValue() { return data; };
+	void SetValue(std::string value) { data = value; };
 protected:
-	std::string m_Data;
+	std::string data;
 };

-using AMFNullValue = AMFValue<std::nullptr_t>;
-using AMFBoolValue = AMFValue<bool>;
-using AMFIntValue = AMFValue<int32_t>;
-using AMFStringValue = AMFValue<std::string>;
-using AMFDoubleValue = AMFValue<double>;
+typedef AMFValue<std::nullptr_t> AMFNullValue;
+typedef AMFValue<bool> AMFBoolValue;
+typedef AMFValue<int32_t> AMFIntValue;
+typedef AMFValue<std::string> AMFStringValue;
+typedef AMFValue<double> AMFDoubleValue;
+
+template<> inline eAmf AMFValue<std::nullptr_t>::GetValueType() { return eAmf::Null; };
+template<> inline eAmf AMFValue<bool>::GetValueType() { return this->data ? eAmf::True : eAmf::False; };
+template<> inline eAmf AMFValue<int32_t>::GetValueType() { return eAmf::Integer; };
+template<> inline eAmf AMFValue<uint32_t>::GetValueType() { return eAmf::Integer; };
+template<> inline eAmf AMFValue<std::string>::GetValueType() { return eAmf::String; };
+template<> inline eAmf AMFValue<double>::GetValueType() { return eAmf::Double; };

 /**
 * The AMFArrayValue object holds 2 types of lists:
@@ -105,23 +89,37 @@ using AMFDoubleValue = AMFValue<double>;
 * and are not to be deleted by a caller.
 */
 class AMFArrayValue : public AMFBaseValue {
-	using AMFAssociative =
-		std::unordered_map<std::string, std::unique_ptr<AMFBaseValue>, GeneralUtils::transparent_string_hash, std::equal_to<>>;

-	using AMFDense = std::vector<std::unique_ptr<AMFBaseValue>>;
+	typedef std::unordered_map<std::string, AMFBaseValue*> AMFAssociative;
+	typedef std::vector<AMFBaseValue*> AMFDense;

 public:
-	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override { return eAmf::Array; }
+	eAmf GetValueType() override { return eAmf::Array; };
+
+	~AMFArrayValue() override {
+		for (auto valueToDelete : GetDense()) {
+			if (valueToDelete) {
+				delete valueToDelete;
+				valueToDelete = nullptr;
+			}
+		}
+		for (auto valueToDelete : GetAssociative()) {
+			if (valueToDelete.second) {
+				delete valueToDelete.second;
+				valueToDelete.second = nullptr;
+			}
+		}
+	};

 	/**
 	 * Returns the Associative portion of the object
 	 */
-	[[nodiscard]] inline const AMFAssociative& GetAssociative() const noexcept { return m_Associative; }
+	inline AMFAssociative& GetAssociative() { return this->associative; };

 	/**
 	 * Returns the dense portion of the object
 	 */
-	[[nodiscard]] inline const AMFDense& GetDense() const noexcept { return m_Dense; }
+	inline AMFDense& GetDense() { return this->dense; };

 	/**
 	 * Inserts an AMFValue into the associative portion with the given key.
@@ -137,48 +135,48 @@ public:
 	 * @return The inserted element if the type matched,
 	 * or nullptr if a key existed and was not the same type
 	 */
-	template <typename ValueType>
-	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const std::string_view key, const ValueType value) {
-		const auto element = m_Associative.find(key);
+	template<typename ValueType>
+	std::pair<AMFValue<ValueType>*, bool> Insert(const std::string& key, ValueType value) {
+		auto element = associative.find(key);
 		AMFValue<ValueType>* val = nullptr;
 		bool found = true;
-		if (element == m_Associative.cend()) {
-			auto newVal = std::make_unique<AMFValue<ValueType>>(value);
-			val = newVal.get();
-			m_Associative.emplace(key, std::move(newVal));
+		if (element == associative.end()) {
+			val = new AMFValue<ValueType>(value);
+			associative.insert(std::make_pair(key, val));
 		} else {
-			val = dynamic_cast<AMFValue<ValueType>*>(element->second.get());
+			val = dynamic_cast<AMFValue<ValueType>*>(element->second);
 			found = false;
 		}
 		return std::make_pair(val, found);
-	}
+	};

 	// Associates an array with a string key
-	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const std::string_view key) {
-		const auto element = m_Associative.find(key);
+	std::pair<AMFBaseValue*, bool> Insert(const std::string& key) {
+		auto element = associative.find(key);
 		AMFArrayValue* val = nullptr;
 		bool found = true;
-		if (element == m_Associative.cend()) {
-			auto newVal = std::make_unique<AMFArrayValue>();
-			val = newVal.get();
-			m_Associative.emplace(key, std::move(newVal));
+		if (element == associative.end()) {
+			val = new AMFArrayValue();
+			associative.insert(std::make_pair(key, val));
 		} else {
-			val = dynamic_cast<AMFArrayValue*>(element->second.get());
+			val = dynamic_cast<AMFArrayValue*>(element->second);
 			found = false;
 		}
 		return std::make_pair(val, found);
-	}
+	};

 	// Associates an array with an integer key
-	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const size_t index) {
+	std::pair<AMFBaseValue*, bool> Insert(const uint32_t& index) {
+		AMFArrayValue* val = nullptr;
 		bool inserted = false;
-		if (index >= m_Dense.size()) {
-			m_Dense.resize(index + 1);
-			m_Dense.at(index) = std::make_unique<AMFArrayValue>();
+		if (index >= dense.size()) {
+			dense.resize(index + 1);
+			val = new AMFArrayValue();
+			dense.at(index) = val;
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFArrayValue*>(m_Dense.at(index).get()), inserted);
-	}
+		return std::make_pair(dynamic_cast<AMFArrayValue*>(dense.at(index)), inserted);
+	};

 	/**
 	 * @brief Inserts an AMFValue into the AMFArray key'd by index.
@@ -190,16 +188,18 @@ public:
 	 * @return The inserted element, or nullptr if the type did not match
 	 * what was at the index.
 	 */
-	template <typename ValueType>
-	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const size_t index, const ValueType value) {
+	template<typename ValueType>
+	std::pair<AMFValue<ValueType>*, bool> Insert(const uint32_t& index, ValueType value) {
+		AMFValue<ValueType>* val = nullptr;
 		bool inserted = false;
-		if (index >= m_Dense.size()) {
-			m_Dense.resize(index + 1);
-			m_Dense.at(index) = std::make_unique<AMFValue<ValueType>>(value);
+		if (index >= this->dense.size()) {
+			this->dense.resize(index + 1);
+			val = new AMFValue<ValueType>(value);
+			this->dense.at(index) = val;
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(m_Dense.at(index).get()), inserted);
-	}
+		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(this->dense.at(index)), inserted);
+	};

 	/**
 	 * Inserts an AMFValue into the associative portion with the given key.
@@ -210,14 +210,15 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const std::string_view key, std::unique_ptr<AMFBaseValue> value) {
-		const auto element = m_Associative.find(key);
-		if (element != m_Associative.cend() && element->second) {
-			element->second = std::move(value);
+	void Insert(const std::string& key, AMFBaseValue* value) {
+		auto element = associative.find(key);
+		if (element != associative.end() && element->second) {
+			delete element->second;
+			element->second = value;
 		} else {
-			m_Associative.emplace(key, std::move(value));
+			associative.insert(std::make_pair(key, value));
 		}
-	}
+	};

 	/**
 	 * Inserts an AMFValue into the associative portion with the given index.
@@ -228,12 +229,15 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const size_t index, std::unique_ptr<AMFBaseValue> value) {
-		if (index >= m_Dense.size()) {
-			m_Dense.resize(index + 1);
+	void Insert(const uint32_t index, AMFBaseValue* value) {
+		if (index < dense.size()) {
+			AMFDense::iterator itr = dense.begin() + index;
+			if (*itr) delete dense.at(index);
+		} else {
+			dense.resize(index + 1);
 		}
-		m_Dense.at(index) = std::move(value);
-	}
+		dense.at(index) = value;
+	};

 	/**
 	 * Pushes an AMFValue into the back of the dense portion.
@@ -245,10 +249,10 @@ public:
 	 *
 	 * @return The inserted pointer, or nullptr should the key already be in use.
 	 */
-	template <typename ValueType>
-	[[maybe_unused]] inline AMFValue<ValueType>* Push(const ValueType value) {
-		return Insert(m_Dense.size(), value).first;
-	}
+	template<typename ValueType>
+	inline AMFValue<ValueType>* Push(ValueType value) {
+		return Insert(this->dense.size(), value).first;
+	};

 	/**
 	 * Removes the key from the associative portion
@@ -257,47 +261,52 @@ public:
 	 *
 	 * @param key The key to remove from the associative portion
 	 */
-	void Remove(const std::string& key, const bool deleteValue = true) {
-		const AMFAssociative::const_iterator it = m_Associative.find(key);
-		if (it != m_Associative.cend()) {
-			if (deleteValue) m_Associative.erase(it);
+	void Remove(const std::string& key, bool deleteValue = true) {
+		AMFAssociative::iterator it = this->associative.find(key);
+		if (it != this->associative.end()) {
+			if (deleteValue) delete it->second;
+			this->associative.erase(it);
 		}
 	}

 	/**
 	 * Pops the last element in the dense portion, deleting it in the process.
 	 */
-	void Remove(const size_t index) {
-		if (!m_Dense.empty() && index < m_Dense.size()) {
-			const auto itr = m_Dense.cbegin() + index;
-			m_Dense.erase(itr);
+	void Remove(const uint32_t index) {
+		if (!this->dense.empty() && index < this->dense.size()) {
+			auto itr = this->dense.begin() + index;
+			if (*itr) delete (*itr);
+			this->dense.erase(itr);
 		}
 	}

 	void Pop() {
-		if (!m_Dense.empty()) Remove(m_Dense.size() - 1);
+		if (!this->dense.empty()) Remove(this->dense.size() - 1);
 	}

-	[[nodiscard]] AMFArrayValue* GetArray(const std::string_view key) const {
-		const AMFAssociative::const_iterator it = m_Associative.find(key);
-		return it != m_Associative.cend() ? dynamic_cast<AMFArrayValue*>(it->second.get()) : nullptr;
-	}
+	AMFArrayValue* GetArray(const std::string& key) {
+		AMFAssociative::const_iterator it = this->associative.find(key);
+		if (it != this->associative.end()) {
+			return dynamic_cast<AMFArrayValue*>(it->second);
+		}
+		return nullptr;
+	};

-	[[nodiscard]] AMFArrayValue* GetArray(const size_t index) const {
-		return index < m_Dense.size() ? dynamic_cast<AMFArrayValue*>(m_Dense.at(index).get()) : nullptr;
-	}
+	AMFArrayValue* GetArray(const uint32_t index) {
+		return index >= this->dense.size() ? nullptr : dynamic_cast<AMFArrayValue*>(this->dense.at(index));
+	};

-	[[maybe_unused]] inline AMFArrayValue* InsertArray(const std::string_view key) {
+	inline AMFArrayValue* InsertArray(const std::string& key) {
 		return static_cast<AMFArrayValue*>(Insert(key).first);
-	}
+	};

-	[[maybe_unused]] inline AMFArrayValue* InsertArray(const size_t index) {
+	inline AMFArrayValue* InsertArray(const uint32_t index) {
 		return static_cast<AMFArrayValue*>(Insert(index).first);
-	}
+	};

-	[[maybe_unused]] inline AMFArrayValue* PushArray() {
-		return static_cast<AMFArrayValue*>(Insert(m_Dense.size()).first);
-	}
+	inline AMFArrayValue* PushArray() {
+		return static_cast<AMFArrayValue*>(Insert(this->dense.size()).first);
+	};

 	/**
 	 * Gets an AMFValue by the key from the associative portion and converts it
@@ -309,18 +318,18 @@ public:
 	 * @return The AMFValue
 	 */
 	template <typename AmfType>
-	[[nodiscard]] AMFValue<AmfType>* Get(const std::string_view key) const {
-		const AMFAssociative::const_iterator it = m_Associative.find(key);
-		return it != m_Associative.cend() ?
-			dynamic_cast<AMFValue<AmfType>*>(it->second.get()) :
+	AMFValue<AmfType>* Get(const std::string& key) const {
+		AMFAssociative::const_iterator it = this->associative.find(key);
+		return it != this->associative.end() ?
+			dynamic_cast<AMFValue<AmfType>*>(it->second) :
 			nullptr;
-	}
+	};

 	// Get from the array but dont cast it
-	[[nodiscard]] AMFBaseValue* Get(const std::string_view key) const {
-		const AMFAssociative::const_iterator it = m_Associative.find(key);
-		return it != m_Associative.cend() ? it->second.get() : nullptr;
-	}
+	AMFBaseValue* Get(const std::string& key) const {
+		AMFAssociative::const_iterator it = this->associative.find(key);
+		return it != this->associative.end() ? it->second : nullptr;
+	};

 	/**
 	 * @brief Get an AMFValue object at a position in the dense portion.
@@ -332,28 +341,27 @@ public:
 	 * @return The casted object, or nullptr.
 	 */
 	template <typename AmfType>
-	[[nodiscard]] AMFValue<AmfType>* Get(const size_t index) const {
-		return index < m_Dense.size() ?
-			dynamic_cast<AMFValue<AmfType>*>(m_Dense.at(index).get()) :
+	AMFValue<AmfType>* Get(uint32_t index) const {
+		return index < this->dense.size() ?
+			dynamic_cast<AMFValue<AmfType>*>(this->dense.at(index)) :
 			nullptr;
-	}
+	};

 	// Get from the dense but dont cast it
-	[[nodiscard]] AMFBaseValue* Get(const size_t index) const {
-		return index < m_Dense.size() ? m_Dense.at(index).get() : nullptr;
-	}
-
+	AMFBaseValue* Get(const uint32_t index) const {
+		return index < this->dense.size() ? this->dense.at(index) : nullptr;
+	};
 private:
 	/**
 	 * The associative portion.  These values are key'd with strings to an AMFValue.
 	 */
-	AMFAssociative m_Associative;
+	AMFAssociative associative;

 	/**
 	 * The dense portion.  These AMFValue's are stored one after
 	 * another with the most recent addition being at the back.
 	 */
-	AMFDense m_Dense;
+	AMFDense dense;
 };

 #endif  //!__AMF3__H__
--- a/dCommon/AmfSerialize.cpp
+++ b/dCommon/AmfSerialize.cpp
@@ -53,7 +53,7 @@ void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value) {
 * A private function to write an value to a RakNet::BitStream
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteUInt29(RakNet::BitStream& bs, uint32_t v) {
+void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
 	unsigned char b4 = static_cast<unsigned char>(v);
 	if (v < 0x00200000) {
 		b4 = b4 & 0x7F;
@@ -65,10 +65,10 @@ void WriteUInt29(RakNet::BitStream& bs, uint32_t v) {
 				unsigned char b2;
 				v = v >> 7;
 				b2 = static_cast<unsigned char>(v) | 0x80;
-				bs.Write(b2);
+				bs->Write(b2);
 			}

-			bs.Write(b3);
+			bs->Write(b3);
 		}
 	} else {
 		unsigned char b1;
@@ -82,19 +82,19 @@ void WriteUInt29(RakNet::BitStream& bs, uint32_t v) {
 		v = v >> 7;
 		b1 = static_cast<unsigned char>(v) | 0x80;

-		bs.Write(b1);
-		bs.Write(b2);
-		bs.Write(b3);
+		bs->Write(b1);
+		bs->Write(b2);
+		bs->Write(b3);
 	}

-	bs.Write(b4);
+	bs->Write(b4);
 }

 /**
 * Writes a flag number to a RakNet::BitStream
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteFlagNumber(RakNet::BitStream& bs, uint32_t v) {
+void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
 	v = (v << 1) | 0x01;
 	WriteUInt29(bs, v);
 }
@@ -104,9 +104,9 @@ void WriteFlagNumber(RakNet::BitStream& bs, uint32_t v) {
 *
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteAMFString(RakNet::BitStream& bs, const std::string& str) {
+void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
 	WriteFlagNumber(bs, static_cast<uint32_t>(str.size()));
-	bs.Write(str.c_str(), static_cast<uint32_t>(str.size()));
+	bs->Write(str.c_str(), static_cast<uint32_t>(str.size()));
 }

 /**
@@ -114,8 +114,8 @@ void WriteAMFString(RakNet::BitStream& bs, const std::string& str) {
 *
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteAMFU16(RakNet::BitStream& bs, uint16_t value) {
-	bs.Write(value);
+void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
+	bs->Write(value);
 }

 /**
@@ -123,8 +123,8 @@ void WriteAMFU16(RakNet::BitStream& bs, uint16_t value) {
 *
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteAMFU32(RakNet::BitStream& bs, uint32_t value) {
-	bs.Write(value);
+void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
+	bs->Write(value);
 }

 /**
@@ -132,40 +132,40 @@ void WriteAMFU32(RakNet::BitStream& bs, uint32_t value) {
 *
 * RakNet writes in the correct byte order - do not reverse this.
 */
-void WriteAMFU64(RakNet::BitStream& bs, uint64_t value) {
-	bs.Write(value);
+void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
+	bs->Write(value);
 }

 // Writes an AMFIntegerValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value) {
-	WriteUInt29(*this, value.GetValue());
+	WriteUInt29(this, value.GetValue());
 }

 // Writes an AMFDoubleValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value) {
 	double d = value.GetValue();
-	WriteAMFU64(*this, *reinterpret_cast<uint64_t*>(&d));
+	WriteAMFU64(this, *reinterpret_cast<uint64_t*>(&d));
 }

 // Writes an AMFStringValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value) {
-	WriteAMFString(*this, value.GetValue());
+	WriteAMFString(this, value.GetValue());
 }

 // Writes an AMFArrayValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value) {
 	uint32_t denseSize = value.GetDense().size();
-	WriteFlagNumber(*this, denseSize);
+	WriteFlagNumber(this, denseSize);

 	auto it = value.GetAssociative().begin();
 	auto end = value.GetAssociative().end();

 	while (it != end) {
-		WriteAMFString(*this, it->first);
+		WriteAMFString(this, it->first);
 		this->Write<AMFBaseValue&>(*it->second);
 		it++;
 	}
--- a/dCommon/CMakeLists.txt
+++ b/dCommon/CMakeLists.txt
@@ -8,9 +8,11 @@ set(DCOMMON_SOURCES
 		"Game.cpp"
 		"GeneralUtils.cpp"
 		"LDFFormat.cpp"
+		"MD5.cpp"
 		"Metrics.cpp"
 		"NiPoint3.cpp"
 		"NiQuaternion.cpp"
+		"SHA512.cpp"
 		"Demangler.cpp"
 		"ZCompression.cpp"
 		"BrickByBrickFix.cpp"
@@ -30,29 +32,22 @@ foreach(file ${DCOMMON_DCLIENT_SOURCES})
 	set(DCOMMON_SOURCES ${DCOMMON_SOURCES} "dClient/${file}")
 endforeach()

+include_directories(${PROJECT_SOURCE_DIR}/dCommon/)
+
 add_library(dCommon STATIC ${DCOMMON_SOURCES})
-target_include_directories(dCommon
-	PUBLIC "." "dClient" "dEnums"
-	PRIVATE
-	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
-	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
-	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
-	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
-)
+
+target_link_libraries(dCommon bcrypt dDatabase tinyxml2)

 if (UNIX)
 	find_package(ZLIB REQUIRED)
 elseif (WIN32)
 	include(FetchContent)

-    set(WITH_GTEST OFF CACHE BOOL "" FORCE)
-    set(ZLIB_ENABLE_TESTS OFF CACHE BOOL "" FORCE)
-
 	# TODO Keep an eye on the zlib repository for an update to disable testing.  Don't forget to update CMakePresets
 	FetchContent_Declare(
 		zlib
-		URL https://github.com/zlib-ng/zlib-ng/archive/refs/tags/2.2.2.zip
-		URL_HASH MD5=2cf9199fb785ea579a2a9905a75c38b3
+		URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
+		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
 	)

 	# Disable warning about no project version.
@@ -63,6 +58,7 @@ elseif (WIN32)
 	FetchContent_MakeAvailable(zlib)

 	set(ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
+	set_target_properties(zlib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIRS}")
 	add_library(ZLIB::ZLIB ALIAS zlib)
 else ()
 	message(
@@ -71,6 +67,9 @@ else ()
 	)
 endif ()

-target_link_libraries(dCommon
-	PRIVATE ZLIB::ZLIB bcrypt tinyxml2
-	INTERFACE dDatabase)
+target_link_libraries(dCommon ZLIB::ZLIB)
+
+# Disable deprecation warnings on MD5.cpp and SHA512.cpp for Apple Clang
+if (APPLE)
+	set_source_files_properties("MD5.cpp" "SHA512.cpp" PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations")
+endif()
--- a/dCommon/Diagnostics.cpp
+++ b/dCommon/Diagnostics.cpp
@@ -120,8 +120,6 @@ void CatchUnhandled(int sig) {
 		if (eptr) std::rethrow_exception(eptr);
 	} catch(const std::exception& e) {
 		LOG("Caught exception: '%s'", e.what());
-	} catch (...) {
-		LOG("Caught unknown exception.");
 	}

 #ifndef INCLUDE_BACKTRACE
@@ -201,7 +199,7 @@ void OnTerminate() {
 }

 void MakeBacktrace() {
-	struct sigaction sigact{};
+	struct sigaction sigact;

 	sigact.sa_sigaction = CritErrHdlr;
 	sigact.sa_flags = SA_RESTART | SA_SIGINFO;
--- a/dCommon/GeneralUtils.cpp
+++ b/dCommon/GeneralUtils.cpp
@@ -8,23 +8,23 @@
 #include <map>

 template <typename T>
-static inline size_t MinSize(const size_t size, const std::basic_string_view<T> string) {
-	if (size == SIZE_MAX || size > string.size()) {
+inline size_t MinSize(size_t size, const std::basic_string_view<T>& string) {
+	if (size == size_t(-1) || size > string.size()) {
 		return string.size();
 	} else {
 		return size;
 	}
 }

-inline bool IsLeadSurrogate(const char16_t c) {
+inline bool IsLeadSurrogate(char16_t c) {
 	return (0xD800 <= c) && (c <= 0xDBFF);
 }

-inline bool IsTrailSurrogate(const char16_t c) {
+inline bool IsTrailSurrogate(char16_t c) {
 	return (0xDC00 <= c) && (c <= 0xDFFF);
 }

-inline void PushUTF8CodePoint(std::string& ret, const char32_t cp) {
+inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
 	if (cp <= 0x007F) {
 		ret.push_back(static_cast<uint8_t>(cp));
 	} else if (cp <= 0x07FF) {
@@ -46,16 +46,16 @@ inline void PushUTF8CodePoint(std::string& ret, const char32_t cp) {

 constexpr const char16_t REPLACEMENT_CHARACTER = 0xFFFD;

-bool static _IsSuffixChar(const uint8_t c) {
+bool _IsSuffixChar(uint8_t c) {
 	return (c & 0xC0) == 0x80;
 }

-bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
-	const size_t rem = slice.length();
+bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
+	size_t rem = slice.length();
 	if (slice.empty()) return false;
 	const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&slice.front());
 	if (rem > 0) {
-		const uint8_t first = bytes[0];
+		uint8_t first = bytes[0];
 		if (first < 0x80) { // 1 byte character
 			out = static_cast<uint32_t>(first & 0x7F);
 			slice.remove_prefix(1);
@@ -64,7 +64,7 @@ bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out
 			// middle byte, not valid at start, fall through
 		} else if (first < 0xE0) { // two byte character
 			if (rem > 1) {
-				const uint8_t second = bytes[1];
+				uint8_t second = bytes[1];
 				if (_IsSuffixChar(second)) {
 					out = (static_cast<uint32_t>(first & 0x1F) << 6)
 						+ static_cast<uint32_t>(second & 0x3F);
@@ -74,8 +74,8 @@ bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out
 			}
 		} else if (first < 0xF0) { // three byte character
 			if (rem > 2) {
-				const uint8_t second = bytes[1];
-				const uint8_t third = bytes[2];
+				uint8_t second = bytes[1];
+				uint8_t third = bytes[2];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third)) {
 					out = (static_cast<uint32_t>(first & 0x0F) << 12)
 						+ (static_cast<uint32_t>(second & 0x3F) << 6)
@@ -86,9 +86,9 @@ bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out
 			}
 		} else if (first < 0xF8) { // four byte character
 			if (rem > 3) {
-				const uint8_t second = bytes[1];
-				const uint8_t third = bytes[2];
-				const uint8_t fourth = bytes[3];
+				uint8_t second = bytes[1];
+				uint8_t third = bytes[2];
+				uint8_t fourth = bytes[3];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third) && _IsSuffixChar(fourth)) {
 					out = (static_cast<uint32_t>(first & 0x07) << 18)
 						+ (static_cast<uint32_t>(second & 0x3F) << 12)
@@ -107,7 +107,7 @@ bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out
 }

 /// See <https://www.ietf.org/rfc/rfc2781.html#section-2.1>
-bool PushUTF16CodePoint(std::u16string& output, const uint32_t U, const size_t size) {
+bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
 	if (output.length() >= size) return false;
 	if (U < 0x10000) {
 		// If U < 0x10000, encode U as a 16-bit unsigned integer and terminate.
@@ -120,7 +120,7 @@ bool PushUTF16CodePoint(std::u16string& output, const uint32_t U, const size_t s
 		// Let U' = U - 0x10000. Because U is less than or equal to 0x10FFFF,
 		// U' must be less than or equal to 0xFFFFF. That is, U' can be
 		// represented in 20 bits.
-		const uint32_t Ut = U - 0x10000;
+		uint32_t Ut = U - 0x10000;

 		// Initialize two 16-bit unsigned integers, W1 and W2, to 0xD800 and
 		// 0xDC00, respectively. These integers each have 10 bits free to
@@ -141,25 +141,25 @@ bool PushUTF16CodePoint(std::u16string& output, const uint32_t U, const size_t s
 	} else return false;
 }

-std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view string, const size_t size) {
-	const size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view& string, size_t size) {
+	size_t newSize = MinSize(size, string);
 	std::u16string output;
 	output.reserve(newSize);
 	std::string_view iterator = string;

 	uint32_t c;
-	while (details::_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
+	while (_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
 	return output;
 }

 //! Converts an std::string (ASCII) to UCS-2 / UTF-16
-std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view string, const size_t size) {
-	const size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view& string, size_t size) {
+	size_t newSize = MinSize(size, string);
 	std::u16string ret;
 	ret.reserve(newSize);

-	for (size_t i = 0; i < newSize; ++i) {
-		const char c = string[i];
+	for (size_t i = 0; i < newSize; i++) {
+		char c = string[i];
 		// Note: both 7-bit ascii characters and REPLACEMENT_CHARACTER fit in one char16_t
 		ret.push_back((c > 0 && c <= 127) ? static_cast<char16_t>(c) : REPLACEMENT_CHARACTER);
 	}
@@ -169,18 +169,18 @@ std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view string, const s

 //! Converts a (potentially-ill-formed) UTF-16 string to UTF-8
 //! See: <http://simonsapin.github.io/wtf-8/#decoding-ill-formed-utf-16>
-std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const size_t size) {
-	const size_t newSize = MinSize(size, string);
+std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view& string, size_t size) {
+	size_t newSize = MinSize(size, string);
 	std::string ret;
 	ret.reserve(newSize);

-	for (size_t i = 0; i < newSize; ++i) {
-		const char16_t u = string[i];
+	for (size_t i = 0; i < newSize; i++) {
+		char16_t u = string[i];
 		if (IsLeadSurrogate(u) && (i + 1) < newSize) {
-			const char16_t next = string[i + 1];
+			char16_t next = string[i + 1];
 			if (IsTrailSurrogate(next)) {
 				i += 1;
-				const char32_t cp = 0x10000
+				char32_t cp = 0x10000
 					+ ((static_cast<char32_t>(u) - 0xD800) << 10)
 					+ (static_cast<char32_t>(next) - 0xDC00);
 				PushUTF8CodePoint(ret, cp);
@@ -195,40 +195,40 @@ std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const si
 	return ret;
 }

-bool GeneralUtils::CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b) {
+bool GeneralUtils::CaseInsensitiveStringCompare(const std::string& a, const std::string& b) {
 	return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char a, char b) { return tolower(a) == tolower(b); });
 }

 // MARK: Bits

 //! Sets a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::SetBit(int64_t value, const uint32_t index) {
+int64_t GeneralUtils::SetBit(int64_t value, uint32_t index) {
 	return value |= 1ULL << index;
 }

 //! Clears a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::ClearBit(int64_t value, const uint32_t index) {
+int64_t GeneralUtils::ClearBit(int64_t value, uint32_t index) {
 	return value &= ~(1ULL << index);
 }

 //! Checks a specific bit in a signed 64-bit integer
-bool GeneralUtils::CheckBit(int64_t value, const uint32_t index) {
+bool GeneralUtils::CheckBit(int64_t value, uint32_t index) {
 	return value & (1ULL << index);
 }

-bool GeneralUtils::ReplaceInString(std::string& str, const std::string_view from, const std::string_view to) {
-	const size_t start_pos = str.find(from);
+bool GeneralUtils::ReplaceInString(std::string& str, const std::string& from, const std::string& to) {
+	size_t start_pos = str.find(from);
 	if (start_pos == std::string::npos)
 		return false;
 	str.replace(start_pos, from.length(), to);
 	return true;
 }

-std::vector<std::wstring> GeneralUtils::SplitString(const std::wstring_view str, const wchar_t delimiter) {
+std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t delimiter) {
 	std::vector<std::wstring> vector = std::vector<std::wstring>();
 	std::wstring current;

-	for (const wchar_t c : str) {
+	for (const auto& c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = L"";
@@ -237,15 +237,15 @@ std::vector<std::wstring> GeneralUtils::SplitString(const std::wstring_view str,
 		}
 	}

-	vector.push_back(std::move(current));
+	vector.push_back(current);
 	return vector;
 }

-std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string_view str, const char16_t delimiter) {
+std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str, char16_t delimiter) {
 	std::vector<std::u16string> vector = std::vector<std::u16string>();
 	std::u16string current;

-	for (const char16_t c : str) {
+	for (const auto& c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = u"";
@@ -254,15 +254,17 @@ std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string_view
 		}
 	}

-	vector.push_back(std::move(current));
+	vector.push_back(current);
 	return vector;
 }

-std::vector<std::string> GeneralUtils::SplitString(const std::string_view str, const char delimiter) {
+std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char delimiter) {
 	std::vector<std::string> vector = std::vector<std::string>();
 	std::string current = "";

-	for (const char c : str) {
+	for (size_t i = 0; i < str.length(); i++) {
+		char c = str[i];
+
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = "";
@@ -271,70 +273,53 @@ std::vector<std::string> GeneralUtils::SplitString(const std::string_view str, c
 		}
 	}

-	vector.push_back(std::move(current));
+	vector.push_back(current);
+
 	return vector;
 }

-std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
+std::u16string GeneralUtils::ReadWString(RakNet::BitStream* inStream) {
 	uint32_t length;
-	inStream.Read<uint32_t>(length);
+	inStream->Read<uint32_t>(length);

 	std::u16string string;
-	for (uint32_t i = 0; i < length; ++i) {
+	for (auto i = 0; i < length; i++) {
 		uint16_t c;
-		inStream.Read(c);
+		inStream->Read(c);
 		string.push_back(c);
 	}

 	return string;
 }

-std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string_view folder) {
+std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string& folder) {
 	// Because we dont know how large the initial number before the first _ is we need to make it a map like so.
    std::map<uint32_t, std::string> filenames{};
-	for (const auto& t : std::filesystem::directory_iterator(folder)) {
+	for (auto& t : std::filesystem::directory_iterator(folder)) {
        auto filename = t.path().filename().string();
-        const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
-        filenames.emplace(index, std::move(filename));
+        auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
+        filenames.insert(std::make_pair(index, filename));
 	}

 	// Now sort the map by the oldest migration.
 	std::vector<std::string> sortedFiles{};
-	auto fileIterator = filenames.cbegin();
-	auto oldest = filenames.cbegin();
-	while (!filenames.empty()) {
-		if (fileIterator == filenames.cend()) {
-			sortedFiles.push_back(oldest->second);
-			filenames.erase(oldest);
-			fileIterator = filenames.cbegin();
-			oldest = filenames.cbegin();
-			continue;
+    auto fileIterator = filenames.begin();
+    std::map<uint32_t, std::string>::iterator oldest = filenames.begin();
+    while (!filenames.empty()) {
+		if (fileIterator == filenames.end()) {
+            sortedFiles.push_back(oldest->second);
+            filenames.erase(oldest);
+            fileIterator = filenames.begin();
+            oldest = filenames.begin();
+            continue;
 		}
-		if (oldest->first > fileIterator->first) oldest = fileIterator;
-		++fileIterator;
+        if (oldest->first > fileIterator->first) oldest = fileIterator;
+        fileIterator++;
 	}

 	return sortedFiles;
 }

-#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
-
-// MacOS floating-point parse function specializations
-namespace GeneralUtils::details {
-	template <>
-	[[nodiscard]] float _parse<float>(const std::string_view str, size_t& parseNum) {
-		return std::stof(std::string{ str }, &parseNum);
-	}
-
-	template <>
-	[[nodiscard]] double _parse<double>(const std::string_view str, size_t& parseNum) {
-		return std::stod(std::string{ str }, &parseNum);
-	}
-
-	template <>
-	[[nodiscard]] long double _parse<long double>(const std::string_view str, size_t& parseNum) {
-		return std::stold(std::string{ str }, &parseNum);
-	}
+bool GeneralUtils::TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst) {
+	return TryParse<float>(x.c_str(), dst.x) && TryParse<float>(y.c_str(), dst.y) && TryParse<float>(z.c_str(), dst.z);
 }
-
-#endif
--- a/dCommon/GeneralUtils.h
+++ b/dCommon/GeneralUtils.h
@@ -1,21 +1,17 @@
 #pragma once

 // C++
-#include <charconv>
-#include <cstdint>
-#include <ctime>
-#include <functional>
-#include <optional>
+#include <stdint.h>
 #include <random>
-#include <span>
-#include <stdexcept>
+#include <time.h>
 #include <string>
-#include <string_view>
 #include <type_traits>
-
+#include <functional>
+#include <type_traits>
+#include <stdexcept>
 #include "BitStream.h"
 #include "NiPoint3.h"
-#include "dPlatforms.h"
+
 #include "Game.h"
 #include "Logger.h"

@@ -33,31 +29,29 @@ namespace GeneralUtils {
 	//! Converts a plain ASCII string to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
+	  \param size A size to trim the string to. Default is -1 (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string ASCIIToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
+	std::u16string ASCIIToUTF16(const std::string_view& string, size_t size = -1);

 	//! Converts a UTF-8 String to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
+	  \param size A size to trim the string to. Default is -1 (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string UTF8ToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
+	std::u16string UTF8ToUTF16(const std::string_view& string, size_t size = -1);

-	namespace details {
-		//! Internal, do not use
-		bool _NextUTF8Char(std::string_view& slice, uint32_t& out);
-	}
+	//! Internal, do not use
+	bool _NextUTF8Char(std::string_view& slice, uint32_t& out);

 	//! Converts a UTF-16 string to a UTF-8 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
+	  \param size A size to trim the string to. Default is -1 (No trimming)
 	  \return An UTF-8 representation of the string
 	 */
-	std::string UTF16ToWTF8(const std::u16string_view string, const size_t size = SIZE_MAX);
+	std::string UTF16ToWTF8(const std::u16string_view& string, size_t size = -1);

 	/**
 	 * Compares two basic strings but does so ignoring case sensitivity
@@ -65,7 +59,7 @@ namespace GeneralUtils {
 	 * \param b the second string to compare against the first string
 	 * @return if the two strings are equal
 	 */
-	bool CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b);
+	bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b);

 	// MARK: Bits

@@ -73,9 +67,9 @@ namespace GeneralUtils {

 	//! Sets a bit on a numerical value
 	template <typename T>
-	inline void SetBit(T& value, const eObjectBits bits) {
+	inline void SetBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		const auto index = static_cast<size_t>(bits);
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -85,9 +79,9 @@ namespace GeneralUtils {

 	//! Clears a bit on a numerical value
 	template <typename T>
-	inline void ClearBit(T& value, const eObjectBits bits) {
+	inline void ClearBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		const auto index = static_cast<size_t>(bits);
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -100,14 +94,14 @@ namespace GeneralUtils {
 	  \param value The value to set the bit for
 	  \param index The index of the bit
 	 */
-	int64_t SetBit(int64_t value, const uint32_t index);
+	int64_t SetBit(int64_t value, uint32_t index);

 	//! Clears a specific bit in a signed 64-bit integer
 	/*!
 	  \param value The value to clear the bit from
 	  \param index The index of the bit
 	 */
-	int64_t ClearBit(int64_t value, const uint32_t index);
+	int64_t ClearBit(int64_t value, uint32_t index);

 	//! Checks a specific bit in a signed 64-bit integer
 	/*!
@@ -115,151 +109,104 @@ namespace GeneralUtils {
 	  \param index The index of the bit
 	  \return Whether or not the bit is set
 	 */
-	bool CheckBit(int64_t value, const uint32_t index);
+	bool CheckBit(int64_t value, uint32_t index);

-	bool ReplaceInString(std::string& str, const std::string_view from, const std::string_view to);
+	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);

-	std::u16string ReadWString(RakNet::BitStream& inStream);
+	std::u16string ReadWString(RakNet::BitStream* inStream);

-	std::vector<std::wstring> SplitString(const std::wstring_view str, const wchar_t delimiter);
+	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);

-	std::vector<std::u16string> SplitString(const std::u16string_view str, const char16_t delimiter);
+	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);

-	std::vector<std::string> SplitString(const std::string_view str, const char delimiter);
+	std::vector<std::string> SplitString(const std::string& str, char delimiter);

-	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string_view folder);
+	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string& folder);

-	/**
-	 * Transparent string hasher - used to allow string_view key lookups for maps storing std::string keys
-	 * https://www.reddit.com/r/cpp_questions/comments/12xw3sn/find_stdstring_view_in_unordered_map_with/jhki225/
-	 * https://godbolt.org/z/789xv8Eeq
-	*/
-	template <typename... Bases>
-	struct overload : Bases... {
-		using is_transparent = void;
-		using Bases::operator() ... ;
-	};
+	template <typename T>
+	T Parse(const char* value);

-	struct char_pointer_hash {
-		auto operator()(const char* const ptr) const noexcept {
-			return std::hash<std::string_view>{}(ptr);
+	template <>
+	inline bool Parse(const char* value) {
+		return std::stoi(value);
+	}
+
+	template <>
+	inline int32_t Parse(const char* value) {
+		return std::stoi(value);
+	}
+
+	template <>
+	inline int64_t Parse(const char* value) {
+		return std::stoll(value);
+	}
+
+	template <>
+	inline float Parse(const char* value) {
+		return std::stof(value);
+	}
+
+	template <>
+	inline double Parse(const char* value) {
+		return std::stod(value);
+	}
+
+	template <>
+	inline uint16_t Parse(const char* value) {
+		return std::stoul(value);
+	}
+
+	template <>
+	inline uint32_t Parse(const char* value) {
+		return std::stoul(value);
+	}
+
+	template <>
+	inline uint64_t Parse(const char* value) {
+		return std::stoull(value);
+	}
+
+	template <>
+	inline eInventoryType Parse(const char* value) {
+		return static_cast<eInventoryType>(std::stoul(value));
+	}
+
+	template <>
+	inline eReplicaComponentType Parse(const char* value) {
+		return static_cast<eReplicaComponentType>(std::stoul(value));
+	}
+
+	template <typename T>
+	bool TryParse(const char* value, T& dst) {
+		try {
+			dst = Parse<T>(value);
+
+			return true;
+		} catch (...) {
+			return false;
 		}
-	};
-
-	using transparent_string_hash = overload<
-		std::hash<std::string>,
-		std::hash<std::string_view>,
-		char_pointer_hash
-	>;
-
-	// Concept constraining to enum types
-	template <typename T>
-	concept Enum = std::is_enum_v<T>;
-
-	// Concept constraining to numeric types
-	template <typename T>
-	concept Numeric = std::integral<T> || Enum<T> || std::floating_point<T>;
-
-	// Concept trickery to enable parsing underlying numeric types
-	template <Numeric T>
-	struct numeric_parse { using type = T; };
-
-	// If an enum, present an alias to its underlying type for parsing
-	template <Numeric T> requires Enum<T>
-	struct numeric_parse<T> { using type = std::underlying_type_t<T>; };
-
-	// If a boolean, present an alias to an intermediate integral type for parsing
-	template <Numeric T> requires std::same_as<T, bool>
-	struct numeric_parse<T> { using type = uint8_t; };
-
-	// Shorthand type alias
-	template <Numeric T>
-	using numeric_parse_t = numeric_parse<T>::type;
-
-	/**
-	 * For numeric values: Parses a string_view and returns an optional variable depending on the result.
-	 * @param str The string_view to be evaluated
-	 * @returns An std::optional containing the desired value if it is equivalent to the string
-	*/
-	template <Numeric T>
-	[[nodiscard]] std::optional<T> TryParse(std::string_view str) {
-		numeric_parse_t<T> result;
-		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
-
-		const char* const strEnd = str.data() + str.size();
-		const auto [parseEnd, ec] = std::from_chars(str.data(), strEnd, result);
-		const bool isParsed = parseEnd == strEnd && ec == std::errc{};
-
-		return isParsed ? static_cast<T>(result) : std::optional<T>{};
-	}
-
-#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
-
-	// MacOS floating-point parse helper function specializations
-	namespace details {
-		template <std::floating_point T>
-		[[nodiscard]] T _parse(const std::string_view str, size_t& parseNum);
-	}
-
-	/**
-	 * For floating-point values: Parses a string_view and returns an optional variable depending on the result.
-	 * Note that this function overload is only included for MacOS, as from_chars will fulfill its purpose otherwise.
-	 * @param str The string_view to be evaluated
-	 * @returns An std::optional containing the desired value if it is equivalent to the string
-	*/
-	template <std::floating_point T>
-	[[nodiscard]] std::optional<T> TryParse(std::string_view str) noexcept
-	try {
-		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
-
-		size_t parseNum;
-		const T result = details::_parse<T>(str, parseNum);
-		const bool isParsed = str.length() == parseNum;
-
-		return isParsed ? result : std::optional<T>{};
-	} catch (...) {
-		return std::nullopt;
-	}
-
-#endif
-
-	/**
-	 * The TryParse overload for handling NiPoint3 by passing 3 seperate string references
-	 * @param strX The string representing the X coordinate
-	 * @param strY The string representing the Y coordinate
-	 * @param strZ The string representing the Z coordinate
-	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
-	*/
-	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string_view strX, const std::string_view strY, const std::string_view strZ) {
-		const auto x = TryParse<float>(strX);
-		if (!x) return std::nullopt;
-
-		const auto y = TryParse<float>(strY);
-		if (!y) return std::nullopt;
-
-		const auto z = TryParse<float>(strZ);
-		return z ? std::make_optional<NiPoint3>(x.value(), y.value(), z.value()) : std::nullopt;
-	}
-
-	/**
-	 * The TryParse overload for handling NiPoint3 by passing a span of three strings
-	 * @param str The string vector representing the X, Y, and Z coordinates
-	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
-	*/
-	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::span<const std::string> str) {
-		return (str.size() == 3) ? TryParse<NiPoint3>(str[0], str[1], str[2]) : std::nullopt;
 	}

 	template <typename T>
-	std::u16string to_u16string(const T value) {
+	T Parse(const std::string& value) {
+		return Parse<T>(value.c_str());
+	}
+
+	template <typename T>
+	bool TryParse(const std::string& value, T& dst) {
+		return TryParse<T>(value.c_str(), dst);
+	}
+
+	bool TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst);
+
+	template<typename T>
+	std::u16string to_u16string(T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
 	}

 	// From boost::hash_combine
 	template <class T>
-	constexpr void hash_combine(std::size_t& s, const T& v) {
+	void hash_combine(std::size_t& s, const T& v) {
 		std::hash<T> h;
 		s ^= h(v) + 0x9e3779b9 + (s << 6) + (s >> 2);
 	}
@@ -272,7 +219,7 @@ namespace GeneralUtils {
 	  \param max The maximum to generate to
 	 */
 	template <typename T>
-	inline T GenerateRandomNumber(const std::size_t min, const std::size_t max) {
+	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
 		// Make sure it is a numeric type
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");

@@ -292,17 +239,19 @@ namespace GeneralUtils {
 	 * @param entry Enum entry to cast
 	 * @returns The enum entry's value in its underlying type
 	*/
-	template <Enum eType>
-	constexpr std::underlying_type_t<eType> ToUnderlying(const eType entry) noexcept {
-		return static_cast<std::underlying_type_t<eType>>(entry);
+	template <typename eType>
+	inline constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) {
+		static_assert(std::is_enum_v<eType>, "Not an enum");
+
+		return static_cast<typename std::underlying_type_t<eType>>(entry);
 	}

 	// on Windows we need to undef these or else they conflict with our numeric limits calls
 	// DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS
-#ifdef _WIN32
-#undef min
-#undef max
-#endif
+	#ifdef _WIN32
+	#undef min
+	#undef max
+	#endif

 	template <typename T>
 	inline T GenerateRandomNumber() {
--- a/dCommon/Implementation.h
+++ b/dCommon/Implementation.h
@@ -1,92 +0,0 @@
-#ifndef __IMPLEMENTATION_H__
-#define __IMPLEMENTATION_H__
-
-#include <functional>
-#include <optional>
-
-/**
- * @brief A way to defer the implementation of an action.
- * 
- * @tparam R The result of the action.
- * @tparam T The types of the arguments that the implementation requires.
- */
-template <typename R, typename... T>
-class Implementation {
-public:
-	typedef std::function<std::optional<R>(T...)> ImplementationFunction;
-
-	/**
-	 * @brief Sets the implementation of the action.
-	 * 
-	 * @param implementation The implementation of the action.
-	 */
-	void SetImplementation(const ImplementationFunction& implementation) {
-		this->implementation = implementation;
-	}
-
-	/**
-	 * @brief Clears the implementation of the action.
-	 */
-	void ClearImplementation() {
-		implementation.reset();
-	}
-
-	/**
-	 * @brief Checks if the implementation is set.
-	 * 
-	 * @return true If the implementation is set.
-	 * @return false If the implementation is not set.
-	 */
-	bool IsSet() const {
-		return implementation.has_value();
-	}
-
-	/**
-	 * @brief Executes the implementation if it is set.
-	 * 
-	 * @param args The arguments to pass to the implementation.
-	 * @return std::optional<R> The optional result of the implementation. If the result is not set, it indicates that the default action should be taken.
-	 */
-	std::optional<R> Execute(T... args) const {
-		return IsSet() ? implementation.value()(args...) : std::nullopt;
-	}
-
-	/**
-	 * @brief Exectues the implementation if it is set, otherwise returns a default value.
-	 * 
-	 * @param args The arguments to pass to the implementation.
-	 * @param defaultValue The default value to return if the implementation is not set or should not be deferred.
-	 */
-	R ExecuteWithDefault(T... args, const R& defaultValue) const {
-		return Execute(args...).value_or(defaultValue);
-	}
-
-	/**
-	 * = operator overload.
-	 */
-	Implementation& operator=(const Implementation& other) {
-		implementation = other.implementation;
-		return *this;
-	}
-
-	/**
-	 * = operator overload.
-	 */
-	Implementation& operator=(const ImplementationFunction& implementation) {
-		this->implementation = implementation;
-		return *this;
-	}
-
-	/**
-	 * () operator overload.
-	 */
-	std::optional<R> operator()(T... args) {
-		return !IsSet() ? std::nullopt : implementation(args...);
-	}
-
-private:
-	std::optional<ImplementationFunction> implementation;
-
-};
-
-#endif  //!__IMPLEMENTATION_H__
--- a/dCommon/LDFFormat.cpp
+++ b/dCommon/LDFFormat.cpp
@@ -61,33 +61,33 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}

 	case LDF_TYPE_S32: {
-		const auto data = GeneralUtils::TryParse<int32_t>(ldfTypeAndValue.second);
-		if (!data) {
+		int32_t data;
+		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 			LOG("Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<int32_t>(key, data.value());
+		returnValue = new LDFData<int32_t>(key, data);

 		break;
 	}

 	case LDF_TYPE_FLOAT: {
-		const auto data = GeneralUtils::TryParse<float>(ldfTypeAndValue.second);
-		if (!data) {
+		float data;
+		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 			LOG("Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<float>(key, data.value());
+		returnValue = new LDFData<float>(key, data);
 		break;
 	}

 	case LDF_TYPE_DOUBLE: {
-		const auto data = GeneralUtils::TryParse<double>(ldfTypeAndValue.second);
-		if (!data) {
+		double data;
+		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 			LOG("Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<double>(key, data.value());
+		returnValue = new LDFData<double>(key, data);
 		break;
 	}

@@ -100,12 +100,10 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = 0;
 		} else {
-			const auto dataOptional = GeneralUtils::TryParse<uint32_t>(ldfTypeAndValue.second);
-			if (!dataOptional) {
+			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 				LOG("Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 				return nullptr;
 			}
-			data = dataOptional.value();
 		}

 		returnValue = new LDFData<uint32_t>(key, data);
@@ -120,12 +118,10 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = false;
 		} else {
-			const auto dataOptional = GeneralUtils::TryParse<bool>(ldfTypeAndValue.second);
-			if (!dataOptional) {
+			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 				LOG("Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 				return nullptr;
 			}
-			data = dataOptional.value();
 		}

 		returnValue = new LDFData<bool>(key, data);
@@ -133,22 +129,22 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}

 	case LDF_TYPE_U64: {
-		const auto data = GeneralUtils::TryParse<uint64_t>(ldfTypeAndValue.second);
-		if (!data) {
+		uint64_t data;
+		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 			LOG("Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<uint64_t>(key, data.value());
+		returnValue = new LDFData<uint64_t>(key, data);
 		break;
 	}

 	case LDF_TYPE_OBJID: {
-		const auto data = GeneralUtils::TryParse<LWOOBJID>(ldfTypeAndValue.second);
-		if (!data) {
+		LWOOBJID data;
+		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
 			LOG("Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 			return nullptr;
 		}
-		returnValue = new LDFData<LWOOBJID>(key, data.value());
+		returnValue = new LDFData<LWOOBJID>(key, data);
 		break;
 	}

--- a/dCommon/LDFFormat.h
+++ b/dCommon/LDFFormat.h
@@ -31,22 +31,22 @@ public:

 	virtual ~LDFBaseData() {}

-	virtual void WriteToPacket(RakNet::BitStream& packet) const = 0;
+	virtual void WriteToPacket(RakNet::BitStream* packet) = 0;

-	virtual const std::u16string& GetKey() const = 0;
+	virtual const std::u16string& GetKey() = 0;

-	virtual eLDFType GetValueType() const = 0;
+	virtual eLDFType GetValueType() = 0;

 	/** Gets a string from the key/value pair
 	 * @param includeKey Whether or not to include the key in the data
 	 * @param includeTypeId Whether or not to include the type id in the data
 	 * @return The string representation of the data
 	 */
-	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) const = 0;
+	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;

-	virtual std::string GetValueAsString() const = 0;
+	virtual std::string GetValueAsString() = 0;

-	virtual LDFBaseData* Copy() const = 0;
+	virtual LDFBaseData* Copy() = 0;

 	/**
 	 * Given an input string, return the data as a LDF key.
@@ -62,17 +62,17 @@ private:
 	T value;

 	//! Writes the key to the packet
-	void WriteKey(RakNet::BitStream& packet) const {
-		packet.Write<uint8_t>(this->key.length() * sizeof(uint16_t));
+	void WriteKey(RakNet::BitStream* packet) {
+		packet->Write<uint8_t>(this->key.length() * sizeof(uint16_t));
 		for (uint32_t i = 0; i < this->key.length(); ++i) {
-			packet.Write<uint16_t>(this->key[i]);
+			packet->Write<uint16_t>(this->key[i]);
 		}
 	}

 	//! Writes the value to the packet
-	void WriteValue(RakNet::BitStream& packet) const {
-		packet.Write<uint8_t>(this->GetValueType());
-		packet.Write(this->value);
+	void WriteValue(RakNet::BitStream* packet) {
+		packet->Write<uint8_t>(this->GetValueType());
+		packet->Write(this->value);
 	}

 public:
@@ -90,7 +90,7 @@ public:
 	/*!
 	  \return The value
 	 */
-	const T& GetValue(void) const { return this->value; }
+	const T& GetValue(void) { return this->value; }

 	//! Sets the value
 	/*!
@@ -102,13 +102,13 @@ public:
 	/*!
 	  \return The value string
 	 */
-	std::string GetValueString(void) const { return ""; }
+	std::string GetValueString(void) { return ""; }

 	//! Writes the data to a packet
 	/*!
 	  \param packet The packet
 	 */
-	void WriteToPacket(RakNet::BitStream& packet) const override {
+	void WriteToPacket(RakNet::BitStream* packet) override {
 		this->WriteKey(packet);
 		this->WriteValue(packet);
 	}
@@ -117,13 +117,13 @@ public:
 	/*!
 	 \return The key
 	 */
-	const std::u16string& GetKey(void) const override { return this->key; }
+	const std::u16string& GetKey(void) override { return this->key; }

 	//! Gets the LDF Type
 	/*!
 	 \return The LDF value type
 	 */
-	eLDFType GetValueType(void) const override { return LDF_TYPE_UNKNOWN; }
+	eLDFType GetValueType(void) override { return LDF_TYPE_UNKNOWN; }

 	//! Gets the string data
 	/*!
@@ -131,7 +131,7 @@ public:
 	  \param includeTypeId Whether or not to include the type id in the data
 	  \return The string representation of the data
 	 */
-	std::string GetString(const bool includeKey = true, const bool includeTypeId = true) const override {
+	std::string GetString(const bool includeKey = true, const bool includeTypeId = true) override {
 		if (GetValueType() == -1) {
 			return GeneralUtils::UTF16ToWTF8(this->key) + "=-1:<server variable>";
 		}
@@ -154,70 +154,70 @@ public:
 		return stream.str();
 	}

-	std::string GetValueAsString() const override {
+	std::string GetValueAsString() override {
 		return this->GetValueString();
 	}

-	LDFBaseData* Copy() const override {
+	LDFBaseData* Copy() override {
 		return new LDFData<T>(key, value);
 	}

-	inline static const T Default = {};
+	inline static T Default = {};
 };

 // LDF Types
-template<> inline eLDFType LDFData<std::u16string>::GetValueType(void) const { return LDF_TYPE_UTF_16; };
-template<> inline eLDFType LDFData<int32_t>::GetValueType(void) const { return LDF_TYPE_S32; };
-template<> inline eLDFType LDFData<float>::GetValueType(void) const { return LDF_TYPE_FLOAT; };
-template<> inline eLDFType LDFData<double>::GetValueType(void) const { return LDF_TYPE_DOUBLE; };
-template<> inline eLDFType LDFData<uint32_t>::GetValueType(void) const { return LDF_TYPE_U32; };
-template<> inline eLDFType LDFData<bool>::GetValueType(void) const { return LDF_TYPE_BOOLEAN; };
-template<> inline eLDFType LDFData<uint64_t>::GetValueType(void) const { return LDF_TYPE_U64; };
-template<> inline eLDFType LDFData<LWOOBJID>::GetValueType(void) const { return LDF_TYPE_OBJID; };
-template<> inline eLDFType LDFData<std::string>::GetValueType(void) const { return LDF_TYPE_UTF_8; };
+template<> inline eLDFType LDFData<std::u16string>::GetValueType(void) { return LDF_TYPE_UTF_16; };
+template<> inline eLDFType LDFData<int32_t>::GetValueType(void) { return LDF_TYPE_S32; };
+template<> inline eLDFType LDFData<float>::GetValueType(void) { return LDF_TYPE_FLOAT; };
+template<> inline eLDFType LDFData<double>::GetValueType(void) { return LDF_TYPE_DOUBLE; };
+template<> inline eLDFType LDFData<uint32_t>::GetValueType(void) { return LDF_TYPE_U32; };
+template<> inline eLDFType LDFData<bool>::GetValueType(void) { return LDF_TYPE_BOOLEAN; };
+template<> inline eLDFType LDFData<uint64_t>::GetValueType(void) { return LDF_TYPE_U64; };
+template<> inline eLDFType LDFData<LWOOBJID>::GetValueType(void) { return LDF_TYPE_OBJID; };
+template<> inline eLDFType LDFData<std::string>::GetValueType(void) { return LDF_TYPE_UTF_8; };

 // The specialized version for std::u16string (UTF-16)
 template<>
-inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream& packet) const {
-	packet.Write<uint8_t>(this->GetValueType());
+inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream* packet) {
+	packet->Write<uint8_t>(this->GetValueType());

-	packet.Write<uint32_t>(this->value.length());
+	packet->Write<uint32_t>(this->value.length());
 	for (uint32_t i = 0; i < this->value.length(); ++i) {
-		packet.Write<uint16_t>(this->value[i]);
+		packet->Write<uint16_t>(this->value[i]);
 	}
 }

 // The specialized version for bool
 template<>
-inline void LDFData<bool>::WriteValue(RakNet::BitStream& packet) const {
-	packet.Write<uint8_t>(this->GetValueType());
+inline void LDFData<bool>::WriteValue(RakNet::BitStream* packet) {
+	packet->Write<uint8_t>(this->GetValueType());

-	packet.Write<uint8_t>(this->value);
+	packet->Write<uint8_t>(this->value);
 }

 // The specialized version for std::string (UTF-8)
 template<>
-inline void LDFData<std::string>::WriteValue(RakNet::BitStream& packet) const {
-	packet.Write<uint8_t>(this->GetValueType());
+inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
+	packet->Write<uint8_t>(this->GetValueType());

-	packet.Write<uint32_t>(this->value.length());
+	packet->Write<uint32_t>(this->value.length());
 	for (uint32_t i = 0; i < this->value.length(); ++i) {
-		packet.Write<uint8_t>(this->value[i]);
+		packet->Write<uint8_t>(this->value[i]);
 	}
 }

-template<> inline std::string LDFData<std::u16string>::GetValueString() const {
+template<> inline std::string LDFData<std::u16string>::GetValueString() {
 	return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
 }

-template<> inline std::string LDFData<int32_t>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<float>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<double>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint32_t>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<bool>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint64_t>::GetValueString() const { return std::to_string(this->value); }
-template<> inline std::string LDFData<LWOOBJID>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }

-template<> inline std::string LDFData<std::string>::GetValueString() const { return this->value; }
+template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }

 #endif  //!__LDFFORMAT__H__
--- a/thirdparty/MD5/MD5.cpp
+++ b/thirdparty/MD5/MD5.cpp
--- a/thirdparty/MD5/MD5.h
+++ b/thirdparty/MD5/MD5.h
--- a/dCommon/Observable.h
+++ b/dCommon/Observable.h
@@ -1,73 +0,0 @@
-#ifndef __OBSERVABLE_H__
-#define __OBSERVABLE_H__
-
-#include <vector>
-#include <functional>
-
-/**
- * @brief An event which can be observed by multiple observers.
- * 
- * @tparam T The types of the arguments to be passed to the observers.
- */
-template <typename... T>
-class Observable {
-public:
-	typedef std::function<void(T...)> Observer;
-
-	/**
-	 * @brief Adds an observer to the event.
-	 * 
-	 * @param observer The observer to add.
-	 */
-	void AddObserver(const Observer& observer) {
-		observers.push_back(observer);
-	}
-
-	/**
-	 * @brief Removes an observer from the event.
-	 * 
-	 * @param observer The observer to remove.
-	 */
-	void RemoveObserver(const Observer& observer) {
-		observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
-	}
-
-	/**
-	 * @brief Notifies all observers of the event.
-	 * 
-	 * @param args The arguments to pass to the observers.
-	 */
-	void Notify(T... args) {
-		for (const auto& observer : observers) {
-			observer(args...);
-		}
-	}
-
-	/**
-	 * += operator overload.
-	 */
-	Observable& operator+=(const Observer& observer) {
-		AddObserver(observer);
-		return *this;
-	}
-
-	/**
-	 * -= operator overload.
-	 */
-	Observable& operator-=(const Observer& observer) {
-		RemoveObserver(observer);
-		return *this;
-	}
-	
-	/**
-	 * () operator overload.
-	 */
-	void operator()(T... args) {
-		Notify(args...);
-	}
-
-private:
-	std::vector<Observer> observers;
-};
-
-#endif  //!__OBSERVABLE_H__
--- a/dCommon/PositionUpdate.h
+++ b/dCommon/PositionUpdate.h
@@ -6,14 +6,28 @@


 struct RemoteInputInfo {
+	RemoteInputInfo() {
+		m_RemoteInputX = 0;
+		m_RemoteInputY = 0;
+		m_IsPowersliding = false;
+		m_IsModified = false;
+	}
+
+	void operator=(const RemoteInputInfo& other) {
+		m_RemoteInputX = other.m_RemoteInputX;
+		m_RemoteInputY = other.m_RemoteInputY;
+		m_IsPowersliding = other.m_IsPowersliding;
+		m_IsModified = other.m_IsModified;
+	}
+
 	bool operator==(const RemoteInputInfo& other) {
 		return m_RemoteInputX == other.m_RemoteInputX && m_RemoteInputY == other.m_RemoteInputY && m_IsPowersliding == other.m_IsPowersliding && m_IsModified == other.m_IsModified;
 	}

-	float m_RemoteInputX = 0;
-	float m_RemoteInputY = 0;
-	bool m_IsPowersliding = false;
-	bool m_IsModified = false;
+	float m_RemoteInputX;
+	float m_RemoteInputY;
+	bool m_IsPowersliding;
+	bool m_IsModified;
 };

 struct LocalSpaceInfo {
--- a/dCommon/SHA512.cpp
+++ b/dCommon/SHA512.cpp
@@ -0,0 +1,154 @@
+// Source: http://www.zedwood.com/article/cpp-sha512-function
+
+#include "SHA512.h"
+
+#include <cstring>
+#include <fstream>
+
+const unsigned long long SHA512::sha512_k[80] = //ULL = uint64
+{ 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+	0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+	0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+	0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+	0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+	0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+	0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+	0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+	0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+	0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+	0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+	0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+	0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+	0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+	0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+	0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+	0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+	0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+	0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+	0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+	0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+	0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+	0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+	0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+	0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+	0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+	0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+	0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+	0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+	0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+	0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+	0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+	0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+	0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+	0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+	0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+	0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+	0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+	0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+	0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL };
+
+void SHA512::transform(const unsigned char* message, unsigned int block_nb) {
+	uint64 w[80];
+	uint64 wv[8];
+	uint64 t1, t2;
+	const unsigned char* sub_block;
+	int i, j;
+	for (i = 0; i < (int)block_nb; i++) {
+		sub_block = message + (i << 7);
+		for (j = 0; j < 16; j++) {
+			SHA2_PACK64(&sub_block[j << 3], &w[j]);
+		}
+		for (j = 16; j < 80; j++) {
+			w[j] = SHA512_F4(w[j - 2]) + w[j - 7] + SHA512_F3(w[j - 15]) + w[j - 16];
+		}
+		for (j = 0; j < 8; j++) {
+			wv[j] = m_h[j];
+		}
+		for (j = 0; j < 80; j++) {
+			t1 = wv[7] + SHA512_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
+				+ sha512_k[j] + w[j];
+			t2 = SHA512_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
+			wv[7] = wv[6];
+			wv[6] = wv[5];
+			wv[5] = wv[4];
+			wv[4] = wv[3] + t1;
+			wv[3] = wv[2];
+			wv[2] = wv[1];
+			wv[1] = wv[0];
+			wv[0] = t1 + t2;
+		}
+		for (j = 0; j < 8; j++) {
+			m_h[j] += wv[j];
+		}
+
+	}
+}
+
+void SHA512::init() {
+	m_h[0] = 0x6a09e667f3bcc908ULL;
+	m_h[1] = 0xbb67ae8584caa73bULL;
+	m_h[2] = 0x3c6ef372fe94f82bULL;
+	m_h[3] = 0xa54ff53a5f1d36f1ULL;
+	m_h[4] = 0x510e527fade682d1ULL;
+	m_h[5] = 0x9b05688c2b3e6c1fULL;
+	m_h[6] = 0x1f83d9abfb41bd6bULL;
+	m_h[7] = 0x5be0cd19137e2179ULL;
+	m_len = 0;
+	m_tot_len = 0;
+}
+
+void SHA512::update(const unsigned char* message, unsigned int len) {
+	unsigned int block_nb;
+	unsigned int new_len, rem_len, tmp_len;
+	const unsigned char* shifted_message;
+	tmp_len = SHA384_512_BLOCK_SIZE - m_len;
+	rem_len = len < tmp_len ? len : tmp_len;
+	memcpy(&m_block[m_len], message, rem_len);
+	if (m_len + len < SHA384_512_BLOCK_SIZE) {
+		m_len += len;
+		return;
+	}
+	new_len = len - rem_len;
+	block_nb = new_len / SHA384_512_BLOCK_SIZE;
+	shifted_message = message + rem_len;
+	transform(m_block, 1);
+	transform(shifted_message, block_nb);
+	rem_len = new_len % SHA384_512_BLOCK_SIZE;
+	memcpy(m_block, &shifted_message[block_nb << 7], rem_len);
+	m_len = rem_len;
+	m_tot_len += (block_nb + 1) << 7;
+}
+
+void SHA512::final(unsigned char* digest) {
+	unsigned int block_nb;
+	unsigned int pm_len;
+	unsigned int len_b;
+	int i;
+	block_nb = 1 + ((SHA384_512_BLOCK_SIZE - 17)
+		< (m_len % SHA384_512_BLOCK_SIZE));
+	len_b = (m_tot_len + m_len) << 3;
+	pm_len = block_nb << 7;
+	memset(m_block + m_len, 0, pm_len - m_len);
+	m_block[m_len] = 0x80;
+	SHA2_UNPACK32(len_b, m_block + pm_len - 4);
+	transform(m_block, block_nb);
+	for (i = 0; i < 8; i++) {
+		SHA2_UNPACK64(m_h[i], &digest[i << 3]);
+	}
+}
+
+std::string sha512(std::string input) {
+	unsigned char digest[SHA512::DIGEST_SIZE];
+	memset(digest, 0, SHA512::DIGEST_SIZE);
+	class SHA512 ctx;
+	ctx.init();
+	ctx.update((unsigned char*)input.c_str(), input.length());
+	ctx.final(digest);
+
+	char buf[2 * SHA512::DIGEST_SIZE + 1];
+	buf[2 * SHA512::DIGEST_SIZE] = 0;
+	for (int i = 0; i < SHA512::DIGEST_SIZE; i++)
+		sprintf(buf + i * 2, "%02x", digest[i]);
+
+	return std::string(buf);
+}
--- a/dCommon/SHA512.h
+++ b/dCommon/SHA512.h
@@ -0,0 +1,68 @@
+#pragma once
+
+// C++
+#include <string>
+
+class SHA512 {
+protected:
+	typedef unsigned char uint8;
+	typedef unsigned int uint32;
+	typedef unsigned long long uint64;
+
+	const static uint64 sha512_k[];
+	static const unsigned int SHA384_512_BLOCK_SIZE = (1024 / 8);
+
+public:
+	void init();
+	void update(const unsigned char* message, unsigned int len);
+	void final(unsigned char* digest);
+	static const unsigned int DIGEST_SIZE = (512 / 8);
+
+protected:
+	void transform(const unsigned char* message, unsigned int block_nb);
+	unsigned int m_tot_len;
+	unsigned int m_len;
+	unsigned char m_block[2 * SHA384_512_BLOCK_SIZE];
+	uint64 m_h[8];
+};
+
+std::string sha512(std::string input);
+
+#define SHA2_SHFR(x, n)    (x >> n)
+#define SHA2_ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
+#define SHA2_ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
+#define SHA2_CH(x, y, z)  ((x & y) ^ (~x & z))
+#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
+#define SHA512_F1(x) (SHA2_ROTR(x, 28) ^ SHA2_ROTR(x, 34) ^ SHA2_ROTR(x, 39))
+#define SHA512_F2(x) (SHA2_ROTR(x, 14) ^ SHA2_ROTR(x, 18) ^ SHA2_ROTR(x, 41))
+#define SHA512_F3(x) (SHA2_ROTR(x,  1) ^ SHA2_ROTR(x,  8) ^ SHA2_SHFR(x,  7))
+#define SHA512_F4(x) (SHA2_ROTR(x, 19) ^ SHA2_ROTR(x, 61) ^ SHA2_SHFR(x,  6))
+#define SHA2_UNPACK32(x, str)                 \
+{                                             \
+*((str) + 3) = (uint8) ((x)      );       \
+*((str) + 2) = (uint8) ((x) >>  8);       \
+*((str) + 1) = (uint8) ((x) >> 16);       \
+*((str) + 0) = (uint8) ((x) >> 24);       \
+}
+#define SHA2_UNPACK64(x, str)                 \
+{                                             \
+*((str) + 7) = (uint8) ((x)      );       \
+*((str) + 6) = (uint8) ((x) >>  8);       \
+*((str) + 5) = (uint8) ((x) >> 16);       \
+*((str) + 4) = (uint8) ((x) >> 24);       \
+*((str) + 3) = (uint8) ((x) >> 32);       \
+*((str) + 2) = (uint8) ((x) >> 40);       \
+*((str) + 1) = (uint8) ((x) >> 48);       \
+*((str) + 0) = (uint8) ((x) >> 56);       \
+}
+#define SHA2_PACK64(str, x)                   \
+{                                             \
+*(x) =   ((uint64) *((str) + 7)      )    \
+| ((uint64) *((str) + 6) <<  8)    \
+| ((uint64) *((str) + 5) << 16)    \
+| ((uint64) *((str) + 4) << 24)    \
+| ((uint64) *((str) + 3) << 32)    \
+| ((uint64) *((str) + 2) << 40)    \
+| ((uint64) *((str) + 1) << 48)    \
+| ((uint64) *((str) + 0) << 56);   \
+}
--- a/dCommon/ZCompression.cpp
+++ b/dCommon/ZCompression.cpp
@@ -1,6 +1,6 @@
 #include "ZCompression.h"

-#include "zlib-ng.h"
+#include "zlib.h"

 namespace ZCompression {
 	int32_t GetMaxCompressedLength(int32_t nLenSrc) {
@@ -9,41 +9,41 @@ namespace ZCompression {
 	}

 	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst) {
-		zng_stream zInfo = { 0 };
+		z_stream zInfo = { 0 };
 		zInfo.total_in = zInfo.avail_in = nLenSrc;
 		zInfo.total_out = zInfo.avail_out = nLenDst;
 		zInfo.next_in = const_cast<Bytef*>(abSrc);
 		zInfo.next_out = abDst;

 		int nErr, nRet = -1;
-		nErr = zng_deflateInit(&zInfo, Z_DEFAULT_COMPRESSION); // zlib function
+		nErr = deflateInit(&zInfo, Z_DEFAULT_COMPRESSION); // zlib function
 		if (nErr == Z_OK) {
-			nErr = zng_deflate(&zInfo, Z_FINISH);              // zlib function
+			nErr = deflate(&zInfo, Z_FINISH);              // zlib function
 			if (nErr == Z_STREAM_END) {
 				nRet = zInfo.total_out;
 			}
 		}
-		zng_deflateEnd(&zInfo);    // zlib function
+		deflateEnd(&zInfo);    // zlib function
 		return(nRet);
 	}

 	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr) {
 		// Get the size of the decompressed data
-		zng_stream zInfo = { 0 };
+		z_stream zInfo = { 0 };
 		zInfo.total_in = zInfo.avail_in = nLenSrc;
 		zInfo.total_out = zInfo.avail_out = nLenDst;
 		zInfo.next_in = const_cast<Bytef*>(abSrc);
 		zInfo.next_out = abDst;

 		int nRet = -1;
-		nErr = zng_inflateInit(&zInfo); // zlib function
+		nErr = inflateInit(&zInfo); // zlib function
 		if (nErr == Z_OK) {
-			nErr = zng_inflate(&zInfo, Z_FINISH); // zlib function
+			nErr = inflate(&zInfo, Z_FINISH); // zlib function
 			if (nErr == Z_STREAM_END) {
 				nRet = zInfo.total_out;
 			}
 		}
-		zng_inflateEnd(&zInfo); // zlib function
+		inflateEnd(&zInfo); // zlib function
 		return(nRet);
 	}
 }
--- a/dCommon/dClient/AssetManager.cpp
+++ b/dCommon/dClient/AssetManager.cpp
@@ -4,6 +4,8 @@
 #include "Game.h"
 #include "Logger.h"

+#include "zlib.h"
+
 AssetManager::AssetManager(const std::filesystem::path& path) {
 	if (!std::filesystem::is_directory(path)) {
 		throw std::runtime_error("Attempted to load asset bundle (" + path.string() + ") however it is not a valid directory.");
@@ -80,7 +82,7 @@ bool AssetManager::HasFile(const char* name) {
 	if (fixedName.rfind("client\\res\\", 0) != 0) fixedName = "client\\res\\" + fixedName;

 	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);

 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -128,7 +130,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 	}
 	int32_t packIndex = -1;
 	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);

 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
--- a/dCommon/dClient/CMakeLists.txt
+++ b/dCommon/dClient/CMakeLists.txt
@@ -1,6 +1,6 @@
 set(DCOMMON_DCLIENT_SOURCES
-	"AssetManager.cpp"
 	"PackIndex.cpp"
 	"Pack.cpp"
+	"AssetManager.cpp"
 	PARENT_SCOPE
 )
--- a/dCommon/dClient/ClientVersion.h
+++ b/dCommon/dClient/ClientVersion.h
@@ -1,12 +0,0 @@
-#ifndef __CLIENTVERSION_H__
-#define __CLIENTVERSION_H__
-
-#include <cstdint>
-
-namespace ClientVersion {
-	constexpr uint16_t major = 1;
-	constexpr uint16_t current = 10;
-	constexpr uint16_t minor = 64;
-}
-
-#endif // !__CLIENTVERSION_H__
--- a/dCommon/dConfig.cpp
+++ b/dCommon/dConfig.cpp
@@ -1,7 +1,6 @@
 #include "dConfig.h"

 #include <sstream>
-#include <algorithm>

 #include "BinaryPathFinder.h"
 #include "GeneralUtils.h"
--- a/dCommon/dEnums/MessageType/Auth.h
+++ b/dCommon/dEnums/MessageType/Auth.h
@@ -1,13 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace MessageType {
-	enum class Auth : uint32_t {
-		LOGIN_REQUEST = 0,
-		LOGOUT_REQUEST,
-		CREATE_NEW_ACCOUNT_REQUEST,
-		LEGOINTERFACE_AUTH_RESPONSE,
-		SESSIONKEY_RECEIVED_CONFIRM,
-		RUNTIME_CONFIG
-	};
-}
--- a/dCommon/dEnums/MessageType/Chat.h
+++ b/dCommon/dEnums/MessageType/Chat.h
@@ -1,78 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace MessageType {
-	//! The Internal Chat Packet Identifiers
-	enum class Chat : uint32_t {
-		LOGIN_SESSION_NOTIFY = 0,
-		GENERAL_CHAT_MESSAGE,
-		PRIVATE_CHAT_MESSAGE,
-		USER_CHANNEL_CHAT_MESSAGE,
-		WORLD_DISCONNECT_REQUEST,
-		WORLD_PROXIMITY_RESPONSE,
-		WORLD_PARCEL_RESPONSE,
-		ADD_FRIEND_REQUEST,
-		ADD_FRIEND_RESPONSE,
-		REMOVE_FRIEND,
-		GET_FRIENDS_LIST,
-		ADD_IGNORE,
-		REMOVE_IGNORE,
-		GET_IGNORE_LIST,
-		TEAM_MISSED_INVITE_CHECK,
-		TEAM_INVITE,
-		TEAM_INVITE_RESPONSE,
-		TEAM_KICK,
-		TEAM_LEAVE,
-		TEAM_SET_LOOT,
-		TEAM_SET_LEADER,
-		TEAM_GET_STATUS,
-		GUILD_CREATE,
-		GUILD_INVITE,
-		GUILD_INVITE_RESPONSE,
-		GUILD_LEAVE,
-		GUILD_KICK,
-		GUILD_GET_STATUS,
-		GUILD_GET_ALL,
-		SHOW_ALL,
-		BLUEPRINT_MODERATED,
-		BLUEPRINT_MODEL_READY,
-		PROPERTY_READY_FOR_APPROVAL,
-		PROPERTY_MODERATION_CHANGED,
-		PROPERTY_BUILDMODE_CHANGED,
-		PROPERTY_BUILDMODE_CHANGED_REPORT,
-		MAIL,
-		WORLD_INSTANCE_LOCATION_REQUEST,
-		REPUTATION_UPDATE,
-		SEND_CANNED_TEXT,
-		GMLEVEL_UPDATE,
-		CHARACTER_NAME_CHANGE_REQUEST,
-		CSR_REQUEST,
-		CSR_REPLY,
-		GM_KICK,
-		GM_ANNOUNCE,
-		GM_MUTE,
-		ACTIVITY_UPDATE,
-		WORLD_ROUTE_PACKET,
-		GET_ZONE_POPULATIONS,
-		REQUEST_MINIMUM_CHAT_MODE,
-		REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
-		MATCH_REQUEST,
-		UGCMANIFEST_REPORT_MISSING_FILE,
-		UGCMANIFEST_REPORT_DONE_FILE,
-		UGCMANIFEST_REPORT_DONE_BLUEPRINT,
-		UGCC_REQUEST,
-		WHO,
-		WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
-		ACHIEVEMENT_NOTIFY,
-		GM_CLOSE_PRIVATE_CHAT_WINDOW,
-		UNEXPECTED_DISCONNECT,
-		PLAYER_READY,
-		GET_DONATION_TOTAL,
-		UPDATE_DONATION,
-		PRG_CSR_COMMAND,
-		HEARTBEAT_REQUEST_FROM_WORLD,
-		UPDATE_FREE_TRIAL_STATUS,
-		// CUSTOM DLU MESSAGE ID FOR INTERNAL USE
-		CREATE_TEAM,
-	};
-}
--- a/dCommon/dEnums/MessageType/Client.h
+++ b/dCommon/dEnums/MessageType/Client.h
@@ -1,74 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace MessageType {
-	enum class Client : uint32_t {
-		LOGIN_RESPONSE = 0,
-		LOGOUT_RESPONSE,
-		LOAD_STATIC_ZONE,
-		CREATE_OBJECT,
-		CREATE_CHARACTER,
-		CREATE_CHARACTER_EXTENDED,
-		CHARACTER_LIST_RESPONSE,
-		CHARACTER_CREATE_RESPONSE,
-		CHARACTER_RENAME_RESPONSE,
-		CHAT_CONNECT_RESPONSE,
-		AUTH_ACCOUNT_CREATE_RESPONSE,
-		DELETE_CHARACTER_RESPONSE,
-		GAME_MSG,
-		CONNECT_CHAT,
-		TRANSFER_TO_WORLD,
-		IMPENDING_RELOAD_NOTIFY,
-		MAKE_GM_RESPONSE,
-		HTTP_MONITOR_INFO_RESPONSE,
-		SLASH_PUSH_MAP_RESPONSE,
-		SLASH_PULL_MAP_RESPONSE,
-		SLASH_LOCK_MAP_RESPONSE,
-		BLUEPRINT_SAVE_RESPONSE,
-		BLUEPRINT_LUP_SAVE_RESPONSE,
-		BLUEPRINT_LOAD_RESPONSE_ITEMID,
-		BLUEPRINT_GET_ALL_DATA_RESPONSE,
-		MODEL_INSTANTIATE_RESPONSE,
-		DEBUG_OUTPUT,
-		ADD_FRIEND_REQUEST,
-		ADD_FRIEND_RESPONSE,
-		REMOVE_FRIEND_RESPONSE,
-		GET_FRIENDS_LIST_RESPONSE,
-		UPDATE_FRIEND_NOTIFY,
-		ADD_IGNORE_RESPONSE,
-		REMOVE_IGNORE_RESPONSE,
-		GET_IGNORE_LIST_RESPONSE,
-		TEAM_INVITE,
-		TEAM_INVITE_INITIAL_RESPONSE,
-		GUILD_CREATE_RESPONSE,
-		GUILD_GET_STATUS_RESPONSE,
-		GUILD_INVITE,
-		GUILD_INVITE_INITIAL_RESPONSE,
-		GUILD_INVITE_FINAL_RESPONSE,
-		GUILD_INVITE_CONFIRM,
-		GUILD_ADD_PLAYER,
-		GUILD_REMOVE_PLAYER,
-		GUILD_LOGIN_LOGOUT,
-		GUILD_RANK_CHANGE,
-		GUILD_DATA,
-		GUILD_STATUS,
-		MAIL,
-		DB_PROXY_RESULT,
-		SHOW_ALL_RESPONSE,
-		WHO_RESPONSE,
-		SEND_CANNED_TEXT,
-		UPDATE_CHARACTER_NAME,
-		SET_NETWORK_SIMULATOR,
-		INVALID_CHAT_MESSAGE,
-		MINIMUM_CHAT_MODE_RESPONSE,
-		MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
-		CHAT_MODERATION_STRING,
-		UGC_MANIFEST_RESPONSE,
-		IN_LOGIN_QUEUE,
-		SERVER_STATES,
-		GM_CLOSE_TARGET_CHAT_WINDOW,
-		GENERAL_TEXT_FOR_LOCALIZATION,
-		UPDATE_FREE_TRIAL_STATUS,
-		UGC_DOWNLOAD_FAILED = 120
-	};
-}
--- a/dCommon/dEnums/MessageType/Game.h
+++ b/dCommon/dEnums/MessageType/Game.h
--- a/dCommon/dEnums/MessageType/Master.h
+++ b/dCommon/dEnums/MessageType/Master.h
@@ -1,34 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace MessageType {
-	enum class Master : uint32_t {
-		REQUEST_PERSISTENT_ID = 1,
-		REQUEST_PERSISTENT_ID_RESPONSE,
-		REQUEST_ZONE_TRANSFER,
-		REQUEST_ZONE_TRANSFER_RESPONSE,
-		SERVER_INFO,
-		REQUEST_SESSION_KEY,
-		SET_SESSION_KEY,
-		SESSION_KEY_RESPONSE,
-		PLAYER_ADDED,
-		PLAYER_REMOVED,
-
-		CREATE_PRIVATE_ZONE,
-		REQUEST_PRIVATE_ZONE,
-
-		WORLD_READY,
-		PREP_ZONE,
-
-		SHUTDOWN,
-		SHUTDOWN_RESPONSE,
-		SHUTDOWN_IMMEDIATE,
-
-		SHUTDOWN_UNIVERSE,
-
-		AFFIRM_TRANSFER_REQUEST,
-		AFFIRM_TRANSFER_RESPONSE,
-
-		NEW_SESSION_ALERT
-	};
-}
--- a/dCommon/dEnums/MessageType/Server.h
+++ b/dCommon/dEnums/MessageType/Server.h
@@ -1,11 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace MessageType {
-	//! The Internal Server Packet Identifiers
-	enum class Server : uint32_t {
-		VERSION_CONFIRM = 0,
-		DISCONNECT_NOTIFY,
-		GENERAL_NOTIFY
-	};
-}
--- a/dCommon/dEnums/MessageType/World.h
+++ b/dCommon/dEnums/MessageType/World.h
@@ -1,49 +0,0 @@
-#pragma once
-#include <cstdint>
-
-#include "magic_enum.hpp"
-
-namespace MessageType {
-	enum class World : uint32_t {
-		VALIDATION = 1,  // 				Session info
-		CHARACTER_LIST_REQUEST,
-		CHARACTER_CREATE_REQUEST,
-		LOGIN_REQUEST,  // 			Character selected
-		GAME_MSG,
-		CHARACTER_DELETE_REQUEST,
-		CHARACTER_RENAME_REQUEST,
-		HAPPY_FLOWER_MODE_NOTIFY,
-		SLASH_RELOAD_MAP,  // 			Reload map cmp
-		SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
-		SLASH_PUSH_MAP,  // 			Push map cmd
-		SLASH_PULL_MAP,  // 			Pull map cmd
-		LOCK_MAP_REQUEST,
-		GENERAL_CHAT_MESSAGE,  // 		General chat message
-		HTTP_MONITOR_INFO_REQUEST,
-		SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
-		MODELS_CLEAR,
-		EXHIBIT_INSERT_MODEL,
-		LEVEL_LOAD_COMPLETE,  // 		Character data request
-		TMP_GUILD_CREATE,
-		ROUTE_PACKET,  // 				Social?
-		POSITION_UPDATE,
-		MAIL,
-		WORD_CHECK, // 				AllowList word check
-		STRING_CHECK,  // 				AllowList string check
-		GET_PLAYERS_IN_ZONE,
-		REQUEST_UGC_MANIFEST_INFO,
-		BLUEPRINT_GET_ALL_DATA_REQUEST,
-		CANCEL_MAP_QUEUE,
-		HANDLE_FUNNESS,
-		FAKE_PRG_CSR_MESSAGE,
-		REQUEST_FREE_TRIAL_REFRESH,
-		GM_SET_FREE_TRIAL_STATUS,
-		UI_HELP_TOP_5 = 91
-	};
-}
-
-template <>
-struct magic_enum::customize::enum_range<MessageType::World> {
-	static constexpr int min = 0;
-	static constexpr int max = 91;
-};
--- a/dCommon/dEnums/dCommonVars.h
+++ b/dCommon/dEnums/dCommonVars.h
@@ -8,7 +8,7 @@
 #include <set>
 #include "BitStream.h"
 #include "eConnectionType.h"
-#include "MessageType/Client.h"
+#include "eClientMessageType.h"
 #include "BitStreamUtils.h"

 #pragma warning (disable:4251) //Disables SQL warnings
@@ -33,90 +33,92 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
 #define CINSTREAM_SKIP_HEADER CINSTREAM if (inStream.GetNumberOfUnreadBits() >= BYTES_TO_BITS(HEADER_SIZE)) inStream.IgnoreBytes(HEADER_SIZE); else inStream.IgnoreBits(inStream.GetNumberOfUnreadBits());
-#define CMSGHEADER BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
-#define SEND_PACKET Game::server->Send(bitStream, sysAddr, false);
-#define SEND_PACKET_BROADCAST Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+#define CMSGHEADER BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+#define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
+#define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);

 //=========== TYPEDEFS ==========

-using LOT = int32_t;                        //!< A LOT
-using LWOOBJID = int64_t;                   //!< An object ID (should be unsigned actually but ok)
-using TSkillID = int32_t;                   //!< A skill ID
-using LWOCLONEID = uint32_t;                 //!< Used for Clone IDs
-using LWOMAPID = uint16_t;                   //!< Used for Map IDs
-using LWOINSTANCEID = uint16_t;              //!< Used for Instance IDs
-using PROPERTYCLONELIST = uint32_t;          //!< Used for Property Clone IDs
-using StripId = uint32_t;
+typedef int32_t LOT;                        //!< A LOT
+typedef int64_t LWOOBJID;                   //!< An object ID (should be unsigned actually but ok)
+typedef int32_t TSkillID;                   //!< A skill ID
+typedef uint32_t LWOCLONEID;                 //!< Used for Clone IDs
+typedef uint16_t LWOMAPID;                   //!< Used for Map IDs
+typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
+typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
+typedef uint32_t StripId;

-constexpr LWOOBJID LWOOBJID_EMPTY = 0;          	//!< An empty object ID
-constexpr LOT LOT_NULL = -1;                    	//!< A null LOT
-constexpr int32_t LOOTTYPE_NONE = 0;            	//!< No loot type available
-constexpr float SECONDARY_PRIORITY = 1.0f;      	//!< Secondary Priority
-constexpr uint32_t INVENTORY_MAX = 9999999;     	//!< The Maximum Inventory Size
-constexpr LWOCLONEID LWOCLONEID_INVALID = -1;     	//!< Invalid LWOCLONEID
-constexpr LWOINSTANCEID LWOINSTANCEID_INVALID = -1; //!< Invalid LWOINSTANCEID
-constexpr LWOMAPID LWOMAPID_INVALID = -1;       	//!< Invalid LWOMAPID
-constexpr uint64_t LWOZONEID_INVALID = 0;       	//!< Invalid LWOZONEID
+const LWOOBJID LWOOBJID_EMPTY = 0;          //!< An empty object ID
+const LOT LOT_NULL = -1;                    //!< A null LOT
+const int32_t LOOTTYPE_NONE = 0;            //!< No loot type available
+const float SECONDARY_PRIORITY = 1.0f;      //!< Secondary Priority
+const uint32_t INVENTORY_MAX = 9999999;     //!< The Maximum Inventory Size
+const uint32_t LWOCLONEID_INVALID = -1;     //!< Invalid LWOCLONEID
+const uint16_t LWOINSTANCEID_INVALID = -1;  //!< Invalid LWOINSTANCEID
+const uint16_t LWOMAPID_INVALID = -1;       //!< Invalid LWOMAPID
+const uint64_t LWOZONEID_INVALID = 0;       //!< Invalid LWOZONEID

-constexpr float PI = 3.14159f;
+const float PI = 3.14159f;

 //============ STRUCTS ==============

 struct LWOSCENEID {
 public:
-	constexpr LWOSCENEID() noexcept { m_sceneID = -1; m_layerID = 0; }
-	constexpr LWOSCENEID(int32_t sceneID) noexcept { m_sceneID = sceneID; m_layerID = 0; }
-	constexpr LWOSCENEID(int32_t sceneID, uint32_t layerID) noexcept { m_sceneID = sceneID; m_layerID = layerID; }
+	LWOSCENEID() { m_sceneID = -1; m_layerID = 0; }
+	LWOSCENEID(int sceneID) { m_sceneID = sceneID; m_layerID = 0; }
+	LWOSCENEID(int sceneID, unsigned int layerID) { m_sceneID = sceneID; m_layerID = layerID; }

-	constexpr LWOSCENEID& operator=(const LWOSCENEID& rhs) noexcept { m_sceneID = rhs.m_sceneID; m_layerID = rhs.m_layerID; return *this; }
-	constexpr LWOSCENEID& operator=(const int32_t rhs) noexcept { m_sceneID = rhs; m_layerID = 0; return *this; }
+	LWOSCENEID& operator=(const LWOSCENEID& rhs) { m_sceneID = rhs.m_sceneID; m_layerID = rhs.m_layerID; return *this; }
+	LWOSCENEID& operator=(const int rhs) { m_sceneID = rhs; m_layerID = 0; return *this; }

-	constexpr bool operator<(const LWOSCENEID& rhs) const noexcept { return (m_sceneID < rhs.m_sceneID || (m_sceneID == rhs.m_sceneID && m_layerID < rhs.m_layerID)); }
-	constexpr bool operator<(const int32_t rhs) const noexcept { return m_sceneID < rhs; }
+	bool operator<(const LWOSCENEID& rhs) const { return (m_sceneID < rhs.m_sceneID || (m_sceneID == rhs.m_sceneID && m_layerID < rhs.m_layerID)); }
+	bool operator<(const int rhs) const { return m_sceneID < rhs; }

-	constexpr bool operator==(const LWOSCENEID& rhs) const noexcept { return (m_sceneID == rhs.m_sceneID && m_layerID == rhs.m_layerID); }
-	constexpr bool operator==(const int32_t rhs) const noexcept { return m_sceneID == rhs; }
+	bool operator==(const LWOSCENEID& rhs) const { return (m_sceneID == rhs.m_sceneID && m_layerID == rhs.m_layerID); }
+	bool operator==(const int rhs) const { return m_sceneID == rhs; }

-	constexpr int32_t GetSceneID() const noexcept { return m_sceneID; }
-	constexpr uint32_t GetLayerID() const noexcept { return m_layerID; }
+	const int GetSceneID() const { return m_sceneID; }
+	const unsigned int GetLayerID() const { return m_layerID; }

-	constexpr void SetSceneID(const int32_t sceneID) noexcept { m_sceneID = sceneID; }
-	constexpr void SetLayerID(const uint32_t layerID) noexcept { m_layerID = layerID; }
+	void SetSceneID(const int sceneID) { m_sceneID = sceneID; }
+	void SetLayerID(const unsigned int layerID) { m_layerID = layerID; }

 private:
-	int32_t m_sceneID;
-	uint32_t m_layerID;
+	int m_sceneID;
+	unsigned int m_layerID;
 };

 struct LWOZONEID {
 public:
-	constexpr const LWOMAPID& GetMapID() const noexcept { return m_MapID; }
-	constexpr const LWOINSTANCEID& GetInstanceID() const noexcept { return m_InstanceID; }
-	constexpr const LWOCLONEID& GetCloneID() const noexcept { return m_CloneID; }
+	const LWOMAPID& GetMapID() const { return m_MapID; }
+	const LWOINSTANCEID& GetInstanceID() const { return m_InstanceID; }
+	const LWOCLONEID& GetCloneID() const { return m_CloneID; }

 	//In order: def constr, constr, assign op
-	constexpr LWOZONEID() noexcept = default;
-	constexpr LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) noexcept { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
-	constexpr LWOZONEID(const LWOZONEID& replacement) noexcept { *this = replacement; }
+	LWOZONEID() { m_MapID = LWOMAPID_INVALID; m_InstanceID = LWOINSTANCEID_INVALID; m_CloneID = LWOCLONEID_INVALID; }
+	LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
+	LWOZONEID(const LWOZONEID& replacement) { *this = replacement; }

 private:
-	LWOMAPID m_MapID = LWOMAPID_INVALID; //1000 for VE, 1100 for AG, etc...
-	LWOINSTANCEID m_InstanceID = LWOINSTANCEID_INVALID; //Instances host the same world, but on a different dWorld process.
-	LWOCLONEID m_CloneID = LWOCLONEID_INVALID; //To differentiate between "your property" and "my property". Always 0 for non-prop worlds.
+	LWOMAPID m_MapID; //1000 for VE, 1100 for AG, etc...
+	LWOINSTANCEID m_InstanceID; //Instances host the same world, but on a different dWorld process.
+	LWOCLONEID m_CloneID; //To differentiate between "your property" and "my property". Always 0 for non-prop worlds.
 };

-constexpr LWOSCENEID LWOSCENEID_INVALID = -1;
+const LWOSCENEID LWOSCENEID_INVALID = -1;

 struct LWONameValue {
 	uint32_t length = 0;        //!< The length of the name
 	std::u16string name;			//!< The name

-	LWONameValue() = default;
+	LWONameValue(void) {}

 	LWONameValue(const std::u16string& name) {
 		this->name = name;
 		this->length = static_cast<uint32_t>(name.length());
 	}
+
+	~LWONameValue(void) {}
 };

 struct FriendData {
--- a/dCommon/dEnums/eAninmationFlags.h
+++ b/dCommon/dEnums/eAninmationFlags.h
--- a/dCommon/dEnums/eAuthMessageType.h
+++ b/dCommon/dEnums/eAuthMessageType.h
@@ -0,0 +1,15 @@
+#ifndef __EAUTHMESSAGETYPE__H__
+#define __EAUTHMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eAuthMessageType : uint32_t {
+	LOGIN_REQUEST = 0,
+	LOGOUT_REQUEST,
+	CREATE_NEW_ACCOUNT_REQUEST,
+	LEGOINTERFACE_AUTH_RESPONSE,
+	SESSIONKEY_RECEIVED_CONFIRM,
+	RUNTIME_CONFIG
+};
+
+#endif  //!__EAUTHMESSAGETYPE__H__
--- a/dCommon/dEnums/eCharacterVersion.h
+++ b/dCommon/dEnums/eCharacterVersion.h
@@ -15,8 +15,7 @@ enum class eCharacterVersion : uint32_t {
 	// Fixes vault size value
 	VAULT_SIZE,
 	// Fixes speed base value in level component
-	SPEED_BASE,
-	UP_TO_DATE, // will become NJ_JAYMISSIONS
+	UP_TO_DATE, // will become SPEED_BASE
 };

 #endif  //!__ECHARACTERVERSION__H__
--- a/dCommon/dEnums/eChatInternalMessageType.h
+++ b/dCommon/dEnums/eChatInternalMessageType.h
@@ -0,0 +1,31 @@
+#ifndef __ECHATINTERNALMESSAGETYPE__H__
+#define __ECHATINTERNALMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum eChatInternalMessageType : uint32_t {
+	PLAYER_ADDED_NOTIFICATION = 0,
+	PLAYER_REMOVED_NOTIFICATION,
+	ADD_FRIEND,
+	ADD_BEST_FRIEND,
+	ADD_TO_TEAM,
+	ADD_BLOCK,
+	REMOVE_FRIEND,
+	REMOVE_BLOCK,
+	REMOVE_FROM_TEAM,
+	DELETE_TEAM,
+	REPORT,
+	PRIVATE_CHAT,
+	PRIVATE_CHAT_RESPONSE,
+	ANNOUNCEMENT,
+	MAIL_COUNT_UPDATE,
+	MAIL_SEND_NOTIFY,
+	REQUEST_USER_LIST,
+	FRIEND_LIST,
+	ROUTE_TO_PLAYER,
+	TEAM_UPDATE,
+	MUTE_UPDATE,
+	CREATE_TEAM,
+};
+
+#endif  //!__ECHATINTERNALMESSAGETYPE__H__
--- a/dCommon/dEnums/eChatMessageType.h
+++ b/dCommon/dEnums/eChatMessageType.h
@@ -0,0 +1,78 @@
+#ifndef __ECHATMESSAGETYPE__H__
+#define __ECHATMESSAGETYPE__H__
+
+#include <cstdint>
+
+//! The Internal Chat Packet Identifiers
+enum class eChatMessageType :uint32_t {
+	LOGIN_SESSION_NOTIFY = 0,
+	GENERAL_CHAT_MESSAGE,
+	PRIVATE_CHAT_MESSAGE,
+	USER_CHANNEL_CHAT_MESSAGE,
+	WORLD_DISCONNECT_REQUEST,
+	WORLD_PROXIMITY_RESPONSE,
+	WORLD_PARCEL_RESPONSE,
+	ADD_FRIEND_REQUEST,
+	ADD_FRIEND_RESPONSE,
+	REMOVE_FRIEND,
+	GET_FRIENDS_LIST,
+	ADD_IGNORE,
+	REMOVE_IGNORE,
+	GET_IGNORE_LIST,
+	TEAM_MISSED_INVITE_CHECK,
+	TEAM_INVITE,
+	TEAM_INVITE_RESPONSE,
+	TEAM_KICK,
+	TEAM_LEAVE,
+	TEAM_SET_LOOT,
+	TEAM_SET_LEADER,
+	TEAM_GET_STATUS,
+	GUILD_CREATE,
+	GUILD_INVITE,
+	GUILD_INVITE_RESPONSE,
+	GUILD_LEAVE,
+	GUILD_KICK,
+	GUILD_GET_STATUS,
+	GUILD_GET_ALL,
+	SHOW_ALL,
+	BLUEPRINT_MODERATED,
+	BLUEPRINT_MODEL_READY,
+	PROPERTY_READY_FOR_APPROVAL,
+	PROPERTY_MODERATION_CHANGED,
+	PROPERTY_BUILDMODE_CHANGED,
+	PROPERTY_BUILDMODE_CHANGED_REPORT,
+	MAIL,
+	WORLD_INSTANCE_LOCATION_REQUEST,
+	REPUTATION_UPDATE,
+	SEND_CANNED_TEXT,
+	GMLEVEL_UPDATE,
+	CHARACTER_NAME_CHANGE_REQUEST,
+	CSR_REQUEST,
+	CSR_REPLY,
+	GM_KICK,
+	GM_ANNOUNCE,
+	GM_MUTE,
+	ACTIVITY_UPDATE,
+	WORLD_ROUTE_PACKET,
+	GET_ZONE_POPULATIONS,
+	REQUEST_MINIMUM_CHAT_MODE,
+	REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
+	MATCH_REQUEST,
+	UGCMANIFEST_REPORT_MISSING_FILE,
+	UGCMANIFEST_REPORT_DONE_FILE,
+	UGCMANIFEST_REPORT_DONE_BLUEPRINT,
+	UGCC_REQUEST,
+	WHO,
+	WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
+	ACHIEVEMENT_NOTIFY,
+	GM_CLOSE_PRIVATE_CHAT_WINDOW,
+	UNEXPECTED_DISCONNECT,
+	PLAYER_READY,
+	GET_DONATION_TOTAL,
+	UPDATE_DONATION,
+	PRG_CSR_COMMAND,
+	HEARTBEAT_REQUEST_FROM_WORLD,
+	UPDATE_FREE_TRIAL_STATUS
+};
+
+#endif  //!__ECHATMESSAGETYPE__H__
--- a/dCommon/dEnums/eClientMessageType.h
+++ b/dCommon/dEnums/eClientMessageType.h
@@ -0,0 +1,76 @@
+#ifndef __ECLIENTMESSAGETYPE__H__
+#define __ECLIENTMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eClientMessageType : uint32_t {
+	LOGIN_RESPONSE = 0,
+	LOGOUT_RESPONSE,
+	LOAD_STATIC_ZONE,
+	CREATE_OBJECT,
+	CREATE_CHARACTER,
+	CREATE_CHARACTER_EXTENDED,
+	CHARACTER_LIST_RESPONSE,
+	CHARACTER_CREATE_RESPONSE,
+	CHARACTER_RENAME_RESPONSE,
+	CHAT_CONNECT_RESPONSE,
+	AUTH_ACCOUNT_CREATE_RESPONSE,
+	DELETE_CHARACTER_RESPONSE,
+	GAME_MSG,
+	CONNECT_CHAT,
+	TRANSFER_TO_WORLD,
+	IMPENDING_RELOAD_NOTIFY,
+	MAKE_GM_RESPONSE,
+	HTTP_MONITOR_INFO_RESPONSE,
+	SLASH_PUSH_MAP_RESPONSE,
+	SLASH_PULL_MAP_RESPONSE,
+	SLASH_LOCK_MAP_RESPONSE,
+	BLUEPRINT_SAVE_RESPONSE,
+	BLUEPRINT_LUP_SAVE_RESPONSE,
+	BLUEPRINT_LOAD_RESPONSE_ITEMID,
+	BLUEPRINT_GET_ALL_DATA_RESPONSE,
+	MODEL_INSTANTIATE_RESPONSE,
+	DEBUG_OUTPUT,
+	ADD_FRIEND_REQUEST,
+	ADD_FRIEND_RESPONSE,
+	REMOVE_FRIEND_RESPONSE,
+	GET_FRIENDS_LIST_RESPONSE,
+	UPDATE_FRIEND_NOTIFY,
+	ADD_IGNORE_RESPONSE,
+	REMOVE_IGNORE_RESPONSE,
+	GET_IGNORE_LIST_RESPONSE,
+	TEAM_INVITE,
+	TEAM_INVITE_INITIAL_RESPONSE,
+	GUILD_CREATE_RESPONSE,
+	GUILD_GET_STATUS_RESPONSE,
+	GUILD_INVITE,
+	GUILD_INVITE_INITIAL_RESPONSE,
+	GUILD_INVITE_FINAL_RESPONSE,
+	GUILD_INVITE_CONFIRM,
+	GUILD_ADD_PLAYER,
+	GUILD_REMOVE_PLAYER,
+	GUILD_LOGIN_LOGOUT,
+	GUILD_RANK_CHANGE,
+	GUILD_DATA,
+	GUILD_STATUS,
+	MAIL,
+	DB_PROXY_RESULT,
+	SHOW_ALL_RESPONSE,
+	WHO_RESPONSE,
+	SEND_CANNED_TEXT,
+	UPDATE_CHARACTER_NAME,
+	SET_NETWORK_SIMULATOR,
+	INVALID_CHAT_MESSAGE,
+	MINIMUM_CHAT_MODE_RESPONSE,
+	MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
+	CHAT_MODERATION_STRING,
+	UGC_MANIFEST_RESPONSE,
+	IN_LOGIN_QUEUE,
+	SERVER_STATES,
+	GM_CLOSE_TARGET_CHAT_WINDOW,
+	GENERAL_TEXT_FOR_LOCALIZATION,
+	UPDATE_FREE_TRIAL_STATUS,
+	UGC_DOWNLOAD_FAILED = 120
+};
+
+#endif  //!__ECLIENTMESSAGETYPE__H__
--- a/dCommon/dEnums/eConnectionType.h
+++ b/dCommon/dEnums/eConnectionType.h
@@ -5,7 +5,8 @@ enum class eConnectionType : uint16_t {
 	SERVER = 0,
 	AUTH,
 	CHAT,
-	WORLD = 4,
+	CHAT_INTERNAL,
+	WORLD,
 	CLIENT,
 	MASTER
 };
--- a/dCommon/dEnums/eGameMessageType.h
+++ b/dCommon/dEnums/eGameMessageType.h
--- a/dCommon/dEnums/eInventoryType.h
+++ b/dCommon/dEnums/eInventoryType.h
@@ -4,9 +4,6 @@
 #define __EINVENTORYTYPE__H__

 #include <cstdint>
-
-#include "magic_enum.hpp"
-
 static const uint8_t NUMBER_OF_INVENTORIES = 17;
 /**
 * Represents the different types of inventories an entity may have
@@ -59,10 +56,4 @@ public:
 	};
 };

-template <>
-struct magic_enum::customize::enum_range<eInventoryType> {
-	static constexpr int min = 0;
-	static constexpr int max = 16;
-};
-
 #endif  //!__EINVENTORYTYPE__H__
--- a/dCommon/dEnums/eMasterMessageType.h
+++ b/dCommon/dEnums/eMasterMessageType.h
@@ -0,0 +1,36 @@
+#ifndef __EMASTERMESSAGETYPE__H__
+#define __EMASTERMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eMasterMessageType : uint32_t {
+	REQUEST_PERSISTENT_ID = 1,
+	REQUEST_PERSISTENT_ID_RESPONSE,
+	REQUEST_ZONE_TRANSFER,
+	REQUEST_ZONE_TRANSFER_RESPONSE,
+	SERVER_INFO,
+	REQUEST_SESSION_KEY,
+	SET_SESSION_KEY,
+	SESSION_KEY_RESPONSE,
+	PLAYER_ADDED,
+	PLAYER_REMOVED,
+
+	CREATE_PRIVATE_ZONE,
+	REQUEST_PRIVATE_ZONE,
+
+	WORLD_READY,
+	PREP_ZONE,
+
+	SHUTDOWN,
+	SHUTDOWN_RESPONSE,
+	SHUTDOWN_IMMEDIATE,
+
+	SHUTDOWN_UNIVERSE,
+
+	AFFIRM_TRANSFER_REQUEST,
+	AFFIRM_TRANSFER_RESPONSE,
+
+	NEW_SESSION_ALERT
+};
+
+#endif  //!__EMASTERMESSAGETYPE__H__
--- a/dCommon/dEnums/ePropertySortType.h
+++ b/dCommon/dEnums/ePropertySortType.h
@@ -1,11 +0,0 @@
-#ifndef EPROPERTYSORTTYPE_H
-#define EPROPERTYSORTTYPE_H
-
-enum ePropertySortType : int32_t {
-	SORT_TYPE_FRIENDS = 0,
-	SORT_TYPE_REPUTATION = 1,
-	SORT_TYPE_RECENT = 3,
-	SORT_TYPE_FEATURED = 5
-};
-
-#endif  //!EPROPERTYSORTTYPE_H
--- a/dCommon/dEnums/eReplicaComponentType.h
+++ b/dCommon/dEnums/eReplicaComponentType.h
@@ -106,7 +106,7 @@ enum class eReplicaComponentType : uint32_t {
 	INTERACTION_MANAGER,
 	DONATION_VENDOR,
 	COMBAT_MEDIATOR,
-	ACHIEVEMENT_VENDOR,
+	COMMENDATION_VENDOR,
 	GATE_RUSH_CONTROL,
 	RAIL_ACTIVATOR,
 	ROLLER,
--- a/dCommon/dEnums/eReponseMoveItemBetweenInventoryTypeCode.h
+++ b/dCommon/dEnums/eReponseMoveItemBetweenInventoryTypeCode.h
@@ -1,21 +0,0 @@
-#ifndef __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
-#define __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
-
-#include <cstdint>
-
-enum class eReponseMoveItemBetweenInventoryTypeCode : int32_t {
-	SUCCESS,
-	FAIL_GENERIC,
-	FAIL_INV_FULL,
-	FAIL_ITEM_NOT_FOUND,
-	FAIL_CANT_MOVE_TO_THAT_INV_TYPE,
-	FAIL_NOT_NEAR_BANK,
-	FAIL_CANT_SWAP_ITEMS,
-	FAIL_SOURCE_TYPE,
-	FAIL_WRONG_DEST_TYPE,
-	FAIL_SWAP_DEST_TYPE,
-	FAIL_CANT_MOVE_THINKING_HAT,
-	FAIL_DISMOUNT_BEFORE_MOVING
-};
-
-#endif  //!__EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
--- a/dCommon/dEnums/eServerMessageType.h
+++ b/dCommon/dEnums/eServerMessageType.h
@@ -0,0 +1,12 @@
+#ifndef __ESERVERMESSAGETYPE__H__
+#define __ESERVERMESSAGETYPE__H__
+
+#include <cstdint>
+//! The Internal Server Packet Identifiers
+enum class eServerMessageType : uint32_t {
+	VERSION_CONFIRM = 0,
+	DISCONNECT_NOTIFY,
+	GENERAL_NOTIFY
+};
+
+#endif  //!__ESERVERMESSAGETYPE__H__
--- a/dCommon/dEnums/eVendorTransactionResult.h
+++ b/dCommon/dEnums/eVendorTransactionResult.h
@@ -1,15 +0,0 @@
-#ifndef __EVENDORTRANSACTIONRESULT__
-#define __EVENDORTRANSACTIONRESULT__
-
-#include <cstdint>
-
-enum class eVendorTransactionResult : uint32_t {
-	SELL_SUCCESS = 0,
-	SELL_FAIL,
-	PURCHASE_SUCCESS,
-	PURCHASE_FAIL,
-	DONATION_FAIL,
-	DONATION_FULL
-};
-
-#endif // !__EVENDORTRANSACTIONRESULT__
--- a/dCommon/dEnums/eWaypointCommandType.h
+++ b/dCommon/dEnums/eWaypointCommandType.h
@@ -1,59 +0,0 @@
-
-#ifndef __EWAYPOINTCOMMANDTYPES__H__
-#define __EWAYPOINTCOMMANDTYPES__H__
-
-#include <cstdint>
-
-enum class eWaypointCommandType : uint32_t {
-	INVALID,
-	BOUNCE,
-	STOP,
-	GROUP_EMOTE,
-	SET_VARIABLE,
-	CAST_SKILL,
-	EQUIP_INVENTORY,
-	UNEQUIP_INVENTORY,
-	DELAY,
-	EMOTE,
-	TELEPORT,
-	PATH_SPEED,
-	REMOVE_NPC,
-	CHANGE_WAYPOINT,
-	DELETE_SELF,
-	KILL_SELF,
-	SPAWN_OBJECT,
-	PLAY_SOUND,
-};
-
-class WaypointCommandType {
-public:
-	static eWaypointCommandType StringToWaypointCommandType(std::string commandString) {
-		const std::map<std::string, eWaypointCommandType> WaypointCommandTypeMap = {
-			{"bounce", eWaypointCommandType::BOUNCE},
-			{"stop", eWaypointCommandType::STOP},
-			{"groupemote", eWaypointCommandType::GROUP_EMOTE},
-			{"setvar", eWaypointCommandType::SET_VARIABLE},
-			{"castskill", eWaypointCommandType::CAST_SKILL},
-			{"eqInvent", eWaypointCommandType::EQUIP_INVENTORY},
-			{"unInvent", eWaypointCommandType::UNEQUIP_INVENTORY},
-			{"delay", eWaypointCommandType::DELAY},
-			{"femote", eWaypointCommandType::EMOTE},
-			{"emote", eWaypointCommandType::EMOTE},
-			{"teleport", eWaypointCommandType::TELEPORT},
-			{"pathspeed", eWaypointCommandType::PATH_SPEED},
-			{"removeNPC", eWaypointCommandType::REMOVE_NPC},
-			{"changeWP", eWaypointCommandType::CHANGE_WAYPOINT},
-			{"DeleteSelf", eWaypointCommandType::DELETE_SELF},
-			{"killself", eWaypointCommandType::KILL_SELF},
-			{"removeself", eWaypointCommandType::DELETE_SELF},
-			{"spawnOBJ", eWaypointCommandType::SPAWN_OBJECT},
-			{"playSound", eWaypointCommandType::PLAY_SOUND},
-		};
-
-		auto intermed = WaypointCommandTypeMap.find(commandString);
-		return (intermed != WaypointCommandTypeMap.end()) ? intermed->second : eWaypointCommandType::INVALID;
-	};
-};
-
-
-#endif  //!__EWAYPOINTCOMMANDTYPES__H__
--- a/dCommon/dEnums/eWorldMessageType.h
+++ b/dCommon/dEnums/eWorldMessageType.h
@@ -0,0 +1,51 @@
+#ifndef __EWORLDMESSAGETYPE__H__
+#define __EWORLDMESSAGETYPE__H__
+
+#include <cstdint>
+
+#include "magic_enum.hpp"
+
+enum class eWorldMessageType : uint32_t {
+	VALIDATION = 1,  // 				Session info
+	CHARACTER_LIST_REQUEST,
+	CHARACTER_CREATE_REQUEST,
+	LOGIN_REQUEST,  // 			Character selected
+	GAME_MSG,
+	CHARACTER_DELETE_REQUEST,
+	CHARACTER_RENAME_REQUEST,
+	HAPPY_FLOWER_MODE_NOTIFY,
+	SLASH_RELOAD_MAP,  // 			Reload map cmp
+	SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
+	SLASH_PUSH_MAP,  // 			Push map cmd
+	SLASH_PULL_MAP,  // 			Pull map cmd
+	LOCK_MAP_REQUEST,
+	GENERAL_CHAT_MESSAGE,  // 		General chat message
+	HTTP_MONITOR_INFO_REQUEST,
+	SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
+	MODELS_CLEAR,
+	EXHIBIT_INSERT_MODEL,
+	LEVEL_LOAD_COMPLETE,  // 		Character data request
+	TMP_GUILD_CREATE,
+	ROUTE_PACKET,  // 				Social?
+	POSITION_UPDATE,
+	MAIL,
+	WORD_CHECK, // 				Whitelist word check
+	STRING_CHECK,  // 				Whitelist string check
+	GET_PLAYERS_IN_ZONE,
+	REQUEST_UGC_MANIFEST_INFO,
+	BLUEPRINT_GET_ALL_DATA_REQUEST,
+	CANCEL_MAP_QUEUE,
+	HANDLE_FUNNESS,
+	FAKE_PRG_CSR_MESSAGE,
+	REQUEST_FREE_TRIAL_REFRESH,
+	GM_SET_FREE_TRIAL_STATUS,
+	UI_HELP_TOP_5 = 91
+};
+
+template <>
+struct magic_enum::customize::enum_range<eWorldMessageType> {
+	static constexpr int min = 0;
+	static constexpr int max = 91;
+};
+
+#endif  //!__EWORLDMESSAGETYPE__H__
--- a/dDatabase/CDClientDatabase/CDClientManager.cpp
+++ b/dDatabase/CDClientDatabase/CDClientManager.cpp
@@ -25,7 +25,6 @@
 #include "CDScriptComponentTable.h"
 #include "CDSkillBehaviorTable.h"
 #include "CDZoneTableTable.h"
-#include "CDTamingBuildPuzzleTable.h"
 #include "CDVendorComponentTable.h"
 #include "CDActivitiesTable.h"
 #include "CDPackageComponentTable.h"
@@ -40,7 +39,8 @@
 #include "CDFeatureGatingTable.h"
 #include "CDRailActivatorComponent.h"
 #include "CDRewardCodesTable.h"
-#include "CDPetComponentTable.h"
+
+#include <exception>

 #ifndef CDCLIENT_CACHE_ALL
 // Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
@@ -54,60 +54,15 @@
 	#define CDCLIENT_DONT_CACHE_TABLE(x)
 #endif

-// Using a macro to reduce repetitive code and issues from copy and paste.
-// As a note, ## in a macro is used to concatenate two tokens together.
-
-#define SPECIALIZE_TABLE_STORAGE(table) \
-	template<> typename table::StorageType& CDClientManager::GetEntriesMutable<table>() { return table##Entries; };
-
-#define DEFINE_TABLE_STORAGE(table) namespace { table::StorageType table##Entries; }; SPECIALIZE_TABLE_STORAGE(table)
-
-DEFINE_TABLE_STORAGE(CDActivityRewardsTable);
-DEFINE_TABLE_STORAGE(CDActivitiesTable);
-DEFINE_TABLE_STORAGE(CDAnimationsTable);
-DEFINE_TABLE_STORAGE(CDBehaviorParameterTable);
-DEFINE_TABLE_STORAGE(CDBehaviorTemplateTable);
-DEFINE_TABLE_STORAGE(CDBrickIDTableTable);
-DEFINE_TABLE_STORAGE(CDComponentsRegistryTable);
-DEFINE_TABLE_STORAGE(CDCurrencyTableTable);
-DEFINE_TABLE_STORAGE(CDDestructibleComponentTable);
-DEFINE_TABLE_STORAGE(CDEmoteTableTable);
-DEFINE_TABLE_STORAGE(CDFeatureGatingTable);
-DEFINE_TABLE_STORAGE(CDInventoryComponentTable);
-DEFINE_TABLE_STORAGE(CDItemComponentTable);
-DEFINE_TABLE_STORAGE(CDItemSetSkillsTable);
-DEFINE_TABLE_STORAGE(CDItemSetsTable);
-DEFINE_TABLE_STORAGE(CDLevelProgressionLookupTable);
-DEFINE_TABLE_STORAGE(CDLootMatrixTable);
-DEFINE_TABLE_STORAGE(CDLootTableTable);
-DEFINE_TABLE_STORAGE(CDMissionEmailTable);
-DEFINE_TABLE_STORAGE(CDMissionNPCComponentTable);
-DEFINE_TABLE_STORAGE(CDMissionTasksTable);
-DEFINE_TABLE_STORAGE(CDMissionsTable);
-DEFINE_TABLE_STORAGE(CDMovementAIComponentTable);
-DEFINE_TABLE_STORAGE(CDObjectSkillsTable);
-DEFINE_TABLE_STORAGE(CDObjectsTable);
-DEFINE_TABLE_STORAGE(CDPhysicsComponentTable);
-DEFINE_TABLE_STORAGE(CDPackageComponentTable);
-DEFINE_TABLE_STORAGE(CDPetComponentTable);
-DEFINE_TABLE_STORAGE(CDProximityMonitorComponentTable);
-DEFINE_TABLE_STORAGE(CDPropertyEntranceComponentTable);
-DEFINE_TABLE_STORAGE(CDPropertyTemplateTable);
-DEFINE_TABLE_STORAGE(CDRailActivatorComponentTable);
-DEFINE_TABLE_STORAGE(CDRarityTableTable);
-DEFINE_TABLE_STORAGE(CDRebuildComponentTable);
-DEFINE_TABLE_STORAGE(CDRewardCodesTable);
-DEFINE_TABLE_STORAGE(CDRewardsTable);
-DEFINE_TABLE_STORAGE(CDScriptComponentTable);
-DEFINE_TABLE_STORAGE(CDSkillBehaviorTable);
-DEFINE_TABLE_STORAGE(CDTamingBuildPuzzleTable);
-DEFINE_TABLE_STORAGE(CDVendorComponentTable);
-DEFINE_TABLE_STORAGE(CDZoneTableTable);
+class CDClientConnectionException : public std::exception {
+public:
+	virtual const char* what() const throw() {
+		return "CDClientDatabase is not connected!";
+	}
+};

 void CDClientManager::LoadValuesFromDatabase() {
-	if (!CDClientDatabase::isConnected) {
-		throw std::runtime_error{ "CDClientDatabase is not connected!" };
-	}
+	if (!CDClientDatabase::isConnected) throw CDClientConnectionException();

 	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
 	CDActivitiesTable::Instance().LoadValuesFromDatabase();
@@ -147,7 +102,6 @@ void CDClientManager::LoadValuesFromDatabase() {
 	CDRewardsTable::Instance().LoadValuesFromDatabase();
 	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
 	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
-	CDTamingBuildPuzzleTable::Instance().LoadValuesFromDatabase();
 	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
 	CDZoneTableTable::Instance().LoadValuesFromDatabase();
 }
--- a/dDatabase/CDClientDatabase/CDClientManager.h
+++ b/dDatabase/CDClientDatabase/CDClientManager.h
@@ -1,12 +1,18 @@
-#ifndef __CDCLIENTMANAGER__H__
-#define __CDCLIENTMANAGER__H__
+#pragma once
+
+#include "CDTable.h"
+
+#include "Singleton.h"

 #define UNUSED_TABLE(v)

 /**
 * Initialize the CDClient tables so they are all loaded into memory.
 */
-namespace CDClientManager {
+class CDClientManager : public Singleton<CDClientManager> {
+public:
+	CDClientManager() = default;
+
 	void LoadValuesFromDatabase();
 	void LoadValuesFromDefaults();

@@ -17,28 +23,7 @@ namespace CDClientManager {
 	 * @return A pointer to the requested table.
 	 */
 	template<typename T>
-	T* GetTable();
-
-	/**
-	 * Fetch a table from CDClient
-	 * Note: Calling this function without a template specialization in CDClientManager.cpp will cause a linker error.
-	 * 
-	 * @tparam Table type to fetch
-	 * @return A pointer to the requested table.
-	 */
-	template<typename T>
-	typename T::StorageType& GetEntriesMutable();
+	T* GetTable() {
+		return &T::Instance();
+	}
 };
-
-
-// These are included after the CDClientManager namespace declaration as CDTable as of Jan 29 2024 relies on CDClientManager in Templated code.
-#include "CDTable.h"
-
-#include "Singleton.h"
-
-template<typename T>
-T* CDClientManager::GetTable() {
-	return &T::Instance();
-};
-
-#endif  //!__CDCLIENTMANAGER__H__
--- a/dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp
@@ -1,6 +1,5 @@
 #include "CDActivitiesTable.h"

-
 void CDActivitiesTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
 	uint32_t size = 0;
@@ -14,8 +13,7 @@ void CDActivitiesTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Activities");
@@ -41,7 +39,7 @@ void CDActivitiesTable::LoadValuesFromDatabase() {
 		entry.noTeamLootOnDeath = tableData.getIntField("noTeamLootOnDeath", -1);
 		entry.optionalPercentage = tableData.getFloatField("optionalPercentage", -1.0f);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -50,7 +48,7 @@ void CDActivitiesTable::LoadValuesFromDatabase() {

 std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActivities)> predicate) {

-	std::vector<CDActivities> data = cpplinq::from(GetEntries())
+	std::vector<CDActivities> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

--- a/dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h
@@ -25,10 +25,15 @@ struct CDActivities {
 	float optionalPercentage;
 };

-class CDActivitiesTable : public CDTable<CDActivitiesTable, std::vector<CDActivities>> {
+class CDActivitiesTable : public CDTable<CDActivitiesTable> {
+private:
+	std::vector<CDActivities> entries;
+
 public:
 	void LoadValuesFromDatabase();

 	// Queries the table with a custom "where" clause
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
+
+	const std::vector<CDActivities>& GetEntries() const { return this->entries; }
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.cpp
@@ -1,6 +1,5 @@
 #include "CDActivityRewardsTable.h"

-
 void CDActivityRewardsTable::LoadValuesFromDatabase() {

 	// First, get the size of the table
@@ -15,8 +14,7 @@ void CDActivityRewardsTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ActivityRewards");
@@ -30,7 +28,7 @@ void CDActivityRewardsTable::LoadValuesFromDatabase() {
 		entry.ChallengeRating = tableData.getIntField("ChallengeRating", -1);
 		entry.description = tableData.getStringField("description", "");

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -39,7 +37,7 @@ void CDActivityRewardsTable::LoadValuesFromDatabase() {

 std::vector<CDActivityRewards> CDActivityRewardsTable::Query(std::function<bool(CDActivityRewards)> predicate) {

-	std::vector<CDActivityRewards> data = cpplinq::from(GetEntries())
+	std::vector<CDActivityRewards> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

--- a/dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.h
@@ -13,9 +13,15 @@ struct CDActivityRewards {
 	std::string description;            //!< The description
 };

-class CDActivityRewardsTable : public CDTable<CDActivityRewardsTable, std::vector<CDActivityRewards>> {
+class CDActivityRewardsTable : public CDTable<CDActivityRewardsTable> {
+private:
+	std::vector<CDActivityRewards> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivityRewards> Query(std::function<bool(CDActivityRewards)> predicate);
+
+	std::vector<CDActivityRewards> GetEntries() const;
+
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.cpp
@@ -5,7 +5,6 @@

 void CDAnimationsTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Animations");
-	auto& animations = GetEntriesMutable();
 	while (!tableData.eof()) {
 		std::string animation_type = tableData.getStringField("animation_type", "");
 		DluAssert(!animation_type.empty());
@@ -25,7 +24,7 @@ void CDAnimationsTable::LoadValuesFromDatabase() {
 		UNUSED_COLUMN(entry.priority = tableData.getFloatField("priority", 0.0f);)
 		UNUSED_COLUMN(entry.blendTime = tableData.getFloatField("blendTime", 0.0f);)

-		animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
+		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
 		tableData.nextRow();
 	}

@@ -36,7 +35,6 @@ bool CDAnimationsTable::CacheData(CppSQLite3Statement& queryToCache) {
 	auto tableData = queryToCache.execQuery();
 	// If we received a bad lookup, cache it anyways so we do not run the query again.
 	if (tableData.eof()) return false;
-	auto& animations = GetEntriesMutable();

 	do {
 		std::string animation_type = tableData.getStringField("animation_type", "");
@@ -57,7 +55,7 @@ bool CDAnimationsTable::CacheData(CppSQLite3Statement& queryToCache) {
 		UNUSED_COLUMN(entry.priority = tableData.getFloatField("priority", 0.0f);)
 		UNUSED_COLUMN(entry.blendTime = tableData.getFloatField("blendTime", 0.0f);)

-		animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
+		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
 		tableData.nextRow();
 	} while (!tableData.eof());

@@ -70,17 +68,15 @@ void CDAnimationsTable::CacheAnimations(const CDAnimationKey animationKey) {
 	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Animations WHERE animationGroupID = ? and animation_type = ?");
 	query.bind(1, static_cast<int32_t>(animationKey.second));
 	query.bind(2, animationKey.first.c_str());
-	auto& animations = GetEntriesMutable();
 	// If we received a bad lookup, cache it anyways so we do not run the query again.
 	if (!CacheData(query)) {
-		animations[animationKey];
+		this->animations[animationKey];
 	}
 }

 void CDAnimationsTable::CacheAnimationGroup(AnimationGroupID animationGroupID) {
-	auto& animations = GetEntriesMutable();
-	auto animationEntryCached = animations.find(CDAnimationKey("", animationGroupID));
-	if (animationEntryCached != animations.end()) {
+	auto animationEntryCached = this->animations.find(CDAnimationKey("", animationGroupID));
+	if (animationEntryCached != this->animations.end()) {
 		return;
 	}

@@ -89,29 +85,28 @@ void CDAnimationsTable::CacheAnimationGroup(AnimationGroupID animationGroupID) {

 	// Cache the query so we don't run the query again.
 	CacheData(query);
-	animations[CDAnimationKey("", animationGroupID)];
+	this->animations[CDAnimationKey("", animationGroupID)];
 }

-std::optional<CDAnimation> CDAnimationsTable::GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID) {
-	auto& animations = GetEntriesMutable();
+CDAnimationLookupResult CDAnimationsTable::GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID) {
 	CDAnimationKey animationKey(animationType, animationGroupID);
-	auto animationEntryCached = animations.find(animationKey);
-	if (animationEntryCached == animations.end()) {
+	auto animationEntryCached = this->animations.find(animationKey);
+	if (animationEntryCached == this->animations.end()) {
 		this->CacheAnimations(animationKey);
 	}

-	auto animationEntry = animations.find(animationKey);
+	auto animationEntry = this->animations.find(animationKey);
 	// If we have only one animation, return it regardless of the chance to play.
 	if (animationEntry->second.size() == 1) {
-		return animationEntry->second.front();
+		return CDAnimationLookupResult(animationEntry->second.front());
 	}
 	auto randomAnimation = GeneralUtils::GenerateRandomNumber<float>(0, 1);

 	for (auto& animationEntry : animationEntry->second) {
 		randomAnimation -= animationEntry.chance_to_play;
 		// This is how the client gets the random animation.
-		if (animationEntry.animation_name != previousAnimationName && randomAnimation <= 0.0f) return animationEntry;
+		if (animationEntry.animation_name != previousAnimationName && randomAnimation <= 0.0f) return CDAnimationLookupResult(animationEntry);
 	}

-	return std::nullopt;
+	return CDAnimationLookupResult();
 }
--- a/dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.h
@@ -2,11 +2,6 @@

 #include "CDTable.h"
 #include <list>
-#include <optional>
-
-typedef int32_t AnimationGroupID;
-typedef std::string AnimationID;
-typedef std::pair<std::string, AnimationGroupID> CDAnimationKey;

 struct CDAnimation {
 	// uint32_t animationGroupID;
@@ -25,7 +20,12 @@ struct CDAnimation {
 	UNUSED_COLUMN(float blendTime;)                //!< The blend time
 };

-class CDAnimationsTable : public CDTable<CDAnimationsTable, std::map<CDAnimationKey, std::list<CDAnimation>>> {
+typedef LookupResult<CDAnimation> CDAnimationLookupResult;
+
+class CDAnimationsTable : public CDTable<CDAnimationsTable> {
+	typedef int32_t AnimationGroupID;
+	typedef std::string AnimationID;
+	typedef std::pair<std::string, AnimationGroupID> CDAnimationKey;
 public:
 	void LoadValuesFromDatabase();
 	/**
@@ -38,7 +38,7 @@ public:
 	 * @param animationGroupID The animationGroupID to lookup
 	 * @return CDAnimationLookupResult 
 	 */
-	[[nodiscard]] std::optional<CDAnimation> GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID);
+	[[nodiscard]] CDAnimationLookupResult GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID);

 	/**
 	 * Cache a full AnimationGroup by its ID.
@@ -58,4 +58,10 @@ private:
 	 * @return false 
 	 */
 	bool CacheData(CppSQLite3Statement& queryToCache);
+
+	/**
+	 * Each animation is key'd by its animationName and its animationGroupID.  Each
+	 * animation has a possible list of animations.  This is because there can be animations have a percent chance to play so one is selected at random.
+	 */
+	std::map<CDAnimationKey, std::list<CDAnimation>> animations;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorParameterTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorParameterTable.cpp
@@ -1,10 +1,6 @@
 #include "CDBehaviorParameterTable.h"
 #include "GeneralUtils.h"

-namespace {
-	std::unordered_map<std::string, uint32_t> m_ParametersList;
-};
-
 uint64_t GetKey(const uint32_t behaviorID, const uint32_t parameterID) {
 	uint64_t key = behaviorID;
 	key <<= 31U;
@@ -15,7 +11,6 @@ uint64_t GetKey(const uint32_t behaviorID, const uint32_t parameterID) {

 void CDBehaviorParameterTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorParameter");
-	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
 		uint32_t behaviorID = tableData.getIntField("behaviorID", -1);
 		auto candidateStringToAdd = std::string(tableData.getStringField("parameterID", ""));
@@ -29,7 +24,7 @@ void CDBehaviorParameterTable::LoadValuesFromDatabase() {
 		uint64_t hash = GetKey(behaviorID, parameterId);
 		float value = tableData.getFloatField("value", -1.0f);

-		entries.insert(std::make_pair(hash, value));
+		m_Entries.insert(std::make_pair(hash, value));

 		tableData.nextRow();
 	}
@@ -37,24 +32,22 @@ void CDBehaviorParameterTable::LoadValuesFromDatabase() {
 }

 float CDBehaviorParameterTable::GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue) {
-	auto parameterID = m_ParametersList.find(name);
-	if (parameterID == m_ParametersList.end()) return defaultValue;
+	auto parameterID = this->m_ParametersList.find(name);
+	if (parameterID == this->m_ParametersList.end()) return defaultValue;
 	auto hash = GetKey(behaviorID, parameterID->second);

 	// Search for specific parameter
-	auto& entries = GetEntriesMutable();
-	auto it = entries.find(hash);
-	return it != entries.end() ? it->second : defaultValue;
+	auto it = m_Entries.find(hash);
+	return it != m_Entries.end() ? it->second : defaultValue;
 }

 std::map<std::string, float> CDBehaviorParameterTable::GetParametersByBehaviorID(uint32_t behaviorID) {
-	auto& entries = GetEntriesMutable();
 	uint64_t hashBase = behaviorID;
 	std::map<std::string, float> returnInfo;
 	for (auto& [parameterString, parameterId] : m_ParametersList) {
 		uint64_t hash = GetKey(hashBase, parameterId);
-		auto infoCandidate = entries.find(hash);
-		if (infoCandidate != entries.end()) {
+		auto infoCandidate = m_Entries.find(hash);
+		if (infoCandidate != m_Entries.end()) {
 			returnInfo.insert(std::make_pair(parameterString, infoCandidate->second));
 		}
 	}
--- a/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorParameterTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorParameterTable.h
@@ -5,10 +5,12 @@
 #include <unordered_map>
 #include <unordered_set>

-typedef uint64_t BehaviorParameterHash;
-typedef float BehaviorParameterValue;
-
-class CDBehaviorParameterTable : public CDTable<CDBehaviorParameterTable, std::unordered_map<BehaviorParameterHash, BehaviorParameterValue>> {
+class CDBehaviorParameterTable : public CDTable<CDBehaviorParameterTable> {
+private:
+	typedef uint64_t BehaviorParameterHash;
+	typedef float BehaviorParameterValue;
+	std::unordered_map<BehaviorParameterHash, BehaviorParameterValue> m_Entries;
+	std::unordered_map<std::string, uint32_t> m_ParametersList;
 public:
 	void LoadValuesFromDatabase();

--- a/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.cpp
@@ -1,9 +1,5 @@
 #include "CDBehaviorTemplateTable.h"

-namespace {
-	std::unordered_set<std::string> m_EffectHandles;
-};
-
 void CDBehaviorTemplateTable::LoadValuesFromDatabase() {

 	// First, get the size of the table
@@ -17,9 +13,11 @@ void CDBehaviorTemplateTable::LoadValuesFromDatabase() {

 	tableSize.finalize();

+	// Reserve the size
+	this->entries.reserve(size);
+
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorTemplate");
-	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
 		CDBehaviorTemplate entry;
 		entry.behaviorID = tableData.getIntField("behaviorID", -1);
@@ -33,17 +31,30 @@ void CDBehaviorTemplateTable::LoadValuesFromDatabase() {
 			entry.effectHandle = m_EffectHandles.insert(candidateToAdd).first;
 		}

-		entries.insert(std::make_pair(entry.behaviorID, entry));
+		this->entries.push_back(entry);
+		this->entriesMappedByBehaviorID.insert(std::make_pair(entry.behaviorID, entry));
 		tableData.nextRow();
 	}

 	tableData.finalize();
 }

+std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::Query(std::function<bool(CDBehaviorTemplate)> predicate) {
+
+	std::vector<CDBehaviorTemplate> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
+}
+
+const std::vector<CDBehaviorTemplate>& CDBehaviorTemplateTable::GetEntries() const {
+	return this->entries;
+}
+
 const CDBehaviorTemplate CDBehaviorTemplateTable::GetByBehaviorID(uint32_t behaviorID) {
-	auto& entries = GetEntriesMutable();
-	auto entry = entries.find(behaviorID);
-	if (entry == entries.end()) {
+	auto entry = this->entriesMappedByBehaviorID.find(behaviorID);
+	if (entry == this->entriesMappedByBehaviorID.end()) {
 		CDBehaviorTemplate entryToReturn;
 		entryToReturn.behaviorID = 0;
 		entryToReturn.effectHandle = m_EffectHandles.end();
--- a/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.h
@@ -12,9 +12,19 @@ struct CDBehaviorTemplate {
 	std::unordered_set<std::string>::iterator effectHandle;          //!< The effect handle
 };

-class CDBehaviorTemplateTable : public CDTable<CDBehaviorTemplateTable, std::unordered_map<uint32_t, CDBehaviorTemplate>> {
+
+class CDBehaviorTemplateTable : public CDTable<CDBehaviorTemplateTable> {
+private:
+	std::vector<CDBehaviorTemplate> entries;
+	std::unordered_map<uint32_t, CDBehaviorTemplate> entriesMappedByBehaviorID;
+	std::unordered_set<std::string> m_EffectHandles;
 public:
 	void LoadValuesFromDatabase();

+	// Queries the table with a custom "where" clause
+	std::vector<CDBehaviorTemplate> Query(std::function<bool(CDBehaviorTemplate)> predicate);
+
+	const std::vector<CDBehaviorTemplate>& GetEntries(void) const;
+
 	const CDBehaviorTemplate GetByBehaviorID(uint32_t behaviorID);
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.cpp
@@ -14,8 +14,7 @@ void CDBrickIDTableTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BrickIDTable");
@@ -24,7 +23,7 @@ void CDBrickIDTableTable::LoadValuesFromDatabase() {
 		entry.NDObjectID = tableData.getIntField("NDObjectID", -1);
 		entry.LEGOBrickID = tableData.getIntField("LEGOBrickID", -1);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -32,9 +31,15 @@ void CDBrickIDTableTable::LoadValuesFromDatabase() {
 }

 std::vector<CDBrickIDTable> CDBrickIDTableTable::Query(std::function<bool(CDBrickIDTable)> predicate) {
-	std::vector<CDBrickIDTable> data = cpplinq::from(GetEntries())
+
+	std::vector<CDBrickIDTable> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }
+
+const std::vector<CDBrickIDTable>& CDBrickIDTableTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.h
@@ -16,9 +16,14 @@ struct CDBrickIDTable {


 //! BrickIDTable table
-class CDBrickIDTableTable : public CDTable<CDBrickIDTableTable, std::vector<CDBrickIDTable>> {
+class CDBrickIDTableTable : public CDTable<CDBrickIDTableTable> {
+private:
+	std::vector<CDBrickIDTable> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDBrickIDTable> Query(std::function<bool(CDBrickIDTable)> predicate);
+
+	const std::vector<CDBrickIDTable>& GetEntries() const;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.cpp
@@ -4,15 +4,14 @@
 void CDComponentsRegistryTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ComponentsRegistry");
-	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
 		CDComponentsRegistry entry;
 		entry.id = tableData.getIntField("id", -1);
 		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
 		entry.component_id = tableData.getIntField("component_id", -1);

-		entries.insert_or_assign(static_cast<uint64_t>(entry.component_type) << 32 | static_cast<uint64_t>(entry.id), entry.component_id);
-		entries.insert_or_assign(entry.id, 0);
+		this->mappedEntries.insert_or_assign(static_cast<uint64_t>(entry.component_type) << 32 | static_cast<uint64_t>(entry.id), entry.component_id);
+		this->mappedEntries.insert_or_assign(entry.id, 0);

 		tableData.nextRow();
 	}
@@ -21,11 +20,10 @@ void CDComponentsRegistryTable::LoadValuesFromDatabase() {
 }

 int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue) {
-	auto& entries = GetEntriesMutable();
-	auto exists = entries.find(id);
-	if (exists != entries.end()) {
-		auto iter = entries.find(static_cast<uint64_t>(componentType) << 32 | static_cast<uint64_t>(id));
-		return iter == entries.end() ? defaultValue : iter->second;
+	auto exists = mappedEntries.find(id);
+	if (exists != mappedEntries.end()) {
+		auto iter = mappedEntries.find(static_cast<uint64_t>(componentType) << 32 | static_cast<uint64_t>(id));
+		return iter == mappedEntries.end() ? defaultValue : iter->second;
 	}

 	// Now get the data. Get all components of this entity so we dont do a query for each component
@@ -40,14 +38,14 @@ int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponent
 		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
 		entry.component_id = tableData.getIntField("component_id", -1);

-		entries.insert_or_assign(static_cast<uint64_t>(entry.component_type) << 32 | static_cast<uint64_t>(entry.id), entry.component_id);
+		this->mappedEntries.insert_or_assign(static_cast<uint64_t>(entry.component_type) << 32 | static_cast<uint64_t>(entry.id), entry.component_id);

 		tableData.nextRow();
 	}

-	entries.insert_or_assign(id, 0);
+	mappedEntries.insert_or_assign(id, 0);

-	auto iter = entries.find(static_cast<uint64_t>(componentType) << 32 | static_cast<uint64_t>(id));
+	auto iter = this->mappedEntries.find(static_cast<uint64_t>(componentType) << 32 | static_cast<uint64_t>(id));

-	return iter == entries.end() ? defaultValue : iter->second;
+	return iter == this->mappedEntries.end() ? defaultValue : iter->second;
 }
--- a/dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.h
@@ -13,7 +13,10 @@ struct CDComponentsRegistry {
 };


-class CDComponentsRegistryTable : public CDTable<CDComponentsRegistryTable, std::unordered_map<uint64_t, uint32_t>> {
+class CDComponentsRegistryTable : public CDTable<CDComponentsRegistryTable> {
+private:
+	std::unordered_map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
+
 public:
 	void LoadValuesFromDatabase();
 	int32_t GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue = 0);
--- a/dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.cpp
@@ -15,8 +15,7 @@ void CDCurrencyTableTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM CurrencyTable");
@@ -28,7 +27,7 @@ void CDCurrencyTableTable::LoadValuesFromDatabase() {
 		entry.maxvalue = tableData.getIntField("maxvalue", -1);
 		entry.id = tableData.getIntField("id", -1);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -36,9 +35,15 @@ void CDCurrencyTableTable::LoadValuesFromDatabase() {
 }

 std::vector<CDCurrencyTable> CDCurrencyTableTable::Query(std::function<bool(CDCurrencyTable)> predicate) {
-	std::vector<CDCurrencyTable> data = cpplinq::from(GetEntries())
+
+	std::vector<CDCurrencyTable> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }
+
+const std::vector<CDCurrencyTable>& CDCurrencyTableTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.h
@@ -18,9 +18,14 @@ struct CDCurrencyTable {
 };

 //! CurrencyTable table
-class CDCurrencyTableTable : public CDTable<CDCurrencyTableTable, std::vector<CDCurrencyTable>> {
+class CDCurrencyTableTable : public CDTable<CDCurrencyTableTable> {
+private:
+	std::vector<CDCurrencyTable> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDCurrencyTable> Query(std::function<bool(CDCurrencyTable)> predicate);
+
+	const std::vector<CDCurrencyTable>& GetEntries() const;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.cpp
@@ -13,8 +13,7 @@ void CDDestructibleComponentTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM DestructibleComponent");
@@ -35,7 +34,7 @@ void CDDestructibleComponentTable::LoadValuesFromDatabase() {
 		entry.isSmashable = tableData.getIntField("isSmashable", -1) == 1 ? true : false;
 		entry.difficultyLevel = tableData.getIntField("difficultyLevel", -1);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -43,9 +42,15 @@ void CDDestructibleComponentTable::LoadValuesFromDatabase() {
 }

 std::vector<CDDestructibleComponent> CDDestructibleComponentTable::Query(std::function<bool(CDDestructibleComponent)> predicate) {
-	std::vector<CDDestructibleComponent> data = cpplinq::from(GetEntries())
+
+	std::vector<CDDestructibleComponent> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }
+
+const std::vector<CDDestructibleComponent>& CDDestructibleComponentTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.h
@@ -20,9 +20,14 @@ struct CDDestructibleComponent {
 	int32_t difficultyLevel;               //!< ???
 };

-class CDDestructibleComponentTable : public CDTable<CDDestructibleComponentTable, std::vector<CDDestructibleComponent>> {
+class CDDestructibleComponentTable : public CDTable<CDDestructibleComponentTable> {
+private:
+	std::vector<CDDestructibleComponent> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDDestructibleComponent> Query(std::function<bool(CDDestructibleComponent)> predicate);
+
+	const std::vector<CDDestructibleComponent>& GetEntries(void) const;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.cpp
@@ -2,7 +2,6 @@

 void CDEmoteTableTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Emotes");
-	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
 		CDEmoteTable entry;
 		entry.ID = tableData.getIntField("id", -1);
@@ -22,7 +21,6 @@ void CDEmoteTableTable::LoadValuesFromDatabase() {
 }

 CDEmoteTable* CDEmoteTableTable::GetEmote(int32_t id) {
-	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(id);
 	return itr != entries.end() ? &itr->second : nullptr;
 }
--- a/dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.h
@@ -26,7 +26,10 @@ struct CDEmoteTable {
 	std::string gateVersion;
 };

-class CDEmoteTableTable : public CDTable<CDEmoteTableTable, std::map<int, CDEmoteTable>> {
+class CDEmoteTableTable : public CDTable<CDEmoteTableTable> {
+private:
+	std::map<int, CDEmoteTable> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Returns an emote by ID
--- a/dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.cpp
@@ -14,8 +14,7 @@ void CDFeatureGatingTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM FeatureGating");
@@ -27,7 +26,7 @@ void CDFeatureGatingTable::LoadValuesFromDatabase() {
 		entry.minor = tableData.getIntField("minor", -1);
 		entry.description = tableData.getStringField("description", "");

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -36,8 +35,7 @@ void CDFeatureGatingTable::LoadValuesFromDatabase() {

 std::vector<CDFeatureGating> CDFeatureGatingTable::Query(std::function<bool(CDFeatureGating)> predicate) {

-	auto& entries = GetEntriesMutable();
-	std::vector<CDFeatureGating> data = cpplinq::from(entries)
+	std::vector<CDFeatureGating> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

@@ -45,7 +43,6 @@ std::vector<CDFeatureGating> CDFeatureGatingTable::Query(std::function<bool(CDFe
 }

 bool CDFeatureGatingTable::FeatureUnlocked(const CDFeatureGating& feature) const {
-	auto& entries = GetEntriesMutable();
 	for (const auto& entry : entries) {
 		if (entry.featureName == feature.featureName && feature >= entry) {
 			return true;
@@ -54,3 +51,8 @@ bool CDFeatureGatingTable::FeatureUnlocked(const CDFeatureGating& feature) const

 	return false;
 }
+
+const std::vector<CDFeatureGating>& CDFeatureGatingTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.h
@@ -17,7 +17,10 @@ struct CDFeatureGating {
 	}
 };

-class CDFeatureGatingTable : public CDTable<CDFeatureGatingTable, std::vector<CDFeatureGating>> {
+class CDFeatureGatingTable : public CDTable<CDFeatureGatingTable> {
+private:
+	std::vector<CDFeatureGating> entries;
+
 public:
 	void LoadValuesFromDatabase();

@@ -25,4 +28,6 @@ public:
 	std::vector<CDFeatureGating> Query(std::function<bool(CDFeatureGating)> predicate);

 	bool FeatureUnlocked(const CDFeatureGating& feature) const;
+
+	const std::vector<CDFeatureGating>& GetEntries(void) const;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.cpp
@@ -14,8 +14,7 @@ void CDInventoryComponentTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM InventoryComponent");
@@ -26,7 +25,7 @@ void CDInventoryComponentTable::LoadValuesFromDatabase() {
 		entry.count = tableData.getIntField("count", -1);
 		entry.equip = tableData.getIntField("equip", -1) == 1 ? true : false;

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -34,9 +33,15 @@ void CDInventoryComponentTable::LoadValuesFromDatabase() {
 }

 std::vector<CDInventoryComponent> CDInventoryComponentTable::Query(std::function<bool(CDInventoryComponent)> predicate) {
-	std::vector<CDInventoryComponent> data = cpplinq::from(GetEntries())
+
+	std::vector<CDInventoryComponent> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }
+
+const std::vector<CDInventoryComponent>& CDInventoryComponentTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.h
@@ -10,9 +10,14 @@ struct CDInventoryComponent {
 	bool equip;             //!< Whether or not to equip the item
 };

-class CDInventoryComponentTable : public CDTable<CDInventoryComponentTable, std::vector<CDInventoryComponent>> {
+class CDInventoryComponentTable : public CDTable<CDInventoryComponentTable> {
+private:
+	std::vector<CDInventoryComponent> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDInventoryComponent> Query(std::function<bool(CDInventoryComponent)> predicate);
+
+	const std::vector<CDInventoryComponent>& GetEntries() const;
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.cpp
@@ -17,7 +17,6 @@ void CDItemComponentTable::LoadValuesFromDatabase() {

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemComponent");
-	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
 		CDItemComponent entry;
 		entry.id = tableData.getIntField("id", -1);
@@ -63,7 +62,7 @@ void CDItemComponentTable::LoadValuesFromDatabase() {
 		entry.forgeType = tableData.getIntField("forgeType", -1);
 		entry.SellMultiplier = tableData.getFloatField("SellMultiplier", -1.0f);

-		entries.insert(std::make_pair(entry.id, entry));
+		this->entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}

@@ -71,9 +70,8 @@ void CDItemComponentTable::LoadValuesFromDatabase() {
 }

 const CDItemComponent& CDItemComponentTable::GetItemComponentByID(uint32_t skillID) {
-	auto& entries = GetEntriesMutable();
-	const auto& it = entries.find(skillID);
-	if (it != entries.end()) {
+	const auto& it = this->entries.find(skillID);
+	if (it != this->entries.end()) {
 		return it->second;
 	}

@@ -131,12 +129,12 @@ const CDItemComponent& CDItemComponentTable::GetItemComponentByID(uint32_t skill
 		entry.forgeType = tableData.getIntField("forgeType", -1);
 		entry.SellMultiplier = tableData.getFloatField("SellMultiplier", -1.0f);

-		entries.insert(std::make_pair(entry.id, entry));
+		this->entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}

-	const auto& it2 = entries.find(skillID);
-	if (it2 != entries.end()) {
+	const auto& it2 = this->entries.find(skillID);
+	if (it2 != this->entries.end()) {
 		return it2->second;
 	}

--- a/dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.h
@@ -49,7 +49,10 @@ struct CDItemComponent {
 	float SellMultiplier;           //!< Something to do with early vendors perhaps (but replaced)
 };

-class CDItemComponentTable : public CDTable<CDItemComponentTable, std::map<uint32_t, CDItemComponent>> {
+class CDItemComponentTable : public CDTable<CDItemComponentTable> {
+private:
+	std::map<uint32_t, CDItemComponent> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	static std::map<LOT, uint32_t> ParseCraftingCurrencies(const CDItemComponent& itemComponent);
--- a/dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.cpp
@@ -14,8 +14,7 @@ void CDItemSetSkillsTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemSetSkills");
@@ -25,7 +24,7 @@ void CDItemSetSkillsTable::LoadValuesFromDatabase() {
 		entry.SkillID = tableData.getIntField("SkillID", -1);
 		entry.SkillCastType = tableData.getIntField("SkillCastType", -1);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -33,17 +32,22 @@ void CDItemSetSkillsTable::LoadValuesFromDatabase() {
 }

 std::vector<CDItemSetSkills> CDItemSetSkillsTable::Query(std::function<bool(CDItemSetSkills)> predicate) {
-	std::vector<CDItemSetSkills> data = cpplinq::from(GetEntries())
+
+	std::vector<CDItemSetSkills> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }

+const std::vector<CDItemSetSkills>& CDItemSetSkillsTable::GetEntries() const {
+	return this->entries;
+}
+
 std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetBySkillID(uint32_t SkillSetID) {
 	std::vector<CDItemSetSkills> toReturn;

-	for (const auto& entry : GetEntries()) {
+	for (CDItemSetSkills entry : this->entries) {
 		if (entry.SkillSetID == SkillSetID) toReturn.push_back(entry);
 		if (entry.SkillSetID > SkillSetID) return toReturn; //stop seeking in the db if it's not needed.
 	}
--- a/dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.h
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.h
@@ -9,11 +9,16 @@ struct CDItemSetSkills {
 	uint32_t SkillCastType;         //!< The skill cast type
 };

-class CDItemSetSkillsTable : public CDTable<CDItemSetSkillsTable, std::vector<CDItemSetSkills>> {
+class CDItemSetSkillsTable : public CDTable<CDItemSetSkillsTable> {
+private:
+	std::vector<CDItemSetSkills> entries;
+
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
 	std::vector<CDItemSetSkills> Query(std::function<bool(CDItemSetSkills)> predicate);

+	const std::vector<CDItemSetSkills>& GetEntries() const;
+
 	std::vector<CDItemSetSkills> GetBySkillID(uint32_t SkillSetID);
 };
--- a/dDatabase/CDClientDatabase/CDClientTables/CDItemSetsTable.cpp
+++ b/dDatabase/CDClientDatabase/CDClientTables/CDItemSetsTable.cpp
@@ -14,8 +14,7 @@ void CDItemSetsTable::LoadValuesFromDatabase() {
 	tableSize.finalize();

 	// Reserve the size
-	auto& entries = GetEntriesMutable();
-	entries.reserve(size);
+	this->entries.reserve(size);

 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemSets");
@@ -37,7 +36,7 @@ void CDItemSetsTable::LoadValuesFromDatabase() {
 		entry.kitID = tableData.getIntField("kitID", -1);
 		entry.priority = tableData.getFloatField("priority", -1.0f);

-		entries.push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}

@@ -46,9 +45,14 @@ void CDItemSetsTable::LoadValuesFromDatabase() {

 std::vector<CDItemSets> CDItemSetsTable::Query(std::function<bool(CDItemSets)> predicate) {

-	std::vector<CDItemSets> data = cpplinq::from(GetEntries())
+	std::vector<CDItemSets> data = cpplinq::from(this->entries)
 		>> cpplinq::where(predicate)
 		>> cpplinq::to_vector();

 	return data;
 }
+
+const std::vector<CDItemSets>& CDItemSetsTable::GetEntries() const {
+	return this->entries;
+}
+
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Markowitz	4d6f11fed1	Merge branch 'main' into physicsSimplification	2024-02-08 03:55:30 -08:00
David Markowitz	0bbc8e6643	remove copy pasted logic tested that the ninjago platforms and fire still works, tested that point of interest work as well Update PhantomPhysicsComponent.cpp	2024-02-04 03:38:11 -08:00