address feedback

Co-authored-by: David Markowitz <39972741+EmosewaMC@users.noreply.github.com>

CMakeLists.txt

@@ -1,9 +1,12 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 project(Darkflame)
 include(CTest)
 
 set(CMAKE_CXX_STANDARD 20)
 set(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")
 
 # Read variables from file
@@ -70,13 +73,15 @@ if(UNIX)
 	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
-	add_compile_options("/wd4267" "/utf-8")
+	# Also disable non-portable MSVC volatile behavior
+	add_compile_options("/wd4267" "/utf-8" "/volatile:iso")
 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
 
 # TODO make this not have to override the build type directories
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR})
@@ -90,6 +95,9 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
+find_package(MariaDB)
+find_package(JSON)
+
 # Create a /resServer directory
 make_directory(${CMAKE_BINARY_DIR}/resServer)
 
@@ -97,7 +105,7 @@ make_directory(${CMAKE_BINARY_DIR}/resServer)
 make_directory(${CMAKE_BINARY_DIR}/logs)
 
 # Copy resource files on first build
-set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blacklist.dcf")
+set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
 message(STATUS "Checking resource file integrity")
 
 include(Utils)
@@ -179,7 +187,7 @@ file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip DESTINATION ${PRO
 file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)
 
 # Copy vanity files on first build
-set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "NPC.xml")
+set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "root.xml" "dev-tribute.xml" "atm.xml" "demo.xml")
 
 foreach(file ${VANITY_FILES})
 	configure_file("${CMAKE_SOURCE_DIR}/vanity/${file}" "${CMAKE_BINARY_DIR}/vanity/${file}" COPYONLY)
@@ -202,91 +210,47 @@ foreach(file ${SQL_FILES})
 	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${PROJECT_BINARY_DIR}/migrations/cdserver/${file})
 endforeach()
 
-# Create our list of include directories
-set(INCLUDED_DIRECTORIES
-	"dCommon"
-	"dCommon/dClient"
-	"dCommon/dEnums"
-
-	"dChatFilter"
-
-	"dGame"
-	"dGame/dBehaviors"
-	"dGame/dComponents"
-	"dGame/dGameMessages"
-	"dGame/dInventory"
-	"dGame/dMission"
-	"dGame/dEntity"
-	"dGame/dPropertyBehaviors"
-	"dGame/dPropertyBehaviors/ControlBehaviorMessages"
-	"dGame/dUtilities"
-
-	"dPhysics"
-
-	"dNavigation"
-	"dNavigation/dTerrain"
-
-	"dZoneManager"
-
-	"dDatabase"
-	"dDatabase/CDClientDatabase"
-	"dDatabase/CDClientDatabase/CDClientTables"
-	"dDatabase/GameDatabase"
-	"dDatabase/GameDatabase/ITables"
-	"dDatabase/GameDatabase/MySQL"
-	"dDatabase/GameDatabase/MySQL/Tables"
-
-	"dNet"
-
-	"thirdparty/magic_enum/include/magic_enum"
-	"thirdparty/raknet/Source"
-	"thirdparty/tinyxml2"
-	"thirdparty/recastnavigation"
-	"thirdparty/SQLite"
-	"thirdparty/cpplinq"
-	"thirdparty/cpp-httplib"
-	"thirdparty/MD5"
-
-	"tests"
-	"tests/dCommonTests"
-	"tests/dGameTests"
-	"tests/dGameTests/dComponentsTests"
-)
-
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
 	include_directories("/usr/local/include/")
 endif()
 
-# Actually include the directories from our list
-foreach(dir ${INCLUDED_DIRECTORIES})
-	include_directories(${PROJECT_SOURCE_DIR}/${dir})
-endforeach()
-
-if(NOT WIN32)
-	include_directories("${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include/bcrypt")
-endif()
-
-include_directories("${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include")
-
-# Add linking directories:
-link_directories(${PROJECT_BINARY_DIR})
-
 # Load all of our third party directories
