Merge branch 'main' into windows-clang-fixes

tested that vanity npcs now chat when close, and then on a cooldown

.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=fasle
+cpp_indent_comment=false

.github/workflows/build-and-push-docker.yml

@@ -1,4 +1,4 @@
-name: CI
+name: Build and Update Docker 
 
 on:
   push:

.github/workflows/build-and-test.yml

@@ -1,4 +1,4 @@
-name: CI
+name: Build And Test
 
 on:
   push:
@@ -14,14 +14,21 @@ jobs:
     strategy:
       matrix:
         os: [ windows-2022, ubuntu-22.04, macos-13 ]
+        include:
+          - os: windows-2022
+            configureType: windows-msvc
+          - os: ubuntu-22.04
+            configureType: linux-gnu
+          - os: macos-13
+            configureType: macos
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         submodules: true
     - name: Add msbuild to PATH (Windows only)
       if: ${{ matrix.os == 'windows-2022' }}
-      uses: microsoft/setup-msbuild@v1.1
+      uses: microsoft/setup-msbuild@v2
       with:
         vs-version: '[17,18)'
         msbuild-architecture: x64
@@ -33,21 +40,13 @@ jobs:
     - name: cmake
       uses: lukka/run-cmake@v10
       with:
-        configurePreset: "ci-${{matrix.os}}"
+        configurePreset: "${{matrix.configureType}}"
         buildPreset: "ci-${{matrix.os}}"
         testPreset: "ci-${{matrix.os}}"
+
     - name: artifacts
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       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/*

.gitignore

@@ -95,6 +95,7 @@ ipch/
 
 # Exceptions:
 CMakeSettings.json
+CMakeUserPresets.json
 *.vcxproj
 *.filters
 *.cmake
@@ -112,6 +113,8 @@ CMakeFiles/TargetDirectories.txt
 *.sln
 *.recipe
 
+CMakeUserPresets.json
+
 # clangd
 .cache
 thirdparty/zlib-1.2.11/
@@ -122,4 +125,7 @@ docker/__pycache__
 docker-compose.override.yml
 
 !*Test.bin
+
+# CMake scripts
 !cmake/*
+!cmake/toolchains/*

CMakeLists.txt

@@ -1,5 +1,8 @@
 cmake_minimum_required(VERSION 3.25)
-project(Darkflame)
+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 " ")
@@ -8,12 +11,22 @@ endif()
 
 include(CTest)
 
+set(CMAKE_C_STANDARD 99)
 set(CMAKE_CXX_STANDARD 20)
-set(CXX_STANDARD_REQUIRED ON)
+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(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")
+
+if (${CMAKE_BUILD_TYPE} MATCHES "") # CI likes to set CMAKE_BUILD_TYPE to an empty string
+    set(CMAKE_BUILD_TYPE "RelWithDebInfo")
+endif()
+
+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)
@@ -61,35 +74,38 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wuninitialized -fPIC")
+	add_link_options("-Wl,-rpath,$ORIGIN/")
+	add_compile_options("-fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)
 
-	if(NOT APPLE)
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -lstdc++fs")
+	# 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")
 	endif()
 
 	if(${DYNAMIC} AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -rdynamic")
+		add_link_options("-export-dynamic")
 	endif()
 
 	if(${GGDB})
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb")
+		add_compile_options("-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")
+	add_compile_options("/wd4267" "/utf-8" "/volatile:iso" "/Zc:inline")
 elseif(WIN32)
 	add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()
 
-# Our output dir
-set(CMAKE_BINARY_DIR ${PROJECT_BINARY_DIR})
-#set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE ON) # unfortunately, forces all libraries to be built in series, which will slow down the build process
+# Set the output directories
+# ./build/<platform + architecture (x64, x86, aarch64)>/<compiler>/<build_mode>/
 
-# TODO make this not have to override the build type directories
+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})
 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})
@@ -101,6 +117,15 @@ 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
@@ -113,27 +138,28 @@ make_directory(${CMAKE_BINARY_DIR}/logs)
 set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
 message(STATUS "Checking resource file integrity")
 
+
 include(Utils)
-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")
+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")
 
 foreach(resource_file ${RESOURCE_FILES})
 	set(file_size 0)
 
-	if(EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
-		file(SIZE ${PROJECT_BINARY_DIR}/${resource_file} file_size)
+	if(EXISTS ${DLU_CONFIG_DIR}/${resource_file})
+		file(SIZE ${DLU_CONFIG_DIR}/${resource_file} file_size)
 	endif()
 
 	if(${file_size} EQUAL 0)
 		configure_file(
-			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${PROJECT_BINARY_DIR}/${resource_file}
+			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${DLU_CONFIG_DIR}/${resource_file}
 			COPYONLY
 		)
-		message(STATUS "Moved " ${resource_file} " to project binary directory")
+		message(STATUS "Moved " ${resource_file} " to DLU config directory")
 	elseif(resource_file MATCHES ".ini")
 		message(STATUS "Checking " ${resource_file} " for missing config options")
-		file(READ ${PROJECT_BINARY_DIR}/${resource_file} current_file_contents)
+		file(READ ${DLU_CONFIG_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 "")
@@ -164,10 +190,10 @@ foreach(resource_file ${RESOURCE_FILES})
 					set(line_to_add ${line_to_add} ${line})
 
 					foreach(line_to_append ${line_to_add})
-						file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n" ${line_to_append})
+						file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
 					endforeach()
 
-					file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n")
+					file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n")
 				endif()
 
 				set(line_to_add "")
@@ -181,15 +207,15 @@ endforeach()
 message(STATUS "Resource file integrity check complete")
 
 # if navmeshes directory does not exist, create it
-if(NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes)
-	file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/navmeshes)
+if(NOT EXISTS ${CMAKE_BINARY_DIR}/navmeshes)
+	file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/navmeshes)
 endif()
 
 # Copy navmesh data on first build and extract it
-configure_file(${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${PROJECT_BINARY_DIR}/navmeshes.zip COPYONLY)
+configure_file(${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${CMAKE_BINARY_DIR}/navmeshes.zip COPYONLY)
 
-file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip DESTINATION ${PROJECT_BINARY_DIR}/navmeshes)
-file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)
+file(ARCHIVE_EXTRACT INPUT ${CMAKE_BINARY_DIR}/navmeshes.zip DESTINATION ${CMAKE_BINARY_DIR}/navmeshes)
+file(REMOVE ${CMAKE_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")
@@ -199,20 +225,20 @@ foreach(file ${VANITY_FILES})
 endforeach()
 
 # Move our migrations for MasterServer to run
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/dlu/)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/migrations/dlu/)
 file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/dlu/*.sql)
 
 foreach(file ${SQL_FILES})
 	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${PROJECT_BINARY_DIR}/migrations/dlu/${file})
+	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${CMAKE_BINARY_DIR}/migrations/dlu/${file})
 endforeach()
 
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/cdserver/)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/migrations/cdserver/)
 file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/cdserver/*.sql)
 
 foreach(file ${SQL_FILES})
 	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${PROJECT_BINARY_DIR}/migrations/cdserver/${file})
+	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${CMAKE_BINARY_DIR}/migrations/cdserver/${file})
 endforeach()
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -236,14 +262,15 @@ include_directories(
 	"tests/dGameTests"
 	"tests/dGameTests/dComponentsTests"
 
-	SYSTEM "thirdparty/magic_enum/include/magic_enum"
-	SYSTEM "thirdparty/raknet/Source"
-	SYSTEM "thirdparty/tinyxml2"
-	SYSTEM "thirdparty/recastnavigation"
-	SYSTEM "thirdparty/SQLite"
-	SYSTEM "thirdparty/cpplinq"
-	SYSTEM "thirdparty/cpp-httplib"
-	SYSTEM "thirdparty/MD5"
+	SYSTEM
+	"thirdparty/magic_enum/include/magic_enum"
+	"thirdparty/raknet/Source"
+	"thirdparty/tinyxml2"
+	"thirdparty/recastnavigation"
+	"thirdparty/SQLite"
+	"thirdparty/cpplinq"
+	"thirdparty/cpp-httplib"
+	"thirdparty/MD5"
 )
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -252,10 +279,17 @@ if(APPLE)
 	include_directories("/usr/local/include/")
 endif()
 
-# Add linking directories:
-if (UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Werror") # Warning flags
+# 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.")
 endif()
+
+# Add linking directories:
 file(
 	GLOB HEADERS_DZONEMANAGER
 	LIST_DIRECTORIES false
@@ -290,7 +324,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" "magic_enum")
 
 # Add platform specific common libraries
 if(UNIX)

CMakePresets.json

@@ -1,128 +1,124 @@
 {
-    "version": 3,
-    "cmakeMinimumRequired": {
-      "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"
-      },
-      {
-        "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"
-        },
-        "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": "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
+	"version": 6,
+	"cmakeMinimumRequired": {
+		"major": 3,
+		"minor": 25,
+		"patch": 0
+	},
+	"configurePresets": [
+		{
+			"name": "default",
+			"displayName": "Default configure step",
+			"description": "Use 'build' dir and Unix makefiles",
+			"binaryDir": "${sourceDir}/build",
+			"generator": "Unix Makefiles",
+			"hidden": true
 		},
-        "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
+		{
+			"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
 		},
-        "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
+		{
+			"name": "windows-msvc",
+			"inherits": "windows-default",
+			"displayName": "Windows (MSVC)",
+			"description": "Create a build using MSVC"
 		},
-        "output": {
-          "outputOnFailure": true
-        },
-		"filter": {
-			"exclude": {
-				"name": "((example)|(minigzip))+"
+		{
+			"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"
 			}
 		}
-      }
-    ]
-  }
+	],
+	"buildPresets": [
+        { "name": "ci-ubuntu-22.04", "configurePreset": "linux-gnu"    },
+        { "name": "ci-macos-13",     "configurePreset": "macos"        },
+        { "name": "ci-windows-2022", "configurePreset": "windows-msvc" }
+	],
+	"testPresets": [
+        {
+            "name": "default",
+            "hidden": true,
+            "execution": {
+                "jobs": 2
+            },
+            "output": {
+                "outputOnFailure": true
+            }
+        },
+		{
+			"name": "ci-ubuntu-22.04",
+			"configurePreset": "linux-gnu",
+			"displayName": "CI Tests on Linux",
+			"inherits": "default"
+		},
+		{
+			"name": "ci-macos-13",
+			"configurePreset": "macos",
+			"displayName": "CI Tests on MacOS",
+			"inherits": "default"
+		},
+		{
+			"name": "ci-windows-2022",
+			"configurePreset": "windows-msvc",
+			"displayName": "CI Tests on windows",
+            "inherits": "default",
+            
+			"configuration": "RelWithDebInfo",
+			"filter": {
+				"exclude": {
+					"name": "((example)|(minigzip))+"
+				}
+			}
+		}
+	],
+	"workflowPresets": [
+
+	]
+}

Dockerfile

@@ -23,23 +23,23 @@ 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/Linux-x86_64/GNU/Release/mariadbcpp/libmariadbcpp.so /usr/local/lib/
 RUN ldconfig
 
 # Server bins
-COPY --from=build /app/build/*Server /app/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*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/navmeshes /app/navmeshes
-COPY --from=build /app/build/migrations /app/migrations
-COPY --from=build /app/build/*.dcf /app/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*.ini /app/configs/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/vanity/*.* /app/vanity/
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/navmeshes /app/navmeshes
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/migrations /app/migrations
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/*.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/Linux-x86_64/GNU/Release/*.ini /app/default-configs/ 
+COPY --from=build /app/build/Linux-x86_64/GNU/Release/vanity/*.* /app/default-vanity/
 
 # needed as the container runs with the root user
 # and therefore sudo doesn't exist

build.sh

@@ -6,8 +6,7 @@ mkdir -p build
 cd build
 
 # Run cmake to generate make files
-cmake ..
+cmake -DCMAKE_BUILD_TYPE="Release" ..
 
 # 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
-

cmake/FindMariaDB.cmake

@@ -2,8 +2,8 @@
 # On Windows ClangCL can't compile the connector from source but can link to an msvc compiled one,
 # so prefer the prebuilt binaries unless MARIADB_BUILD_SOURCE is specified
 if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
-	set(MARIADB_MSI_DIR "${PROJECT_BINARY_DIR}/msi")
-	set(MARIADB_CONNECTOR_DIR "${PROJECT_BINARY_DIR}/mariadbcpp")
+	set(MARIADB_MSI_DIR "${CMAKE_BINARY_DIR}/msi")
+	set(MARIADB_CONNECTOR_DIR "${CMAKE_BINARY_DIR}/mariadbcpp")
 	set(MARIADB_C_CONNECTOR_DIR "${MARIADB_CONNECTOR_DIR}/MariaDB/MariaDB Connector C 64-bit")
 	set(MARIADB_CPP_CONNECTOR_DIR "${MARIADB_CONNECTOR_DIR}/MariaDB/MariaDB C++ Connector 64-bit")
 
@@ -59,7 +59,7 @@ if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
 					COMMAND ${CMAKE_COMMAND} -E copy_if_different
 					"${MARIADBCPP_SHARED_LIBRARY_LOCATION}"
 					"${MARIADBC_SHARED_LIBRARY_LOCATION}"
-					"${PROJECT_BINARY_DIR}")
+					"${CMAKE_BINARY_DIR}")
 
 	# MariaDB uses plugins that the database needs to load, the prebuilt binaries by default will try to find the libraries in system directories,
 	# so set this define and the servers will set the MARIADB_PLUGIN_DIR environment variable to the appropriate directory.
@@ -86,13 +86,13 @@ else() # Build from source
 			-DCMAKE_CXX_FLAGS=-D_GLIBCXX_USE_CXX11_ABI=0)
 	endif()
 
-	set(MARIADBCPP_INSTALL_DIR ${PROJECT_BINARY_DIR}/prefix)
-	set(MARIADBCPP_LIBRARY_DIR ${PROJECT_BINARY_DIR}/mariadbcpp)
+	set(MARIADBCPP_INSTALL_DIR ${CMAKE_BINARY_DIR}/prefix)
+	set(MARIADBCPP_LIBRARY_DIR ${CMAKE_BINARY_DIR}/mariadbcpp)
 	set(MARIADBCPP_PLUGIN_DIR ${MARIADBCPP_LIBRARY_DIR}/plugin)
 	set(MARIADBCPP_SOURCE_DIR ${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp)
 	set(MARIADB_INCLUDE_DIR "${MARIADBCPP_SOURCE_DIR}/include")
 	ExternalProject_Add(mariadb_connector_cpp
-		PREFIX "${PROJECT_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
+		PREFIX "${CMAKE_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
 		SOURCE_DIR ${MARIADBCPP_SOURCE_DIR}
 		INSTALL_DIR ${MARIADBCPP_INSTALL_DIR}
 		CMAKE_ARGS  -Wno-dev
@@ -127,20 +127,20 @@ else() # Build from source
 endif()
 
 # Create mariadb connector library object
-add_library(MariaDB::ConnCpp SHARED IMPORTED GLOBAL)
-add_dependencies(MariaDB::ConnCpp mariadb_connector_cpp)
-set_target_properties(MariaDB::ConnCpp PROPERTIES
+add_library(mariadb_cpp_connector SHARED IMPORTED GLOBAL)
+add_dependencies(mariadb_cpp_connector mariadb_connector_cpp)
+set_target_properties(mariadb_cpp_connector PROPERTIES
 	IMPORTED_LOCATION "${MARIADBCPP_SHARED_LIBRARY_LOCATION}")
 
 if(WIN32)
-	set_target_properties(MariaDB::ConnCpp PROPERTIES
+	set_target_properties(mariadb_cpp_connector PROPERTIES
 		IMPORTED_IMPLIB "${MARIADB_IMPLIB_LOCATION}")
 elseif(APPLE)
-	set_target_properties(MariaDB::ConnCpp PROPERTIES
+	set_target_properties(mariadb_cpp_connector PROPERTIES
 		IMPORTED_SONAME "libmariadbcpp")
 endif()
 
 # Add directories to include lists
-target_include_directories(MariaDB::ConnCpp SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
+target_include_directories(mariadb_cpp_connector SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
 
-set(MariaDB_FOUND TRUE)
+set(mariadb_found TRUE)

cmake/toolchains/linux-clang.cmake

@@ -0,0 +1,14 @@
+# 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")

cmake/toolchains/linux-gnu.cmake

@@ -0,0 +1,11 @@
+# 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")

dAuthServer/AuthServer.cpp

@@ -21,8 +21,8 @@
 //Auth includes:
 #include "AuthPackets.h"
 #include "eConnectionType.h"
-#include "eServerMessageType.h"
-#include "eAuthMessageType.h"
+#include "MessageType/Server.h"
+#include "MessageType/Auth.h"
 
 #include "Game.h"
 #include "Server.h"
@@ -60,7 +60,7 @@ int main(int argc, char** argv) {
 
 	try {
 		Database::Connect();
-	} catch (sql::SQLException& ex) {
+	} catch (std::exception& ex) {
 		LOG("Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("AuthServer");
 		delete Game::server;
@@ -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<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
+			if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
 		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
-			if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
+			if (static_cast<MessageType::Auth>(packet->data[3]) == MessageType::Auth::LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}
 		}

dChatServer/ChatIgnoreList.cpp

@@ -1,6 +1,6 @@
 #include "ChatIgnoreList.h"
 #include "PlayerContainer.h"
-#include "eChatMessageType.h"
+#include "MessageType/Chat.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,  eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT,  MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receivingPlayer);
 
 	//portion that will get routed:

dChatServer/ChatIgnoreList.h

@@ -1,5 +1,5 @@
-#ifndef CHATIGNORELIST_H
-#define CHATIGNORELIST_H
+#ifndef __CHATIGNORELIST__H__
+#define __CHATIGNORELIST__H__
 
 struct Packet;
 
@@ -24,4 +24,4 @@ namespace ChatIgnoreList {
 	};
 };
 
-#endif  //!CHATIGNORELIST_H
+#endif  //!__CHATIGNORELIST__H__

dChatServer/ChatPacketHandler.cpp

@@ -13,9 +13,9 @@
 #include "dConfig.h"
 #include "eObjectBits.h"
 #include "eConnectionType.h"
-#include "eChatMessageType.h"
-#include "eClientMessageType.h"
-#include "eGameMessageType.h"
+#include "MessageType/Chat.h"
+#include "MessageType/Client.h"
+#include "MessageType/Game.h"
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
 #include "ChatPackets.h"
@@ -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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::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());
@@ -368,10 +368,10 @@ void ChatPacketHandler::HandleWho(Packet* packet) {
 	bool online = player;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(request.requestor);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::WHO_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::WHO_RESPONSE);
 	bitStream.Write<uint8_t>(online);
 	bitStream.Write(player.zoneID.GetMapID());
 	bitStream.Write(player.zoneID.GetInstanceID());
@@ -391,10 +391,10 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	if (!sender) return;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(request.requestor);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SHOW_ALL_RESPONSE);
+	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());
@@ -416,7 +416,7 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	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 +428,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 
 	eChatChannel channel;
 	uint32_t size;
-	
+
 	inStream.IgnoreBytes(4);
 	inStream.Read(channel);
 	inStream.Read(size);
@@ -436,7 +436,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 +457,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 +484,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 +515,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(routeTo.playerID);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::PRIVATE_CHAT_MESSAGE);
 	bitStream.Write(sender.playerID);
 	bitStream.Write(channel);
 	bitStream.Write<uint32_t>(0); // not used
@@ -757,11 +757,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::TEAM_INVITE);
 
 	bitStream.Write(LUWString(sender.playerName.c_str()));
 	bitStream.Write(sender.playerID);
@@ -772,14 +772,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
+	bitStream.Write(MessageType::Game::TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -799,14 +799,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(MessageType::Game::TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -824,14 +824,14 @@ void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64L
 
 void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
+	bitStream.Write(MessageType::Game::TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
@@ -841,14 +841,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
+	bitStream.Write(MessageType::Game::TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -870,14 +870,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
+	bitStream.Write(MessageType::Game::TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -896,14 +896,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver.playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(MessageType::Game::TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
 	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -930,11 +930,11 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(friendData.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData.playerName.c_str();
@@ -967,11 +967,11 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 	}
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::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 +981,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	// Portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::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 +1004,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, eChatMessageType::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	bitStream.Write(LUWString(personToRemove));
 

dChatServer/ChatServer.cpp

@@ -16,8 +16,8 @@
 #include "eConnectionType.h"
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
-#include "eChatMessageType.h"
-#include "eWorldMessageType.h"
+#include "MessageType/Chat.h"
+#include "MessageType/World.h"
 #include "ChatIgnoreList.h"
 #include "StringifiedEnum.h"
 
@@ -81,7 +81,7 @@ int main(int argc, char** argv) {
 	//Connect to the MySQL Database
 	try {
 		Database::Connect();
-	} catch (sql::SQLException& ex) {
+	} catch (std::exception& ex) {
 		LOG("Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("ChatServer");
 		delete Game::server;
@@ -108,7 +108,7 @@ int main(int argc, char** argv) {
 
 	const bool dontGenerateDCF = GeneralUtils::TryParse<bool>(Game::config->GetValue("dont_generate_dcf")).value_or(false);
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", dontGenerateDCF);
-	
+
 	Game::randomEngine = std::mt19937(time(0));
 
 	Game::playerContainer.Initialize();
@@ -190,154 +190,154 @@ void HandlePacket(Packet* packet) {
 	inStream.SetReadOffset(BYTES_TO_BITS(1));
 
 	eConnectionType connection;
-	eChatMessageType chatMessageID;
+	MessageType::Chat chatMessageID;
 
 	inStream.Read(connection);
 	if (connection != eConnectionType::CHAT) return;
 	inStream.Read(chatMessageID);
-	
+
 	switch (chatMessageID) {
-		case eChatMessageType::GM_MUTE:
+		case MessageType::Chat::GM_MUTE:
 			Game::playerContainer.MuteUpdate(packet);
 			break;
 
-		case eChatMessageType::CREATE_TEAM:
+		case MessageType::Chat::CREATE_TEAM:
 			Game::playerContainer.CreateTeamServer(packet);
 			break;
 
-		case eChatMessageType::GET_FRIENDS_LIST:
+		case MessageType::Chat::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
 
-		case eChatMessageType::GET_IGNORE_LIST:
+		case MessageType::Chat::GET_IGNORE_LIST:
 			ChatIgnoreList::GetIgnoreList(packet);
 			break;
 
-		case eChatMessageType::ADD_IGNORE:
+		case MessageType::Chat::ADD_IGNORE:
 			ChatIgnoreList::AddIgnore(packet);
 			break;
 
-		case eChatMessageType::REMOVE_IGNORE:
+		case MessageType::Chat::REMOVE_IGNORE:
 			ChatIgnoreList::RemoveIgnore(packet);
 			break;
 
-		case eChatMessageType::TEAM_GET_STATUS:
+		case MessageType::Chat::TEAM_GET_STATUS:
 			ChatPacketHandler::HandleTeamStatusRequest(packet);
 			break;
 
-		case eChatMessageType::ADD_FRIEND_REQUEST:
+		case MessageType::Chat::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 eChatMessageType::ADD_FRIEND_RESPONSE:
+		case MessageType::Chat::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 eChatMessageType::REMOVE_FRIEND:
+		case MessageType::Chat::REMOVE_FRIEND:
 			ChatPacketHandler::HandleRemoveFriend(packet);
 			break;
 
-		case eChatMessageType::GENERAL_CHAT_MESSAGE:
+		case MessageType::Chat::GENERAL_CHAT_MESSAGE:
 			ChatPacketHandler::HandleChatMessage(packet);
 			break;
 
-		case eChatMessageType::PRIVATE_CHAT_MESSAGE:
+		case MessageType::Chat::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 eChatMessageType::TEAM_INVITE:
+		case MessageType::Chat::TEAM_INVITE:
 			ChatPacketHandler::HandleTeamInvite(packet);
 			break;
 
-		case eChatMessageType::TEAM_INVITE_RESPONSE:
+		case MessageType::Chat::TEAM_INVITE_RESPONSE:
 			ChatPacketHandler::HandleTeamInviteResponse(packet);
 			break;
 
-		case eChatMessageType::TEAM_LEAVE:
+		case MessageType::Chat::TEAM_LEAVE:
 			ChatPacketHandler::HandleTeamLeave(packet);
 			break;
 
-		case eChatMessageType::TEAM_SET_LEADER:
+		case MessageType::Chat::TEAM_SET_LEADER:
 			ChatPacketHandler::HandleTeamPromote(packet);
 			break;
 
-		case eChatMessageType::TEAM_KICK:
+		case MessageType::Chat::TEAM_KICK:
 			ChatPacketHandler::HandleTeamKick(packet);
 			break;
 
-		case eChatMessageType::TEAM_SET_LOOT:
+		case MessageType::Chat::TEAM_SET_LOOT:
 			ChatPacketHandler::HandleTeamLootOption(packet);
 			break;
-		case eChatMessageType::GMLEVEL_UPDATE:
+		case MessageType::Chat::GMLEVEL_UPDATE:
 			ChatPacketHandler::HandleGMLevelUpdate(packet);
 			break;
-		case eChatMessageType::LOGIN_SESSION_NOTIFY:
+		case MessageType::Chat::LOGIN_SESSION_NOTIFY:
 			Game::playerContainer.InsertPlayer(packet);
 			break;
-		case eChatMessageType::GM_ANNOUNCE:{
+		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 eChatMessageType::UNEXPECTED_DISCONNECT:
+		case MessageType::Chat::UNEXPECTED_DISCONNECT:
 			Game::playerContainer.RemovePlayer(packet);
 			break;
-		case eChatMessageType::WHO:
+		case MessageType::Chat::WHO:
 			ChatPacketHandler::HandleWho(packet);
 			break;
-		case eChatMessageType::SHOW_ALL:
+		case MessageType::Chat::SHOW_ALL:
 			ChatPacketHandler::HandleShowAll(packet);
 			break;
-		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::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::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::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
-		case eChatMessageType::ACHIEVEMENT_NOTIFY:
-		case eChatMessageType::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		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:
+		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);
 			break;
 		default:

dChatServer/PlayerContainer.cpp

@@ -11,7 +11,7 @@
 #include "eConnectionType.h"
 #include "ChatPackets.h"
 #include "dConfig.h"
-#include "eChatMessageType.h"
+#include "MessageType/Chat.h"
 
 void PlayerContainer::Initialize() {
 	m_MaxNumberOfBestFriends =
@@ -148,14 +148,13 @@ 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, eChatMessageType::GM_MUTE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_MUTE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -362,7 +361,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::TEAM_GET_STATUS);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::TEAM_GET_STATUS);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);

dCommon/AMFDeserialize.cpp

@@ -9,73 +9,54 @@
  * AMF3 Deserializer written by EmosewaMC
  */
 
-AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream& inStream) {
-	AMFBaseValue* returnValue = nullptr;
+std::unique_ptr<AMFBaseValue> AMFDeserialize::Read(RakNet::BitStream& inStream) {
 	// Read in the value type from the bitStream
 	eAmf 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: {
-		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;
-	}
+	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);
 
 	// 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:
-	case eAmf::Dictionary: {
+		[[fallthrough]];
+	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) {
@@ -118,14 +99,14 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
 	}
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream& inStream) {
+std::unique_ptr<AMFDoubleValue> AMFDeserialize::ReadAmfDouble(RakNet::BitStream& inStream) {
 	double value;
 	inStream.Read<double>(value);
-	return new AMFDoubleValue(value);
+	return std::make_unique<AMFDoubleValue>(value);
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream& inStream) {
-	auto arrayValue = new AMFArrayValue();
+std::unique_ptr<AMFArrayValue> AMFDeserialize::ReadAmfArray(RakNet::BitStream& inStream) {
+	auto arrayValue = std::make_unique<AMFArrayValue>();
 
 	// Read size of dense array
 	const auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
@@ -143,10 +124,10 @@ AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream& inStream) {
 	return arrayValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream& inStream) {
-	return new AMFStringValue(ReadString(inStream));
+std::unique_ptr<AMFStringValue> AMFDeserialize::ReadAmfString(RakNet::BitStream& inStream) {
+	return std::make_unique<AMFStringValue>(ReadString(inStream));
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream& inStream) {
-	return new AMFIntValue(ReadU29(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?
 }

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.
 	 */
-	AMFBaseValue* Read(RakNet::BitStream& inStream);
+	std::unique_ptr<AMFBaseValue> Read(RakNet::BitStream& inStream);
 private:
 	/**
 	 * @brief Private method to read a U29 integer from a bitstream
@@ -39,7 +39,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Double value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfDouble(RakNet::BitStream& inStream);
+	static std::unique_ptr<AMFDoubleValue> 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
 	 */
-	AMFBaseValue* ReadAmfArray(RakNet::BitStream& inStream);
+	std::unique_ptr<AMFArrayValue> 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
 	 */
-	AMFBaseValue* ReadAmfString(RakNet::BitStream& inStream);
+	std::unique_ptr<AMFStringValue> 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
 	 */
-	AMFBaseValue* ReadAmfInteger(RakNet::BitStream& inStream);
+	static std::unique_ptr<AMFIntValue> ReadAmfInteger(RakNet::BitStream& inStream);
 
 	/**
 	 * List of strings read so far saved to be read by reference.

dCommon/Amf3.h

@@ -1,5 +1,5 @@
-#ifndef AMF3_H
-#define AMF3_H
+#ifndef __AMF3__H__
+#define __AMF3__H__
 
 #include "dCommonVars.h"
 #include "Logger.h"
@@ -105,27 +105,14 @@ using AMFDoubleValue = AMFValue<double>;
  * and are not to be deleted by a caller.
  */
 class AMFArrayValue : public AMFBaseValue {
-	using AMFAssociative = std::unordered_map<std::string, AMFBaseValue*>;
-	using AMFDense = std::vector<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>>;
 
 public:
 	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override { return eAmf::Array; }
 
-	~AMFArrayValue() override {
-		for (const 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
 	 */
@@ -151,30 +138,32 @@ public:
 	 * 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& key, const ValueType value) {
+	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const std::string_view key, const ValueType value) {
 		const auto element = m_Associative.find(key);
 		AMFValue<ValueType>* val = nullptr;
 		bool found = true;
 		if (element == m_Associative.cend()) {
-			val = new AMFValue<ValueType>(value);
-			m_Associative.emplace(key, val);
+			auto newVal = std::make_unique<AMFValue<ValueType>>(value);
+			val = newVal.get();
+			m_Associative.emplace(key, std::move(newVal));
 		} else {
-			val = dynamic_cast<AMFValue<ValueType>*>(element->second);
+			val = dynamic_cast<AMFValue<ValueType>*>(element->second.get());
 			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& key) {
+	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const std::string_view key) {
 		const auto element = m_Associative.find(key);
 		AMFArrayValue* val = nullptr;
 		bool found = true;
 		if (element == m_Associative.cend()) {
-			val = new AMFArrayValue();
-			m_Associative.emplace(key, val);
+			auto newVal = std::make_unique<AMFArrayValue>();
+			val = newVal.get();
+			m_Associative.emplace(key, std::move(newVal));
 		} else {
-			val = dynamic_cast<AMFArrayValue*>(element->second);
+			val = dynamic_cast<AMFArrayValue*>(element->second.get());
 			found = false;
 		}
 		return std::make_pair(val, found);
@@ -182,15 +171,13 @@ public:
 
 	// Associates an array with an integer key
 	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const size_t index) {
-		AMFArrayValue* val = nullptr;
 		bool inserted = false;
 		if (index >= m_Dense.size()) {
 			m_Dense.resize(index + 1);
-			val = new AMFArrayValue();
-			m_Dense.at(index) = val;
+			m_Dense.at(index) = std::make_unique<AMFArrayValue>();
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFArrayValue*>(m_Dense.at(index)), inserted);
+		return std::make_pair(dynamic_cast<AMFArrayValue*>(m_Dense.at(index).get()), inserted);
 	}
 
 	/**
@@ -205,15 +192,13 @@ public:
 	 */
 	template <typename ValueType>
 	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const size_t index, const ValueType value) {
-		AMFValue<ValueType>* val = nullptr;
 		bool inserted = false;
 		if (index >= m_Dense.size()) {
 			m_Dense.resize(index + 1);
-			val = new AMFValue<ValueType>(value);
-			m_Dense.at(index) = val;
+			m_Dense.at(index) = std::make_unique<AMFValue<ValueType>>(value);
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(m_Dense.at(index)), inserted);
+		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(m_Dense.at(index).get()), inserted);
 	}
 
 	/**
@@ -225,13 +210,12 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const std::string& key, AMFBaseValue* const value) {
+	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) {
-			delete element->second;
-			element->second = value;
+			element->second = std::move(value);
 		} else {
-			m_Associative.emplace(key, value);
+			m_Associative.emplace(key, std::move(value));
 		}
 	}
 
@@ -244,14 +228,11 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const size_t index, AMFBaseValue* const value) {
-		if (index < m_Dense.size()) {
-			const AMFDense::const_iterator itr = m_Dense.cbegin() + index;
-			if (*itr) delete m_Dense.at(index);
-		} else {
+	void Insert(const size_t index, std::unique_ptr<AMFBaseValue> value) {
+		if (index >= m_Dense.size()) {
 			m_Dense.resize(index + 1);
 		}
-		m_Dense.at(index) = value;
+		m_Dense.at(index) = std::move(value);
 	}
 
 	/**
@@ -279,8 +260,7 @@ public:
 	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) delete it->second;
-			m_Associative.erase(it);
+			if (deleteValue) m_Associative.erase(it);
 		}
 	}
 
@@ -290,7 +270,6 @@ public:
 	void Remove(const size_t index) {
 		if (!m_Dense.empty() && index < m_Dense.size()) {
 			const auto itr = m_Dense.cbegin() + index;
-			if (*itr) delete (*itr);
 			m_Dense.erase(itr);
 		}
 	}
@@ -299,16 +278,16 @@ public:
 		if (!m_Dense.empty()) Remove(m_Dense.size() - 1);
 	}
 
-	[[nodiscard]] AMFArrayValue* GetArray(const std::string& key) const {
+	[[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) : nullptr;
+		return it != m_Associative.cend() ? dynamic_cast<AMFArrayValue*>(it->second.get()) : nullptr;
 	}
 
 	[[nodiscard]] AMFArrayValue* GetArray(const size_t index) const {
-		return index < m_Dense.size() ? dynamic_cast<AMFArrayValue*>(m_Dense.at(index)) : nullptr;
+		return index < m_Dense.size() ? dynamic_cast<AMFArrayValue*>(m_Dense.at(index).get()) : nullptr;
 	}
 
-	[[maybe_unused]] inline AMFArrayValue* InsertArray(const std::string& key) {
+	[[maybe_unused]] inline AMFArrayValue* InsertArray(const std::string_view key) {
 		return static_cast<AMFArrayValue*>(Insert(key).first);
 	}
 
@@ -330,17 +309,17 @@ public:
 	 * @return The AMFValue
 	 */
 	template <typename AmfType>
-	[[nodiscard]] AMFValue<AmfType>* Get(const std::string& key) const {
+	[[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) :
+			dynamic_cast<AMFValue<AmfType>*>(it->second.get()) :
 			nullptr;
 	}
 
 	// Get from the array but dont cast it
-	[[nodiscard]] AMFBaseValue* Get(const std::string& key) const {
+	[[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 : nullptr;
+		return it != m_Associative.cend() ? it->second.get() : nullptr;
 	}
 
 	/**
@@ -355,13 +334,13 @@ public:
 	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)) :
+			dynamic_cast<AMFValue<AmfType>*>(m_Dense.at(index).get()) :
 			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) : nullptr;
+		return index < m_Dense.size() ? m_Dense.at(index).get() : nullptr;
 	}
 
 private:
@@ -377,4 +356,4 @@ private:
 	AMFDense m_Dense;
 };
 
-#endif  //!AMF3_H
+#endif  //!__AMF3__H__

dCommon/BinaryIO.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef BINARYIO_H
-#define BINARYIO_H
+#ifndef __BINARYIO__H__
+#define __BINARYIO__H__
 
 #include <iostream>
 #include <fstream>
@@ -71,4 +71,4 @@ namespace BinaryIO {
 	}
 }
 
-#endif  //!BINARYIO_H
+#endif  //!__BINARYIO__H__

dCommon/BinaryPathFinder.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef BINARYPATHFINDER_H
-#define BINARYPATHFINDER_H
+#ifndef __BINARYPATHFINDER__H__
+#define __BINARYPATHFINDER__H__
 
 #include <filesystem>
 
@@ -12,4 +12,4 @@ public:
 	static std::filesystem::path GetBinaryDir();
 };
 
-#endif  //!BINARYPATHFINDER_H
+#endif  //!__BINARYPATHFINDER__H__

dCommon/Brick.h

@@ -1,5 +1,5 @@
-#ifndef BRICK_H
-#define BRICK_H
+#ifndef __BRICK__H__
+#define __BRICK__H__
 
 #include <cstdint>
 
@@ -8,4 +8,4 @@ struct Brick {
 	uint32_t materialID;
 };
 
-#endif  //!BRICK_H
+#endif  //!__BRICK__H__

dCommon/BrickByBrickFix.cpp

@@ -123,7 +123,7 @@ uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 				Database::Get()->UpdateUgcModelData(model.id, outputStringStream);
 				LOG("Updated model %i to sd0", model.id);
 				updatedModels++;
-			} catch (sql::SQLException exception) {
+			} catch (std::exception& exception) {
 				LOG("Failed to update model %i.  This model should be inspected manually to see why."
 					"The database error is %s", model.id, exception.what());
 			}

dCommon/CMakeLists.txt

@@ -45,11 +45,15 @@ if (UNIX)
 elseif (WIN32)
 	include(FetchContent)
 
+    set(WITH_GTEST OFF CACHE BOOL "" FORCE)
+    set(ZLIB_ENABLE_TESTS OFF CACHE BOOL "" FORCE)
+    set(ZLIB_COMPAT ON CACHE BOOL "Enable ZLIB compatibility mode" 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/madler/zlib/archive/refs/tags/v1.2.11.zip
-		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
+		URL https://github.com/zlib-ng/zlib-ng/archive/refs/tags/2.2.2.zip
+		URL_HASH MD5=2cf9199fb785ea579a2a9905a75c38b3
 	)
 
 	# Disable warning about no project version.
@@ -60,7 +64,6 @@ 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(

dCommon/DluAssert.h

@@ -1,5 +1,5 @@
-#ifndef DLUASSERT_H
-#define DLUASSERT_H
+#ifndef __DLUASSERT__H__
+#define __DLUASSERT__H__
 
 #include <assert.h>
 
@@ -9,4 +9,4 @@
 #	define DluAssert(expression)
 #endif
 
-#endif  //!DLUASSERT_H
+#endif  //!__DLUASSERT__H__

dCommon/FdbToSqlite.h

@@ -1,5 +1,5 @@
-#ifndef FDBTOSQLITE_H
-#define FDBTOSQLITE_H
+#ifndef __FDBTOSQLITE__H__
+#define __FDBTOSQLITE__H__
 
 #pragma once
 
@@ -142,4 +142,4 @@ namespace FdbToSqlite {
 	}; //! class FdbToSqlite
 }; //! namespace FdbToSqlite
 
-#endif  //!FDBTOSQLITE_H
+#endif  //!__FDBTOSQLITE__H__

dCommon/GeneralUtils.h

@@ -129,6 +129,29 @@ namespace GeneralUtils {
 
 	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string_view 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() ... ;
+	};
+
+	struct char_pointer_hash {
+		auto operator()(const char* const ptr) const noexcept {
+			return std::hash<std::string_view>{}(ptr);
+		}
+	};
+
+	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>;

dCommon/Implementation.h

@@ -0,0 +1,92 @@
+#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__

dCommon/LDFFormat.h

@@ -1,5 +1,5 @@
-#ifndef LDFFORMAT_H
-#define LDFFORMAT_H
+#ifndef __LDFFORMAT__H__
+#define __LDFFORMAT__H__
 
 // Custom Classes
 #include "dCommonVars.h"
@@ -220,4 +220,4 @@ template<> inline std::string LDFData<LWOOBJID>::GetValueString() const { return
 
 template<> inline std::string LDFData<std::string>::GetValueString() const { return this->value; }
 
-#endif  //!LDFFORMAT_H
+#endif  //!__LDFFORMAT__H__

dCommon/NiPoint3.h

@@ -1,5 +1,5 @@
-#ifndef NIPOINT3_H
-#define NIPOINT3_H
+#ifndef __NIPOINT3_H__
+#define __NIPOINT3_H__
 
 /*!
   \file NiPoint3.hpp
@@ -201,4 +201,4 @@ namespace NiPoint3Constant {
 // .inl file needed for code organization and to circumvent circular dependency issues
 #include "NiPoint3.inl"
 
-#endif // !NIPOINT3_H
+#endif // !__NIPOINT3_H__

dCommon/NiPoint3.inl

@@ -1,5 +1,5 @@
 #pragma once
-#ifndef NIPOINT3_H
+#ifndef __NIPOINT3_H__
 #error "This should only be included inline in NiPoint3.h: Do not include directly!"
 #endif
 

dCommon/NiQuaternion.h

@@ -1,5 +1,5 @@
-#ifndef NIQUATERNION_H
-#define NIQUATERNION_H
+#ifndef __NIQUATERNION_H__
+#define __NIQUATERNION_H__
 
 // Custom Classes
 #include "NiPoint3.h"
@@ -155,4 +155,4 @@ namespace NiQuaternionConstant {
 // Include constexpr and inline function definitions in a seperate file for readability
 #include "NiQuaternion.inl"
 
-#endif // !NIQUATERNION_H
+#endif // !__NIQUATERNION_H__

dCommon/NiQuaternion.inl

@@ -1,5 +1,5 @@
 #pragma once
-#ifndef NIQUATERNION_H
+#ifndef __NIQUATERNION_H__
 #error "This should only be included inline in NiQuaternion.h: Do not include directly!"
 #endif
 

dCommon/Observable.h

@@ -0,0 +1,73 @@
+#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__

dCommon/PositionUpdate.h

@@ -1,5 +1,5 @@
-#ifndef POSITIONUPDATE_H
-#define POSITIONUPDATE_H
+#ifndef __POSITIONUPDATE__H__
+#define __POSITIONUPDATE__H__
 
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
@@ -33,4 +33,4 @@ struct PositionUpdate {
 	RemoteInputInfo remoteInputInfo;
 };
 
-#endif  //!POSITIONUPDATE_H
+#endif  //!__POSITIONUPDATE__H__

dCommon/ZCompression.cpp

@@ -9,6 +9,7 @@ namespace ZCompression {
 	}
 
 	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst) {
+        
 		z_stream zInfo = { 0 };
 		zInfo.total_in = zInfo.avail_in = nLenSrc;
 		zInfo.total_out = zInfo.avail_out = nLenDst;

dCommon/dClient/AssetManager.cpp

@@ -4,8 +4,6 @@
 #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.");
@@ -82,7 +80,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<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -130,7 +128,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<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	crc = crc32b(crc, reinterpret_cast<uint8_t*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {

dCommon/dClient/ClientVersion.h

@@ -1,5 +1,5 @@
-#ifndef CLIENTVERSION_H
-#define CLIENTVERSION_H
+#ifndef __CLIENTVERSION_H__
+#define __CLIENTVERSION_H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ namespace ClientVersion {
 	constexpr uint16_t minor = 64;
 }
 
-#endif // !CLIENTVERSION_H
+#endif // !__CLIENTVERSION_H__

dCommon/dEnums/MessageType/Auth.h

@@ -0,0 +1,13 @@
+#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
+	};
+}

dCommon/dEnums/MessageType/Chat.h

@@ -0,0 +1,78 @@
+#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,
+	};
+}

dCommon/dEnums/MessageType/Client.h

@@ -0,0 +1,74 @@
+#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
+	};
+}

dCommon/dEnums/MessageType/Master.h

@@ -0,0 +1,34 @@
+#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
+	};
+}

dCommon/dEnums/MessageType/Server.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <cstdint>
+
+namespace MessageType {
+	//! The Internal Server Packet Identifiers
+	enum class Server : uint32_t {
+		VERSION_CONFIRM = 0,
+		DISCONNECT_NOTIFY,
+		GENERAL_NOTIFY
+	};
+}

dCommon/dEnums/MessageType/World.h

@@ -0,0 +1,49 @@
+#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;
+};

dCommon/dEnums/StringifiedEnum.h

@@ -1,5 +1,5 @@
-#ifndef STRINGIFIEDENUM_H
-#define STRINGIFIEDENUM_H
+#ifndef __STRINGIFIEDENUM_H__
+#define __STRINGIFIEDENUM_H__
 
 #include <string>
 #include "magic_enum.hpp"
@@ -26,4 +26,4 @@ namespace StringifiedEnum {
 	}
 }
 
-#endif // !STRINGIFIEDENUM_H
+#endif // !__STRINGIFIEDENUM_H__

dCommon/dEnums/dCommonVars.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#ifndef DCOMMONVARS_H
-#define DCOMMONVARS_H
+#ifndef __DCOMMONVARS__H__
+#define __DCOMMONVARS__H__
 
 #include <cstdint>
 #include <string>
 #include <set>
 #include "BitStream.h"
 #include "eConnectionType.h"
-#include "eClientMessageType.h"
+#include "MessageType/Client.h"
 #include "BitStreamUtils.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
@@ -33,7 +33,7 @@ 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, eClientMessageType::GAME_MSG);
+#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);
 
@@ -158,4 +158,4 @@ public:
 	}
 };
 
-#endif  //!DCOMMONVARS_H
+#endif  //!__DCOMMONVARS__H__

dCommon/dEnums/dPlatforms.h

@@ -8,6 +8,8 @@
 #define DARKFLAME_PLATFORM_IOS
 #elif TARGET_OS_MAC
 #define DARKFLAME_PLATFORM_MACOS
+#pragma clang diagnostic push // prevent pragma messages being counted as a warning
+#pragma clang diagnostic ignored "-W#pragma-messages"
 #else
 #error unknown Apple operating system
 #endif

dCommon/dEnums/eAddFriendResponseCode.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EADDFRIENDRESPONSECODE_H
-#define EADDFRIENDRESPONSECODE_H
+#ifndef __EADDFRIENDRESPONSECODE__H__
+#define __EADDFRIENDRESPONSECODE__H__
 
 #include <cstdint>
 
@@ -12,4 +12,4 @@ enum class eAddFriendResponseCode : uint8_t {
 	CANCELLED
 };
 
-#endif  //!ADDFRIENDRESPONSECODE_H
+#endif  //!__ADDFRIENDRESPONSECODE__H__

dCommon/dEnums/eAddFriendResponseType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EADDFRIENDRESPONSETYPE_H
-#define EADDFRIENDRESPONSETYPE_H
+#ifndef __EADDFRIENDRESPONSETYPE__H__
+#define __EADDFRIENDRESPONSETYPE__H__
 
 #include <cstdint>
 
@@ -21,4 +21,4 @@ enum class eAddFriendResponseType : uint8_t {
 	FRIENDISFREETRIAL
 };
 
-#endif  //!EADDFRIENDRESPONSETYPE_H
+#endif  //!__EADDFRIENDRESPONSETYPE__H__

dCommon/dEnums/eAnimationFlags.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EANINMATIONFLAGS_H
-#define EANINMATIONFLAGS_H
+#ifndef __EANINMATIONFLAGS__H__
+#define __EANINMATIONFLAGS__H__
 
 #include <cstdint>
 
@@ -41,4 +41,4 @@ enum class eAnimationFlags : uint32_t {
 	IDLE_MISC12
 };
 
-#endif  //!EANINMATIONFLAGS_H
+#endif  //!__EANINMATIONFLAGS__H__

dCommon/dEnums/eAuthMessageType.h

@@ -1,15 +0,0 @@
-#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

dCommon/dEnums/eBasicAttackSuccessTypes.h

@@ -1,5 +1,5 @@
-#ifndef EBASICATTACKSUCCESSTYPES_H
-#define EBASICATTACKSUCCESSTYPES_H
+#ifndef __EBASICATTACKSUCCESSTYPES__H__
+#define __EBASICATTACKSUCCESSTYPES__H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ enum class eBasicAttackSuccessTypes : uint8_t {
 	FAILIMMUNE
 };
 
-#endif  //!EBASICATTACKSUCCESSTYPES_H
+#endif  //!__EBASICATTACKSUCCESSTYPES__H__

dCommon/dEnums/eBlueprintSaveResponseType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EBLUEPRINTSAVERESPONSETYPE_H
-#define EBLUEPRINTSAVERESPONSETYPE_H
+#ifndef __EBLUEPRINTSAVERESPONSETYPE__H__
+#define __EBLUEPRINTSAVERESPONSETYPE__H__
 
 #include <cstdint>
 
@@ -23,4 +23,4 @@ enum class eBlueprintSaveResponseType : uint32_t {
     FindMatchesFailed
 };
 
-#endif  //!EBLUEPRINTSAVERESPONSETYPE_H
+#endif  //!__EBLUEPRINTSAVERESPONSETYPE__H__

dCommon/dEnums/eBubbleType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EBUBBLETYPE_H
-#define EBUBBLETYPE_H
+#ifndef __EBUBBLETYPE__H__
+#define __EBUBBLETYPE__H__
 
 #include <cstdint>
 
@@ -11,4 +11,4 @@ enum class eBubbleType : uint32_t {
 	SKUNK
 };
 
-#endif  //!EBUBBLETYPE_H
+#endif  //!__EBUBBLETYPE__H__

dCommon/dEnums/eBuildType.h

@@ -1,5 +1,5 @@
-#ifndef EBUILDTYPE_H
-#define EBUILDTYPE_H
+#ifndef __EBUILDTYPE__H__
+#define __EBUILDTYPE__H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ enum class eBuildType :uint32_t {
 	ON_PROPERTY
 };
 
-#endif  //!EBUILDTYPE_H
+#endif  //!__EBUILDTYPE__H__

dCommon/dEnums/eCharacterCreationResponse.h

@@ -1,5 +1,5 @@
-#ifndef ECHARACTERCREATIONRESPONSE_H
-#define ECHARACTERCREATIONRESPONSE_H
+#ifndef __ECHARACTERCREATIONRESPONSE__H__
+#define __ECHARACTERCREATIONRESPONSE__H__
 
 #include <cstdint>
 
@@ -11,4 +11,4 @@ enum class eCharacterCreationResponse : uint8_t {
 	CUSTOM_NAME_IN_USE
 };
 
-#endif  //!ECHARACTERCREATIONRESPONSE_H
+#endif  //!__ECHARACTERCREATIONRESPONSE__H__

dCommon/dEnums/eCharacterVersion.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef ECHARACTERVERSION_H
-#define ECHARACTERVERSION_H
+#ifndef __ECHARACTERVERSION__H__
+#define __ECHARACTERVERSION__H__
 
 #include <cstdint>
 
@@ -15,7 +15,8 @@ enum class eCharacterVersion : uint32_t {
 	// Fixes vault size value
 	VAULT_SIZE,
 	// Fixes speed base value in level component
-	UP_TO_DATE, // will become SPEED_BASE
+	SPEED_BASE,
+	UP_TO_DATE, // will become NJ_JAYMISSIONS
 };
 
-#endif  //!ECHARACTERVERSION_H
+#endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eChatMessageType.h

@@ -1,80 +0,0 @@
-#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,
-	// CUSTOM DLU MESSAGE ID FOR INTERNAL USE
-	CREATE_TEAM,
-};
-
-#endif  //!ECHATMESSAGETYPE_H

dCommon/dEnums/eCinematicEvent.h

@@ -1,5 +1,5 @@
-#ifndef ECINEMATICEVENT_H
-#define ECINEMATICEVENT_H
+#ifndef __ECINEMATICEVENT__H__
+#define __ECINEMATICEVENT__H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ enum class eCinematicEvent : uint32_t {
 	ENDED,
 };
 
-#endif  //!ECINEMATICEVENT_H
+#endif  //!__ECINEMATICEVENT__H__

dCommon/dEnums/eClientMessageType.h

@@ -1,76 +0,0 @@
-#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

dCommon/dEnums/eConnectionType.h

@@ -1,5 +1,5 @@
-#ifndef ECONNECTIONTYPE_H
-#define ECONNECTIONTYPE_H
+#ifndef __ECONNECTIONTYPE__H__
+#define __ECONNECTIONTYPE__H__
 
 enum class eConnectionType : uint16_t {
 	SERVER = 0,
@@ -10,4 +10,4 @@ enum class eConnectionType : uint16_t {
 	MASTER
 };
 
-#endif  //!ECONNECTIONTYPE_H
+#endif  //!__ECONNECTIONTYPE__H__

dCommon/dEnums/eControlScheme.h

@@ -1,5 +1,5 @@
-#ifndef ECONTROLSCHEME_H
-#define ECONTROLSCHEME_H
+#ifndef __ECONTROLSCHEME__H__
+#define __ECONTROLSCHEME__H__
 
 #include <cstdint>
 
@@ -15,4 +15,4 @@ enum class eControlScheme : uint32_t {
 	SCHEME_WEAR_A_ROBOT //== freecam?
 };
 
-#endif  //!ECONTROLSCHEME_H
+#endif  //!__ECONTROLSCHEME__H__

dCommon/dEnums/eCyclingMode.h

@@ -1,5 +1,5 @@
-#ifndef ECYCLINGMODE_H
-#define ECYCLINGMODE_H
+#ifndef __ECYCLINGMODE__H__
+#define __ECYCLINGMODE__H__
 
 #include <cstdint>
 
@@ -8,4 +8,4 @@ enum class eCyclingMode : uint32_t {
 	DISALLOW_CYCLING
 };
 
-#endif  //!ECYCLINGMODE_H
+#endif  //!__ECYCLINGMODE__H__

dCommon/dEnums/eEndBehavior.h

@@ -1,5 +1,5 @@
-#ifndef EENDBEHAVIOR_H
-#define EENDBEHAVIOR_H
+#ifndef __EENDBEHAVIOR__H__
+#define __EENDBEHAVIOR__H__
 
 #include <cstdint>
 
@@ -8,4 +8,4 @@ enum class eEndBehavior : uint32_t {
 	WAIT
 };
 
-#endif  //!EENDBEHAVIOR_H
+#endif  //!__EENDBEHAVIOR__H__

dCommon/dEnums/eGameActivity.h

@@ -1,5 +1,5 @@
-#ifndef EGAMEACTIVITY_H
-#define EGAMEACTIVITY_H
+#ifndef __EGAMEACTIVITY__H__
+#define __EGAMEACTIVITY__H__
 
 #include <cstdint>
 
@@ -12,4 +12,4 @@ enum class eGameActivity : uint32_t {
 	PET_TAMING
 };
 
-#endif  //!EGAMEACTIVITY_H
+#endif  //!__EGAMEACTIVITY__H__

dCommon/dEnums/eGameMasterLevel.h

@@ -1,5 +1,5 @@
-#ifndef EGAMEMASTERLEVEL_H
-#define EGAMEMASTERLEVEL_H
+#ifndef __EGAMEMASTERLEVEL__H__
+#define __EGAMEMASTERLEVEL__H__
 
 #include <cstdint>
 
@@ -17,4 +17,4 @@ enum class eGameMasterLevel : uint8_t {
 };
 
 
-#endif  //!EGAMEMASTERLEVEL_H
+#endif  //!__EGAMEMASTERLEVEL__H__

dCommon/dEnums/eHelpType.h

@@ -1,6 +1,6 @@
 
-#ifndef EHELPTYPE_H
-#define EHELPTYPE_H
+#ifndef __EHELPTYPE__H__
+#define __EHELPTYPE__H__
 
 #include <cstdint>
 
@@ -38,4 +38,4 @@ enum class eHelpType : int32_t {
 	UI_INVENTORY_FULL_CANNOT_PICKUP_ITEM = 86
 };
 
-#endif  //!EHELPTYPE_H
+#endif  //!__EHELPTYPE__H__

dCommon/dEnums/eInventoryType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EINVENTORYTYPE_H
-#define EINVENTORYTYPE_H
+#ifndef __EINVENTORYTYPE__H__
+#define __EINVENTORYTYPE__H__
 
 #include <cstdint>
 
@@ -65,4 +65,4 @@ struct magic_enum::customize::enum_range<eInventoryType> {
 	static constexpr int max = 16;
 };
 
-#endif  //!EINVENTORYTYPE_H
+#endif  //!__EINVENTORYTYPE__H__

dCommon/dEnums/eItemSetPassiveAbilityID.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EITEMSETPASSIVEABILITYID_H
-#define EITEMSETPASSIVEABILITYID_H
+#ifndef __EITEMSETPASSIVEABILITYID__H__
+#define __EITEMSETPASSIVEABILITYID__H__
 
 enum class eItemSetPassiveAbilityID {
 	EngineerRank1 = 2,
@@ -55,4 +55,4 @@ enum class eItemSetPassiveAbilityID {
 	LightningSpinjitzu = 52
 };
 
-#endif  //!EITEMSETPASSIVEABILITYID_H
+#endif  //!__EITEMSETPASSIVEABILITYID__H__

dCommon/dEnums/eItemType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EITEMTYPE_H
-#define EITEMTYPE_H
+#ifndef __EITEMTYPE__H__
+#define __EITEMTYPE__H__
 
 #include <cstdint>
 
@@ -33,4 +33,4 @@ enum class eItemType : int32_t {
 	MOUNT
 };
 
-#endif  //!EITEMTYPE_H
+#endif  //!__EITEMTYPE__H__

dCommon/dEnums/eKillType.h

@@ -1,5 +1,5 @@
-#ifndef EKILLTYPE_H
-#define EKILLTYPE_H
+#ifndef __EKILLTYPE__H__
+#define __EKILLTYPE__H__
 
 #include <cstdint>
 
@@ -8,4 +8,4 @@ enum class eKillType : uint32_t {
 	SILENT
 };
 
-#endif  //!EKILLTYPE_H
+#endif  //!__EKILLTYPE__H__

dCommon/dEnums/eLoginResponse.h

@@ -1,5 +1,5 @@
-#ifndef ELOGINRESPONSE_H
-#define ELOGINRESPONSE_H
+#ifndef __ELOGINRESPONSE__H__
+#define __ELOGINRESPONSE__H__
 
 #include <cstdint>
 
@@ -21,4 +21,4 @@ enum class eLoginResponse : uint8_t {
 	ACCOUNT_NOT_ACTIVATED
 };
 
-#endif  //!ELOGINRESPONSE_H
+#endif  //!__ELOGINRESPONSE__H__

dCommon/dEnums/eLootSourceType.h

@@ -1,5 +1,5 @@
-#ifndef ELOOTSOURCETYPE_H
-#define ELOOTSOURCETYPE_H
+#ifndef __ELOOTSOURCETYPE__H__
+#define __ELOOTSOURCETYPE__H__
 
 #include <cstdint>
 
@@ -28,4 +28,4 @@ enum class eLootSourceType : uint32_t {
 	RELOCATE
 };
 
-#endif  //!ELOOTSOURCETYPE_H
+#endif  //!__ELOOTSOURCETYPE__H__

dCommon/dEnums/eMasterMessageType.h

@@ -1,36 +0,0 @@
-#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

dCommon/dEnums/eMatchUpdate.h

@@ -1,5 +1,5 @@
-#ifndef EMATCHUPDATE_H
-#define EMATCHUPDATE_H
+#ifndef __EMATCHUPDATE__H__
+#define __EMATCHUPDATE__H__
 
 #include <cstdint>
 
@@ -14,4 +14,4 @@ enum class eMatchUpdate : int32_t {
 	PLAYER_UPDATE
 };
 
-#endif  //!EMATCHUPDATE_H
+#endif  //!__EMATCHUPDATE__H__

dCommon/dEnums/eMissionLockState.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EMISSIONLOCKSTATE_H
-#define EMISSIONLOCKSTATE_H
+#ifndef __EMISSIONLOCKSTATE__H__
+#define __EMISSIONLOCKSTATE__H__
 
 enum class eMissionLockState : int {
 	LOCKED,
@@ -9,4 +9,4 @@ enum class eMissionLockState : int {
 	UNLOCKED,
 };
 
-#endif  //!EMISSIONLOCKSTATE_H
+#endif  //!__EMISSIONLOCKSTATE__H__

dCommon/dEnums/eMissionState.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef MISSIONSTATE_H
-#define MISSIONSTATE_H
+#ifndef __MISSIONSTATE__H__
+#define __MISSIONSTATE__H__
 
 /**
  * Represents the possible states a mission can be in
@@ -53,4 +53,4 @@ enum class eMissionState : int {
 	COMPLETE_READY_TO_COMPLETE = 12
 };
 
-#endif  //!MISSIONSTATE_H
+#endif  //!__MISSIONSTATE__H__

dCommon/dEnums/eMissionTaskType.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef EMISSIONTASKTYPE_H
-#define EMISSIONTASKTYPE_H
+#ifndef __EMISSIONTASKTYPE__H__
+#define __EMISSIONTASKTYPE__H__
 
 enum class eMissionTaskType : int {
 	UNKNOWN = -1,
@@ -40,4 +40,4 @@ enum class eMissionTaskType : int {
 	DONATION
 };
 
-#endif  //!EMISSIONTASKTYPE_H
+#endif  //!__EMISSIONTASKTYPE__H__

dCommon/dEnums/eMovementPlatformState.h

@@ -1,5 +1,5 @@
-#ifndef EMOVEMENTPLATFORMSTATE_H
-#define EMOVEMENTPLATFORMSTATE_H
+#ifndef __EMOVEMENTPLATFORMSTATE__H__
+#define __EMOVEMENTPLATFORMSTATE__H__
 
 #include <cstdint>
 
@@ -13,4 +13,4 @@ enum class eMovementPlatformState : uint32_t
 	Stopped = 0b01100
 };
 
-#endif  //!EMOVEMENTPLATFORMSTATE_H
+#endif  //!__EMOVEMENTPLATFORMSTATE__H__

dCommon/dEnums/eObjectBits.h

@@ -1,5 +1,5 @@
-#ifndef EOBJECTBITS_H
-#define EOBJECTBITS_H
+#ifndef __EOBJECTBITS__H__
+#define __EOBJECTBITS__H__
 
 #include <cstdint>
 
@@ -10,4 +10,4 @@ enum class eObjectBits : size_t {
 	CHARACTER = 60
 };
 
-#endif  //!EOBJECTBITS_H
+#endif  //!__EOBJECTBITS__H__

dCommon/dEnums/eObjectWorldState.h

@@ -1,5 +1,5 @@
-#ifndef EOBJECTWORLDSTATE_H
-#define EOBJECTWORLDSTATE_H
+#ifndef __EOBJECTWORLDSTATE__H__
+#define __EOBJECTWORLDSTATE__H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ enum class eObjectWorldState : uint32_t {
 	INVENTORY
 };
 
-#endif  //!EOBJECTWORLDSTATE_H
+#endif  //!__EOBJECTWORLDSTATE__H__

dCommon/dEnums/ePackageType.h

@@ -1,5 +1,5 @@
-#ifndef EPACKAGETYPE_H
-#define EPACKAGETYPE_H
+#ifndef __EPACKAGETYPE__H__
+#define __EPACKAGETYPE__H__
 
 enum class ePackageType {
 	INVALID = -1,
@@ -10,4 +10,4 @@ enum class ePackageType {
 };
 
 
-#endif  //!EPACKAGETYPE_H
+#endif  //!__EPACKAGETYPE__H__

dCommon/dEnums/ePermissionMap.h

@@ -2,8 +2,8 @@
 
 #include <cstdint>
 
-#ifndef EPERMISSIONMAP_H
-#define EPERMISSIONMAP_H
+#ifndef __EPERMISSIONMAP__H__
+#define __EPERMISSIONMAP__H__
 
 /**
  * Bitmap of permissions and restrictions for characters.
@@ -29,4 +29,4 @@ enum class ePermissionMap : uint64_t {
 	RestrictedChatAccess = 0x1 << 6,
 };
 
-#endif  //!EPERMISSIONMAP_H
+#endif  //!__EPERMISSIONMAP__H__

dCommon/dEnums/ePetAbilityType.h

@@ -1,5 +1,5 @@
-#ifndef EPETABILITYTYPE_H
-#define EPETABILITYTYPE_H
+#ifndef __EPETABILITYTYPE__H__
+#define __EPETABILITYTYPE__H__
 
 #include <cstdint>
 
@@ -10,4 +10,4 @@ enum class ePetAbilityType : uint32_t {
 	DigAtPosition
 };
 
-#endif  //!EPETABILITYTYPE_H
+#endif  //!__EPETABILITYTYPE__H__

dCommon/dEnums/ePetTamingNotifyType.h

@@ -1,5 +1,5 @@
-#ifndef EPETTAMINGNOTIFYTYPE_H
-#define EPETTAMINGNOTIFYTYPE_H
+#ifndef __EPETTAMINGNOTIFYTYPE__H__
+#define __EPETTAMINGNOTIFYTYPE__H__
 
 #include <cstdint>
 
@@ -12,4 +12,4 @@ enum class ePetTamingNotifyType : uint32_t {
 	NAMINGPET
 };
 
-#endif  //!EPETTAMINGNOTIFYTYPE_H
+#endif  //!__EPETTAMINGNOTIFYTYPE__H__

dCommon/dEnums/ePhysicsEffectType.h

@@ -1,5 +1,5 @@
-#ifndef EPHYSICSEFFECTTYPE_H
-#define EPHYSICSEFFECTTYPE_H
+#ifndef __EPHYSICSEFFECTTYPE__H__
+#define __EPHYSICSEFFECTTYPE__H__
 
 
 #include <cstdint>
@@ -12,4 +12,4 @@ enum class ePhysicsEffectType : uint32_t {
 	FRICTION
 };
 
-#endif  //!EPHYSICSEFFECTTYPE_H
+#endif  //!__EPHYSICSEFFECTTYPE__H__

dCommon/dEnums/ePlayerFlag.h

@@ -1,5 +1,5 @@
-#ifndef EPLAYERFLAG_H
-#define EPLAYERFLAG_H
+#ifndef __EPLAYERFLAG__H__
+#define __EPLAYERFLAG__H__
 
 #include <cstdint>
 
@@ -170,4 +170,4 @@ enum ePlayerFlag : int32_t {
 	DLU_SKIP_CINEMATICS = 1'000'000,
 };
 
-#endif  //!EPLAYERFLAG_H
+#endif  //!__EPLAYERFLAG__H__

dCommon/dEnums/ePropertySortType.h

@@ -0,0 +1,11 @@
+#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

dCommon/dEnums/eQuickBuildFailReason.h

@@ -1,5 +1,5 @@
-#ifndef EQUICKBUILDFAILREASON_H
-#define EQUICKBUILDFAILREASON_H
+#ifndef __EQUICKBUILDFAILREASON__H__
+#define __EQUICKBUILDFAILREASON__H__
 
 #include <cstdint>
 
@@ -10,4 +10,4 @@ enum class eQuickBuildFailReason : uint32_t {
 	BUILD_ENDED
 };
 
-#endif  //!EQUICKBUILDFAILREASON_H
+#endif  //!__EQUICKBUILDFAILREASON__H__

dCommon/dEnums/eQuickBuildState.h

@@ -1,5 +1,5 @@
-#ifndef EQUICKBUILDSTATE_H
-#define EQUICKBUILDSTATE_H
+#ifndef __EQUICKBUILDSTATE__H__
+#define __EQUICKBUILDSTATE__H__
 
 #include <cstdint>
 
@@ -12,4 +12,4 @@ enum class eQuickBuildState : uint32_t {
 };
 
 
-#endif  //!EQUICKBUILDSTATE_H
+#endif  //!__EQUICKBUILDSTATE__H__

dCommon/dEnums/eRacingTaskParam.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef ERACINGTASKPARAM_H
-#define ERACINGTASKPARAM_H
+#ifndef __ERACINGTASKPARAM__H__
+#define __ERACINGTASKPARAM__H__
 
 #include <cstdint>
 
@@ -22,4 +22,4 @@ enum class eRacingTaskParam : int32_t {
 	SMASH_SPECIFIC_SMASHABLE
 };
 
-#endif  //!ERACINGTASKPARAM_H
+#endif  //!__ERACINGTASKPARAM__H__

dCommon/dEnums/eRenameResponse.h

@@ -1,5 +1,5 @@
-#ifndef ERENAMERESPONSE_H
-#define ERENAMERESPONSE_H
+#ifndef __ERENAMERESPONSE__H__
+#define __ERENAMERESPONSE__H__
 
 #include <cstdint>
 
@@ -12,4 +12,4 @@ enum class eRenameResponse : uint8_t {
 };
 
 
-#endif  //!ERENAMERESPONSE_H
+#endif  //!__ERENAMERESPONSE__H__

dCommon/dEnums/eReplicaComponentType.h

@@ -1,5 +1,5 @@
-#ifndef EREPLICACOMPONENTTYPE_H
-#define EREPLICACOMPONENTTYPE_H
+#ifndef __EREPLICACOMPONENTTYPE__H__
+#define __EREPLICACOMPONENTTYPE__H__
 
 #include <cstdint>
 
@@ -124,4 +124,4 @@ enum class eReplicaComponentType : uint32_t {
 	DESTROYABLE = 1000 // Actually 7
 };
 
-#endif  //!EREPLICACOMPONENTTYPE_H
+#endif  //!__EREPLICACOMPONENTTYPE__H__

dCommon/dEnums/eReplicaPacketType.h

@@ -1,5 +1,5 @@
-#ifndef EREPLICAPACKETTYPE_H
-#define EREPLICAPACKETTYPE_H
+#ifndef __EREPLICAPACKETTYPE__H__
+#define __EREPLICAPACKETTYPE__H__
 
 #include <cstdint>
 
@@ -9,4 +9,4 @@ enum class eReplicaPacketType : uint8_t {
 	DESTRUCTION
 };
 
-#endif  //!EREPLICAPACKETTYPE_H
+#endif  //!__EREPLICAPACKETTYPE__H__

dCommon/dEnums/eReponseMoveItemBetweenInventoryTypeCode.h

@@ -1,5 +1,5 @@
-#ifndef EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE_H
-#define EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE_H
+#ifndef __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
+#define __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
 
 #include <cstdint>
 
@@ -18,4 +18,4 @@ enum class eReponseMoveItemBetweenInventoryTypeCode : int32_t {
 	FAIL_DISMOUNT_BEFORE_MOVING
 };
 
-#endif  //!EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE_H
+#endif  //!__EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__

dCommon/dEnums/eServerDisconnectIdentifiers.h

@@ -1,5 +1,5 @@
-#ifndef ESERVERDISCONNECTIDENTIFIERS_H
-#define ESERVERDISCONNECTIDENTIFIERS_H
+#ifndef __ESERVERDISCONNECTIDENTIFIERS__H__
+#define __ESERVERDISCONNECTIDENTIFIERS__H__
 
 #include <cstdint>
 
@@ -21,4 +21,4 @@ enum class eServerDisconnectIdentifiers : uint32_t {
 	PLAY_SCHEDULE_TIME_DONE
 };
 
-#endif  //!ESERVERDISCONNECTIDENTIFIERS_H
+#endif  //!__ESERVERDISCONNECTIDENTIFIERS__H__

dCommon/dEnums/eServerMessageType.h

@@ -1,12 +0,0 @@
-#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