-add_subdirectory(thirdparty)
-if (UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-endif()
-# Glob together all headers that need to be precompiled
-file(
-	GLOB HEADERS_DDATABASE
-	LIST_DIRECTORIES false
-	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/*.h
-	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables/*.h
-	${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables/*.h
-	${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.h
+add_subdirectory(thirdparty SYSTEM)
+
+# Create our list of include directories
+include_directories(
+	"dPhysics"
+
+	"dNavigation"
+
+	"dNet"
+
+	"tests"
+	"tests/dCommonTests"
+	"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"
 )
 
+# Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
+# TODO: Should probably not do this.
+if(APPLE)
+	include_directories("/usr/local/include/")
+endif()
+
+# Add linking directories:
+if (UNIX)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Werror") # Warning flags
+endif()
 file(
 	GLOB HEADERS_DZONEMANAGER
 	LIST_DIRECTORIES false
@@ -321,7 +285,7 @@ add_subdirectory(dPhysics)
 add_subdirectory(dServer)
 
 # Create a list of common libraries shared between all binaries
-set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "mariadbConnCpp" "magic_enum" "MD5")
+set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "MariaDB::ConnCpp" "magic_enum" "nlohmann_json::nlohmann_json")
 
 # Add platform specific common libraries
 if(UNIX)
@@ -343,12 +307,6 @@ target_precompile_headers(
 	${HEADERS_DZONEMANAGER}
 )
 
-# Need to specify to use the CXX compiler language here or else we get errors including <string>.
-target_precompile_headers(
-	dDatabase PRIVATE
-	"$<$<COMPILE_LANGUAGE:CXX>:${HEADERS_DDATABASE}>"
-)
-
 target_precompile_headers(
 	dCommon PRIVATE
 	${HEADERS_DCOMMON}

Dockerfile

@@ -23,8 +23,7 @@ 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/src/mariadb_connector_cpp-build/libmariadbcpp.so /usr/local/lib/
-COPY --from=build /app/build/mariadbcpp/src/mariadb_connector_cpp-build/libmariadb/libmariadb/libmariadb.so.3 /usr/local/lib
+COPY --from=build /app/build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
 RUN ldconfig
 
 # Server bins

README.md

@@ -51,7 +51,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.18**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
 
 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.
@@ -73,7 +73,7 @@ sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-serve
 ```
 
 #### Required CMake version
-This project uses <font size="4">**CMake version 3.18**</font> or higher and as such you will need to ensure you have this version installed.
+This project uses <font size="4">**CMake version 3.25**</font> or higher and as such you will need to ensure you have this version installed.
 You can check your CMake version by using the following command in a terminal.
 ```bash
 cmake --version

cmake/FindGoogleTest.cmake

@@ -0,0 +1,17 @@
+include(FetchContent)
+
+message(STATUS "Fetching gtest...")
+
+FetchContent_Declare(
+	googletest
+	GIT_REPOSITORY https://github.com/google/googletest.git
+	GIT_TAG release-1.12.1
+)
+
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(GoogleTest)
+
+message(STATUS "gtest fetched and is now ready.")
+set(GoogleTest_FOUND TRUE)

cmake/FindJSON.cmake

@@ -0,0 +1,20 @@
+include(FetchContent)
+
+message(STATUS "Fetching json...")
+
+FetchContent_Declare(
+	json
+	GIT_REPOSITORY https://github.com/nlohmann/json
+	GIT_TAG v3.11.3
+)
+
+FetchContent_GetProperties(json)
+if(NOT json_POPULATED)
+	FetchContent_Populate(json)
+	add_subdirectory(${json_SOURCE_DIR} ${json_BINARY_DIR} EXCLUDE_FROM_ALL)
+endif()
+
+FetchContent_MakeAvailable(json)
+
+message(STATUS "json fetched and is now ready.")
+set(JSON_FOUND TRUE)

cmake/FindMariaDB.cmake

@@ -23,14 +23,14 @@ if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
 	set(MARIADB_CONNECTOR_CPP_MSI "mariadb-connector-cpp-${MARIADB_CONNECTOR_CPP_VERSION}-win64.msi")
 	
 	if(NOT EXISTS "${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_C_MSI}" )
-		message("Downloading mariadb connector/c")
+		message(STATUS "Downloading mariadb connector/c")
 		file(DOWNLOAD https://dlm.mariadb.com/${MARIADB_CONNECTOR_C_BUCKET}/Connectors/c/connector-c-${MARIADB_CONNECTOR_C_VERSION}/${MARIADB_CONNECTOR_C_MSI}
 			"${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_C_MSI}"
 			EXPECTED_HASH MD5=${MARIADB_CONNECTOR_C_MD5})
 	endif()
 
 	if(NOT EXISTS "${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_CPP_MSI}" )
-		message("Downloading mariadb connector/c++")
+		message(STATUS "Downloading mariadb connector/c++")
 		file(DOWNLOAD https://dlm.mariadb.com/${MARIADB_CONNECTOR_CPP_BUCKET}/Connectors/cpp/connector-cpp-${MARIADB_CONNECTOR_CPP_VERSION}/${MARIADB_CONNECTOR_CPP_MSI}
 			"${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_CPP_MSI}"
 			EXPECTED_HASH MD5=${MARIADB_CONNECTOR_CPP_MD5})
@@ -43,27 +43,28 @@ if(WIN32 AND NOT MARIADB_BUILD_SOURCE)
 		file(TO_NATIVE_PATH "${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_C_MSI}" MSI_DIR)
 		execute_process(COMMAND msiexec /a ${MSI_DIR} /qn TARGETDIR=${MSIEXEC_TARGETDIR})
 	endif()
+	set(MARIADBC_SHARED_LIBRARY_LOCATION "${MARIADB_C_CONNECTOR_DIR}/lib/libmariadb.dll")
 
 	if(NOT EXISTS "${MARIADB_CPP_CONNECTOR_DIR}")
 	file(TO_NATIVE_PATH "${MARIADB_MSI_DIR}/${MARIADB_CONNECTOR_CPP_MSI}" MSI_DIR)
 		execute_process(COMMAND msiexec /a ${MSI_DIR} /qn TARGETDIR=${MSIEXEC_TARGETDIR})
 	endif()
 
-	set(MARIADB_SHARED_LIBRARY_LOCATION "${MARIADB_CPP_CONNECTOR_DIR}/mariadbcpp.dll")
+	set(MARIADBCPP_SHARED_LIBRARY_LOCATION "${MARIADB_CPP_CONNECTOR_DIR}/mariadbcpp.dll")
 	set(MARIADB_IMPLIB_LOCATION "${MARIADB_CPP_CONNECTOR_DIR}/mariadbcpp.lib")
 	set(MARIADB_INCLUDE_DIR "${MARIADB_CPP_CONNECTOR_DIR}/include/mariadb")
 
 	add_custom_target(mariadb_connector_cpp)
 	add_custom_command(TARGET mariadb_connector_cpp POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E copy_if_different
-					"${MARIADB_CPP_CONNECTOR_DIR}/mariadbcpp.dll"
-					"${MARIADB_C_CONNECTOR_DIR}/lib/libmariadb.dll"
+					"${MARIADBCPP_SHARED_LIBRARY_LOCATION}"
+					"${MARIADBC_SHARED_LIBRARY_LOCATION}"
 					"${PROJECT_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.
 	# Plugin directory is determined at dll load time (this will happen before main()) so we need to delay the dll load so that we can set the environment variable
-	add_link_options(/DELAYLOAD:${MARIADB_SHARED_LIBRARY_LOCATION})
+	add_link_options(/DELAYLOAD:${MARIADBCPP_SHARED_LIBRARY_LOCATION})
 	add_compile_definitions(MARIADB_PLUGIN_DIR_OVERRIDE="${MARIADB_CPP_CONNECTOR_DIR}/plugin")
 else() # Build from source
 
@@ -85,77 +86,61 @@ 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_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
-						SOURCE_DIR ${CMAKE_SOURCE_DIR}/thirdparty/mariadb-connector-cpp
+		PREFIX "${PROJECT_BINARY_DIR}/thirdparty/mariadb-connector-cpp"
+		SOURCE_DIR ${MARIADBCPP_SOURCE_DIR}
+		INSTALL_DIR ${MARIADBCPP_INSTALL_DIR}
 		CMAKE_ARGS  -Wno-dev
+					-DWITH_UNIT_TESTS=OFF
+					-DMARIADB_LINK_DYNAMIC=OFF
 					-DCMAKE_BUILD_RPATH_USE_ORIGIN=${CMAKE_BUILD_RPATH_USE_ORIGIN}
-									-DCMAKE_INSTALL_PREFIX=./mariadbcpp # Points the connector to the correct plugin directory
-									-DINSTALL_PLUGINDIR=plugin
+					-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
+					-DINSTALL_LIBDIR=${MARIADBCPP_LIBRARY_DIR}
+					-DINSTALL_PLUGINDIR=${MARIADBCPP_PLUGIN_DIR}
 					${MARIADB_EXTRA_CMAKE_ARGS}
-						PREFIX "${PROJECT_BINARY_DIR}/mariadbcpp"
-						BUILD_COMMAND cmake --build . --config RelWithDebInfo -j${MARIADB_CONNECTOR_COMPILE_JOBS}
-						INSTALL_COMMAND "")
-
-	ExternalProject_Get_Property(mariadb_connector_cpp BINARY_DIR)
+		BUILD_ALWAYS true
+	)
 
 	if(WIN32)
 		set(MARIADB_SHARED_LIBRARY_NAME mariadbcpp.dll)
 		set(MARIADB_PLUGIN_SUFFIX .dll)
-		set(MARIADB_IMPLIB_LOCATION "${BINARY_DIR}/RelWithDebInfo/mariadbcpp.lib")
+		set(MARIADB_IMPLIB_LOCATION "${MARIADBCPP_LIBRARY_DIR}/mariadbcpp.lib")
 
 		# When built from source windows only seems to check same folder as exe instead specified folder, so use
 		# environment variable to force it
 		add_link_options(/DELAYLOAD:mariadbcpp.dll)
-		add_compile_definitions(MARIADB_PLUGIN_DIR_OVERRIDE="${PROJECT_BINARY_DIR}/mariadbcpp/plugin")
+		add_compile_definitions(MARIADB_PLUGIN_DIR_OVERRIDE="${MARIADBCPP_PLUGIN_DIR}")
 	else()
 		set(MARIADB_SHARED_LIBRARY_NAME libmariadbcpp${CMAKE_SHARED_LIBRARY_SUFFIX})
-		set(MARIADB_PLUGIN_SUFFIX .so)
+		set(MARIADB_PLUGIN_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
 	endif()
 
-	get_property(isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-	if(isMultiConfig)
-		set(MARIADB_SHARED_LIBRARY_LOCATION "${BINARY_DIR}/RelWithDebInfo/${MARIADB_SHARED_LIBRARY_NAME}")
-		set(MARIADB_SHARED_LIBRARY_COPY_LOCATION "${PROJECT_BINARY_DIR}/$<CONFIG>")
-		set(MARIADB_PLUGINS_LOCATION "${BINARY_DIR}/libmariadb/RelWithDebInfo")
-	else()
-		set(MARIADB_SHARED_LIBRARY_LOCATION "${BINARY_DIR}/${MARIADB_SHARED_LIBRARY_NAME}")
-		set(MARIADB_SHARED_LIBRARY_COPY_LOCATION "${PROJECT_BINARY_DIR}")
-		set(MARIADB_PLUGINS_LOCATION "${BINARY_DIR}/libmariadb")
+	set(MARIADBCPP_SHARED_LIBRARY_LOCATION "${MARIADBCPP_LIBRARY_DIR}/${MARIADB_SHARED_LIBRARY_NAME}")
+	if(WIN32)
+		set(MARIADBC_SHARED_LIBRARY_LOCATION "${MARIADBCPP_LIBRARY_DIR}/libmariadb.lib")
 	endif()
-
-	set(MARIADB_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include/")
-
-	add_custom_command(TARGET mariadb_connector_cpp POST_BUILD
-						COMMAND ${CMAKE_COMMAND} -E make_directory
-						${BINARY_DIR}/mariadbcpp/plugin
-						${MARIADB_SHARED_LIBRARY_COPY_LOCATION}
-
-						COMMAND ${CMAKE_COMMAND} -E copy_if_different
-						${MARIADB_SHARED_LIBRARY_LOCATION}
-						${MARIADB_SHARED_LIBRARY_COPY_LOCATION}
-
-						COMMAND ${CMAKE_COMMAND} -E copy_if_different
-						${MARIADB_PLUGINS_LOCATION}/caching_sha2_password${MARIADB_PLUGIN_SUFFIX}
-						${MARIADB_PLUGINS_LOCATION}/client_ed25519${MARIADB_PLUGIN_SUFFIX}
-						${MARIADB_PLUGINS_LOCATION}/dialog${MARIADB_PLUGIN_SUFFIX}
-						${MARIADB_PLUGINS_LOCATION}/mysql_clear_password${MARIADB_PLUGIN_SUFFIX}
-						${MARIADB_PLUGINS_LOCATION}/sha256_password${MARIADB_PLUGIN_SUFFIX}
-						${BINARY_DIR}/mariadbcpp/plugin)
-endif()
-
-# Remove the CMakeLists.txt file from the tests folder for the maria-db-connector so we dont compile the tests.
-if(EXISTS "${CMAKE_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/test/CMakeLists.txt")
-	file(REMOVE "${CMAKE_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/test/CMakeLists.txt")
 endif()
 
 # Create mariadb connector library object
-add_library(mariadbConnCpp SHARED IMPORTED GLOBAL)
-set_property(TARGET mariadbConnCpp PROPERTY IMPORTED_LOCATION ${MARIADB_SHARED_LIBRARY_LOCATION})
+add_library(MariaDB::ConnCpp SHARED IMPORTED GLOBAL)
+add_dependencies(MariaDB::ConnCpp mariadb_connector_cpp)
+set_target_properties(MariaDB::ConnCpp PROPERTIES
+	IMPORTED_LOCATION "${MARIADBCPP_SHARED_LIBRARY_LOCATION}")
 
 if(WIN32)
-	set_property(TARGET mariadbConnCpp PROPERTY IMPORTED_IMPLIB ${MARIADB_IMPLIB_LOCATION})
+	set_target_properties(MariaDB::ConnCpp PROPERTIES
+		IMPORTED_IMPLIB "${MARIADB_IMPLIB_LOCATION}")
+elseif(APPLE)
+	set_target_properties(MariaDB::ConnCpp PROPERTIES
+		IMPORTED_SONAME "libmariadbcpp")
 endif()
 
 # Add directories to include lists
-target_include_directories(mariadbConnCpp INTERFACE ${MARIADB_INCLUDE_DIR})
-add_dependencies(mariadbConnCpp mariadb_connector_cpp)
+target_include_directories(MariaDB::ConnCpp SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
+
+set(MariaDB_FOUND TRUE)

dChatFilter/dChatFilter.cpp

@@ -27,8 +27,8 @@ dChatFilter::dChatFilter(const std::string& filepath, bool dontGenerateDCF) {
 		ExportWordlistToDCF(filepath + ".dcf", true);
 	}
 
-	if (BinaryIO::DoesFileExist("blacklist.dcf")) {
-		ReadWordlistDCF("blacklist.dcf", false);
+	if (BinaryIO::DoesFileExist("blocklist.dcf")) {
+		ReadWordlistDCF("blocklist.dcf", false);
 	}
 
 	//Read player names that are ok as well:
@@ -44,20 +44,20 @@ dChatFilter::~dChatFilter() {
 	m_DeniedWords.clear();
 }
 
-void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool whiteList) {
+void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool allowList) {
 	std::ifstream file(filepath);
 	if (file) {
 		std::string line;
 		while (std::getline(file, line)) {
 			line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
 			std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
-			if (whiteList) m_ApprovedWords.push_back(CalculateHash(line));
+			if (allowList) m_ApprovedWords.push_back(CalculateHash(line));
 			else m_DeniedWords.push_back(CalculateHash(line));
 		}
 	}
 }
 
-bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
+bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool allowList) {
 	std::ifstream file(filepath, std::ios::binary);
 	if (file) {
 		fileHeader hdr;
@@ -70,13 +70,13 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
 		if (hdr.formatVersion == formatVersion) {
 			size_t wordsToRead = 0;
 			BinaryIO::BinaryRead(file, wordsToRead);
-			if (whiteList) m_ApprovedWords.reserve(wordsToRead);
+			if (allowList) m_ApprovedWords.reserve(wordsToRead);
 			else m_DeniedWords.reserve(wordsToRead);
 
 			size_t word = 0;
 			for (size_t i = 0; i < wordsToRead; ++i) {
 				BinaryIO::BinaryRead(file, word);
-				if (whiteList) m_ApprovedWords.push_back(word);
+				if (allowList) m_ApprovedWords.push_back(word);
 				else m_DeniedWords.push_back(word);
 			}
 
@@ -90,14 +90,14 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
 	return false;
 }
 
-void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteList) {
+void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowList) {
 	std::ofstream file(filepath, std::ios::binary | std::ios_base::out);
 	if (file) {
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::header));
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::formatVersion));
-		BinaryIO::BinaryWrite(file, size_t(whiteList ? m_ApprovedWords.size() : m_DeniedWords.size()));
+		BinaryIO::BinaryWrite(file, size_t(allowList ? m_ApprovedWords.size() : m_DeniedWords.size()));
 
-		for (size_t word : whiteList ? m_ApprovedWords : m_DeniedWords) {
+		for (size_t word : allowList ? m_ApprovedWords : m_DeniedWords) {
 			BinaryIO::BinaryWrite(file, word);
 		}
 
@@ -105,10 +105,10 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteLis
 	}
 }
 
-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList) {
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
 	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
-	if (!whiteList && m_DeniedWords.empty()) return { { 0, message.length() } };
+	if (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
 
 	std::stringstream sMessage(message);
 	std::string segment;
@@ -126,16 +126,16 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 
 		size_t hash = CalculateHash(segment);
 
-		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && whiteList) {
+		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
-		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && whiteList) {
+		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
-		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !whiteList) {
+		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}

dChatFilter/dChatFilter.h

@@ -21,10 +21,10 @@ public:
 	dChatFilter(const std::string& filepath, bool dontGenerateDCF);
 	~dChatFilter();
 
-	void ReadWordlistPlaintext(const std::string& filepath, bool whiteList);
-	bool ReadWordlistDCF(const std::string& filepath, bool whiteList);
-	void ExportWordlistToDCF(const std::string& filepath, bool whiteList);
-	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList = true);
+	void ReadWordlistPlaintext(const std::string& filepath, bool allowList);
+	bool ReadWordlistDCF(const std::string& filepath, bool allowList);
+	void ExportWordlistToDCF(const std::string& filepath, bool allowList);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/CMakeLists.txt

@@ -1,14 +1,17 @@
 set(DCHATSERVER_SOURCES
+	"ChatWebApi.cpp"
 	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
 	"PlayerContainer.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
-add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE ${PROJECT_SOURCE_DIR}/dServer)
+target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
+add_library(dChatServer ${DCHATSERVER_SOURCES})
+target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
+
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
 target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
 

dChatServer/ChatIgnoreList.cpp

@@ -1,6 +1,6 @@
 #include "ChatIgnoreList.h"
 #include "PlayerContainer.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT,  eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receivingPlayer);
 
 	//portion that will get routed:
@@ -59,7 +59,7 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 		bitStream.Write(LUWString(ignoredPlayer.playerName, 36));
 	}
 
-	Game::server->Send(&bitStream, packet->systemAddress, false);
+	Game::server->Send(bitStream, packet->systemAddress, false);
 }
 
 void ChatIgnoreList::AddIgnore(Packet* packet) {
@@ -131,7 +131,7 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 	bitStream.Write(playerNameSend);
 	bitStream.Write(ignoredPlayerId);
 
-	Game::server->Send(&bitStream, packet->systemAddress, false);
+	Game::server->Send(bitStream, packet->systemAddress, false);
 }
 
 void ChatIgnoreList::RemoveIgnore(Packet* packet) {
@@ -167,5 +167,5 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 	LUWString playerNameSend(removedIgnoreStr, 33);
 	bitStream.Write(playerNameSend);
 
-	Game::server->Send(&bitStream, packet->systemAddress, false);
+	Game::server->Send(bitStream, packet->systemAddress, false);
 }

dChatServer/ChatPacketHandler.cpp

@@ -14,11 +14,11 @@
 #include "eObjectBits.h"
 #include "eConnectionType.h"
 #include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
 #include "eClientMessageType.h"
 #include "eGameMessageType.h"
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
+#include "ChatPackets.h"
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
@@ -60,7 +60,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
@@ -355,6 +355,67 @@ void ChatPacketHandler::HandleGMLevelUpdate(Packet* packet) {
 	inStream.Read(player.gmLevel);
 }
 
+
+void ChatPacketHandler::HandleWho(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	FindPlayerRequest request;
+	request.Deserialize(inStream);
+
+	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
+	if (!sender) return;
+
+	const auto& player = Game::playerContainer.GetPlayerData(request.playerName.GetAsString());
+	bool online = player;
+
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	bitStream.Write(request.requestor);
+
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::WHO_RESPONSE);
+	bitStream.Write<uint8_t>(online);
+	bitStream.Write(player.zoneID.GetMapID());
+	bitStream.Write(player.zoneID.GetInstanceID());
+	bitStream.Write(player.zoneID.GetCloneID());
+	bitStream.Write(request.playerName);
+
+	SystemAddress sysAddr = sender.sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::HandleShowAll(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	ShowAllRequest request;
+	request.Deserialize(inStream);
+
+	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
+	if (!sender) return;
+
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	bitStream.Write(request.requestor);
+
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SHOW_ALL_RESPONSE);
+	bitStream.Write<uint8_t>(!request.displayZoneData && !request.displayIndividualPlayers);
+	bitStream.Write(Game::playerContainer.GetPlayerCount());
+	bitStream.Write(Game::playerContainer.GetSimCount());
+	bitStream.Write<uint8_t>(request.displayIndividualPlayers);
+	bitStream.Write<uint8_t>(request.displayZoneData);
+	if (request.displayZoneData || request.displayIndividualPlayers){
+		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
+			if (!playerData) continue;
+			bitStream.Write<uint8_t>(0); // structure packing
+			if (request.displayIndividualPlayers) bitStream.Write(LUWString(playerData.playerName));
+			if (request.displayZoneData) {
+				bitStream.Write(playerData.zoneID.GetMapID());
+				bitStream.Write(playerData.zoneID.GetInstanceID());
+				bitStream.Write(playerData.zoneID.GetCloneID());
+			}
+		}
+	}
+	SystemAddress sysAddr = sender.sysAddr;
+	SEND_PACKET;
+}
+
 // the structure the client uses to send this packet is shared in many chat messages 
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
@@ -454,7 +515,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(routeTo.playerID);
 
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
@@ -696,7 +757,7 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -711,7 +772,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -738,7 +799,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -763,7 +824,7 @@ void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64L
 
 void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -780,7 +841,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -809,7 +870,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -835,7 +896,7 @@ void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bD
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -869,7 +930,7 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(friendData.playerID);
 
 	//portion that will get routed:
@@ -906,7 +967,7 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 	}
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -920,7 +981,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	// Portion that will get routed:
@@ -943,7 +1004,7 @@ 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_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:

dChatServer/ChatPacketHandler.h

@@ -50,6 +50,8 @@ namespace ChatPacketHandler {
 	void HandleFriendResponse(Packet* packet);
 	void HandleRemoveFriend(Packet* packet);
 	void HandleGMLevelUpdate(Packet* packet);
+	void HandleWho(Packet* packet);
+	void HandleShowAll(Packet* packet);
 
 	void HandleChatMessage(Packet* packet);
 	void HandlePrivateChatMessage(Packet* packet);

dChatServer/ChatServer.cpp

@@ -17,10 +17,10 @@
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
 #include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
 #include "eWorldMessageType.h"
 #include "ChatIgnoreList.h"
 #include "StringifiedEnum.h"
+#include "ChatWebApi.h"
 
 #include "Game.h"
 #include "Server.h"
@@ -101,7 +101,7 @@ int main(int argc, char** argv) {
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	std::string ourIP = "localhost";
 	const uint32_t maxClients = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_clients")).value_or(999);
-	const uint32_t ourPort = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("chat_server_port")).value_or(1501);
+	const uint32_t ourPort = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("chat_server_port")).value_or(2005);
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;
 
@@ -123,6 +123,9 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
+	// start the web api thread
+	std::thread webAPIThread(ChatWebApi::Listen, ourPort);
+
 	Game::logger->Flush(); // once immediately before main loop
 	while (!Game::ShouldShutdown()) {
 		//Check if we're still connected to master:
@@ -176,53 +179,39 @@ int main(int argc, char** argv) {
 	delete Game::logger;
 	delete Game::config;
 	
+	// rejoin the web api thread
+	ChatWebApi::Stop();
+	webAPIThread.join();
+
 	return EXIT_SUCCESS;
 }
 
 void HandlePacket(Packet* packet) {
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
 		LOG("A server has disconnected, erasing their connected players from the list.");
-	}
-
-	if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
+	} else if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
 		LOG("A server is connecting, awaiting user list.");
-	}
+	} else if (packet->length < 4 || packet->data[0] != ID_USER_PACKET_ENUM) return; // Nothing left to process or not the right packet type
 
-	if (packet->length < 4) return; // Nothing left to process.  Need 4 bytes to continue.
+	CINSTREAM;
+	inStream.SetReadOffset(BYTES_TO_BITS(1));
 
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
-			Game::playerContainer.InsertPlayer(packet);
-			break;
+	eConnectionType connection;
+	eChatMessageType chatMessageID;
 
-		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
-			Game::playerContainer.RemovePlayer(packet);
-			break;
+	inStream.Read(connection);
+	if (connection != eConnectionType::CHAT) return;
+	inStream.Read(chatMessageID);
 	
-		case eChatInternalMessageType::MUTE_UPDATE:
+	switch (chatMessageID) {
+		case eChatMessageType::GM_MUTE:
 			Game::playerContainer.MuteUpdate(packet);
 			break;
 
-		case eChatInternalMessageType::CREATE_TEAM:
+		case eChatMessageType::CREATE_TEAM:
 			Game::playerContainer.CreateTeamServer(packet);
 			break;
 
-		case eChatInternalMessageType::ANNOUNCEMENT: {
-			//we just forward this packet to every connected server
-			CINSTREAM;
-			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
-			break;
-		}
-
-		default:
-			LOG("Unknown CHAT_INTERNAL id: %i", int(packet->data[3]));
-		}
-	}
-
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
-		eChatMessageType chat_message_type = static_cast<eChatMessageType>(packet->data[3]);
-		switch (chat_message_type) {
 		case eChatMessageType::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
@@ -296,6 +285,23 @@ void HandlePacket(Packet* packet) {
 			ChatPacketHandler::HandleGMLevelUpdate(packet);
 			break;
 		case eChatMessageType::LOGIN_SESSION_NOTIFY:
+			Game::playerContainer.InsertPlayer(packet);
+			break;
+		case eChatMessageType::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:
+			Game::playerContainer.RemovePlayer(packet);
+			break;
+		case eChatMessageType::WHO:
+			ChatPacketHandler::HandleWho(packet);
+			break;
+		case eChatMessageType::SHOW_ALL:
+			ChatPacketHandler::HandleShowAll(packet);
+			break;
 		case eChatMessageType::USER_CHANNEL_CHAT_MESSAGE:
 		case eChatMessageType::WORLD_DISCONNECT_REQUEST:
 		case eChatMessageType::WORLD_PROXIMITY_RESPONSE:
@@ -308,7 +314,6 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::GUILD_KICK:
 		case eChatMessageType::GUILD_GET_STATUS:
 		case eChatMessageType::GUILD_GET_ALL:
-		case eChatMessageType::SHOW_ALL:
 		case eChatMessageType::BLUEPRINT_MODERATED:
 		case eChatMessageType::BLUEPRINT_MODEL_READY:
 		case eChatMessageType::PROPERTY_READY_FOR_APPROVAL:
@@ -323,7 +328,6 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::CSR_REQUEST:
 		case eChatMessageType::CSR_REPLY:
 		case eChatMessageType::GM_KICK:
-		case eChatMessageType::GM_ANNOUNCE:
 		case eChatMessageType::WORLD_ROUTE_PACKET:
 		case eChatMessageType::GET_ZONE_POPULATIONS:
 		case eChatMessageType::REQUEST_MINIMUM_CHAT_MODE:
@@ -332,33 +336,18 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::UGCMANIFEST_REPORT_DONE_FILE:
 		case eChatMessageType::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
 		case eChatMessageType::UGCC_REQUEST:
-		case eChatMessageType::WHO:
 		case eChatMessageType::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
 		case eChatMessageType::ACHIEVEMENT_NOTIFY:
 		case eChatMessageType::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		case eChatMessageType::UNEXPECTED_DISCONNECT:
 		case eChatMessageType::PLAYER_READY:
 		case eChatMessageType::GET_DONATION_TOTAL:
 		case eChatMessageType::UPDATE_DONATION:
 		case eChatMessageType::PRG_CSR_COMMAND:
 		case eChatMessageType::HEARTBEAT_REQUEST_FROM_WORLD:
 		case eChatMessageType::UPDATE_FREE_TRIAL_STATUS:
-			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chat_message_type).data(), chat_message_type);
+			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
 			break;
 		default:
-			LOG("Unknown CHAT Message id: %i", chat_message_type);
-		}
-	}
-
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
-		switch (static_cast<eWorldMessageType>(packet->data[3])) {
-		case eWorldMessageType::ROUTE_PACKET: {
-			LOG("Routing packet from world");
-			break;
-		}
-
-		default:
-			LOG("Unknown World id: %i", int(packet->data[3]));
-		}
+			LOG("Unknown CHAT Message id: %i", chatMessageID);
 	}
 }

dChatServer/ChatWebApi.cpp

@@ -0,0 +1,93 @@
+#include "ChatWebApi.h"
+
+#include <cstdint>
+
+#include "dCommonVars.h"
+#include "eConnectionType.h"
+#include "eChatMessageType.h"
+#include "httplib.h"
+#include "dServer.h"
+#include "PlayerContainer.h"
+#include "dConfig.h"
+#include "httplib.h"
+#include "nlohmann/json.hpp"
+
+using json = nlohmann::json;
+
+namespace {
+	httplib::Server m_APIServer;
+}
+
+void ChatWebApi::Listen(const uint32_t port) {
+	if (Game::config->GetValue("enable_chat_web_api") != "1") {
+		LOG("Chat Web API is disabled");
+		return;
+	}
+	LOG("Chat Web API is enabled, starting web server...");
+
+	m_APIServer.Post("/announce", [](const httplib::Request& req, httplib::Response& res) {
+		const json data = json::parse(req.body);
+		if (!data.contains("title")) {
+			res.set_content("{\"error\":\"Missing paramater: title\"}", "application/json");
+			res.status = 400;
+			return;
+		}
+		std::string title = data["title"];
+		if (!data.contains("message")) {
+			res.set_content("{\"error\":\"Missing paramater: message\"}", "application/json");
+			res.status = 400;
+			return;
+		}
+		std::string message = data["message"];
+		// build and send the packet to all world servers
+		CBITSTREAM;
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_ANNOUNCE);
+		bitStream.Write<uint32_t>(title.size());
+		bitStream.Write(title);
+		bitStream.Write<uint32_t>(message.size());
+		bitStream.Write(message);
+		Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	});
+
+	m_APIServer.Get("/players", [](const httplib::Request& req, httplib::Response& res) {
+		auto data = json::array();
+		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
+			if (!playerData) continue;
+			data.push_back(playerData.to_json());
+		}
+		res.set_content(data.dump(), "application/json");
+		if (data.empty()) res.status = 204;
+	});
+
+	m_APIServer.Get("/teams", [](const httplib::Request& req, httplib::Response& res) {
+		auto data = json::array();
+		for (auto& teamData: Game::playerContainer.GetAllTeams()){
+			if (!teamData) continue;
+			json toInsert;
+			toInsert["id"] = teamData->teamID;
+			toInsert["loot_flag"] = teamData->lootFlag;
+			toInsert["local"] = teamData->local;
+
+			auto& leader = Game::playerContainer.GetPlayerData(teamData->leaderID);
+			toInsert["leader"] = leader.to_json();
+
+			json members;
+			for (auto& member : teamData->memberIDs){
+				auto playerData = Game::playerContainer.GetPlayerData(member);
+				if (!playerData) continue;
+				members.push_back(playerData.to_json());
+			}
+			toInsert["members"] = members;
+			data.push_back(toInsert);
+		}
+		res.set_content(data.dump(), "application/json");
+		if (data.empty()) res.status = 204;
+	});
+
+	m_APIServer.listen(Game::config->GetValue("chat_web_api_listen_address").c_str(), port);
+};
+
+void ChatWebApi::Stop(){
+	LOG("Stopping Chat Web API server...");
+	m_APIServer.stop();
+}

dChatServer/ChatWebApi.h

@@ -0,0 +1,6 @@
+#include <cstdint>
+
+namespace ChatWebApi {
+	void Listen(const uint32_t port);
+	void Stop();
+};

dChatServer/PlayerContainer.cpp

@@ -1,7 +1,9 @@
 #include "PlayerContainer.h"
-#include "dNetCommon.h"
+
 #include <iostream>
 #include <algorithm>
+
+#include "dNetCommon.h"
 #include "Game.h"
 #include "Logger.h"
 #include "ChatPacketHandler.h"
@@ -9,9 +11,26 @@
 #include "BitStreamUtils.h"
 #include "Database.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
 #include "ChatPackets.h"
 #include "dConfig.h"
+#include "eChatMessageType.h"	
+
+using json = nlohmann::json;
+
+const json PlayerData::to_json() const {
+	json data;
+	data["id"] = this->playerID;
+	data["name"] = this->playerName;
+	data["gm_level"] = this->gmLevel;
+	data["muted"] = this->GetIsMuted();
+
+	json zoneID;
+	zoneID["map_id"] = std::to_string(this->zoneID.GetMapID());
+	zoneID["instance_id"] = std::to_string(this->zoneID.GetInstanceID());
+	zoneID["clone_id"] = std::to_string(this->zoneID.GetCloneID());
+	data["zone_id"] = zoneID;
+	return data;
+}
 
 void PlayerContainer::Initialize() {
 	m_MaxNumberOfBestFriends =
@@ -49,6 +68,7 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	data.sysAddr = packet->systemAddress;
 
 	m_Names[data.playerID] = GeneralUtils::UTF8ToUTF16(data.playerName);
+	m_PlayerCount++;
 
 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
 
@@ -87,6 +107,7 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		}
 	}
 
+	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);
 
@@ -145,12 +166,12 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_MUTE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
 
-	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 }
 
 TeamData* PlayerContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
@@ -352,7 +373,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::TEAM_GET_STATUS);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);
@@ -365,7 +386,7 @@ void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 		}
 	}
 
-	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 }
 
 std::u16string PlayerContainer::GetName(LWOOBJID playerID) {
@@ -390,7 +411,7 @@ LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
 }
 
 PlayerData& PlayerContainer::GetPlayerDataMutable(const LWOOBJID& playerID) {
-	return m_Players[playerID];
+	return m_Players.contains(playerID) ? m_Players[playerID] : m_Players[LWOOBJID_EMPTY];
 }
 
 PlayerData& PlayerContainer::GetPlayerDataMutable(const std::string& playerName) {

dChatServer/PlayerContainer.h

@@ -6,6 +6,7 @@
 #include "Game.h"
 #include "dServer.h"
 #include <unordered_map>
+#include "nlohmann/json.hpp"
 
 enum class eGameMasterLevel : uint8_t;
 
@@ -36,6 +37,8 @@ struct PlayerData {
 		return muteExpire == 1 || muteExpire > time(NULL);
 	}
 
+	const nlohmann::json to_json() const;
+
 	SystemAddress sysAddr{};
 	LWOZONEID zoneID{};
 	LWOOBJID playerID = LWOOBJID_EMPTY;
@@ -71,6 +74,9 @@ public:
 	const PlayerData& GetPlayerData(const std::string& playerName);
 	PlayerData& GetPlayerDataMutable(const LWOOBJID& playerID);
 	PlayerData& GetPlayerDataMutable(const std::string& playerName);
+	uint32_t GetPlayerCount() { return m_PlayerCount; };
+	uint32_t GetSimCount() { return m_SimCount; };
+	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() { return m_Players; };
 
 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -85,6 +91,7 @@ public:
 	LWOOBJID GetId(const std::u16string& playerName);
 	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
 	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
+	const std::vector<TeamData*>& GetAllTeams() { return mTeams;};
 
 private:
 	LWOOBJID m_TeamIDCounter = 0;
@@ -93,5 +100,7 @@ private:
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
 	uint32_t m_MaxNumberOfBestFriends = 5;
 	uint32_t m_MaxNumberOfFriends = 50;
+	uint32_t m_PlayerCount = 0;
+	uint32_t m_SimCount = 0;
 };
 

dCommon/AMFDeserialize.cpp

@@ -9,12 +9,11 @@
  * AMF3 Deserializer written by EmosewaMC
  */
 
-AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
-	if (!inStream) return nullptr;
+AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream& inStream) {
 	AMFBaseValue* returnValue = nullptr;
 	// Read in the value type from the bitStream
 	eAmf marker;
-	inStream->Read(marker);
+	inStream.Read(marker);
 	// Based on the typing, create the value associated with that and return the base value class
 	switch (marker) {
 	case eAmf::Undefined: {
@@ -79,13 +78,13 @@ AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
 	return returnValue;
 }
 
-uint32_t AMFDeserialize::ReadU29(RakNet::BitStream* inStream) {
+uint32_t AMFDeserialize::ReadU29(RakNet::BitStream& inStream) {
 	bool byteFlag = true;
 	uint32_t actualNumber{};
 	uint8_t numberOfBytesRead{};
 	while (byteFlag && numberOfBytesRead < 4) {
 		uint8_t byte{};
-		inStream->Read(byte);
+		inStream.Read(byte);
 		// Parse the byte
 		if (numberOfBytesRead < 3) {
 			byteFlag = byte & static_cast<uint8_t>(1 << 7);
@@ -101,7 +100,7 @@ uint32_t AMFDeserialize::ReadU29(RakNet::BitStream* inStream) {
 	return actualNumber;
 }
 
-const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
+const std::string AMFDeserialize::ReadString(RakNet::BitStream& inStream) {
 	auto length = ReadU29(inStream);
 	// Check if this is a reference
 	bool isReference = length % 2 == 1;
@@ -109,7 +108,7 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 	length = length >> 1;
 	if (isReference) {
 		std::string value(length, 0);
-		inStream->Read(&value[0], length);
+		inStream.Read(&value[0], length);
 		// Empty strings are never sent by reference
 		if (!value.empty()) accessedElements.push_back(value);
 		return value;
@@ -119,20 +118,20 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 	}
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
+AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream& inStream) {
 	double value;
-	inStream->Read<double>(value);
+	inStream.Read<double>(value);
 	return new AMFDoubleValue(value);
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
+AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream& inStream) {
 	auto arrayValue = new AMFArrayValue();
 
 	// Read size of dense array
-	auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
+	const auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
 	// Then read associative portion
 	while (true) {
-		auto key = ReadString(inStream);
+		const auto key = ReadString(inStream);
 		// No more associative values when we encounter an empty string key
 		if (key.size() == 0) break;
 		arrayValue->Insert(key, Read(inStream));
@@ -144,10 +143,10 @@ AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
 	return arrayValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
+AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream& inStream) {
 	return new AMFStringValue(ReadString(inStream));
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
+AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream& inStream) {
 	return new AMFIntValue(ReadU29(inStream));
 }

dCommon/AMFDeserialize.h

@@ -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);
+	AMFBaseValue* Read(RakNet::BitStream& inStream);
 private:
 	/**
 	 * @brief Private method to read a U29 integer from a bitstream
@@ -23,7 +23,7 @@ private:
 	 * @param inStream bitstream to read data from
 	 * @return The number as an unsigned 29 bit integer
 	 */
-	uint32_t ReadU29(RakNet::BitStream* inStream);
+	static uint32_t ReadU29(RakNet::BitStream& inStream);
 
 	/**
 	 * @brief Reads a string from a bitstream
@@ -31,7 +31,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return The read string
 	 */
-	const std::string ReadString(RakNet::BitStream* inStream);
+	const std::string ReadString(RakNet::BitStream& inStream);
 
 	/**
 	 * @brief Read an AMFDouble value from a bitStream
@@ -39,7 +39,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Double value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfDouble(RakNet::BitStream* inStream);
+	AMFBaseValue* ReadAmfDouble(RakNet::BitStream& inStream);
 
 	/**
 	 * @brief Read an AMFArray from a bitStream
@@ -47,7 +47,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Array value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfArray(RakNet::BitStream* inStream);
+	AMFBaseValue* ReadAmfArray(RakNet::BitStream& inStream);
 
 	/**
 	 * @brief Read an AMFString from a bitStream
@@ -55,7 +55,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return String value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfString(RakNet::BitStream* inStream);
+	AMFBaseValue* ReadAmfString(RakNet::BitStream& inStream);
 
 	/**
 	 * @brief Read an AMFInteger from a bitStream
@@ -63,7 +63,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Integer value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfInteger(RakNet::BitStream* inStream);
+	AMFBaseValue* ReadAmfInteger(RakNet::BitStream& inStream);
 
 	/**
 	 * List of strings read so far saved to be read by reference.

dCommon/Amf3.h

@@ -41,12 +41,14 @@ template <typename ValueType>
 class AMFValue : public AMFBaseValue {
 public:
 	AMFValue() = default;
-	AMFValue(const ValueType value) { m_Data = value; }
+	AMFValue(const ValueType value) : m_Data{ value } {}
+
 	virtual ~AMFValue() override = default;
 
 	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override;
 
 	[[nodiscard]] const ValueType& GetValue() const { return m_Data; }
+
 	void SetValue(const ValueType value) { m_Data = value; }
 
 protected:
@@ -110,7 +112,7 @@ public:
 	[[nodiscard]] constexpr eAmf GetValueType() const noexcept override { return eAmf::Array; }
 
 	~AMFArrayValue() override {
-		for (auto valueToDelete : GetDense()) {
+		for (const auto* valueToDelete : GetDense()) {
 			if (valueToDelete) {
 				delete valueToDelete;
 				valueToDelete = nullptr;
@@ -127,12 +129,12 @@ public:
 	/**
 	 * Returns the Associative portion of the object
 	 */
-	[[nodiscard]] inline const AMFAssociative& GetAssociative() const noexcept { return this->associative; }
+	[[nodiscard]] inline const AMFAssociative& GetAssociative() const noexcept { return m_Associative; }
 
 	/**
 	 * Returns the dense portion of the object
 	 */
-	[[nodiscard]] inline const AMFDense& GetDense() const noexcept { return this->dense; }
+	[[nodiscard]] inline const AMFDense& GetDense() const noexcept { return m_Dense; }
 
 	/**
 	 * Inserts an AMFValue into the associative portion with the given key.
@@ -150,12 +152,12 @@ public:
 	 */
 	template <typename ValueType>
 	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const std::string& key, const ValueType value) {
-		auto element = associative.find(key);
+		const auto element = m_Associative.find(key);
 		AMFValue<ValueType>* val = nullptr;
 		bool found = true;
-		if (element == associative.end()) {
+		if (element == m_Associative.cend()) {
 			val = new AMFValue<ValueType>(value);
-			associative.insert(std::make_pair(key, val));
+			m_Associative.emplace(key, val);
 		} else {
 			val = dynamic_cast<AMFValue<ValueType>*>(element->second);
 			found = false;
@@ -165,12 +167,12 @@ public:
 
 	// Associates an array with a string key
 	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const std::string& key) {
-		auto element = associative.find(key);
+		const auto element = m_Associative.find(key);
 		AMFArrayValue* val = nullptr;
 		bool found = true;
-		if (element == associative.end()) {
+		if (element == m_Associative.cend()) {
 			val = new AMFArrayValue();
-			associative.insert(std::make_pair(key, val));
+			m_Associative.emplace(key, val);
 		} else {
 			val = dynamic_cast<AMFArrayValue*>(element->second);
 			found = false;
@@ -182,13 +184,13 @@ public:
 	[[maybe_unused]] std::pair<AMFBaseValue*, bool> Insert(const size_t index) {
 		AMFArrayValue* val = nullptr;
 		bool inserted = false;
-		if (index >= dense.size()) {
-			dense.resize(index + 1);
+		if (index >= m_Dense.size()) {
+			m_Dense.resize(index + 1);
 			val = new AMFArrayValue();
-			dense.at(index) = val;
+			m_Dense.at(index) = val;
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFArrayValue*>(dense.at(index)), inserted);
+		return std::make_pair(dynamic_cast<AMFArrayValue*>(m_Dense.at(index)), inserted);
 	}
 
 	/**
@@ -205,13 +207,13 @@ public:
 	[[maybe_unused]] std::pair<AMFValue<ValueType>*, bool> Insert(const size_t index, const ValueType value) {
 		AMFValue<ValueType>* val = nullptr;
 		bool inserted = false;
-		if (index >= this->dense.size()) {
-			this->dense.resize(index + 1);
+		if (index >= m_Dense.size()) {
+			m_Dense.resize(index + 1);
 			val = new AMFValue<ValueType>(value);
-			this->dense.at(index) = val;
+			m_Dense.at(index) = val;
 			inserted = true;
 		}
-		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(this->dense.at(index)), inserted);
+		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(m_Dense.at(index)), inserted);
 	}
 
 	/**
@@ -224,12 +226,12 @@ public:
 	 * @param value The value to insert
 	 */
 	void Insert(const std::string& key, AMFBaseValue* const value) {
-		auto element = associative.find(key);
-		if (element != associative.end() && element->second) {
+		const auto element = m_Associative.find(key);
+		if (element != m_Associative.cend() && element->second) {
 			delete element->second;
 			element->second = value;
 		} else {
-			associative.insert(std::make_pair(key, value));
+			m_Associative.emplace(key, value);
 		}
 	}
 
@@ -243,13 +245,13 @@ public:
 	 * @param value The value to insert
 	 */
 	void Insert(const size_t index, AMFBaseValue* const value) {
-		if (index < dense.size()) {
-			AMFDense::iterator itr = dense.begin() + index;
-			if (*itr) delete dense.at(index);
+		if (index < m_Dense.size()) {
+			const AMFDense::const_iterator itr = m_Dense.cbegin() + index;
+			if (*itr) delete m_Dense.at(index);
 		} else {
-			dense.resize(index + 1);
+			m_Dense.resize(index + 1);
 		}
-		dense.at(index) = value;
+		m_Dense.at(index) = value;
 	}
 
 	/**
@@ -264,7 +266,7 @@ public:
 	 */
 	template <typename ValueType>
 	[[maybe_unused]] inline AMFValue<ValueType>* Push(const ValueType value) {
-		return Insert(this->dense.size(), value).first;
+		return Insert(m_Dense.size(), value).first;
 	}
 
 	/**
@@ -275,10 +277,10 @@ public:
 	 * @param key The key to remove from the associative portion
 	 */
 	void Remove(const std::string& key, const bool deleteValue = true) {
-		AMFAssociative::iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
+		const AMFAssociative::const_iterator it = m_Associative.find(key);
+		if (it != m_Associative.cend()) {
 			if (deleteValue) delete it->second;
-			this->associative.erase(it);
+			m_Associative.erase(it);
 		}
 	}
 
@@ -286,27 +288,24 @@ public:
 	 * Pops the last element in the dense portion, deleting it in the process.
 	 */
 	void Remove(const size_t index) {
-		if (!this->dense.empty() && index < this->dense.size()) {
-			auto itr = this->dense.begin() + index;
+		if (!m_Dense.empty() && index < m_Dense.size()) {
+			const auto itr = m_Dense.cbegin() + index;
 			if (*itr) delete (*itr);
-			this->dense.erase(itr);
+			m_Dense.erase(itr);
 		}
 	}
 
 	void Pop() {
-		if (!this->dense.empty()) Remove(this->dense.size() - 1);
+		if (!m_Dense.empty()) Remove(m_Dense.size() - 1);
 	}
 
 	[[nodiscard]] AMFArrayValue* GetArray(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
-			return dynamic_cast<AMFArrayValue*>(it->second);
-		}
-		return nullptr;
+		const AMFAssociative::const_iterator it = m_Associative.find(key);
+		return it != m_Associative.cend() ? dynamic_cast<AMFArrayValue*>(it->second) : nullptr;
 	}
 
 	[[nodiscard]] AMFArrayValue* GetArray(const size_t index) const {
-		return index >= this->dense.size() ? nullptr : dynamic_cast<AMFArrayValue*>(this->dense.at(index));
+		return index < m_Dense.size() ? dynamic_cast<AMFArrayValue*>(m_Dense.at(index)) : nullptr;
 	}
 
 	[[maybe_unused]] inline AMFArrayValue* InsertArray(const std::string& key) {
@@ -318,7 +317,7 @@ public:
 	}
 
 	[[maybe_unused]] inline AMFArrayValue* PushArray() {
-		return static_cast<AMFArrayValue*>(Insert(this->dense.size()).first);
+		return static_cast<AMFArrayValue*>(Insert(m_Dense.size()).first);
 	}
 
 	/**
@@ -332,16 +331,16 @@ public:
 	 */
 	template <typename AmfType>
 	[[nodiscard]] AMFValue<AmfType>* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ?
+		const AMFAssociative::const_iterator it = m_Associative.find(key);
+		return it != m_Associative.cend() ?
 			dynamic_cast<AMFValue<AmfType>*>(it->second) :
 			nullptr;
 	}
 
 	// Get from the array but dont cast it
 	[[nodiscard]] AMFBaseValue* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ? it->second : nullptr;
+		const AMFAssociative::const_iterator it = m_Associative.find(key);
+		return it != m_Associative.cend() ? it->second : nullptr;
 	}
 
 	/**
@@ -355,27 +354,27 @@ public:
 	 */
 	template <typename AmfType>
 	[[nodiscard]] AMFValue<AmfType>* Get(const size_t index) const {
-		return index < this->dense.size() ?
-			dynamic_cast<AMFValue<AmfType>*>(this->dense.at(index)) :
+		return index < m_Dense.size() ?
+			dynamic_cast<AMFValue<AmfType>*>(m_Dense.at(index)) :
 			nullptr;
 	}
 
 	// Get from the dense but dont cast it
 	[[nodiscard]] AMFBaseValue* Get(const size_t index) const {
-		return index < this->dense.size() ? this->dense.at(index) : nullptr;
+		return index < m_Dense.size() ? m_Dense.at(index) : nullptr;
 	}
 
 private:
 	/**
 	 * The associative portion.  These values are key'd with strings to an AMFValue.
 	 */
-	AMFAssociative associative;
+	AMFAssociative m_Associative;
 
 	/**
 	 * The dense portion.  These AMFValue's are stored one after
 	 * another with the most recent addition being at the back.
 	 */
-	AMFDense dense;
+	AMFDense m_Dense;
 };
 
 #endif  //!__AMF3__H__

dCommon/AmfSerialize.cpp

@@ -53,7 +53,7 @@ void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value) {
  * A private function to write an value to a RakNet::BitStream
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
+void WriteUInt29(RakNet::BitStream& bs, uint32_t v) {
 	unsigned char b4 = static_cast<unsigned char>(v);
 	if (v < 0x00200000) {
 		b4 = b4 & 0x7F;
@@ -65,10 +65,10 @@ void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
 				unsigned char b2;
 				v = v >> 7;
 				b2 = static_cast<unsigned char>(v) | 0x80;
-				bs->Write(b2);
+				bs.Write(b2);
 			}
 
-			bs->Write(b3);
+			bs.Write(b3);
 		}
 	} else {
 		unsigned char b1;
@@ -82,19 +82,19 @@ void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
 		v = v >> 7;
 		b1 = static_cast<unsigned char>(v) | 0x80;
 
-		bs->Write(b1);
-		bs->Write(b2);
-		bs->Write(b3);
+		bs.Write(b1);
+		bs.Write(b2);
+		bs.Write(b3);
 	}
 
-	bs->Write(b4);
+	bs.Write(b4);
 }
 
 /**
  * Writes a flag number to a RakNet::BitStream
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
+void WriteFlagNumber(RakNet::BitStream& bs, uint32_t v) {
 	v = (v << 1) | 0x01;
 	WriteUInt29(bs, v);
 }
@@ -104,9 +104,9 @@ void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
  *
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
+void WriteAMFString(RakNet::BitStream& bs, const std::string& str) {
 	WriteFlagNumber(bs, static_cast<uint32_t>(str.size()));
-	bs->Write(str.c_str(), static_cast<uint32_t>(str.size()));
+	bs.Write(str.c_str(), static_cast<uint32_t>(str.size()));
 }
 
 /**
@@ -114,8 +114,8 @@ void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
  *
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
-	bs->Write(value);
+void WriteAMFU16(RakNet::BitStream& bs, uint16_t value) {
+	bs.Write(value);
 }
 
 /**
@@ -123,8 +123,8 @@ void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
  *
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
-	bs->Write(value);
+void WriteAMFU32(RakNet::BitStream& bs, uint32_t value) {
+	bs.Write(value);
 }
 
 /**
@@ -132,40 +132,40 @@ void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
  *
  * RakNet writes in the correct byte order - do not reverse this.
  */
-void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
-	bs->Write(value);
+void WriteAMFU64(RakNet::BitStream& bs, uint64_t value) {
+	bs.Write(value);
 }
 
 // Writes an AMFIntegerValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value) {
-	WriteUInt29(this, value.GetValue());
+	WriteUInt29(*this, value.GetValue());
 }
 
 // Writes an AMFDoubleValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value) {
 	double d = value.GetValue();
-	WriteAMFU64(this, *reinterpret_cast<uint64_t*>(&d));
+	WriteAMFU64(*this, *reinterpret_cast<uint64_t*>(&d));
 }
 
 // Writes an AMFStringValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value) {
-	WriteAMFString(this, value.GetValue());
+	WriteAMFString(*this, value.GetValue());
 }
 
 // Writes an AMFArrayValue to BitStream
 template<>
 void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value) {
 	uint32_t denseSize = value.GetDense().size();
-	WriteFlagNumber(this, denseSize);
+	WriteFlagNumber(*this, denseSize);
 
 	auto it = value.GetAssociative().begin();
 	auto end = value.GetAssociative().end();
 
 	while (it != end) {
-		WriteAMFString(this, it->first);
+		WriteAMFString(*this, it->first);
 		this->Write<AMFBaseValue&>(*it->second);
 		it++;
 	}

dCommon/CMakeLists.txt

@@ -30,11 +30,15 @@ foreach(file ${DCOMMON_DCLIENT_SOURCES})
 	set(DCOMMON_SOURCES ${DCOMMON_SOURCES} "dClient/${file}")
 endforeach()
 
-include_directories(${PROJECT_SOURCE_DIR}/dCommon/)
-
 add_library(dCommon STATIC ${DCOMMON_SOURCES})
-
-target_link_libraries(dCommon bcrypt dDatabase tinyxml2)
+target_include_directories(dCommon
+	PUBLIC "." "dClient" "dEnums"
+	PRIVATE
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
+)
 
 if (UNIX)
 	find_package(ZLIB REQUIRED)
@@ -65,4 +69,6 @@ else ()
 	)
 endif ()
 
-target_link_libraries(dCommon ZLIB::ZLIB)
+target_link_libraries(dCommon
+	PRIVATE ZLIB::ZLIB bcrypt tinyxml2
+	INTERFACE dDatabase)

dCommon/Diagnostics.cpp

@@ -120,6 +120,8 @@ void CatchUnhandled(int sig) {
 		if (eptr) std::rethrow_exception(eptr);
 	} catch(const std::exception& e) {
 		LOG("Caught exception: '%s'", e.what());
+	} catch (...) {
+		LOG("Caught unknown exception.");
 	}
 
 #ifndef INCLUDE_BACKTRACE

dCommon/GeneralUtils.cpp

@@ -8,23 +8,23 @@
 #include <map>
 
 template <typename T>
-inline size_t MinSize(size_t size, const std::basic_string_view<T>& string) {
-	if (size == size_t(-1) || size > string.size()) {
+static inline size_t MinSize(const size_t size, const std::basic_string_view<T> string) {
+	if (size == SIZE_MAX || size > string.size()) {
 		return string.size();
 	} else {
 		return size;
 	}
 }
 
-inline bool IsLeadSurrogate(char16_t c) {
+inline bool IsLeadSurrogate(const char16_t c) {
 	return (0xD800 <= c) && (c <= 0xDBFF);
 }
 
-inline bool IsTrailSurrogate(char16_t c) {
+inline bool IsTrailSurrogate(const char16_t c) {
 	return (0xDC00 <= c) && (c <= 0xDFFF);
 }
 
-inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
+inline void PushUTF8CodePoint(std::string& ret, const char32_t cp) {
 	if (cp <= 0x007F) {
 		ret.push_back(static_cast<uint8_t>(cp));
 	} else if (cp <= 0x07FF) {
@@ -46,16 +46,16 @@ inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
 
 constexpr const char16_t REPLACEMENT_CHARACTER = 0xFFFD;
 
-bool _IsSuffixChar(uint8_t c) {
+bool static _IsSuffixChar(const uint8_t c) {
 	return (c & 0xC0) == 0x80;
 }
 
-bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
-	size_t rem = slice.length();
+bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
+	const size_t rem = slice.length();
 	if (slice.empty()) return false;
 	const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&slice.front());
 	if (rem > 0) {
-		uint8_t first = bytes[0];
+		const uint8_t first = bytes[0];
 		if (first < 0x80) { // 1 byte character
 			out = static_cast<uint32_t>(first & 0x7F);
 			slice.remove_prefix(1);
@@ -64,7 +64,7 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			// middle byte, not valid at start, fall through
 		} else if (first < 0xE0) { // two byte character
 			if (rem > 1) {
-				uint8_t second = bytes[1];
+				const uint8_t second = bytes[1];
 				if (_IsSuffixChar(second)) {
 					out = (static_cast<uint32_t>(first & 0x1F) << 6)
 						+ static_cast<uint32_t>(second & 0x3F);
@@ -74,8 +74,8 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			}
 		} else if (first < 0xF0) { // three byte character
 			if (rem > 2) {
-				uint8_t second = bytes[1];
-				uint8_t third = bytes[2];
+				const uint8_t second = bytes[1];
+				const uint8_t third = bytes[2];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third)) {
 					out = (static_cast<uint32_t>(first & 0x0F) << 12)
 						+ (static_cast<uint32_t>(second & 0x3F) << 6)
@@ -86,9 +86,9 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			}
 		} else if (first < 0xF8) { // four byte character
 			if (rem > 3) {
-				uint8_t second = bytes[1];
-				uint8_t third = bytes[2];
-				uint8_t fourth = bytes[3];
+				const uint8_t second = bytes[1];
+				const uint8_t third = bytes[2];
+				const uint8_t fourth = bytes[3];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third) && _IsSuffixChar(fourth)) {
 					out = (static_cast<uint32_t>(first & 0x07) << 18)
 						+ (static_cast<uint32_t>(second & 0x3F) << 12)
@@ -107,7 +107,7 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 }
 
 /// See <https://www.ietf.org/rfc/rfc2781.html#section-2.1>
-bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
+bool PushUTF16CodePoint(std::u16string& output, const uint32_t U, const size_t size) {
 	if (output.length() >= size) return false;
 	if (U < 0x10000) {
 		// If U < 0x10000, encode U as a 16-bit unsigned integer and terminate.
@@ -120,7 +120,7 @@ bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
 		// Let U' = U - 0x10000. Because U is less than or equal to 0x10FFFF,
 		// U' must be less than or equal to 0xFFFFF. That is, U' can be
 		// represented in 20 bits.
-		uint32_t Ut = U - 0x10000;
+		const uint32_t Ut = U - 0x10000;
 
 		// Initialize two 16-bit unsigned integers, W1 and W2, to 0xD800 and
 		// 0xDC00, respectively. These integers each have 10 bits free to
@@ -141,25 +141,25 @@ bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
 	} else return false;
 }
 
-std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::u16string output;
 	output.reserve(newSize);
 	std::string_view iterator = string;
 
 	uint32_t c;
-	while (_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
+	while (details::_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
 	return output;
 }
 
 //! Converts an std::string (ASCII) to UCS-2 / UTF-16
-std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::u16string ret;
 	ret.reserve(newSize);
 
-	for (size_t i = 0; i < newSize; i++) {
-		char c = string[i];
+	for (size_t i = 0; i < newSize; ++i) {
+		const char c = string[i];
 		// Note: both 7-bit ascii characters and REPLACEMENT_CHARACTER fit in one char16_t
 		ret.push_back((c > 0 && c <= 127) ? static_cast<char16_t>(c) : REPLACEMENT_CHARACTER);
 	}
@@ -169,18 +169,18 @@ std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view& string, size_t
 
 //! Converts a (potentially-ill-formed) UTF-16 string to UTF-8
 //! See: <http://simonsapin.github.io/wtf-8/#decoding-ill-formed-utf-16>
-std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::string ret;
 	ret.reserve(newSize);
 
-	for (size_t i = 0; i < newSize; i++) {
-		char16_t u = string[i];
+	for (size_t i = 0; i < newSize; ++i) {
+		const char16_t u = string[i];
 		if (IsLeadSurrogate(u) && (i + 1) < newSize) {
-			char16_t next = string[i + 1];
+			const char16_t next = string[i + 1];
 			if (IsTrailSurrogate(next)) {
 				i += 1;
-				char32_t cp = 0x10000
+				const char32_t cp = 0x10000
 					+ ((static_cast<char32_t>(u) - 0xD800) << 10)
 					+ (static_cast<char32_t>(next) - 0xDC00);
 				PushUTF8CodePoint(ret, cp);
@@ -195,40 +195,40 @@ std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view& string, size_t
 	return ret;
 }
 
-bool GeneralUtils::CaseInsensitiveStringCompare(const std::string& a, const std::string& b) {
+bool GeneralUtils::CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b) {
 	return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char a, char b) { return tolower(a) == tolower(b); });
 }
 
 // MARK: Bits
 
 //! Sets a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::SetBit(int64_t value, uint32_t index) {
+int64_t GeneralUtils::SetBit(int64_t value, const uint32_t index) {
 	return value |= 1ULL << index;
 }
 
 //! Clears a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::ClearBit(int64_t value, uint32_t index) {
+int64_t GeneralUtils::ClearBit(int64_t value, const uint32_t index) {
 	return value &= ~(1ULL << index);
 }
 
 //! Checks a specific bit in a signed 64-bit integer
-bool GeneralUtils::CheckBit(int64_t value, uint32_t index) {
+bool GeneralUtils::CheckBit(int64_t value, const uint32_t index) {
 	return value & (1ULL << index);
 }
 
-bool GeneralUtils::ReplaceInString(std::string& str, const std::string& from, const std::string& to) {
-	size_t start_pos = str.find(from);
+bool GeneralUtils::ReplaceInString(std::string& str, const std::string_view from, const std::string_view to) {
+	const size_t start_pos = str.find(from);
 	if (start_pos == std::string::npos)
 		return false;
 	str.replace(start_pos, from.length(), to);
 	return true;
 }
 
-std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t delimiter) {
+std::vector<std::wstring> GeneralUtils::SplitString(const std::wstring_view str, const wchar_t delimiter) {
 	std::vector<std::wstring> vector = std::vector<std::wstring>();
 	std::wstring current;
 
-	for (const auto& c : str) {
+	for (const wchar_t c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = L"";
@@ -237,15 +237,15 @@ std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t d
 		}
 	}
 
-	vector.push_back(current);
+	vector.push_back(std::move(current));
 	return vector;
 }
 
-std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str, char16_t delimiter) {
+std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string_view str, const char16_t delimiter) {
 	std::vector<std::u16string> vector = std::vector<std::u16string>();
 	std::u16string current;
 
-	for (const auto& c : str) {
+	for (const char16_t c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = u"";
@@ -254,17 +254,15 @@ std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str,
 		}
 	}
 
-	vector.push_back(current);
+	vector.push_back(std::move(current));
 	return vector;
 }
 
-std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char delimiter) {
+std::vector<std::string> GeneralUtils::SplitString(const std::string_view str, const char delimiter) {
 	std::vector<std::string> vector = std::vector<std::string>();
 	std::string current = "";
 
-	for (size_t i = 0; i < str.length(); i++) {
-		char c = str[i];
-
+	for (const char c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = "";
@@ -273,49 +271,70 @@ std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char
 		}
 	}
 
-	vector.push_back(current);
-
+	vector.push_back(std::move(current));
 	return vector;
 }
 
-std::u16string GeneralUtils::ReadWString(RakNet::BitStream* inStream) {
+std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
 	uint32_t length;
-	inStream->Read<uint32_t>(length);
+	inStream.Read<uint32_t>(length);
 
 	std::u16string string;
-	for (auto i = 0; i < length; i++) {
+	for (uint32_t i = 0; i < length; ++i) {
 		uint16_t c;
-		inStream->Read(c);
+		inStream.Read(c);
 		string.push_back(c);
 	}
 
 	return string;
 }
 
-std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string& folder) {
+std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string_view folder) {
 	// Because we dont know how large the initial number before the first _ is we need to make it a map like so.
     std::map<uint32_t, std::string> filenames{};
-	for (auto& t : std::filesystem::directory_iterator(folder)) {
+	for (const auto& t : std::filesystem::directory_iterator(folder)) {
         auto filename = t.path().filename().string();
-        auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
-        filenames.insert(std::make_pair(index, filename));
+        const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
+        filenames.emplace(index, std::move(filename));
 	}
 
 	// Now sort the map by the oldest migration.
 	std::vector<std::string> sortedFiles{};
-    auto fileIterator = filenames.begin();
-    std::map<uint32_t, std::string>::iterator oldest = filenames.begin();
+	auto fileIterator = filenames.cbegin();
+	auto oldest = filenames.cbegin();
 	while (!filenames.empty()) {
-		if (fileIterator == filenames.end()) {
+		if (fileIterator == filenames.cend()) {
 			sortedFiles.push_back(oldest->second);
 			filenames.erase(oldest);
-            fileIterator = filenames.begin();
-            oldest = filenames.begin();
+			fileIterator = filenames.cbegin();
+			oldest = filenames.cbegin();
 			continue;
 		}
 		if (oldest->first > fileIterator->first) oldest = fileIterator;
-        fileIterator++;
+		++fileIterator;
 	}
 
 	return sortedFiles;
 }
+
+#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
+
+// MacOS floating-point parse function specializations
+namespace GeneralUtils::details {
+	template <>
+	[[nodiscard]] float _parse<float>(const std::string_view str, size_t& parseNum) {
+		return std::stof(std::string{ str }, &parseNum);
+	}
+
+	template <>
+	[[nodiscard]] double _parse<double>(const std::string_view str, size_t& parseNum) {
+		return std::stod(std::string{ str }, &parseNum);
+	}
+
+	template <>
+	[[nodiscard]] long double _parse<long double>(const std::string_view str, size_t& parseNum) {
+		return std::stold(std::string{ str }, &parseNum);
+	}
+}
+
+#endif

dCommon/GeneralUtils.h

@@ -3,17 +3,18 @@
 // C++
 #include <charconv>
 #include <cstdint>
-#include <random>
 #include <ctime>
+#include <functional>
+#include <optional>
+#include <random>
+#include <span>
+#include <stdexcept>
 #include <string>
 #include <string_view>
-#include <optional>
-#include <functional>
 #include <type_traits>
-#include <stdexcept>
+
 #include "BitStream.h"
 #include "NiPoint3.h"
-
 #include "dPlatforms.h"
 #include "Game.h"
 #include "Logger.h"
@@ -32,29 +33,31 @@ namespace GeneralUtils {
 	//! Converts a plain ASCII string to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string ASCIIToUTF16(const std::string_view& string, size_t size = -1);
+	std::u16string ASCIIToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
 
 	//! Converts a UTF-8 String to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string UTF8ToUTF16(const std::string_view& string, size_t size = -1);
+	std::u16string UTF8ToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
 
+	namespace details {
 		//! Internal, do not use
 		bool _NextUTF8Char(std::string_view& slice, uint32_t& out);
+	}
 
 	//! Converts a UTF-16 string to a UTF-8 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-8 representation of the string
 	 */
-	std::string UTF16ToWTF8(const std::u16string_view& string, size_t size = -1);
+	std::string UTF16ToWTF8(const std::u16string_view string, const size_t size = SIZE_MAX);
 
 	/**
 	 * Compares two basic strings but does so ignoring case sensitivity
@@ -62,7 +65,7 @@ namespace GeneralUtils {
 	 * \param b the second string to compare against the first string
 	 * @return if the two strings are equal
 	 */
-	bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b);
+	bool CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b);
 
 	// MARK: Bits
 
@@ -70,9 +73,9 @@ namespace GeneralUtils {
 
 	//! Sets a bit on a numerical value
 	template <typename T>
-	inline void SetBit(T& value, eObjectBits bits) {
+	inline void SetBit(T& value, const eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+		const auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -82,9 +85,9 @@ namespace GeneralUtils {
 
 	//! Clears a bit on a numerical value
 	template <typename T>
-	inline void ClearBit(T& value, eObjectBits bits) {
+	inline void ClearBit(T& value, const eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+		const auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -97,14 +100,14 @@ namespace GeneralUtils {
 	  \param value The value to set the bit for
 	  \param index The index of the bit
 	 */
-	int64_t SetBit(int64_t value, uint32_t index);
+	int64_t SetBit(int64_t value, const uint32_t index);
 
 	//! Clears a specific bit in a signed 64-bit integer
 	/*!
 	  \param value The value to clear the bit from
 	  \param index The index of the bit
 	 */
-	int64_t ClearBit(int64_t value, uint32_t index);
+	int64_t ClearBit(int64_t value, const uint32_t index);
 
 	//! Checks a specific bit in a signed 64-bit integer
 	/*!
@@ -112,19 +115,19 @@ namespace GeneralUtils {
 	  \param index The index of the bit
 	  \return Whether or not the bit is set
 	 */
-	bool CheckBit(int64_t value, uint32_t index);
+	bool CheckBit(int64_t value, const uint32_t index);
 
-	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);
+	bool ReplaceInString(std::string& str, const std::string_view from, const std::string_view to);
 
-	std::u16string ReadWString(RakNet::BitStream* inStream);
+	std::u16string ReadWString(RakNet::BitStream& inStream);
 
-	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);
+	std::vector<std::wstring> SplitString(const std::wstring_view str, const wchar_t delimiter);
 
-	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);
+	std::vector<std::u16string> SplitString(const std::u16string_view str, const char16_t delimiter);
 
-	std::vector<std::string> SplitString(const std::string& str, char delimiter);
+	std::vector<std::string> SplitString(const std::string_view str, const char delimiter);
 
-	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string& folder);
+	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string_view folder);
 
 	// Concept constraining to enum types
 	template <typename T>
@@ -144,7 +147,7 @@ namespace GeneralUtils {
 
 	// If a boolean, present an alias to an intermediate integral type for parsing
 	template <Numeric T> requires std::same_as<T, bool>
-	struct numeric_parse<T> { using type = uint32_t; };
+	struct numeric_parse<T> { using type = uint8_t; };
 
 	// Shorthand type alias
 	template <Numeric T>
@@ -156,8 +159,9 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired value if it is equivalent to the string
 	*/
 	template <Numeric T>
-	[[nodiscard]] std::optional<T> TryParse(const std::string_view str) {
+	[[nodiscard]] std::optional<T> TryParse(std::string_view str) {
 		numeric_parse_t<T> result;
+		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
 
 		const char* const strEnd = str.data() + str.size();
 		const auto [parseEnd, ec] = std::from_chars(str.data(), strEnd, result);
@@ -166,27 +170,12 @@ namespace GeneralUtils {
 		return isParsed ? static_cast<T>(result) : std::optional<T>{};
 	}
 
-#ifdef DARKFLAME_PLATFORM_MACOS
+#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
-	// Anonymous namespace containing MacOS floating-point parse function specializations
-	namespace {
+	// MacOS floating-point parse helper function specializations
+	namespace details {
 		template <std::floating_point T>
-		[[nodiscard]] T Parse(const std::string_view str, size_t* parseNum);
-
-		template <>
-		[[nodiscard]] float Parse<float>(const std::string_view str, size_t* parseNum) {
-			return std::stof(std::string{ str }, parseNum);
-		}
-
-		template <>
-		[[nodiscard]] double Parse<double>(const std::string_view str, size_t* parseNum) {
-			return std::stod(std::string{ str }, parseNum);
-		}
-
-		template <>
-		[[nodiscard]] long double Parse<long double>(const std::string_view str, size_t* parseNum) {
-			return std::stold(std::string{ str }, parseNum);
-		}
+		[[nodiscard]] T _parse(const std::string_view str, size_t& parseNum);
 	}
 
 	/**
@@ -196,9 +185,12 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired value if it is equivalent to the string
 	*/
 	template <std::floating_point T>
-	[[nodiscard]] std::optional<T> TryParse(const std::string_view str) noexcept try {
+	[[nodiscard]] std::optional<T> TryParse(std::string_view str) noexcept
+	try {
+		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
+
 		size_t parseNum;
-		const T result = Parse<T>(str, &parseNum);
+		const T result = details::_parse<T>(str, parseNum);
 		const bool isParsed = str.length() == parseNum;
 
 		return isParsed ? result : std::optional<T>{};
@@ -216,7 +208,7 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
 	*/
 	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string& strX, const std::string& strY, const std::string& strZ) {
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string_view strX, const std::string_view strY, const std::string_view strZ) {
 		const auto x = TryParse<float>(strX);
 		if (!x) return std::nullopt;
 
@@ -228,17 +220,17 @@ namespace GeneralUtils {
 	}
 
 	/**
-	 * The TryParse overload for handling NiPoint3 by passingn a reference to a vector of three strings
-	 * @param str The string vector representing the X, Y, and Xcoordinates
+	 * The TryParse overload for handling NiPoint3 by passing a span of three strings
+	 * @param str The string vector representing the X, Y, and Z coordinates
 	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
 	*/
 	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::vector<std::string>& str) {
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::span<const std::string> str) {
 		return (str.size() == 3) ? TryParse<NiPoint3>(str[0], str[1], str[2]) : std::nullopt;
 	}
 
 	template <typename T>
-	std::u16string to_u16string(T value) {
+	std::u16string to_u16string(const T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
 	}
 
@@ -257,7 +249,7 @@ namespace GeneralUtils {
 	  \param max The maximum to generate to
 	 */
 	template <typename T>
-	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
+	inline T GenerateRandomNumber(const std::size_t min, const std::size_t max) {
 		// Make sure it is a numeric type
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
 
@@ -278,8 +270,8 @@ namespace GeneralUtils {
 	 * @returns The enum entry's value in its underlying type
 	*/
 	template <Enum eType>
-	constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) noexcept {
-		return static_cast<typename std::underlying_type_t<eType>>(entry);
+	constexpr std::underlying_type_t<eType> ToUnderlying(const eType entry) noexcept {
+		return static_cast<std::underlying_type_t<eType>>(entry);
 	}
 
 	// on Windows we need to undef these or else they conflict with our numeric limits calls

dCommon/LDFFormat.h

@@ -31,7 +31,7 @@ public:
 
 	virtual ~LDFBaseData() {}
 
-	virtual void WriteToPacket(RakNet::BitStream* packet) = 0;
+	virtual void WriteToPacket(RakNet::BitStream& packet) = 0;
 
 	virtual const std::u16string& GetKey() = 0;
 
@@ -62,17 +62,17 @@ private:
 	T value;
 
 	//! Writes the key to the packet
-	void WriteKey(RakNet::BitStream* packet) {
-		packet->Write<uint8_t>(this->key.length() * sizeof(uint16_t));
+	void WriteKey(RakNet::BitStream& packet) {
+		packet.Write<uint8_t>(this->key.length() * sizeof(uint16_t));
 		for (uint32_t i = 0; i < this->key.length(); ++i) {
-			packet->Write<uint16_t>(this->key[i]);
+			packet.Write<uint16_t>(this->key[i]);
 		}
 	}
 
 	//! Writes the value to the packet
-	void WriteValue(RakNet::BitStream* packet) {
-		packet->Write<uint8_t>(this->GetValueType());
-		packet->Write(this->value);
+	void WriteValue(RakNet::BitStream& packet) {
+		packet.Write<uint8_t>(this->GetValueType());
+		packet.Write(this->value);
 	}
 
 public:
@@ -108,7 +108,7 @@ public:
 	/*!
 	  \param packet The packet
 	 */
-	void WriteToPacket(RakNet::BitStream* packet) override {
+	void WriteToPacket(RakNet::BitStream& packet) override {
 		this->WriteKey(packet);
 		this->WriteValue(packet);
 	}
@@ -178,31 +178,31 @@ template<> inline eLDFType LDFData<std::string>::GetValueType(void) { return LDF
 
 // The specialized version for std::u16string (UTF-16)
 template<>
-inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream* packet) {
-	packet->Write<uint8_t>(this->GetValueType());
+inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream& packet) {
+	packet.Write<uint8_t>(this->GetValueType());
 
-	packet->Write<uint32_t>(this->value.length());
+	packet.Write<uint32_t>(this->value.length());
 	for (uint32_t i = 0; i < this->value.length(); ++i) {
-		packet->Write<uint16_t>(this->value[i]);
+		packet.Write<uint16_t>(this->value[i]);
 	}
 }
 
 // The specialized version for bool
 template<>
-inline void LDFData<bool>::WriteValue(RakNet::BitStream* packet) {
-	packet->Write<uint8_t>(this->GetValueType());
+inline void LDFData<bool>::WriteValue(RakNet::BitStream& packet) {
+	packet.Write<uint8_t>(this->GetValueType());
 
-	packet->Write<uint8_t>(this->value);
+	packet.Write<uint8_t>(this->value);
 }
 
 // The specialized version for std::string (UTF-8)
 template<>
-inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
-	packet->Write<uint8_t>(this->GetValueType());
+inline void LDFData<std::string>::WriteValue(RakNet::BitStream& packet) {
+	packet.Write<uint8_t>(this->GetValueType());
 
-	packet->Write<uint32_t>(this->value.length());
+	packet.Write<uint32_t>(this->value.length());
 	for (uint32_t i = 0; i < this->value.length(); ++i) {
-		packet->Write<uint8_t>(this->value[i]);
+		packet.Write<uint8_t>(this->value[i]);
 	}
 }
 

dCommon/PositionUpdate.h

@@ -6,28 +6,14 @@
 
 
 struct RemoteInputInfo {
-	RemoteInputInfo() {
-		m_RemoteInputX = 0;
-		m_RemoteInputY = 0;
-		m_IsPowersliding = false;
-		m_IsModified = false;
-	}
-
-	void operator=(const RemoteInputInfo& other) {
-		m_RemoteInputX = other.m_RemoteInputX;
-		m_RemoteInputY = other.m_RemoteInputY;
-		m_IsPowersliding = other.m_IsPowersliding;
-		m_IsModified = other.m_IsModified;
-	}
-
 	bool operator==(const RemoteInputInfo& other) {
 		return m_RemoteInputX == other.m_RemoteInputX && m_RemoteInputY == other.m_RemoteInputY && m_IsPowersliding == other.m_IsPowersliding && m_IsModified == other.m_IsModified;
 	}
 
-	float m_RemoteInputX;
-	float m_RemoteInputY;
-	bool m_IsPowersliding;
-	bool m_IsModified;
+	float m_RemoteInputX = 0;
+	float m_RemoteInputY = 0;
+	bool m_IsPowersliding = false;
+	bool m_IsModified = false;
 };
 
 struct LocalSpaceInfo {

dCommon/dEnums/dCommonVars.h

@@ -34,8 +34,8 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 #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 SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
-#define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+#define SEND_PACKET Game::server->Send(bitStream, sysAddr, false);
+#define SEND_PACKET_BROADCAST Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 
 //=========== TYPEDEFS ==========
 

dCommon/dEnums/eChatInternalMessageType.h

@@ -1,31 +0,0 @@
-#ifndef __ECHATINTERNALMESSAGETYPE__H__
-#define __ECHATINTERNALMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum eChatInternalMessageType : uint32_t {
-	PLAYER_ADDED_NOTIFICATION = 0,
-	PLAYER_REMOVED_NOTIFICATION,
-	ADD_FRIEND,
-	ADD_BEST_FRIEND,
-	ADD_TO_TEAM,
-	ADD_BLOCK,
-	REMOVE_FRIEND,
-	REMOVE_BLOCK,
-	REMOVE_FROM_TEAM,
-	DELETE_TEAM,
-	REPORT,
-	PRIVATE_CHAT,
-	PRIVATE_CHAT_RESPONSE,
-	ANNOUNCEMENT,
-	MAIL_COUNT_UPDATE,
-	MAIL_SEND_NOTIFY,
-	REQUEST_USER_LIST,
-	FRIEND_LIST,
-	ROUTE_TO_PLAYER,
-	TEAM_UPDATE,
-	MUTE_UPDATE,
-	CREATE_TEAM,
-};
-
-#endif  //!__ECHATINTERNALMESSAGETYPE__H__

dCommon/dEnums/eChatMessageType.h

@@ -72,7 +72,9 @@ enum class eChatMessageType :uint32_t {
 	UPDATE_DONATION,
 	PRG_CSR_COMMAND,
 	HEARTBEAT_REQUEST_FROM_WORLD,
-	UPDATE_FREE_TRIAL_STATUS
+	UPDATE_FREE_TRIAL_STATUS,
+	// CUSTOM DLU MESSAGE ID FOR INTERNAL USE
+	CREATE_TEAM,
 };
 
 #endif  //!__ECHATMESSAGETYPE__H__

dCommon/dEnums/eConnectionType.h

@@ -5,8 +5,7 @@ enum class eConnectionType : uint16_t {
 	SERVER = 0,
 	AUTH,
 	CHAT,
-	CHAT_INTERNAL,
-	WORLD,
+	WORLD = 4,
 	CLIENT,
 	MASTER
 };

dCommon/dEnums/eGameMessageType.h

@@ -790,9 +790,10 @@ enum class eGameMessageType : uint16_t {
 	GET_MISSION_TYPE_STATES = 853,
 	GET_TIME_PLAYED = 854,
 	SET_MISSION_VIEWED = 855,
-	SLASH_COMMAND_TEXT_FEEDBACK = 856,
-	HANDLE_SLASH_COMMAND_KORE_DEBUGGER = 857,
+	HKX_VEHICLE_LOADED = 856,
+	SLASH_COMMAND_TEXT_FEEDBACK = 857,
 	BROADCAST_TEXT_TO_CHATBOX = 858,
+	HANDLE_SLASH_COMMAND_KORE_DEBUGGER = 859,
 	OPEN_PROPERTY_MANAGEMENT = 860,
 	OPEN_PROPERTY_VENDOR = 861,
 	VOTE_ON_PROPERTY = 862,

dCommon/dEnums/eReplicaComponentType.h

@@ -106,7 +106,7 @@ enum class eReplicaComponentType : uint32_t {
 	INTERACTION_MANAGER,
 	DONATION_VENDOR,
 	COMBAT_MEDIATOR,
-	COMMENDATION_VENDOR,
+	ACHIEVEMENT_VENDOR,
 	GATE_RUSH_CONTROL,
 	RAIL_ACTIVATOR,
 	ROLLER,

dCommon/dEnums/eVendorTransactionResult.h

@@ -0,0 +1,15 @@
+#ifndef __EVENDORTRANSACTIONRESULT__
+#define __EVENDORTRANSACTIONRESULT__
+
+#include <cstdint>
+
+enum class eVendorTransactionResult : uint32_t {
+	SELL_SUCCESS = 0,
+	SELL_FAIL,
+	PURCHASE_SUCCESS,
+	PURCHASE_FAIL,
+	DONATION_FAIL,
+	DONATION_FULL
+};
+
+#endif // !__EVENDORTRANSACTIONRESULT__

dCommon/dEnums/eWaypointCommandType.h

@@ -0,0 +1,59 @@
+
+#ifndef __EWAYPOINTCOMMANDTYPES__H__
+#define __EWAYPOINTCOMMANDTYPES__H__
+
+#include <cstdint>
+
+enum class eWaypointCommandType : uint32_t {
+	INVALID,
+	BOUNCE,
+	STOP,
+	GROUP_EMOTE,
+	SET_VARIABLE,
+	CAST_SKILL,
+	EQUIP_INVENTORY,
+	UNEQUIP_INVENTORY,
+	DELAY,
+	EMOTE,
+	TELEPORT,
+	PATH_SPEED,
+	REMOVE_NPC,
+	CHANGE_WAYPOINT,
+	DELETE_SELF,
+	KILL_SELF,
+	SPAWN_OBJECT,
+	PLAY_SOUND,
+};
+
+class WaypointCommandType {
+public:
+	static eWaypointCommandType StringToWaypointCommandType(std::string commandString) {
+		const std::map<std::string, eWaypointCommandType> WaypointCommandTypeMap = {
+			{"bounce", eWaypointCommandType::BOUNCE},
+			{"stop", eWaypointCommandType::STOP},
+			{"groupemote", eWaypointCommandType::GROUP_EMOTE},
+			{"setvar", eWaypointCommandType::SET_VARIABLE},
+			{"castskill", eWaypointCommandType::CAST_SKILL},
+			{"eqInvent", eWaypointCommandType::EQUIP_INVENTORY},
+			{"unInvent", eWaypointCommandType::UNEQUIP_INVENTORY},
+			{"delay", eWaypointCommandType::DELAY},
+			{"femote", eWaypointCommandType::EMOTE},
+			{"emote", eWaypointCommandType::EMOTE},
+			{"teleport", eWaypointCommandType::TELEPORT},
+			{"pathspeed", eWaypointCommandType::PATH_SPEED},
+			{"removeNPC", eWaypointCommandType::REMOVE_NPC},
+			{"changeWP", eWaypointCommandType::CHANGE_WAYPOINT},
+			{"DeleteSelf", eWaypointCommandType::DELETE_SELF},
+			{"killself", eWaypointCommandType::KILL_SELF},
+			{"removeself", eWaypointCommandType::DELETE_SELF},
+			{"spawnOBJ", eWaypointCommandType::SPAWN_OBJECT},
+			{"playSound", eWaypointCommandType::PLAY_SOUND},
+		};
+
+		auto intermed = WaypointCommandTypeMap.find(commandString);
+		return (intermed != WaypointCommandTypeMap.end()) ? intermed->second : eWaypointCommandType::INVALID;
+	};
+};
+
+
+#endif  //!__EWAYPOINTCOMMANDTYPES__H__

dCommon/dEnums/eWorldMessageType.h

@@ -29,8 +29,8 @@ enum class eWorldMessageType : uint32_t {
 	ROUTE_PACKET,  // 				Social?
 	POSITION_UPDATE,
 	MAIL,
-	WORD_CHECK, // 				Whitelist word check
-	STRING_CHECK,  // 				Whitelist string check
+	WORD_CHECK, // 				AllowList word check
+	STRING_CHECK,  // 				AllowList string check
 	GET_PLAYERS_IN_ZONE,
 	REQUEST_UGC_MANIFEST_INFO,
 	BLUEPRINT_GET_ALL_DATA_REQUEST,

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -25,6 +25,7 @@
 #include "CDScriptComponentTable.h"
 #include "CDSkillBehaviorTable.h"
 #include "CDZoneTableTable.h"
+#include "CDTamingBuildPuzzleTable.h"
 #include "CDVendorComponentTable.h"
 #include "CDActivitiesTable.h"
 #include "CDPackageComponentTable.h"
@@ -41,8 +42,6 @@
 #include "CDRewardCodesTable.h"
 #include "CDPetComponentTable.h"
 
-#include <exception>
-
 #ifndef CDCLIENT_CACHE_ALL
 // Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
 // A vanilla CDClient takes about 46MB of memory + the regular world data.
@@ -55,13 +54,6 @@
 	#define CDCLIENT_DONT_CACHE_TABLE(x)
 #endif
 
-class CDClientConnectionException : public std::exception {
-public:
-	virtual const char* what() const throw() {
-		return "CDClientDatabase is not connected!";
-	}
-};
-
 // Using a macro to reduce repetitive code and issues from copy and paste.
 // As a note, ## in a macro is used to concatenate two tokens together.
 
@@ -108,11 +100,14 @@ DEFINE_TABLE_STORAGE(CDRewardCodesTable);
 DEFINE_TABLE_STORAGE(CDRewardsTable);
 DEFINE_TABLE_STORAGE(CDScriptComponentTable);
 DEFINE_TABLE_STORAGE(CDSkillBehaviorTable);
+DEFINE_TABLE_STORAGE(CDTamingBuildPuzzleTable);
 DEFINE_TABLE_STORAGE(CDVendorComponentTable);
 DEFINE_TABLE_STORAGE(CDZoneTableTable);
 
 void CDClientManager::LoadValuesFromDatabase() {
-	if (!CDClientDatabase::isConnected) throw CDClientConnectionException();
+	if (!CDClientDatabase::isConnected) {
+		throw std::runtime_error{ "CDClientDatabase is not connected!" };
+	}
 
 	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
 	CDActivitiesTable::Instance().LoadValuesFromDatabase();
@@ -152,6 +147,7 @@ void CDClientManager::LoadValuesFromDatabase() {
 	CDRewardsTable::Instance().LoadValuesFromDatabase();
 	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
 	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
+	CDTamingBuildPuzzleTable::Instance().LoadValuesFromDatabase();
 	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
 	CDZoneTableTable::Instance().LoadValuesFromDatabase();
 }

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.cpp

@@ -58,7 +58,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 		CDLootTable entry;
 		uint32_t lootTableIndex = tableData.getIntField("LootTableIndex", -1);
 
-		entries[lootTableIndex].push_back(ReadRow(tableData));
+		entries[lootTableIndex].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	for (auto& [id, table] : entries) {
@@ -66,7 +66,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 	}
 }
 
-const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
+const LootTableEntries& CDLootTableTable::GetTable(const uint32_t tableId) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(tableId);
 	if (itr != entries.end()) {
@@ -79,7 +79,7 @@ const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
 
 	while (!tableData.eof()) {
 		CDLootTable entry;
-		entries[tableId].push_back(ReadRow(tableData));
+		entries[tableId].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	SortTable(entries[tableId]);

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDLootTable {
 	uint32_t itemid;                 //!< The LOT of the item
 	uint32_t LootTableIndex;         //!< The Loot Table Index
@@ -20,6 +22,5 @@ private:
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	const LootTableEntries& GetTable(uint32_t tableId);
+	const LootTableEntries& GetTable(const uint32_t tableId);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.cpp

@@ -20,7 +20,7 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionEmail");
 	while (!tableData.eof()) {
-		CDMissionEmail entry;
+		auto& entry = entries.emplace_back();
 		entry.ID = tableData.getIntField("ID", -1);
 		entry.messageType = tableData.getIntField("messageType", -1);
 		entry.notificationGroup = tableData.getIntField("notificationGroup", -1);
@@ -30,11 +30,8 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 		entry.locStatus = tableData.getIntField("locStatus", -1);
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionEmail {
 	uint32_t ID;
 	uint32_t messageType;

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.cpp

@@ -20,18 +20,15 @@ void CDMissionNPCComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionNPCComponent");
 	while (!tableData.eof()) {
-		CDMissionNPCComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.missionID = tableData.getIntField("missionID", -1);
 		entry.offersMission = tableData.getIntField("offersMission", -1) == 1 ? true : false;
 		entry.acceptsMission = tableData.getIntField("acceptsMission", -1) == 1 ? true : false;
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionNPCComponent {
 	uint32_t id;                //!< The ID
 	uint32_t missionID;         //!< The Mission ID
@@ -17,4 +19,3 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionNPCComponent> Query(std::function<bool(CDMissionNPCComponent)> predicate);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.cpp

@@ -20,7 +20,7 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionTasks");
 	while (!tableData.eof()) {
-		CDMissionTasks entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.taskType = tableData.getIntField("taskType", -1);
@@ -35,11 +35,8 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 		UNUSED(entry.localize = tableData.getIntField("localize", -1) == 1 ? true : false);
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMissionTasks)> predicate) {
@@ -51,7 +48,7 @@ std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMiss
 	return data;
 }
 
-std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(uint32_t missionID) {
+std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(const uint32_t missionID) {
 	std::vector<CDMissionTasks*> tasks;
 
 	// TODO: this should not be linear(?) and also shouldnt need to be a pointer

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionTasks {
 	uint32_t id;                //!< The Mission ID that the task belongs to
 	UNUSED(uint32_t locStatus);         //!< ???
@@ -25,7 +27,7 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionTasks> Query(std::function<bool(CDMissionTasks)> predicate);
 
-	std::vector<CDMissionTasks*> GetByMissionID(uint32_t missionID);
+	std::vector<CDMissionTasks*> GetByMissionID(const uint32_t missionID);
 
 	// TODO: Remove this and replace it with a proper lookup function.
 	const CDTable::StorageType& GetEntries() const;

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.cpp

@@ -22,7 +22,7 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Missions");
 	while (!tableData.eof()) {
-		CDMissions entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.defined_type = tableData.getStringField("defined_type", "");
 		entry.defined_subtype = tableData.getStringField("defined_subtype", "");
@@ -76,10 +76,8 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.reward_bankinventory = tableData.getIntField("reward_bankinventory", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
 	tableData.finalize();
 
 	Default.id = -1;
@@ -118,3 +116,12 @@ const CDMissions& CDMissionsTable::GetByMissionID(uint32_t missionID, bool& foun
 	return Default;
 }
 
+const std::set<int32_t> CDMissionsTable::GetMissionsForReward(LOT lot) {
+	std::set<int32_t> toReturn {};
+	for (const auto& entry : GetEntries()) {
+		if (lot == entry.reward_item1 || lot == entry.reward_item2 || lot == entry.reward_item3 || lot == entry.reward_item4) {
+			toReturn.insert(entry.id);
+		}
+	}
+	return toReturn;
+}

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.h

@@ -70,6 +70,8 @@ public:
 
 	const CDMissions& GetByMissionID(uint32_t missionID, bool& found) const;
 
+	const std::set<int32_t> GetMissionsForReward(LOT lot);
+
+
 	static CDMissions Default;
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.cpp

@@ -20,7 +20,7 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MovementAIComponent");
 	while (!tableData.eof()) {
-		CDMovementAIComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.MovementType = tableData.getStringField("MovementType", "");
 		entry.WanderChance = tableData.getFloatField("WanderChance", -1.0f);
@@ -30,11 +30,8 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 		entry.WanderRadius = tableData.getFloatField("WanderRadius", -1.0f);
 		entry.attachedPath = tableData.getStringField("attachedPath", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMovementAIComponent> CDMovementAIComponentTable::Query(std::function<bool(CDMovementAIComponent)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMovementAIComponent {
 	uint32_t id;
 	std::string MovementType;

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.cpp

@@ -20,17 +20,14 @@ void CDObjectSkillsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ObjectSkills");
 	while (!tableData.eof()) {
-		CDObjectSkills entry;
+		auto &entry = entries.emplace_back();
 		entry.objectTemplate = tableData.getIntField("objectTemplate", -1);
 		entry.skillID = tableData.getIntField("skillID", -1);
 		entry.castOnType = tableData.getIntField("castOnType", -1);
 		entry.AICombatWeight = tableData.getIntField("AICombatWeight", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObjectSkills)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjectSkills {
 	uint32_t objectTemplate;        //!< The LOT of the item
 	uint32_t skillID;               //!< The Skill ID of the object

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.cpp

@@ -1,7 +1,7 @@
 #include "CDObjectsTable.h"
 
 namespace {
-	CDObjects m_default;
+	CDObjects ObjDefault;
 };
 
 void CDObjectsTable::LoadValuesFromDatabase() {
@@ -20,8 +20,10 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Objects");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDObjects entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t lot = tableData.getIntField("id", 0);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED_COLUMN(entry.placeable = tableData.getIntField("placeable", -1);)
 		entry.type = tableData.getStringField("type", "");
@@ -36,35 +38,34 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 		UNUSED_COLUMN(entry.gate_version = tableData.getStringField("gate_version", "");)
 		UNUSED_COLUMN(entry.HQ_valid = tableData.getIntField("HQ_valid", -1);)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
-	tableData.finalize();
-
-	m_default.id = 0;
+	ObjDefault.id = 0;
 }
 
-const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
+const CDObjects& CDObjectsTable::GetByID(const uint32_t lot) {
 	auto& entries = GetEntriesMutable();
-	const auto& it = entries.find(LOT);
+	const auto& it = entries.find(lot);
 	if (it != entries.end()) {
 		return it->second;
 	}
 
 	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Objects WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(LOT));
+	query.bind(1, static_cast<int32_t>(lot));
 
 	auto tableData = query.execQuery();
 	if (tableData.eof()) {
-		entries.insert(std::make_pair(LOT, m_default));
-		return m_default;
+		entries.emplace(lot, ObjDefault);
+		return ObjDefault;
 	}
 
 	// Now get the data
 	while (!tableData.eof()) {
-		CDObjects entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t lot = tableData.getIntField("id", 0);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED(entry.placeable = tableData.getIntField("placeable", -1));
 		entry.type = tableData.getStringField("type", "");
@@ -79,17 +80,15 @@ const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 		UNUSED(entry.HQ_valid = tableData.getIntField("HQ_valid", -1));
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 
-	const auto& it2 = entries.find(LOT);
+	const auto& it2 = entries.find(lot);
 	if (it2 != entries.end()) {
 		return it2->second;
 	}
 
-	return m_default;
+	return ObjDefault;
 }
-

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjects {
 	uint32_t id;                            //!< The LOT of the object
 	std::string name;                      //!< The internal name of the object
@@ -24,6 +26,6 @@ class CDObjectsTable : public CDTable<CDObjectsTable, std::map<uint32_t, CDObjec
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by ID
-	const CDObjects& GetByID(uint32_t LOT);
+	const CDObjects& GetByID(const uint32_t lot);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.cpp

@@ -19,12 +19,11 @@ void CDPackageComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PackageComponent");
 	while (!tableData.eof()) {
-		CDPackageComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
 		entry.packageType = tableData.getIntField("packageType", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDPackageComponent {
 	uint32_t id;
 	uint32_t LootMatrixIndex;

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.cpp

@@ -50,7 +50,7 @@ void CDPetComponentTable::LoadValuesFromDatabase() {
 }
 
 void CDPetComponentTable::LoadValuesFromDefaults() {
-	GetEntriesMutable().insert(std::make_pair(defaultEntry.id, defaultEntry));
+	GetEntriesMutable().emplace(defaultEntry.id, defaultEntry);
 }
 
 CDPetComponent& CDPetComponentTable::GetByID(const uint32_t componentID) {

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.cpp

@@ -4,32 +4,31 @@ void CDPhysicsComponentTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PhysicsComponent");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDPhysicsComponent entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t componentID = tableData.getIntField("id", -1);
+
+		auto& entry = entries[componentID];
+		entry.id = componentID;
 		entry.bStatic = tableData.getIntField("static", -1) != 0;
 		entry.physicsAsset = tableData.getStringField("physics_asset", "");
-		UNUSED(entry->jump = tableData.getIntField("jump", -1) != 0);
-		UNUSED(entry->doublejump = tableData.getIntField("doublejump", -1) != 0);
-		entry.speed = tableData.getFloatField("speed", -1);
-		UNUSED(entry->rotSpeed = tableData.getFloatField("rotSpeed", -1));
-		entry.playerHeight = tableData.getFloatField("playerHeight");
-		entry.playerRadius = tableData.getFloatField("playerRadius");
+		UNUSED_COLUMN(entry.jump = tableData.getIntField("jump", -1) != 0;)
+		UNUSED_COLUMN(entry.doubleJump = tableData.getIntField("doublejump", -1) != 0;)
+		entry.speed = static_cast<float>(tableData.getFloatField("speed", -1));
+		UNUSED_COLUMN(entry.rotSpeed = tableData.getFloatField("rotSpeed", -1);)
+		entry.playerHeight = static_cast<float>(tableData.getFloatField("playerHeight"));
+		entry.playerRadius = static_cast<float>(tableData.getFloatField("playerRadius"));
 		entry.pcShapeType = tableData.getIntField("pcShapeType");
 		entry.collisionGroup = tableData.getIntField("collisionGroup");
-		UNUSED(entry->airSpeed = tableData.getFloatField("airSpeed"));
-		UNUSED(entry->boundaryAsset = tableData.getStringField("boundaryAsset"));
-		UNUSED(entry->jumpAirSpeed = tableData.getFloatField("jumpAirSpeed"));
-		UNUSED(entry->friction = tableData.getFloatField("friction"));
-		UNUSED(entry->gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset"));
+		UNUSED_COLUMN(entry.airSpeed = tableData.getFloatField("airSpeed");)
+		UNUSED_COLUMN(entry.boundaryAsset = tableData.getStringField("boundaryAsset");)
+		UNUSED_COLUMN(entry.jumpAirSpeed = tableData.getFloatField("jumpAirSpeed");)
+		UNUSED_COLUMN(entry.friction = tableData.getFloatField("friction");)
+		UNUSED_COLUMN(entry.gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset");)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(uint32_t componentID) {
+CDPhysicsComponent* CDPhysicsComponentTable::GetByID(const uint32_t componentID) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(componentID);
 	return itr != entries.end() ? &itr->second : nullptr;

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "CDTable.h"
+#include <cstdint>
 #include <string>
 
 struct CDPhysicsComponent {
@@ -7,7 +8,7 @@ struct CDPhysicsComponent {
 	bool bStatic;
 	std::string physicsAsset;
 	UNUSED(bool jump);
-	UNUSED(bool doublejump);
+	UNUSED(bool doubleJump);
 	float speed;
 	UNUSED(float rotSpeed);
 	float playerHeight;
@@ -26,5 +27,5 @@ public:
 	void LoadValuesFromDatabase();
 
 	static const std::string GetTableName() { return "PhysicsComponent"; };
-	CDPhysicsComponent* GetByID(uint32_t componentID);
+	CDPhysicsComponent* GetByID(const uint32_t componentID);
 };

dDatabase/CDClientDatabase/CDClientTables/CDTamingBuildPuzzleTable.cpp

@@ -0,0 +1,35 @@
+#include "CDTamingBuildPuzzleTable.h"
+
+void CDTamingBuildPuzzleTable::LoadValuesFromDatabase() {
+	// First, get the size of the table
+	uint32_t size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM TamingBuildPuzzles");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+		tableSize.nextRow();
+	}
+
+	// Reserve the size
+	auto& entries = GetEntriesMutable();
+	entries.reserve(size);
+
+	// Now get the data
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM TamingBuildPuzzles");
+	while (!tableData.eof()) {
+		const auto lot = static_cast<LOT>(tableData.getIntField("NPCLot", LOT_NULL));
+		entries.emplace(lot, CDTamingBuildPuzzle{
+			.puzzleModelLot = lot,
+			.validPieces{ tableData.getStringField("ValidPiecesLXF") },
+			.timeLimit = static_cast<float>(tableData.getFloatField("Timelimit", 30.0f)),
+			.numValidPieces = tableData.getIntField("NumValidPieces", 6),
+			.imaginationCost = tableData.getIntField("imagCostPerBuild", 10)
+		});
+		tableData.nextRow();
+	}
+}
+
+const CDTamingBuildPuzzle* CDTamingBuildPuzzleTable::GetByLOT(const LOT lot) const {
+	const auto& entries = GetEntries();
+	const auto itr = entries.find(lot);
+	return itr != entries.cend() ? &itr->second : nullptr;
+}

dDatabase/CDClientDatabase/CDClientTables/CDTamingBuildPuzzleTable.h

@@ -0,0 +1,60 @@
+#pragma once
+#include "CDTable.h"
+
+/**
+ * Information for the minigame to be completed
+ */
+struct CDTamingBuildPuzzle {
+	UNUSED_COLUMN(uint32_t id = 0;)
+
+	// The LOT of the object that is to be created
+	LOT puzzleModelLot = LOT_NULL;
+
+	// The LOT of the NPC
+	UNUSED_COLUMN(LOT npcLot = LOT_NULL;)
+
+	// The .lxfml file that contains the bricks required to build the model
+	std::string validPieces{};
+
+	// The .lxfml file that contains the bricks NOT required to build the model
+	UNUSED_COLUMN(std::string invalidPieces{};)
+
+	// Difficulty value
+	UNUSED_COLUMN(int32_t difficulty = 1;)
+
+	// The time limit to complete the build
+	float timeLimit = 30.0f;
+
+	// The number of pieces required to complete the minigame
+	int32_t numValidPieces = 6;
+
+	// Number of valid pieces
+	UNUSED_COLUMN(int32_t totalNumPieces = 16;)
+
+	// Model name
+	UNUSED_COLUMN(std::string modelName{};)
+
+	// The .lxfml file that contains the full model
+	UNUSED_COLUMN(std::string fullModel{};)
+
+	// The duration of the pet taming minigame
+	UNUSED_COLUMN(float duration = 45.0f;)
+
+	// The imagination cost for the tamer to start the minigame
+	int32_t imaginationCost = 10;
+};
+
+class CDTamingBuildPuzzleTable : public CDTable<CDTamingBuildPuzzleTable, std::unordered_map<LOT, CDTamingBuildPuzzle>> {
+public:
+	/**
+	 * Load values from the CD client database
+	*/
+	void LoadValuesFromDatabase();
+
+	/**
+	 * Gets the pet ability table corresponding to the pet LOT
+	 * @returns A pointer to the corresponding table, or nullptr if one cannot be found
+	*/
+	[[nodiscard]]
+	const CDTamingBuildPuzzle* GetByLOT(const LOT lot) const;
+};

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -36,5 +36,6 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDRewardsTable.cpp"
 	"CDScriptComponentTable.cpp"
 	"CDSkillBehaviorTable.cpp"
+	"CDTamingBuildPuzzleTable.cpp"
 	"CDVendorComponentTable.cpp"
 	"CDZoneTableTable.cpp" PARENT_SCOPE)

dDatabase/CDClientDatabase/CMakeLists.txt

@@ -9,4 +9,28 @@ foreach(file ${DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES})
 	set(DDATABASE_CDCLIENTDATABASE_SOURCES ${DDATABASE_CDCLIENTDATABASE_SOURCES} "CDClientTables/${file}")
 endforeach()
 
-set(DDATABASE_CDCLIENTDATABASE_SOURCES ${DDATABASE_CDCLIENTDATABASE_SOURCES} PARENT_SCOPE)
+add_library(dDatabaseCDClient STATIC ${DDATABASE_CDCLIENTDATABASE_SOURCES})
+target_include_directories(dDatabaseCDClient PUBLIC "."
+	"CDClientTables"
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+)
+target_link_libraries(dDatabaseCDClient PRIVATE sqlite3)
+
+if (${CDCLIENT_CACHE_ALL})
+	add_compile_definitions(dDatabaseCDClient PRIVATE CDCLIENT_CACHE_ALL=${CDCLIENT_CACHE_ALL})
+endif()
+
+file(
+	GLOB HEADERS_DDATABASE_CDCLIENT
+	LIST_DIRECTORIES false
+	${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.h
+	CDClientTables/*.h
+	*.h
+)
+
+# Need to specify to use the CXX compiler language here or else we get errors including <string>.
+target_precompile_headers(
+	dDatabaseCDClient PRIVATE
+	"$<$<COMPILE_LANGUAGE:CXX>:${HEADERS_DDATABASE_CDCLIENT}>"
+)

dDatabase/CMakeLists.txt

@@ -1,20 +1,7 @@
-set(DDATABASE_SOURCES)
-
 add_subdirectory(CDClientDatabase)
-
-foreach(file ${DDATABASE_CDCLIENTDATABASE_SOURCES})
-	set(DDATABASE_SOURCES ${DDATABASE_SOURCES} "CDClientDatabase/${file}")
-endforeach()
-
 add_subdirectory(GameDatabase)
 
-foreach(file ${DDATABASE_GAMEDATABASE_SOURCES})
-	set(DDATABASE_SOURCES ${DDATABASE_SOURCES} "GameDatabase/${file}")
-endforeach()
-
-add_library(dDatabase STATIC ${DDATABASE_SOURCES})
-target_link_libraries(dDatabase sqlite3 mariadbConnCpp)
-
-if (${CDCLIENT_CACHE_ALL})
-	add_compile_definitions(dDatabase CDCLIENT_CACHE_ALL=${CDCLIENT_CACHE_ALL})
-endif()
+add_library(dDatabase STATIC "MigrationRunner.cpp")
+target_include_directories(dDatabase PUBLIC ".")
+target_link_libraries(dDatabase
+	PUBLIC dDatabaseCDClient dDatabaseGame)

dDatabase/GameDatabase/CMakeLists.txt

@@ -1,6 +1,5 @@
 set(DDATABASE_GAMEDATABASE_SOURCES
 	"Database.cpp"
-	"MigrationRunner.cpp"
 )
 
 add_subdirectory(MySQL)
@@ -9,4 +8,25 @@ foreach(file ${DDATABSE_DATABSES_MYSQL_SOURCES})
 	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "MySQL/${file}")
 endforeach()
 
-set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} PARENT_SCOPE)
+add_library(dDatabaseGame STATIC ${DDATABASE_GAMEDATABASE_SOURCES})
+target_include_directories(dDatabaseGame PUBLIC "."
+	"ITables" PRIVATE "MySQL"
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+)
+target_link_libraries(dDatabaseGame
+	PUBLIC MariaDB::ConnCpp
+	INTERFACE dCommon)
+
+# Glob together all headers that need to be precompiled
+file(
+	GLOB HEADERS_DDATABASE_GAME
+	LIST_DIRECTORIES false
+	ITables/*.h
+)
+
+# Need to specify to use the CXX compiler language here or else we get errors including <string>.
+target_precompile_headers(
+	dDatabaseGame PRIVATE
+	"$<$<COMPILE_LANGUAGE:CXX>:${HEADERS_DDATABASE_GAME}>"
+)

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -3,6 +3,7 @@
 
 #include <cstdint>
 #include <optional>
+#include <string>
 #include <string_view>
 
 enum class eGameMasterLevel : uint8_t;

dGame/CMakeLists.txt

@@ -13,11 +13,25 @@ include_directories(
 	${PROJECT_SOURCE_DIR}/dGame
 )
 
-add_library(dGameBase ${DGAME_SOURCES})
+add_library(dGameBase OBJECT ${DGAME_SOURCES})
 target_precompile_headers(dGameBase PRIVATE ${HEADERS_DGAME})
-target_link_libraries(dGameBase
-	PUBLIC dDatabase dPhysics
-	INTERFACE dComponents dEntity)
+target_include_directories(dGameBase PUBLIC "." "dEntity"
+	PRIVATE "dComponents" "dGameMessages" "dBehaviors" "dMission" "dUtilities" "dInventory"
+	$<TARGET_PROPERTY:dPropertyBehaviors,INTERFACE_INCLUDE_DIRECTORIES>
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+	"${PROJECT_SOURCE_DIR}/dCommon/dClient"
+	# dDatabase
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
+	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
+	# dPhysics
+	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Include"
+	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Include"
+	"${PROJECT_SOURCE_DIR}/dZoneManager"
+)
 
 add_subdirectory(dBehaviors)
 add_subdirectory(dComponents)
@@ -28,7 +42,26 @@ add_subdirectory(dMission)
 add_subdirectory(dPropertyBehaviors)
 add_subdirectory(dUtilities)
 
-add_library(dGame INTERFACE)
-target_link_libraries(dGame INTERFACE
-	dGameBase dBehaviors dComponents dEntity dGameMessages dInventory dMission dPropertyBehaviors dUtilities dScripts
+add_library(dGame STATIC
+	$<TARGET_OBJECTS:dGameBase>
+	$<TARGET_OBJECTS:dBehaviors>
+	$<TARGET_OBJECTS:dComponents>
+	$<TARGET_OBJECTS:dEntity>
+	$<TARGET_OBJECTS:dGameMessages>
+	$<TARGET_OBJECTS:dInventory>
+	$<TARGET_OBJECTS:dMission>
+	$<TARGET_OBJECTS:dPropertyBehaviors>
+	$<TARGET_OBJECTS:dUtilities>
+)
+target_link_libraries(dGame INTERFACE dNet)
+target_include_directories(dGame INTERFACE
+	$<TARGET_PROPERTY:dGameBase,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dBehaviors,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dComponents,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dEntity,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dGameMessages,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dInventory,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dMission,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dPropertyBehaviors,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:dUtilities,INTERFACE_INCLUDE_DIRECTORIES>
 )

dGame/Character.cpp

@@ -27,12 +27,9 @@ Character::Character(uint32_t id, User* parentUser) {
 	m_ID = id;
 	m_ParentUser = parentUser;
 	m_OurEntity = nullptr;
-	m_Doc = nullptr;
 }
 
 Character::~Character() {
-	if (m_Doc) delete m_Doc;
-	m_Doc = nullptr;
 	m_OurEntity = nullptr;
 	m_ParentUser = nullptr;
 }
@@ -55,8 +52,6 @@ void Character::UpdateInfoFromDatabase() {
 	m_ZoneInstanceID = 0; //These values don't really matter, these are only used on the char select screen and seem unused.
 	m_ZoneCloneID = 0;
 
-	m_Doc = nullptr;
-
 	//Quickly and dirtly parse the xmlData to get the info we need:
 	DoQuickXMLDataParse();
 
@@ -70,18 +65,13 @@ void Character::UpdateInfoFromDatabase() {
 }
 
 void Character::UpdateFromDatabase() {
-	if (m_Doc) delete m_Doc;
 	UpdateInfoFromDatabase();
 }
 
 void Character::DoQuickXMLDataParse() {
 	if (m_XMLData.size() == 0) return;
 
-	delete m_Doc;
-	m_Doc = new tinyxml2::XMLDocument();
-	if (!m_Doc) return;
-
-	if (m_Doc->Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
+	if (m_Doc.Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
 		LOG("Loaded xmlData for character %s (%i)!", m_Name.c_str(), m_ID);
 	} else {
 		LOG("Failed to load xmlData!");
@@ -89,7 +79,7 @@ void Character::DoQuickXMLDataParse() {
 		return;
 	}
 
-	tinyxml2::XMLElement* mf = m_Doc->FirstChildElement("obj")->FirstChildElement("mf");
+	tinyxml2::XMLElement* mf = m_Doc.FirstChildElement("obj")->FirstChildElement("mf");
 	if (!mf) {
 		LOG("Failed to find mf tag!");
 		return;
@@ -108,7 +98,7 @@ void Character::DoQuickXMLDataParse() {
 	mf->QueryAttribute("ess", &m_Eyes);
 	mf->QueryAttribute("ms", &m_Mouth);
 
-	tinyxml2::XMLElement* inv = m_Doc->FirstChildElement("obj")->FirstChildElement("inv");
+	tinyxml2::XMLElement* inv = m_Doc.FirstChildElement("obj")->FirstChildElement("inv");
 	if (!inv) {
 		LOG("Char has no inv!");
 		return;
@@ -141,7 +131,7 @@ void Character::DoQuickXMLDataParse() {
 	}
 
 
-	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
+	tinyxml2::XMLElement* character = m_Doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->QueryAttribute("cc", &m_Coins);
 		int32_t gm_level = 0;
@@ -205,7 +195,7 @@ void Character::DoQuickXMLDataParse() {
 		character->QueryAttribute("lzrw", &m_OriginalRotation.w);
 	}
 
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (flags) {
 		auto* currentChild = flags->FirstChildElement();
 		while (currentChild) {
@@ -239,12 +229,10 @@ void Character::SetBuildMode(bool buildMode) {
 }
 
 void Character::SaveXMLToDatabase() {
-	if (!m_Doc) return;
-
 	//For metrics, we'll record the time it took to save:
 	auto start = std::chrono::system_clock::now();
 
-	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
+	tinyxml2::XMLElement* character = m_Doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->SetAttribute("gm", static_cast<uint32_t>(m_GMLevel));
 		character->SetAttribute("cc", m_Coins);
@@ -266,11 +254,11 @@ void Character::SaveXMLToDatabase() {
 		}
 
 		auto emotes = character->FirstChildElement("ue");
-		if (!emotes) emotes = m_Doc->NewElement("ue");
+		if (!emotes) emotes = m_Doc.NewElement("ue");
 
 		emotes->DeleteChildren();
 		for (int emoteID : m_UnlockedEmotes) {
-			auto emote = m_Doc->NewElement("e");
+			auto emote = m_Doc.NewElement("e");
 			emote->SetAttribute("id", emoteID);
 
 			emotes->LinkEndChild(emote);
@@ -280,15 +268,15 @@ void Character::SaveXMLToDatabase() {
 	}
 
 	//Export our flags:
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (!flags) {
-		flags = m_Doc->NewElement("flag"); //Create a flags tag if we don't have one
-		m_Doc->FirstChildElement("obj")->LinkEndChild(flags); //Link it to the obj tag so we can find next time
+		flags = m_Doc.NewElement("flag"); //Create a flags tag if we don't have one
+		m_Doc.FirstChildElement("obj")->LinkEndChild(flags); //Link it to the obj tag so we can find next time
 	}
 
 	flags->DeleteChildren(); //Clear it if we have anything, so that we can fill it up again without dupes
 	for (std::pair<uint32_t, uint64_t> flag : m_PlayerFlags) {
-		auto* f = m_Doc->NewElement("f");
+		auto* f = m_Doc.NewElement("f");
 		f->SetAttribute("id", flag.first);
 
 		//Because of the joy that is tinyxml2, it doesn't offer a function to set a uint64 as an attribute.
@@ -301,7 +289,7 @@ void Character::SaveXMLToDatabase() {
 
 	// Prevents the news feed from showing up on world transfers
 	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
-		auto* s = m_Doc->NewElement("s");
+		auto* s = m_Doc.NewElement("s");
 		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
 		flags->LinkEndChild(s);
 	}
@@ -326,7 +314,7 @@ void Character::SaveXMLToDatabase() {
 
 void Character::SetIsNewLogin() {
 	// If we dont have a flag element, then we cannot have a s element as a child of flag.
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (!flags) return;
 
 	auto* currentChild = flags->FirstChildElement();
@@ -344,7 +332,7 @@ void Character::SetIsNewLogin() {
 void Character::WriteToDatabase() {
 	//Dump our xml into m_XMLData:
 	tinyxml2::XMLPrinter printer(0, true, 0);
-	m_Doc->Print(&printer);
+	m_Doc.Print(&printer);
 
 	//Finally, save to db:
 	Database::Get()->UpdateCharacterXml(m_ID, printer.CStr());
@@ -421,15 +409,15 @@ void Character::SetRetroactiveFlags() {
 
 void Character::SaveXmlRespawnCheckpoints() {
 	//Export our respawn points:
-	auto* points = m_Doc->FirstChildElement("obj")->FirstChildElement("res");
+	auto* points = m_Doc.FirstChildElement("obj")->FirstChildElement("res");
 	if (!points) {
-		points = m_Doc->NewElement("res");
-		m_Doc->FirstChildElement("obj")->LinkEndChild(points);
+		points = m_Doc.NewElement("res");
+		m_Doc.FirstChildElement("obj")->LinkEndChild(points);
 	}
 
 	points->DeleteChildren();
 	for (const auto& point : m_WorldRespawnCheckpoints) {
-		auto* r = m_Doc->NewElement("r");
+		auto* r = m_Doc.NewElement("r");
 		r->SetAttribute("w", point.first);
 
 		r->SetAttribute("x", point.second.x);
@@ -443,7 +431,7 @@ void Character::SaveXmlRespawnCheckpoints() {
 void Character::LoadXmlRespawnCheckpoints() {
 	m_WorldRespawnCheckpoints.clear();
 
-	auto* points = m_Doc->FirstChildElement("obj")->FirstChildElement("res");
+	auto* points = m_Doc.FirstChildElement("obj")->FirstChildElement("res");
 	if (!points) {
 		return;
 	}

dGame/Character.h

@@ -37,7 +37,7 @@ public:
 	void LoadXmlRespawnCheckpoints();
 
 	const std::string& GetXMLData() const { return m_XMLData; }
-	tinyxml2::XMLDocument* GetXMLDoc() const { return m_Doc; }
+	const tinyxml2::XMLDocument& GetXMLDoc() const { return m_Doc; }
 
 	/**
 	 * Out of abundance of safety and clarity of what this saves, this is its own function.
@@ -623,7 +623,7 @@ private:
 	/**
 	 * The character XML belonging to this character
 	 */
-	tinyxml2::XMLDocument* m_Doc;
+	tinyxml2::XMLDocument m_Doc;
 
 	/**
 	 * Title of an announcement this character made (reserved for GMs)

dGame/Entity.cpp

@@ -82,6 +82,7 @@
 #include "CollectibleComponent.h"
 #include "ItemComponent.h"
 #include "GhostComponent.h"
+#include "AchievementVendorComponent.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -145,17 +146,15 @@ Entity::~Entity() {
 			return;
 		}
 
-		Entity* zoneControl = Game::entityManager->GetZoneControlEntity();
-		for (CppScripts::Script* script : CppScripts::GetEntityScripts(zoneControl)) {
-			script->OnPlayerExit(zoneControl, this);
+		auto* zoneControl = Game::entityManager->GetZoneControlEntity();
+		if (zoneControl) {
+			zoneControl->GetScript()->OnPlayerExit(zoneControl, this);
 		}
 
 		std::vector<Entity*> scriptedActs = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
-				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {
-					script->OnPlayerExit(scriptEntity, this);
-				}
+				scriptEntity->GetScript()->OnPlayerExit(scriptEntity, this);
 			}
 		}
 	}
@@ -477,8 +476,7 @@ void Entity::Initialize() {
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY) > 0 || m_Character) {
-		auto* xmlDoc = m_Character ? m_Character->GetXMLDoc() : nullptr;
-		AddComponent<InventoryComponent>(xmlDoc);
+		AddComponent<InventoryComponent>();
 	}
 	// if this component exists, then we initialize it. it's value is always 0
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MULTI_ZONE_ENTRANCE, -1) != -1) {
@@ -615,6 +613,8 @@ void Entity::Initialize() {
 		AddComponent<VendorComponent>();
 	} else if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::DONATION_VENDOR, -1) != -1)) {
 		AddComponent<DonationVendorComponent>();
+	} else if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ACHIEVEMENT_VENDOR, -1) != -1)) {
+		AddComponent<AchievementVendorComponent>();
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_VENDOR, -1) != -1) {
@@ -730,15 +730,21 @@ void Entity::Initialize() {
 		// if we have a moving platform path, then we need a moving platform component
 		if (path->pathType == PathType::MovingPlatform) {
 			AddComponent<MovingPlatformComponent>(pathName);
-			// else if we are a movement path
-		} /*else if (path->pathType == PathType::Movement) {
-			auto movementAIcomp = GetComponent<MovementAIComponent>();
-			if (movementAIcomp){
-				// TODO: set path in existing movementAIComp
+		} else if (path->pathType == PathType::Movement) {
+			auto movementAIcomponent = GetComponent<MovementAIComponent>();
+			if (movementAIcomponent && combatAiId == 0) {
+				movementAIcomponent->SetPath(pathName);
 			} else {
-				// TODO: create movementAIcomp and set path
+				MovementAIInfo moveInfo = MovementAIInfo();
+				moveInfo.movementType = "";
+				moveInfo.wanderChance = 0;
+				moveInfo.wanderRadius = 16;
+				moveInfo.wanderSpeed = 2.5f;
+				moveInfo.wanderDelayMax = 5;
+				moveInfo.wanderDelayMin = 2;
+				AddComponent<MovementAIComponent>(moveInfo);
+			}
 		}
-		}*/
 	} else {
 		// else we still need to setup moving platform if it has a moving platform comp but no path
 		int32_t movingPlatformComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVING_PLATFORM, -1);
@@ -759,9 +765,7 @@ void Entity::Initialize() {
 
 	// Hacky way to trigger these when the object has had a chance to get constructed
 	AddCallbackTimer(0, [this]() {
-		for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-			script->OnStartup(this);
-		}
+		this->GetScript()->OnStartup(this);
 		});
 
 	if (!m_Character && Game::entityManager->GetGhostingEnabled()) {
@@ -836,17 +840,6 @@ bool Entity::HasComponent(const eReplicaComponentType componentId) const {
 	return m_Components.find(componentId) != m_Components.end();
 }
 
-std::vector<ScriptComponent*> Entity::GetScriptComponents() {
-	std::vector<ScriptComponent*> comps;
-	for (std::pair<eReplicaComponentType, void*> p : m_Components) {
-		if (p.first == eReplicaComponentType::SCRIPT) {
-			comps.push_back(static_cast<ScriptComponent*>(p.second));
-		}
-	}
-
-	return comps;
-}
-
 void Entity::Subscribe(LWOOBJID scriptObjId, CppScripts::Script* scriptToAdd, const std::string& notificationName) {
 	if (notificationName == "HitOrHealResult" || notificationName == "Hit") {
 		auto* destroyableComponent = GetComponent<DestroyableComponent>();
@@ -896,34 +889,34 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
 	}
 }
 
-void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
+void Entity::WriteBaseReplicaData(RakNet::BitStream& outBitStream, eReplicaPacketType packetType) {
 	if (packetType == eReplicaPacketType::CONSTRUCTION) {
-		outBitStream->Write(m_ObjectID);
-		outBitStream->Write(m_TemplateID);
+		outBitStream.Write(m_ObjectID);
+		outBitStream.Write(m_TemplateID);
 
 		if (IsPlayer()) {
 			std::string name = m_Character != nullptr ? m_Character->GetName() : "Invalid";
-			outBitStream->Write<uint8_t>(uint8_t(name.size()));
+			outBitStream.Write<uint8_t>(uint8_t(name.size()));
 
 			for (size_t i = 0; i < name.size(); ++i) {
-				outBitStream->Write<uint16_t>(name[i]);
+				outBitStream.Write<uint16_t>(name[i]);
 			}
 		} else {
 			const auto& name = GetVar<std::string>(u"npcName");
-			outBitStream->Write<uint8_t>(uint8_t(name.size()));
+			outBitStream.Write<uint8_t>(uint8_t(name.size()));
 
 			for (size_t i = 0; i < name.size(); ++i) {
-				outBitStream->Write<uint16_t>(name[i]);
+				outBitStream.Write<uint16_t>(name[i]);
 			}
 		}
 
-		outBitStream->Write<uint32_t>(0); //Time since created on server
+		outBitStream.Write<uint32_t>(0); //Time since created on server
 
 		const auto& syncLDF = GetVar<std::vector<std::u16string>>(u"syncLDF");
 
 		// Only sync for models.
 		if (m_Settings.size() > 0 && (GetComponent<ModelComponent>() && !GetComponent<PetComponent>())) {
-			outBitStream->Write1(); //ldf data
+			outBitStream.Write1(); //ldf data
 
 			RakNet::BitStream settingStream;
 			int32_t numberOfValidKeys = m_Settings.size();
@@ -940,13 +933,13 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 			for (LDFBaseData* data : m_Settings) {
 				if (data && data->GetValueType() != eLDFType::LDF_TYPE_UNKNOWN) {
-					data->WriteToPacket(&settingStream);
+					data->WriteToPacket(settingStream);
 				}
 			}
 
-			outBitStream->Write(settingStream.GetNumberOfBytesUsed() + 1);
-			outBitStream->Write<uint8_t>(0); //no compression used
-			outBitStream->Write(settingStream);
+			outBitStream.Write(settingStream.GetNumberOfBytesUsed() + 1);
+			outBitStream.Write<uint8_t>(0); //no compression used
+			outBitStream.Write(settingStream);
 		} else if (!syncLDF.empty()) {
 			std::vector<LDFBaseData*> ldfData;
 
@@ -954,79 +947,79 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 				ldfData.push_back(GetVarData(data));
 			}
 
-			outBitStream->Write1(); //ldf data
+			outBitStream.Write1(); //ldf data
 
 			RakNet::BitStream settingStream;
 			settingStream.Write<uint32_t>(ldfData.size());
 			for (LDFBaseData* data : ldfData) {
 				if (data) {
-					data->WriteToPacket(&settingStream);
+					data->WriteToPacket(settingStream);
 				}
 			}
 
-			outBitStream->Write(settingStream.GetNumberOfBytesUsed() + 1);
-			outBitStream->Write<uint8_t>(0); //no compression used
-			outBitStream->Write(settingStream);
+			outBitStream.Write(settingStream.GetNumberOfBytesUsed() + 1);
+			outBitStream.Write<uint8_t>(0); //no compression used
+			outBitStream.Write(settingStream);
 		} else {
-			outBitStream->Write0(); //No ldf data
+			outBitStream.Write0(); //No ldf data
 		}
 
 		TriggerComponent* triggerComponent;
 		if (TryGetComponent(eReplicaComponentType::TRIGGER, triggerComponent)) {
 			// has trigger component, check to see if we have events to handle
 			auto* trigger = triggerComponent->GetTrigger();
-			outBitStream->Write<bool>(trigger && trigger->events.size() > 0);
+			outBitStream.Write<bool>(trigger && trigger->events.size() > 0);
 		} else { // no trigger componenet, so definitely no triggers
-			outBitStream->Write0();
+			outBitStream.Write0();
 		}
 
 
 		if (m_ParentEntity != nullptr || m_SpawnerID != 0) {
-			outBitStream->Write1();
-			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
-			else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream->Write(m_SpawnerID);
-			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
-		} else outBitStream->Write0();
+			outBitStream.Write1();
+			if (m_ParentEntity != nullptr) outBitStream.Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
+			else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream.Write(m_SpawnerID);
+			else outBitStream.Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
+		} else outBitStream.Write0();
 
-		outBitStream->Write(m_HasSpawnerNodeID);
-		if (m_HasSpawnerNodeID) outBitStream->Write(m_SpawnerNodeID);
+		outBitStream.Write(m_HasSpawnerNodeID);
+		if (m_HasSpawnerNodeID) outBitStream.Write(m_SpawnerNodeID);
 
-		//outBitStream->Write0(); //Spawner node id
+		//outBitStream.Write0(); //Spawner node id
 
-		if (m_Scale == 1.0f || m_Scale == 0.0f) outBitStream->Write0();
+		if (m_Scale == 1.0f || m_Scale == 0.0f) outBitStream.Write0();
 		else {
-			outBitStream->Write1();
-			outBitStream->Write(m_Scale);
+			outBitStream.Write1();
+			outBitStream.Write(m_Scale);
 		}
 
-		outBitStream->Write0(); //ObjectWorldState
+		outBitStream.Write0(); //ObjectWorldState
 
 		if (m_GMLevel != eGameMasterLevel::CIVILIAN) {
-			outBitStream->Write1();
-			outBitStream->Write(m_GMLevel);
-		} else outBitStream->Write0(); //No GM Level
+			outBitStream.Write1();
+			outBitStream.Write(m_GMLevel);
+		} else outBitStream.Write0(); //No GM Level
 	}
 
 	// Only serialize parent / child info should the info be dirty (changed) or if this is the construction of the entity.
-	outBitStream->Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
+	outBitStream.Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
 	if (m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION) {
 		m_IsParentChildDirty = false;
-		outBitStream->Write(m_ParentEntity != nullptr);
+		outBitStream.Write(m_ParentEntity != nullptr);
 		if (m_ParentEntity) {
-			outBitStream->Write(m_ParentEntity->GetObjectID());
-			outBitStream->Write0();
+			outBitStream.Write(m_ParentEntity->GetObjectID());
+			outBitStream.Write0();
 		}
-		outBitStream->Write(m_ChildEntities.size() > 0);
+		outBitStream.Write(m_ChildEntities.size() > 0);
 		if (m_ChildEntities.size() > 0) {
-			outBitStream->Write<uint16_t>(m_ChildEntities.size());
+			outBitStream.Write<uint16_t>(m_ChildEntities.size());
 			for (Entity* child : m_ChildEntities) {
-				outBitStream->Write<uint64_t>(child->GetObjectID());
+				outBitStream.Write<uint64_t>(child->GetObjectID());
 			}
 		}
 	}
 }
 
-void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
+void Entity::WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType packetType) {
 
 	/**
 	 * This has to be done in a specific order.
@@ -1114,7 +1107,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 			possessorComponent->Serialize(outBitStream, bIsInitialUpdate);
 		} else {
 			// Should never happen, but just to be safe
-			outBitStream->Write0();
+			outBitStream.Write0();
 		}
 
 		LevelProgressionComponent* levelProgressionComponent;
@@ -1122,7 +1115,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate);
 		} else {
 			// Should never happen, but just to be safe
-			outBitStream->Write0();
+			outBitStream.Write0();
 		}
 
 		PlayerForcedMovementComponent* playerForcedMovementComponent;
@@ -1130,7 +1123,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate);
 		} else {
 			// Should never happen, but just to be safe
-			outBitStream->Write0();
+			outBitStream.Write0();
 		}
 
 		characterComponent->Serialize(outBitStream, bIsInitialUpdate);
@@ -1191,6 +1184,11 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		donationVendorComponent->Serialize(outBitStream, bIsInitialUpdate);
 	}
 
+	AchievementVendorComponent* achievementVendorComponent;
+	if (TryGetComponent(eReplicaComponentType::ACHIEVEMENT_VENDOR, achievementVendorComponent)) {
+		achievementVendorComponent->Serialize(outBitStream, bIsInitialUpdate);
+	}
+
 	BouncerComponent* bouncerComponent;
 	if (TryGetComponent(eReplicaComponentType::BOUNCER, bouncerComponent)) {
 		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate);
@@ -1242,10 +1240,10 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	// BBB Component, unused currently
 	// Need to to write0 so that is serialized correctly
 	// TODO: Implement BBB Component
-	outBitStream->Write0();
+	outBitStream.Write0();
 }
 
-void Entity::UpdateXMLDoc(tinyxml2::XMLDocument* doc) {
+void Entity::UpdateXMLDoc(tinyxml2::XMLDocument& doc) {
 	//This function should only ever be called from within Character, meaning doc should always exist when this is called.
 	//Naturally, we don't include any non-player components in this update function.
 
@@ -1270,9 +1268,7 @@ void Entity::Update(const float deltaTime) {
 			// Remove the timer from the list of timers first so that scripts and events can remove timers without causing iterator invalidation
 			auto timerName = timer.GetName();
 			m_Timers.erase(m_Timers.begin() + timerPosition);
-			for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-				script->OnTimerDone(this, timerName);
-			}
+			GetScript()->OnTimerDone(this, timerName);
 
 			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
 		} else {
@@ -1318,9 +1314,7 @@ void Entity::Update(const float deltaTime) {
 		Wake();
 	}
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnUpdate(this);
-	}
+	GetScript()->OnUpdate(this);
 
 	for (const auto& pair : m_Components) {
 		if (pair.second == nullptr) continue;
@@ -1337,9 +1331,7 @@ void Entity::OnCollisionProximity(LWOOBJID otherEntity, const std::string& proxN
 	Entity* other = Game::entityManager->GetEntity(otherEntity);
 	if (!other) return;
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnProximityUpdate(this, other, proxName, status);
-	}
+	GetScript()->OnProximityUpdate(this, other, proxName, status);
 
 	RocketLaunchpadControlComponent* rocketComp = GetComponent<RocketLaunchpadControlComponent>();
 	if (!rocketComp) return;
@@ -1351,9 +1343,7 @@ void Entity::OnCollisionPhantom(const LWOOBJID otherEntity) {
 	auto* other = Game::entityManager->GetEntity(otherEntity);
 	if (!other) return;
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnCollisionPhantom(this, other);
-	}
+	GetScript()->OnCollisionPhantom(this, other);
 
 	for (const auto& callback : m_PhantomCollisionCallbacks) {
 		callback(other);
@@ -1392,9 +1382,7 @@ void Entity::OnCollisionLeavePhantom(const LWOOBJID otherEntity) {
 	auto* other = Game::entityManager->GetEntity(otherEntity);
 	if (!other) return;
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnOffCollisionPhantom(this, other);
-	}
+	GetScript()->OnOffCollisionPhantom(this, other);
 
 	TriggerEvent(eTriggerEventType::EXIT, other);
 
@@ -1411,46 +1399,32 @@ void Entity::OnCollisionLeavePhantom(const LWOOBJID otherEntity) {
 }
 
 void Entity::OnFireEventServerSide(Entity* sender, std::string args, int32_t param1, int32_t param2, int32_t param3) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnFireEventServerSide(this, sender, args, param1, param2, param3);
-	}
+	GetScript()->OnFireEventServerSide(this, sender, args, param1, param2, param3);
 }
 
 void Entity::OnActivityStateChangeRequest(LWOOBJID senderID, int32_t value1, int32_t value2, const std::u16string& stringValue) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnActivityStateChangeRequest(this, senderID, value1, value2, stringValue);
-	}
+	GetScript()->OnActivityStateChangeRequest(this, senderID, value1, value2, stringValue);
 }
 
 void Entity::OnCinematicUpdate(Entity* self, Entity* sender, eCinematicEvent event, const std::u16string& pathName,
 	float_t pathTime, float_t totalTime, int32_t waypoint) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnCinematicUpdate(self, sender, event, pathName, pathTime, totalTime, waypoint);
-	}
+	GetScript()->OnCinematicUpdate(self, sender, event, pathName, pathTime, totalTime, waypoint);
 }
 
 void Entity::NotifyObject(Entity* sender, const std::string& name, int32_t param1, int32_t param2) {
 	GameMessages::SendNotifyObject(GetObjectID(), sender->GetObjectID(), GeneralUtils::ASCIIToUTF16(name), UNASSIGNED_SYSTEM_ADDRESS);
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnNotifyObject(this, sender, name, param1, param2);
-	}
+	GetScript()->OnNotifyObject(this, sender, name, param1, param2);
 }
 
 void Entity::OnEmoteReceived(const int32_t emote, Entity* target) {
-	for (auto* script : CppScripts::GetEntityScripts(this)) {
-		script->OnEmoteReceived(this, emote, target);
-	}
+	GetScript()->OnEmoteReceived(this, emote, target);
 }
 
 void Entity::OnUse(Entity* originator) {
 	TriggerEvent(eTriggerEventType::INTERACT, originator);
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnUse(this, originator);
-	}
-
-	// component base class when
+	GetScript()->OnUse(this, originator);
 
 	for (const auto& pair : m_Components) {
 		if (pair.second == nullptr) continue;
@@ -1460,82 +1434,63 @@ void Entity::OnUse(Entity* originator) {
 }
 
 void Entity::OnHitOrHealResult(Entity* attacker, int32_t damage) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnHitOrHealResult(this, attacker, damage);
-	}
+	GetScript()->OnHitOrHealResult(this, attacker, damage);
 }
 
 void Entity::OnHit(Entity* attacker) {
 	TriggerEvent(eTriggerEventType::HIT, attacker);
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnHit(this, attacker);
-	}
+	GetScript()->OnHit(this, attacker);
 }
 
 void Entity::OnZonePropertyEditBegin() {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyEditBegin(this);
-	}
+	GetScript()->OnZonePropertyEditBegin(this);
 }
 
 void Entity::OnZonePropertyEditEnd() {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyEditEnd(this);
-	}
+	GetScript()->OnZonePropertyEditEnd(this);
 }
 
 void Entity::OnZonePropertyModelEquipped() {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelEquipped(this);
-	}
+	GetScript()->OnZonePropertyModelEquipped(this);
 }
 
 void Entity::OnZonePropertyModelPlaced(Entity* player) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelPlaced(this, player);
-	}
+	GetScript()->OnZonePropertyModelPlaced(this, player);
 }
 
 void Entity::OnZonePropertyModelPickedUp(Entity* player) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelPickedUp(this, player);
-	}
+	GetScript()->OnZonePropertyModelPickedUp(this, player);
 }
 
 void Entity::OnZonePropertyModelRemoved(Entity* player) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelRemoved(this, player);
-	}
+	GetScript()->OnZonePropertyModelRemoved(this, player);
 }
 
 void Entity::OnZonePropertyModelRemovedWhileEquipped(Entity* player) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelRemovedWhileEquipped(this, player);
-	}
+	GetScript()->OnZonePropertyModelRemovedWhileEquipped(this, player);
 }
 
 void Entity::OnZonePropertyModelRotated(Entity* player) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnZonePropertyModelRotated(this, player);
-	}
+	GetScript()->OnZonePropertyModelRotated(this, player);
 }
 
 void Entity::OnMessageBoxResponse(Entity* sender, int32_t button, const std::u16string& identifier, const std::u16string& userData) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnMessageBoxResponse(this, sender, button, identifier, userData);
-	}
+	GetScript()->OnMessageBoxResponse(this, sender, button, identifier, userData);
 }
 
 void Entity::OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16string& buttonIdentifier, const std::u16string& identifier) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnChoiceBoxResponse(this, sender, button, buttonIdentifier, identifier);
-	}
+	GetScript()->OnChoiceBoxResponse(this, sender, button, buttonIdentifier, identifier);
 }
 
 void Entity::RequestActivityExit(Entity* sender, LWOOBJID player, bool canceled) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnRequestActivityExit(sender, player, canceled);
+	GetScript()->OnRequestActivityExit(sender, player, canceled);
 }
+
+CppScripts::Script* const Entity::GetScript() {
+	auto* scriptComponent = GetComponent<ScriptComponent>();
+	auto* script = scriptComponent ? scriptComponent->GetScript() : CppScripts::GetInvalidScript();
+	DluAssert(script != nullptr);
+	return script;
 }
 
 void Entity::Smash(const LWOOBJID source, const eKillType killType, const std::u16string& deathType) {
@@ -1568,9 +1523,7 @@ void Entity::Kill(Entity* murderer, const eKillType killType) {
 
 	//OMAI WA MOU, SHINDERIU
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnDie(this, murderer);
-	}
+	GetScript()->OnDie(this, murderer);
 
 	if (m_Spawner != nullptr) {
 		m_Spawner->NotifyOfEntityDeath(m_ObjectID);
@@ -1681,10 +1634,8 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 				CDObjectSkillsTable* skillsTable = CDClientManager::GetTable<CDObjectSkillsTable>();
 				std::vector<CDObjectSkills> skills = skillsTable->Query([=](CDObjectSkills entry) {return (entry.objectTemplate == p.second.lot); });
 				for (CDObjectSkills skill : skills) {
-					CDSkillBehaviorTable* skillBehTable = CDClientManager::GetTable<CDSkillBehaviorTable>();
-
 					auto* skillComponent = GetComponent<SkillComponent>();
-					if (skillComponent) skillComponent->CastSkill(skill.skillID, GetObjectID(), GetObjectID());
+					if (skillComponent) skillComponent->CastSkill(skill.skillID, GetObjectID(), GetObjectID(), skill.castOnType, NiQuaternion(0, 0, 0, 0));
 
 					auto* missionComponent = GetComponent<MissionComponent>();
 
@@ -2118,9 +2069,7 @@ void Entity::ProcessPositionUpdate(PositionUpdate& update) {
 				havokVehiclePhysicsComponent->SetIsOnGround(update.onGround);
 				havokVehiclePhysicsComponent->SetIsOnRail(update.onRail);
 				havokVehiclePhysicsComponent->SetVelocity(update.velocity);
-				havokVehiclePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3Constant::ZERO);
 				havokVehiclePhysicsComponent->SetAngularVelocity(update.angularVelocity);
-				havokVehiclePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3Constant::ZERO);
 				havokVehiclePhysicsComponent->SetRemoteInputInfo(update.remoteInputInfo);
 			} else {
 				// Need to get the mount's controllable physics
@@ -2131,9 +2080,7 @@ void Entity::ProcessPositionUpdate(PositionUpdate& update) {
 				possessedControllablePhysicsComponent->SetIsOnGround(update.onGround);
 				possessedControllablePhysicsComponent->SetIsOnRail(update.onRail);
 				possessedControllablePhysicsComponent->SetVelocity(update.velocity);
-				possessedControllablePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3Constant::ZERO);
 				possessedControllablePhysicsComponent->SetAngularVelocity(update.angularVelocity);
-				possessedControllablePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3Constant::ZERO);
 			}
 			Game::entityManager->SerializeEntity(possassableEntity);
 		}
@@ -2155,9 +2102,7 @@ void Entity::ProcessPositionUpdate(PositionUpdate& update) {
 	controllablePhysicsComponent->SetIsOnGround(update.onGround);
 	controllablePhysicsComponent->SetIsOnRail(update.onRail);
 	controllablePhysicsComponent->SetVelocity(update.velocity);
-	controllablePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3Constant::ZERO);
 	controllablePhysicsComponent->SetAngularVelocity(update.angularVelocity);
-	controllablePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3Constant::ZERO);
 
 	auto* ghostComponent = GetComponent<GhostComponent>();
 	if (ghostComponent) ghostComponent->SetGhostReferencePoint(update.position);

dGame/Entity.h

@@ -146,7 +146,8 @@ public:
 
 	void AddComponent(eReplicaComponentType componentId, Component* component);
 
-	std::vector<ScriptComponent*> GetScriptComponents();
+	// This is expceted to never return nullptr, an assert checks this.
+	CppScripts::Script* const GetScript();
 
 	void Subscribe(LWOOBJID scriptObjId, CppScripts::Script* scriptToAdd, const std::string& notificationName);
 	void Unsubscribe(LWOOBJID scriptObjId, const std::string& notificationName);
@@ -171,9 +172,9 @@ public:
 
 	std::unordered_map<eReplicaComponentType, Component*>& GetComponents() { return m_Components; } // TODO: Remove
 
-	void WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
-	void WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
-	void UpdateXMLDoc(tinyxml2::XMLDocument* doc);
+	void WriteBaseReplicaData(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
+	void WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
+	void UpdateXMLDoc(tinyxml2::XMLDocument& doc);
 	void Update(float deltaTime);
 
 	// Events
@@ -295,6 +296,9 @@ public:
 
 	void ProcessPositionUpdate(PositionUpdate& update);
 
+	// Scale will only be communicated to the client when the construction packet is sent
+	void SetScale(const float scale) { m_Scale = scale; };
+
 protected:
 	LWOOBJID m_ObjectID;
 

dGame/EntityManager.cpp

@@ -178,18 +178,18 @@ void EntityManager::SerializeEntities() {
 		stream.Write<char>(ID_REPLICA_MANAGER_SERIALIZE);
 		stream.Write<unsigned short>(entity->GetNetworkId());
 
-		entity->WriteBaseReplicaData(&stream, eReplicaPacketType::SERIALIZATION);
-		entity->WriteComponents(&stream, eReplicaPacketType::SERIALIZATION);
+		entity->WriteBaseReplicaData(stream, eReplicaPacketType::SERIALIZATION);
+		entity->WriteComponents(stream, eReplicaPacketType::SERIALIZATION);
 
 		if (entity->GetIsGhostingCandidate()) {
 			for (auto* player : PlayerManager::GetAllPlayers()) {
 				auto* ghostComponent = player->GetComponent<GhostComponent>();
 				if (ghostComponent && ghostComponent->IsObserved(toSerialize)) {
-					Game::server->Send(&stream, player->GetSystemAddress(), false);
+					Game::server->Send(stream, player->GetSystemAddress(), false);
 				}
 			}
 		} else {
-			Game::server->Send(&stream, UNASSIGNED_SYSTEM_ADDRESS, true);
+			Game::server->Send(stream, UNASSIGNED_SYSTEM_ADDRESS, true);
 		}
 	}
 	m_EntitiesToSerialize.clear();
@@ -359,16 +359,16 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	stream.Write(true);
 	stream.Write<uint16_t>(entity->GetNetworkId());
 
-	entity->WriteBaseReplicaData(&stream, eReplicaPacketType::CONSTRUCTION);
-	entity->WriteComponents(&stream, eReplicaPacketType::CONSTRUCTION);
+	entity->WriteBaseReplicaData(stream, eReplicaPacketType::CONSTRUCTION);
+	entity->WriteComponents(stream, eReplicaPacketType::CONSTRUCTION);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 		if (skipChecks) {
-			Game::server->Send(&stream, UNASSIGNED_SYSTEM_ADDRESS, true);
+			Game::server->Send(stream, UNASSIGNED_SYSTEM_ADDRESS, true);
 		} else {
 			for (auto* player : PlayerManager::GetAllPlayers()) {
 				if (player->GetPlayerReadyForUpdates()) {
-					Game::server->Send(&stream, player->GetSystemAddress(), false);
+					Game::server->Send(stream, player->GetSystemAddress(), false);
 				} else {
 					auto* ghostComponent = player->GetComponent<GhostComponent>();
 					if (ghostComponent) ghostComponent->AddLimboConstruction(entity->GetObjectID());
@@ -376,7 +376,7 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 			}
 		}
 	} else {
-		Game::server->Send(&stream, sysAddr, false);
+		Game::server->Send(stream, sysAddr, false);
 	}
 
 	if (entity->IsPlayer()) {
@@ -407,7 +407,7 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 	stream.Write<uint8_t>(ID_REPLICA_MANAGER_DESTRUCTION);
 	stream.Write<uint16_t>(entity->GetNetworkId());
 
-	Game::server->Send(&stream, sysAddr, sysAddr == UNASSIGNED_SYSTEM_ADDRESS);
+	Game::server->Send(stream, sysAddr, sysAddr == UNASSIGNED_SYSTEM_ADDRESS);
 
 	for (auto* player : PlayerManager::GetAllPlayers()) {
 		if (!player->GetPlayerReadyForUpdates()) {
@@ -418,10 +418,16 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 }
 
 void EntityManager::SerializeEntity(Entity* entity) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (!entity) return;
 	
-	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
-		m_EntitiesToSerialize.push_back(entity->GetObjectID());
+	EntityManager::SerializeEntity(*entity);
+}
+
+void EntityManager::SerializeEntity(const Entity& entity) {
+	if (entity.GetNetworkId() == 0) return;
+
+	if (std::find(m_EntitiesToSerialize.cbegin(), m_EntitiesToSerialize.cend(), entity.GetObjectID()) == m_EntitiesToSerialize.cend()) {
+		m_EntitiesToSerialize.push_back(entity.GetObjectID());
 	}
 }
 

dGame/EntityManager.h

@@ -45,6 +45,7 @@ public:
 	void ConstructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS, bool skipChecks = false);
 	void DestructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SerializeEntity(Entity* entity);
+	void SerializeEntity(const Entity& entity);
 
 	void ConstructAllEntities(const SystemAddress& sysAddr);
 	void DestructAllEntities(const SystemAddress& sysAddr);

dGame/LeaderboardManager.cpp

@@ -43,9 +43,9 @@ inline void WriteLeaderboardRow(std::ostringstream& leaderboard, const uint32_t&
 	leaderboard << "\nResult[0].Row[" << index << "]." << data->GetString();
 }
 
-void Leaderboard::Serialize(RakNet::BitStream* bitStream) const {
-	bitStream->Write(gameID);
-	bitStream->Write(infoType);
+void Leaderboard::Serialize(RakNet::BitStream& bitStream) const {
+	bitStream.Write(gameID);
+	bitStream.Write(infoType);
 
 	std::ostringstream leaderboard;
 
@@ -64,12 +64,12 @@ void Leaderboard::Serialize(RakNet::BitStream* bitStream) const {
 
 	// Serialize the thing to a BitStream
 	uint32_t leaderboardSize = leaderboard.tellp();
-	bitStream->Write<uint32_t>(leaderboardSize);
+	bitStream.Write<uint32_t>(leaderboardSize);
 	// Doing this all in 1 call so there is no possbility of a dangling pointer.
-	bitStream->WriteAlignedBytes(reinterpret_cast<const unsigned char*>(GeneralUtils::ASCIIToUTF16(leaderboard.str()).c_str()), leaderboardSize * sizeof(char16_t));
-	if (leaderboardSize > 0) bitStream->Write<uint16_t>(0);
-	bitStream->Write0();
-	bitStream->Write0();
+	bitStream.WriteAlignedBytes(reinterpret_cast<const unsigned char*>(GeneralUtils::ASCIIToUTF16(leaderboard.str()).c_str()), leaderboardSize * sizeof(char16_t));
+	if (leaderboardSize > 0) bitStream.Write<uint16_t>(0);
+	bitStream.Write0();
+	bitStream.Write0();
 }
 
 void Leaderboard::QueryToLdf(std::unique_ptr<sql::ResultSet>& rows) {

dGame/LeaderboardManager.h

@@ -88,7 +88,7 @@ public:
 	 *
 	 * Expensive!  Leaderboards are very string intensive so be wary of performatnce calling this method.
 	 */
-	void Serialize(RakNet::BitStream* bitStream) const;
+	void Serialize(RakNet::BitStream& bitStream) const;
 
 	/**
 	 * Builds the leaderboard from the database based on the associated gameID

dGame/UserManager.cpp

@@ -26,7 +26,7 @@
 #include "eCharacterCreationResponse.h"
 #include "eRenameResponse.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
 
@@ -83,7 +83,7 @@ void UserManager::Initialize() {
 	auto chatListStream = Game::assetManager->GetFile("chatplus_en_us.txt");
 	if (!chatListStream) {
 		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "chatplus_en_us.txt").string().c_str());
-		throw std::runtime_error("Aborting initialization due to missing chat whitelist file.");
+		throw std::runtime_error("Aborting initialization due to missing chat allowlist file.");
 	}
 
 	while (std::getline(chatListStream, line, '\n')) {
@@ -422,7 +422,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 		Database::Get()->DeleteCharacter(charID);
 
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::UNEXPECTED_DISCONNECT);
 		bitStream.Write(objectID);
 		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 
@@ -536,13 +536,13 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 	try {
 		auto stmt = CDClientDatabase::CreatePreppedStmt(
-			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ? AND icc.decal == ?"
+			"select obj.id as objectId from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ? AND icc.decal == ?"
 		);
 		stmt.bind(1, "character create shirt");
 		stmt.bind(2, static_cast<int>(shirtColor));
 		stmt.bind(3, static_cast<int>(shirtStyle));
 		auto tableData = stmt.execQuery();
-		auto shirtLOT = tableData.getIntField(0, 4069);
+		auto shirtLOT = tableData.getIntField("objectId", 4069);
 		tableData.finalize();
 		return shirtLOT;
 	} catch (const std::exception& ex) {
@@ -555,12 +555,12 @@ uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 uint32_t FindCharPantsID(uint32_t pantsColor) {
 	try {
 		auto stmt = CDClientDatabase::CreatePreppedStmt(
-			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ?"
+			"select obj.id as objectId from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ?"
 		);
 		stmt.bind(1, "cc pants");
 		stmt.bind(2, static_cast<int>(pantsColor));
 		auto tableData = stmt.execQuery();
-		auto pantsLOT = tableData.getIntField(0, 2508);
+		auto pantsLOT = tableData.getIntField("objectId", 2508);
 		tableData.finalize();
 		return pantsLOT;
 	} catch (const std::exception& ex) {

dGame/dBehaviors/AirMovementBehavior.cpp

@@ -5,35 +5,35 @@
 #include "Game.h"
 #include "Logger.h"
 
-void AirMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void AirMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	uint32_t handle{};
 
-	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+	if (!bitStream.Read(handle)) {
+		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 		return;
 	}
 
 	context->RegisterSyncBehavior(handle, this, branch, this->m_Timeout);
 }
 
-void AirMovementBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void AirMovementBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	const auto handle = context->GetUniqueSkillId();
 
-	bitStream->Write(handle);
+	bitStream.Write(handle);
 }
 
-void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	uint32_t behaviorId{};
 
-	if (!bitStream->Read(behaviorId)) {
-		LOG("Unable to read behaviorId from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+	if (!bitStream.Read(behaviorId)) {
+		LOG("Unable to read behaviorId from bitStream, aborting Sync! %i", bitStream.GetNumberOfUnreadBits());
 		return;
 	}
 
 	LWOOBJID target{};
 
-	if (!bitStream->Read(target)) {
-		LOG("Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+	if (!bitStream.Read(target)) {
+		LOG("Unable to read target from bitStream, aborting Sync! %i", bitStream.GetNumberOfUnreadBits());
 		return;
 	}
 

dGame/dBehaviors/AirMovementBehavior.h

@@ -6,11 +6,11 @@ class AirMovementBehavior final : public Behavior
 public:
 	explicit AirMovementBehavior(const uint32_t behavior_id) : Behavior(behavior_id) {}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Sync(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
 private:

dGame/dBehaviors/AndBehavior.cpp

@@ -3,13 +3,13 @@
 #include "Game.h"
 #include "Logger.h"
 
-void AndBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AndBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	for (auto* behavior : this->m_behaviors) {
 		behavior->Handle(context, bitStream, branch);
 	}
 }
 
-void AndBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AndBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	for (auto* behavior : this->m_behaviors) {
 		behavior->Calculate(context, bitStream, branch);
 	}

dGame/dBehaviors/AndBehavior.h

@@ -15,9 +15,9 @@ public:
 	explicit AndBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
 	}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void UnCast(BehaviorContext* context, BehaviorBranchContext branch) override;
 

dGame/dBehaviors/ApplyBuffBehavior.cpp

@@ -5,7 +5,7 @@
 #include "BuffComponent.h"
 
 
-void ApplyBuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void ApplyBuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	auto* entity = Game::entityManager->GetEntity(branch.target == LWOOBJID_EMPTY ? context->originator : branch.target);
 
 	if (entity == nullptr) return;
@@ -30,7 +30,7 @@ void ApplyBuffBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext b
 	buffComponent->RemoveBuff(m_BuffId);
 }
 
-void ApplyBuffBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void ApplyBuffBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	Handle(context, bitStream, branch);
 }
 

dGame/dBehaviors/ApplyBuffBehavior.h

@@ -24,11 +24,11 @@ public:
 	explicit ApplyBuffBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
 	}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void UnCast(BehaviorContext* context, BehaviorBranchContext branch) override;
 
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
 private:

dGame/dBehaviors/AreaOfEffectBehavior.cpp

@@ -12,11 +12,11 @@
 #include "Game.h"
 #include "Logger.h"
 
-void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	uint32_t targetCount{};
 
-	if (!bitStream->Read(targetCount)) {
-		LOG("Unable to read targetCount from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+	if (!bitStream.Read(targetCount)) {
+		LOG("Unable to read targetCount from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 		return;
 	}
 
@@ -40,7 +40,7 @@ void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream* b
 
 	for (auto i = 0u; i < targetCount; ++i) {
 		LWOOBJID target{};
-		if (!bitStream->Read(target)) {
+		if (!bitStream.Read(target)) {
 			LOG("failed to read in target %i from bitStream, aborting target Handle!", i);
 		};
 		targets.push_back(target);
@@ -54,7 +54,7 @@ void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream* b
 	PlayFx(u"cast", context->originator);
 }
 
-void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	auto* caster = Game::entityManager->GetEntity(context->caster);
 	if (!caster) return;
 
@@ -83,7 +83,7 @@ void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream
 	// resize if we have more than max targets allows
 	if (targets.size() > this->m_maxTargets) targets.resize(this->m_maxTargets);
 
-	bitStream->Write<uint32_t>(targets.size());
+	bitStream.Write<uint32_t>(targets.size());
 
 	if (targets.size() == 0) {
 		PlayFx(u"miss", context->originator);
@@ -92,7 +92,7 @@ void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream
 		context->foundTarget = true;
 		// write all the targets to the bitstream
 		for (auto* target : targets) {
-			bitStream->Write(target->GetObjectID());
+			bitStream.Write(target->GetObjectID());
 		}
 
 		// then cast all the actions

dGame/dBehaviors/AreaOfEffectBehavior.h

@@ -6,8 +6,8 @@ class AreaOfEffectBehavior final : public Behavior
 {
 public:
 	explicit AreaOfEffectBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {}
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 	void Load() override;
 private:
 	Behavior* m_action;

dGame/dBehaviors/AttackDelayBehavior.cpp

@@ -4,11 +4,11 @@
 #include "Game.h"
 #include "Logger.h"
 
-void AttackDelayBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AttackDelayBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	uint32_t handle{};
 
-	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+	if (!bitStream.Read(handle)) {
+		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 		return;
 	};
 
@@ -17,10 +17,10 @@ void AttackDelayBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 	}
 }
 
-void AttackDelayBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AttackDelayBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	const auto handle = context->GetUniqueSkillId();
 
-	bitStream->Write(handle);
+	bitStream.Write(handle);
 
 	context->foundTarget = true;
 
@@ -31,11 +31,11 @@ void AttackDelayBehavior::Calculate(BehaviorContext* context, RakNet::BitStream*
 	}
 }
 
-void AttackDelayBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AttackDelayBehavior::Sync(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	this->m_action->Handle(context, bitStream, branch);
 }
 
-void AttackDelayBehavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
+void AttackDelayBehavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	PlayFx(u"cast", context->originator);
 
 	this->m_action->Calculate(context, bitStream, branch);

dGame/dBehaviors/AttackDelayBehavior.h

@@ -19,13 +19,13 @@ public:
 	explicit AttackDelayBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
 	}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Sync(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void SyncCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void SyncCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
 };

dGame/dBehaviors/BasicAttackBehavior.cpp

@@ -9,7 +9,7 @@
 #include "BehaviorContext.h"
 #include "eBasicAttackSuccessTypes.h"
 
-void BasicAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BasicAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	if (context->unmanaged) {
 		auto* entity = Game::entityManager->GetEntity(branch.target);
 
@@ -30,22 +30,22 @@ void BasicAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 		return;
 	}
 
-	bitStream->AlignReadToByteBoundary();
+	bitStream.AlignReadToByteBoundary();
 
 	uint16_t allocatedBits{};
-	if (!bitStream->Read(allocatedBits) || allocatedBits == 0) {
+	if (!bitStream.Read(allocatedBits) || allocatedBits == 0) {
 		LOG_DEBUG("No allocated bits");
 		return;
 	}
 	LOG_DEBUG("Number of allocated bits %i", allocatedBits);
-	const auto baseAddress = bitStream->GetReadOffset();
+	const auto baseAddress = bitStream.GetReadOffset();
 
 	DoHandleBehavior(context, bitStream, branch);
 
-	bitStream->SetReadOffset(baseAddress + allocatedBits);
+	bitStream.SetReadOffset(baseAddress + allocatedBits);
 }
 
-void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	auto* targetEntity = Game::entityManager->GetEntity(branch.target);
 	if (!targetEntity) {
 		LOG("Target targetEntity %llu not found.", branch.target);
@@ -62,7 +62,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	bool isImmune{};
 	bool isSuccess{};
 
-	if (!bitStream->Read(isBlocked)) {
+	if (!bitStream.Read(isBlocked)) {
 		LOG("Unable to read isBlocked");
 		return;
 	}
@@ -74,7 +74,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 		return;
 	}
 
-	if (!bitStream->Read(isImmune)) {
+	if (!bitStream.Read(isImmune)) {
 		LOG("Unable to read isImmune");
 		return;
 	}
@@ -85,20 +85,20 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 		return;
 	}
 
-	if (!bitStream->Read(isSuccess)) {
+	if (!bitStream.Read(isSuccess)) {
 		LOG("failed to read success from bitstream");
 		return;
 	}
 
 	if (isSuccess) {
 		uint32_t armorDamageDealt{};
-		if (!bitStream->Read(armorDamageDealt)) {
+		if (!bitStream.Read(armorDamageDealt)) {
 			LOG("Unable to read armorDamageDealt");
 			return;
 		}
 
 		uint32_t healthDamageDealt{};
-		if (!bitStream->Read(healthDamageDealt)) {
+		if (!bitStream.Read(healthDamageDealt)) {
 			LOG("Unable to read healthDamageDealt");
 			return;
 		}
@@ -111,7 +111,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 		}
 
 		bool died{};
-		if (!bitStream->Read(died)) {
+		if (!bitStream.Read(died)) {
 			LOG("Unable to read died");
 			return;
 		}
@@ -122,7 +122,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	}
 
 	uint8_t successState{};
-	if (!bitStream->Read(successState)) {
+	if (!bitStream.Read(successState)) {
 		LOG("Unable to read success state");
 		return;
 	}
@@ -144,26 +144,26 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	}
 }
 
-void BasicAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
-	bitStream->AlignWriteToByteBoundary();
+void BasicAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
+	bitStream.AlignWriteToByteBoundary();
 
-	const auto allocatedAddress = bitStream->GetWriteOffset();
+	const auto allocatedAddress = bitStream.GetWriteOffset();
 
-	bitStream->Write<uint16_t>(0);
+	bitStream.Write<uint16_t>(0);
 
-	const auto startAddress = bitStream->GetWriteOffset();
+	const auto startAddress = bitStream.GetWriteOffset();
 
 	DoBehaviorCalculation(context, bitStream, branch);
 
-	const auto endAddress = bitStream->GetWriteOffset();
+	const auto endAddress = bitStream.GetWriteOffset();
 	const uint16_t allocate = endAddress - startAddress;
 
-	bitStream->SetWriteOffset(allocatedAddress);
-	bitStream->Write(allocate);
-	bitStream->SetWriteOffset(startAddress + allocate);
+	bitStream.SetWriteOffset(allocatedAddress);
+	bitStream.Write(allocate);
+	bitStream.SetWriteOffset(startAddress + allocate);
 }
 
-void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	auto* targetEntity = Game::entityManager->GetEntity(branch.target);
 	if (!targetEntity) {
 		LOG("Target entity %llu is null!", branch.target);
@@ -178,7 +178,7 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 
 	const bool isBlocking = destroyableComponent->GetAttacksToBlock() > 0;
 
-	bitStream->Write(isBlocking);
+	bitStream.Write(isBlocking);
 
 	if (isBlocking) {
 		destroyableComponent->SetAttacksToBlock(destroyableComponent->GetAttacksToBlock() - 1);
@@ -188,7 +188,7 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 	}
 
 	const bool isImmune = destroyableComponent->IsImmune() || destroyableComponent->IsCooldownImmune();
-	bitStream->Write(isImmune);
+	bitStream.Write(isImmune);
 
 	if (isImmune) {
 		LOG_DEBUG("Target targetEntity %llu is immune!", branch.target);
@@ -210,7 +210,7 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 	const uint32_t healthDamageDealt = previousHealth - destroyableComponent->GetHealth();
 	isSuccess = armorDamageDealt > 0 || healthDamageDealt > 0 || (armorDamageDealt + healthDamageDealt) > 0;
 
-	bitStream->Write(isSuccess);
+	bitStream.Write(isSuccess);
 
 	//Handle player damage cooldown
 	if (isSuccess && targetEntity->IsPlayer() && !this->m_DontApplyImmune) {
@@ -222,15 +222,15 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 		if (healthDamageDealt >= 1) {
 			successState = eBasicAttackSuccessTypes::SUCCESS;
 		} else if (armorDamageDealt >= 1) {
-			successState = this->m_OnFailArmor->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY ? eBasicAttackSuccessTypes::FAILIMMUNE : eBasicAttackSuccessTypes::FAILARMOR;
+			successState = this->m_OnFailArmor->m_templateId == BehaviorTemplate::EMPTY ? eBasicAttackSuccessTypes::FAILIMMUNE : eBasicAttackSuccessTypes::FAILARMOR;
 		}
 
-		bitStream->Write(armorDamageDealt);
-		bitStream->Write(healthDamageDealt);
-		bitStream->Write(targetEntity->GetIsDead());
+		bitStream.Write(armorDamageDealt);
+		bitStream.Write(healthDamageDealt);
+		bitStream.Write(targetEntity->GetIsDead());
 	}
 
-	bitStream->Write(successState);
+	bitStream.Write(successState);
 
 	switch (static_cast<eBasicAttackSuccessTypes>(successState)) {
 	case eBasicAttackSuccessTypes::SUCCESS:

dGame/dBehaviors/BasicAttackBehavior.h

@@ -12,7 +12,7 @@ public:
 	 * is then offset to after the allocated bits for this stream.
 	 *
 	 */
-	void DoHandleBehavior(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	void DoHandleBehavior(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
 	/**
 	 * @brief Handles a client initialized Basic Attack Behavior cast to be deserialized and verified on the server.
@@ -22,14 +22,14 @@ public:
 	 * and will fail gracefully if an overread is detected.
 	 * @param branch The context of this specific branch of the Skill Behavior.  Changes based on which branch you are going down.
 	 */
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	/**
 	 * @brief Writes a 16bit short to the bitStream and when the actual behavior calculation finishes with all of its branches, the number
 	 * of bits used is then written to where the 16bit short initially was.
 	 *
 	 */
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	/**
 	 * @brief Calculates a server initialized Basic Attack Behavior cast to be serialized to the client
@@ -38,7 +38,7 @@ public:
 	 * @param bitStream The bitStream to serialize to.
 	 * @param branch The context of this specific branch of the Skill Behavior.  Changes based on which branch you are going down.
 	 */
-	void DoBehaviorCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	void DoBehaviorCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
 	/**
 	 * @brief Loads this Behaviors parameters from the database.  For this behavior specifically:

dGame/dBehaviors/Behavior.cpp

@@ -5,7 +5,7 @@
 #include "CDActivitiesTable.h"
 #include "Game.h"
 #include "Logger.h"
-#include "BehaviorTemplates.h"
+#include "BehaviorTemplate.h"
 #include "BehaviorBranchContext.h"
 #include <unordered_map>
 
@@ -110,176 +110,176 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	Behavior* behavior = nullptr;
 
 	switch (templateId) {
-	case BehaviorTemplates::BEHAVIOR_EMPTY: break;
-	case BehaviorTemplates::BEHAVIOR_BASIC_ATTACK:
+	case BehaviorTemplate::EMPTY: break;
+	case BehaviorTemplate::BASIC_ATTACK:
 		behavior = new BasicAttackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAC_ARC:
+	case BehaviorTemplate::TAC_ARC:
 		behavior = new TacArcBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AND:
+	case BehaviorTemplate::AND:
 		behavior = new AndBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROJECTILE_ATTACK:
+	case BehaviorTemplate::PROJECTILE_ATTACK:
 		behavior = new ProjectileAttackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_HEAL:
+	case BehaviorTemplate::HEAL:
 		behavior = new HealBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_MOVEMENT_SWITCH:
+	case BehaviorTemplate::MOVEMENT_SWITCH:
 		behavior = new MovementSwitchBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AREA_OF_EFFECT:
+	case BehaviorTemplate::AREA_OF_EFFECT:
 		behavior = new AreaOfEffectBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PLAY_EFFECT:
+	case BehaviorTemplate::PLAY_EFFECT:
 		behavior = new PlayEffectBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMMUNITY:
+	case BehaviorTemplate::IMMUNITY:
 		behavior = new ImmunityBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_BUFF: break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_ABSORBTION:
+	case BehaviorTemplate::DAMAGE_BUFF: break;
+	case BehaviorTemplate::DAMAGE_ABSORBTION:
 		behavior = new DamageAbsorptionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_OVER_TIME:
+	case BehaviorTemplate::OVER_TIME:
 		behavior = new OverTimeBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMAGINATION:
+	case BehaviorTemplate::IMAGINATION:
 		behavior = new ImaginationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TARGET_CASTER:
+	case BehaviorTemplate::TARGET_CASTER:
 		behavior = new TargetCasterBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_STUN:
+	case BehaviorTemplate::STUN:
 		behavior = new StunBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DURATION:
+	case BehaviorTemplate::DURATION:
 		behavior = new DurationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_KNOCKBACK:
+	case BehaviorTemplate::KNOCKBACK:
 		behavior = new KnockbackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ATTACK_DELAY:
+	case BehaviorTemplate::ATTACK_DELAY:
 		behavior = new AttackDelayBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CAR_BOOST:
+	case BehaviorTemplate::CAR_BOOST:
 		behavior = new CarBoostBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_FALL_SPEED:
+	case BehaviorTemplate::FALL_SPEED:
 		behavior = new FallSpeedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SHIELD: break;
-	case BehaviorTemplates::BEHAVIOR_REPAIR_ARMOR:
+	case BehaviorTemplate::SHIELD: break;
+	case BehaviorTemplate::REPAIR_ARMOR:
 		behavior = new RepairBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPEED:
+	case BehaviorTemplate::SPEED:
 		behavior = new SpeedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DARK_INSPIRATION:
+	case BehaviorTemplate::DARK_INSPIRATION:
 		behavior = new DarkInspirationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_LOOT_BUFF:
+	case BehaviorTemplate::LOOT_BUFF:
 		behavior = new LootBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_VENTURE_VISION:
+	case BehaviorTemplate::VENTURE_VISION:
 		behavior = new VentureVisionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPAWN_OBJECT:
+	case BehaviorTemplate::SPAWN_OBJECT:
 		behavior = new SpawnBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_LAY_BRICK: break;
-	case BehaviorTemplates::BEHAVIOR_SWITCH:
+	case BehaviorTemplate::LAY_BRICK: break;
+	case BehaviorTemplate::SWITCH:
 		behavior = new SwitchBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_BUFF:
+	case BehaviorTemplate::BUFF:
 		behavior = new BuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_JETPACK:
+	case BehaviorTemplate::JETPACK:
 		behavior = new JetPackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_EVENT:
+	case BehaviorTemplate::SKILL_EVENT:
 		behavior = new SkillEventBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CONSUME_ITEM:
+	case BehaviorTemplate::CONSUME_ITEM:
 		behavior = new ConsumeItemBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_CAST_FAILED:
+	case BehaviorTemplate::SKILL_CAST_FAILED:
 		behavior = new SkillCastFailedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMITATION_SKUNK_STINK: break;
-	case BehaviorTemplates::BEHAVIOR_CHANGE_IDLE_FLAGS:
+	case BehaviorTemplate::IMITATION_SKUNK_STINK: break;
+	case BehaviorTemplate::CHANGE_IDLE_FLAGS:
 		behavior = new ChangeIdleFlagsBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_APPLY_BUFF:
+	case BehaviorTemplate::APPLY_BUFF:
 		behavior = new ApplyBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CHAIN:
+	case BehaviorTemplate::CHAIN:
 		behavior = new ChainBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CHANGE_ORIENTATION:
+	case BehaviorTemplate::CHANGE_ORIENTATION:
 		behavior = new ChangeOrientationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_FORCE_MOVEMENT:
+	case BehaviorTemplate::FORCE_MOVEMENT:
 		behavior = new ForceMovementBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_INTERRUPT:
+	case BehaviorTemplate::INTERRUPT:
 		behavior = new InterruptBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ALTER_COOLDOWN: break;
-	case BehaviorTemplates::BEHAVIOR_CHARGE_UP:
+	case BehaviorTemplate::ALTER_COOLDOWN: break;
+	case BehaviorTemplate::CHARGE_UP:
 		behavior = new ChargeUpBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SWITCH_MULTIPLE:
+	case BehaviorTemplate::SWITCH_MULTIPLE:
 		behavior = new SwitchMultipleBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_START:
+	case BehaviorTemplate::START:
 		behavior = new StartBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_END:
+	case BehaviorTemplate::END:
 		behavior = new EndBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ALTER_CHAIN_DELAY: break;
-	case BehaviorTemplates::BEHAVIOR_CAMERA: break;
-	case BehaviorTemplates::BEHAVIOR_REMOVE_BUFF:
+	case BehaviorTemplate::ALTER_CHAIN_DELAY: break;
+	case BehaviorTemplate::CAMERA: break;
+	case BehaviorTemplate::REMOVE_BUFF:
 		behavior = new RemoveBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_GRAB: break;
-	case BehaviorTemplates::BEHAVIOR_MODULAR_BUILD: break;
-	case BehaviorTemplates::BEHAVIOR_NPC_COMBAT_SKILL:
+	case BehaviorTemplate::GRAB: break;
+	case BehaviorTemplate::MODULAR_BUILD: break;
+	case BehaviorTemplate::NPC_COMBAT_SKILL:
 		behavior = new NpcCombatSkillBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_BLOCK:
+	case BehaviorTemplate::BLOCK:
 		behavior = new BlockBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_VERIFY:
+	case BehaviorTemplate::VERIFY:
 		behavior = new VerifyBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAUNT:
+	case BehaviorTemplate::TAUNT:
 		behavior = new TauntBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AIR_MOVEMENT:
+	case BehaviorTemplate::AIR_MOVEMENT:
 		behavior = new AirMovementBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPAWN_QUICKBUILD:
+	case BehaviorTemplate::SPAWN_QUICKBUILD:
 		behavior = new SpawnBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PULL_TO_POINT:
+	case BehaviorTemplate::PULL_TO_POINT:
 		behavior = new PullToPointBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_ROTATE: break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_REDUCTION:
+	case BehaviorTemplate::PROPERTY_ROTATE: break;
+	case BehaviorTemplate::DAMAGE_REDUCTION:
 		behavior = new DamageReductionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_TELEPORT:
+	case BehaviorTemplate::PROPERTY_TELEPORT:
 		behavior = new PropertyTeleportBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_CLEAR_TARGET:
+	case BehaviorTemplate::PROPERTY_CLEAR_TARGET:
 		behavior = new ClearTargetBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAKE_PICTURE: break;
-	case BehaviorTemplates::BEHAVIOR_MOUNT: break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_SET: break;
+	case BehaviorTemplate::TAKE_PICTURE: break;
+	case BehaviorTemplate::MOUNT: break;
+	case BehaviorTemplate::SKILL_SET: break;
 	default:
 		//LOG("Failed to load behavior with invalid template id (%i)!", templateId);
 		break;
@@ -296,19 +296,19 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	return behavior;
 }
 
-BehaviorTemplates Behavior::GetBehaviorTemplate(const uint32_t behaviorId) {
+BehaviorTemplate Behavior::GetBehaviorTemplate(const uint32_t behaviorId) {
 	auto behaviorTemplateTable = CDClientManager::GetTable<CDBehaviorTemplateTable>();
 
-	BehaviorTemplates templateID = BehaviorTemplates::BEHAVIOR_EMPTY;
+	BehaviorTemplate templateID = BehaviorTemplate::EMPTY;
 	// Find behavior template by its behavior id.  Default to 0.
 	if (behaviorTemplateTable) {
 		auto templateEntry = behaviorTemplateTable->GetByBehaviorID(behaviorId);
 		if (templateEntry.behaviorID == behaviorId) {
-			templateID = static_cast<BehaviorTemplates>(templateEntry.templateID);
+			templateID = static_cast<BehaviorTemplate>(templateEntry.templateID);
 		}
 	}
 
-	if (templateID == BehaviorTemplates::BEHAVIOR_EMPTY && behaviorId != 0) {
+	if (templateID == BehaviorTemplate::EMPTY && behaviorId != 0) {
 		LOG("Failed to load behavior template with id (%i)!", behaviorId);
 	}
 
@@ -335,27 +335,23 @@ void Behavior::PlayFx(std::u16string type, const LWOOBJID target, const LWOOBJID
 
 	const auto typeString = GeneralUtils::UTF16ToWTF8(type);
 
-	if (m_effectNames == nullptr) {
-		m_effectNames = new std::unordered_map<std::string, std::string>();
-	} else {
-		const auto pair = m_effectNames->find(typeString);
+	const auto itr = m_effectNames.find(typeString);
 
 	if (type.empty()) {
-			type = GeneralUtils::ASCIIToUTF16(*m_effectType);
+		type = GeneralUtils::ASCIIToUTF16(m_effectType);
 	}
 
-		if (pair != m_effectNames->end()) {
+	if (itr != m_effectNames.end()) {
 		if (renderComponent == nullptr) {
-				GameMessages::SendPlayFXEffect(targetEntity, effectId, type, pair->second, secondary, 1, 1, true);
+			GameMessages::SendPlayFXEffect(targetEntity, effectId, type, itr->second, secondary, 1, 1, true);
 
 			return;
 		}
 
-			renderComponent->PlayEffect(effectId, type, pair->second, secondary);
+		renderComponent->PlayEffect(effectId, type, itr->second, secondary);
 
 		return;
 	}
-	}
 
 	// The SQlite result object becomes invalid if the query object leaves scope.
 	// So both queries are defined before the if statement
@@ -381,19 +377,19 @@ void Behavior::PlayFx(std::u16string type, const LWOOBJID target, const LWOOBJID
 		return;
 	}
 
-	const auto name = std::string(result.getStringField(0));
+	const auto name = std::string(result.getStringField("effectName"));
 
 	if (type.empty()) {
-		const auto typeResult = result.getStringField(1);
+		const auto typeResult = result.getStringField("effectType");
 
 		type = GeneralUtils::ASCIIToUTF16(typeResult);
 
-		m_effectType = new std::string(typeResult);
+		m_effectType = typeResult;
 	}
 
 	result.finalize();
 
-	m_effectNames->insert_or_assign(typeString, name);
+	m_effectNames.insert_or_assign(typeString, name);
 
 	if (renderComponent == nullptr) {
 		GameMessages::SendPlayFXEffect(targetEntity, effectId, type, name, secondary, 1, 1, true);
@@ -423,8 +419,7 @@ Behavior::Behavior(const uint32_t behaviorId) {
 
 	if (behaviorId == 0) {
 		this->m_effectId = 0;
-		this->m_effectHandle = nullptr;
-		this->m_templateId = BehaviorTemplates::BEHAVIOR_EMPTY;
+		this->m_templateId = BehaviorTemplate::EMPTY;
 	}
 
 	// Make sure we do not proceed if we are trying to load an invalid behavior
@@ -432,17 +427,16 @@ Behavior::Behavior(const uint32_t behaviorId) {
 		LOG("Failed to load behavior with id (%i)!", behaviorId);
 
 		this->m_effectId = 0;
-		this->m_effectHandle = nullptr;
-		this->m_templateId = BehaviorTemplates::BEHAVIOR_EMPTY;
+		this->m_templateId = BehaviorTemplate::EMPTY;
 
 		return;
 	}
 
-	this->m_templateId = static_cast<BehaviorTemplates>(templateInDatabase.templateID);
+	this->m_templateId = static_cast<BehaviorTemplate>(templateInDatabase.templateID);
 
 	this->m_effectId = templateInDatabase.effectID;
 
-	this->m_effectHandle = *templateInDatabase.effectHandle != "" ? new std::string(*templateInDatabase.effectHandle) : nullptr;
+	this->m_effectHandle = *templateInDatabase.effectHandle;
 }
 
 
@@ -487,10 +481,10 @@ std::map<std::string, float> Behavior::GetParameterNames() const {
 void Behavior::Load() {
 }
 
-void Behavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void Behavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 }
 
-void Behavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void Behavior::Sync(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 }
 
 void Behavior::UnCast(BehaviorContext* context, BehaviorBranchContext branch) {
@@ -502,14 +496,8 @@ void Behavior::Timer(BehaviorContext* context, BehaviorBranchContext branch, LWO
 void Behavior::End(BehaviorContext* context, BehaviorBranchContext branch, LWOOBJID second) {
 }
 
-void Behavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void Behavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 }
 
-void Behavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
-}
-
-Behavior::~Behavior() {
-	delete m_effectNames;
-	delete m_effectType;
-	delete m_effectHandle;
+void Behavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 }

dGame/dBehaviors/Behavior.h

@@ -6,7 +6,7 @@
 #include <unordered_map>
 
 #include "BitStream.h"
-#include "BehaviorTemplates.h"
+#include "BehaviorTemplate.h"
 #include "dCommonVars.h"
 
 struct BehaviorContext;
@@ -26,7 +26,7 @@ public:
 
 	static Behavior* CreateBehavior(uint32_t behaviorId);
 
-	static BehaviorTemplates GetBehaviorTemplate(uint32_t behaviorId);
+	static BehaviorTemplate GetBehaviorTemplate(uint32_t behaviorId);
 
 	/*
 	 * Utilities
@@ -39,11 +39,11 @@ public:
 	 */
 
 	uint32_t m_behaviorId;
-	BehaviorTemplates m_templateId;
+	BehaviorTemplate m_templateId;
 	uint32_t m_effectId;
-	std::string* m_effectHandle = nullptr;
-	std::unordered_map<std::string, std::string>* m_effectNames = nullptr;
-	std::string* m_effectType = nullptr;
+	std::string m_effectHandle;
+	std::unordered_map<std::string, std::string> m_effectNames;
+	std::string m_effectType;
 
 	/*
 	 * Behavior parameters
@@ -68,9 +68,9 @@ public:
 	virtual void Load();
 
 	// Player side
-	virtual void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	virtual void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
-	virtual void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	virtual void Sync(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
 	virtual void UnCast(BehaviorContext* context, BehaviorBranchContext branch);
 
@@ -79,14 +79,20 @@ public:
 	virtual void End(BehaviorContext* context, BehaviorBranchContext branch, LWOOBJID second);
 
 	// Npc side
-	virtual void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	virtual void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
-	virtual void SyncCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch);
+	virtual void SyncCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch);
 
 	/*
 	 * Creations/destruction
 	 */
 
 	explicit Behavior(uint32_t behaviorId);
-	virtual ~Behavior();
+	virtual ~Behavior() = default;
+
+	Behavior(const Behavior& other) = default;
+	Behavior(Behavior&& other) = default;
+
+	Behavior& operator=(const Behavior& other) = default;
+	Behavior& operator=(Behavior&& other) = default;
 };

dGame/dBehaviors/BehaviorContext.cpp

@@ -105,7 +105,7 @@ void BehaviorContext::ExecuteUpdates() {
 	this->scheduledUpdates.clear();
 }
 
-void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream* bitStream) {
+void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream& bitStream) {
 	BehaviorSyncEntry entry;
 	auto found = false;
 
@@ -243,27 +243,25 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
 		echo.uiBehaviorHandle = entry.handle;
 		echo.uiSkillHandle = this->skillUId;
 
-		auto* bitStream = new RakNet::BitStream();
+		RakNet::BitStream bitStream{};
 
 		// Calculate sync
 		entry.behavior->SyncCalculation(this, bitStream, entry.branchContext);
 
 		if (!clientInitalized) {
-			echo.sBitStream.assign(reinterpret_cast<char*>(bitStream->GetData()), bitStream->GetNumberOfBytesUsed());
+			echo.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
 
 			// Write message
 			RakNet::BitStream message;
 
 			BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 			message.Write(this->originator);
-			echo.Serialize(&message);
+			echo.Serialize(message);
 
-			Game::server->Send(&message, UNASSIGNED_SYSTEM_ADDRESS, true);
+			Game::server->Send(message, UNASSIGNED_SYSTEM_ADDRESS, true);
 		}
 
 		ExecuteUpdates();
-
-		delete bitStream;
 	}
 
 	std::vector<BehaviorSyncEntry> valid;

dGame/dBehaviors/BehaviorContext.h

@@ -93,7 +93,7 @@ struct BehaviorContext
 
 	void ExecuteUpdates();
 
-	void SyncBehavior(uint32_t syncId, RakNet::BitStream* bitStream);
+	void SyncBehavior(uint32_t syncId, RakNet::BitStream& bitStream);
 
 	void Update(float deltaTime);
 

dGame/dBehaviors/BehaviorTemplate.h

@@ -0,0 +1,70 @@
+#pragma once
+
+enum class BehaviorTemplate : unsigned int {
+	EMPTY, // Not a real behavior, indicates invalid behaviors
+	BASIC_ATTACK,
+	TAC_ARC,
+	AND,
+	PROJECTILE_ATTACK,
+	HEAL,
+	MOVEMENT_SWITCH,
+	AREA_OF_EFFECT,
+	PLAY_EFFECT,
+	IMMUNITY,
+	DAMAGE_BUFF,
+	DAMAGE_ABSORBTION,
+	OVER_TIME,
+	IMAGINATION,
+	TARGET_CASTER,
+	STUN,
+	DURATION,
+	KNOCKBACK,
+	ATTACK_DELAY,
+	CAR_BOOST,
+	FALL_SPEED,
+	SHIELD,
+	REPAIR_ARMOR,
+	SPEED,
+	DARK_INSPIRATION,
+	LOOT_BUFF,
+	VENTURE_VISION,
+	SPAWN_OBJECT,
+	LAY_BRICK,
+	SWITCH,
+	BUFF,
+	JETPACK,
+	SKILL_EVENT,
+	CONSUME_ITEM,
+	SKILL_CAST_FAILED,
+	IMITATION_SKUNK_STINK,
+	CHANGE_IDLE_FLAGS,
+	APPLY_BUFF,
+	CHAIN,
+	CHANGE_ORIENTATION,
+	FORCE_MOVEMENT,
+	INTERRUPT,
+	ALTER_COOLDOWN,
+	CHARGE_UP,
+	SWITCH_MULTIPLE,
+	START,
+	END,
+	ALTER_CHAIN_DELAY,
+	CAMERA,
+	REMOVE_BUFF,
+	GRAB,
+	MODULAR_BUILD,
+	NPC_COMBAT_SKILL,
+	BLOCK,
+	VERIFY,
+	TAUNT,
+	AIR_MOVEMENT,
+	SPAWN_QUICKBUILD,
+	PULL_TO_POINT,
+	PROPERTY_ROTATE,
+	DAMAGE_REDUCTION,
+	PROPERTY_TELEPORT,
+	PROPERTY_CLEAR_TARGET,
+	TAKE_PICTURE,
+	MOUNT,
+	SKILL_SET
+};

dGame/dBehaviors/BehaviorTemplates.cpp

@@ -1 +0,0 @@
-#include "BehaviorTemplates.h"

dGame/dBehaviors/BehaviorTemplates.h

@@ -1,70 +0,0 @@
-#pragma once
-
-enum class BehaviorTemplates : unsigned int {
-	BEHAVIOR_EMPTY, // Not a real behavior, indicates invalid behaviors
-	BEHAVIOR_BASIC_ATTACK,
-	BEHAVIOR_TAC_ARC,
-	BEHAVIOR_AND,
-	BEHAVIOR_PROJECTILE_ATTACK,
-	BEHAVIOR_HEAL,
-	BEHAVIOR_MOVEMENT_SWITCH,
-	BEHAVIOR_AREA_OF_EFFECT,
-	BEHAVIOR_PLAY_EFFECT,
-	BEHAVIOR_IMMUNITY,
-	BEHAVIOR_DAMAGE_BUFF,
-	BEHAVIOR_DAMAGE_ABSORBTION,
-	BEHAVIOR_OVER_TIME,
-	BEHAVIOR_IMAGINATION,
-	BEHAVIOR_TARGET_CASTER,
-	BEHAVIOR_STUN,
-	BEHAVIOR_DURATION,
-	BEHAVIOR_KNOCKBACK,
-	BEHAVIOR_ATTACK_DELAY,
-	BEHAVIOR_CAR_BOOST,
-	BEHAVIOR_FALL_SPEED,
-	BEHAVIOR_SHIELD,
-	BEHAVIOR_REPAIR_ARMOR,
-	BEHAVIOR_SPEED,
-	BEHAVIOR_DARK_INSPIRATION,
-	BEHAVIOR_LOOT_BUFF,
-	BEHAVIOR_VENTURE_VISION,
-	BEHAVIOR_SPAWN_OBJECT,
-	BEHAVIOR_LAY_BRICK,
-	BEHAVIOR_SWITCH,
-	BEHAVIOR_BUFF,
-	BEHAVIOR_JETPACK,
-	BEHAVIOR_SKILL_EVENT,
-	BEHAVIOR_CONSUME_ITEM,
-	BEHAVIOR_SKILL_CAST_FAILED,
-	BEHAVIOR_IMITATION_SKUNK_STINK,
-	BEHAVIOR_CHANGE_IDLE_FLAGS,
-	BEHAVIOR_APPLY_BUFF,
-	BEHAVIOR_CHAIN,
-	BEHAVIOR_CHANGE_ORIENTATION,
-	BEHAVIOR_FORCE_MOVEMENT,
-	BEHAVIOR_INTERRUPT,
-	BEHAVIOR_ALTER_COOLDOWN,
-	BEHAVIOR_CHARGE_UP,
-	BEHAVIOR_SWITCH_MULTIPLE,
-	BEHAVIOR_START,
-	BEHAVIOR_END,
-	BEHAVIOR_ALTER_CHAIN_DELAY,
-	BEHAVIOR_CAMERA,
-	BEHAVIOR_REMOVE_BUFF,
-	BEHAVIOR_GRAB,
-	BEHAVIOR_MODULAR_BUILD,
-	BEHAVIOR_NPC_COMBAT_SKILL,
-	BEHAVIOR_BLOCK,
-	BEHAVIOR_VERIFY,
-	BEHAVIOR_TAUNT,
-	BEHAVIOR_AIR_MOVEMENT,
-	BEHAVIOR_SPAWN_QUICKBUILD,
-	BEHAVIOR_PULL_TO_POINT,
-	BEHAVIOR_PROPERTY_ROTATE,
-	BEHAVIOR_DAMAGE_REDUCTION,
-	BEHAVIOR_PROPERTY_TELEPORT,
-	BEHAVIOR_PROPERTY_CLEAR_TARGET,
-	BEHAVIOR_TAKE_PICTURE,
-	BEHAVIOR_MOUNT,
-	BEHAVIOR_SKILL_SET
-};

dGame/dBehaviors/BlockBehavior.cpp

@@ -7,7 +7,7 @@
 #include "Logger.h"
 #include "DestroyableComponent.h"
 
-void BlockBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BlockBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	const auto target = context->originator;
 
 	auto* entity = Game::entityManager->GetEntity(target);
@@ -33,7 +33,7 @@ void BlockBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStrea
 	}
 }
 
-void BlockBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BlockBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	Handle(context, bitStream, branch);
 }
 

dGame/dBehaviors/BlockBehavior.h

@@ -13,9 +13,9 @@ public:
 	explicit BlockBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
 	}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void UnCast(BehaviorContext* context, BehaviorBranchContext branch) override;
 

dGame/dBehaviors/BuffBehavior.cpp

@@ -7,7 +7,7 @@
 #include "Logger.h"
 #include "DestroyableComponent.h"
 
-void BuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+void BuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	const auto target = branch.target != LWOOBJID_EMPTY ? branch.target : context->originator;
 
 	auto* entity = Game::entityManager->GetEntity(target);

dGame/dBehaviors/BuffBehavior.h

@@ -16,7 +16,7 @@ public:
 	explicit BuffBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
 	}
 
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+	void Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) override;
 
 	void UnCast(BehaviorContext* context, BehaviorBranchContext branch) override;