fix: coins dropping on killer (#1948)

tested that when a player dies the coins spawn on their body instead

.env.example

@@ -3,12 +3,20 @@ CLIENT_PATH=./client
 # Updates NET_VERSION in CMakeVariables.txt
 NET_VERSION=171022
 # make sure this is a long random string
-# grab a "SHA 256-bit Key" from here: https://keygen.io/
+# generate a "SHA 256-bit Key" from here: https://gchq.github.io/CyberChef/#recipe=Pseudo-Random_Number_Generator(256,'Hex')
 ACCOUNT_MANAGER_SECRET=
 # Should be the externally facing IP of your server host
 EXTERNAL_IP=localhost
+
+# The database type that will be used.
+# Acceptable values are `sqlite`, `mysql`, `mariadb`, `maria`.
+# Case insensitive.
+DATABASE_TYPE=mariadb
+SQLITE_DATABASE_PATH=resServer/dlu.sqlite
+
 # Database values
 # Be careful with special characters here. It is more safe to use normal characters and/or numbers.
 MARIADB_USER=darkflame
 MARIADB_PASSWORD=
 MARIADB_DATABASE=darkflame
+SKIP_ACCOUNT_CREATION=1

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -16,7 +16,10 @@ body:
             I have validated that this issue is not a syntax error of either MySQL or SQLite.
           required: true
         - label: >
-            I have pulled the latest version of the main branch of DarkflameServer and have confirmed that the issue exists there.
+            I have downloaded/pulled the latest version of the main branch of DarkflameServer and have confirmed that the issue exists there.
+          required: true
+        - label: >
+            I have verified that my boot.cfg is configured as per the [README](https://github.com/DarkflameUniverse/DarkflameServer?tab=readme-ov-file#allowing-a-user-to-connect-to-your-server).
           required: true
   - type: input
     id: server-version

.github/copilot-instructions.md

@@ -0,0 +1,29 @@
+# GitHub Copilot Instructions
+
+ * c++20 standard, please use the latest features except NO modules.
+   * use `.contains` for searching in associative containers
+ * use const as much as possible.  If it can be const, it should be made const
+ * DO NOT USE const_cast EVER.
+ * use `cstdint` bitwidth types ALWAYS for integral types.
+ * NEVER use std::wstring. If wide strings are necessary, use std::u16string with conversion utilties in GeneralUtils.h.
+ * Functions are ALWAYS PascalCase.
+ * local variables are camelCase
+ * NEVER use snake case
+ * indentation is TABS, not SPACES.
+ * TABS are 4 spaces by default
+ * Use trailing braces ALWAYS
+ * global variables are prefixed with `g_`
+ * if global variables or functions are needed, they should be located in an anonymous namespace
+ * Use `GeneralUtils::TryParse` for ANY parsing of strings to integrals.
+ * Use brace initialization when possible.
+ * ALWAYS default initialize variables.
+ * Pointers should be avoided unless necessary. Use references when the pointer has been checked and should not be null
+ * headers should be as compact as possible. Do NOT include extra data that isnt needed.
+ * Remember to include logs (LOG macro uses printf style logging) while putting verbose logs under LOG_DEBUG.
+ * NEVER USE `RakNet::BitStream::ReadBit`
+ * NEVER assume pointers are good, always check if they are null. Once a pointer is checked and is known to be non-null, further accesses no longer need checking
+ * Be wary of TOCTOU. Prevent all possible issues relating to TOCTOU.
+ * new memory allocations should never be used unless absolutely necessary.
+    * new for reconstruction of objects is allowed
+ * Prefer following the format of the file over correct formatting.  Consistency over correctness.
+ * When using auto, ALWAYS put a * for pointers.

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

@@ -16,12 +16,12 @@ jobs:
         os: [ windows-2022, ubuntu-22.04, macos-13 ]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
       with:
         submodules: true
     - name: Add msbuild to PATH (Windows only)
       if: ${{ matrix.os == 'windows-2022' }}
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@767f00a3f09872d96a0cb9fcd5e6a4ff33311330
       with:
         vs-version: '[17,18)'
         msbuild-architecture: x64
@@ -30,12 +30,16 @@ jobs:
       run: |
         brew install openssl@3
         sudo xcode-select -s /Applications/Xcode_15.2.app/Contents/Developer
+    - name: Get CMake 3.x
+      uses: lukka/get-cmake@28983e0d3955dba2bb0a6810caae0c6cf268ec0c
+      with:
+        cmakeVersion: "~3.25.0"  # <--= optional, use most recent 3.25.x version
     - name: cmake
-      uses: lukka/run-cmake@v10
+      uses: lukka/run-cmake@67c73a83a46f86c4e0b96b741ac37ff495478c38
       with:
         workflowPreset: "ci-${{matrix.os}}"
     - name: artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
       with:
         name: build-${{matrix.os}}
         path: |
@@ -43,6 +47,7 @@ jobs:
           build/*/*.ini
           build/*/*.so
           build/*/*.dll
+          build/*/*.dylib
           build/*/vanity/
           build/*/navmeshes/
           build/*/migrations/

.gitignore

@@ -6,7 +6,6 @@ docker/configs
 # Third party libraries
 thirdparty/mysql/
 thirdparty/mysql_linux/
-CMakeVariables.txt
 
 # Build folders
 build/
@@ -95,6 +94,7 @@ ipch/
 
 # Exceptions:
 CMakeSettings.json
+CMakeUserPresets.json
 *.vcxproj
 *.filters
 *.cmake

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "thirdparty/cpp-httplib"]
-	path = thirdparty/cpp-httplib
-	url = https://github.com/yhirose/cpp-httplib
 [submodule "thirdparty/tinyxml2"]
 	path = thirdparty/tinyxml2
 	url = https://github.com/leethomason/tinyxml2

CMakeLists.txt

@@ -19,6 +19,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 	# Export the compile commands for debuggi
 set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) 	# Set CMAKE visibility policy to NEW on project and subprojects
 set(CMAKE_VISIBILITY_INLINES_HIDDEN ON) # Set C and C++ symbol visibility to hide inlined functions
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+set(FETCHCONTENT_QUIET FALSE) # GLM takes a long time to clone, this will at least show _something_ while its downloading
 
 # Read variables from file
 FILE(READ "${CMAKE_SOURCE_DIR}/CMakeVariables.txt" variables)
@@ -66,6 +67,7 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
+	add_link_options("-Wl,-rpath,$ORIGIN/")
 	add_compile_options("-fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)
 
@@ -174,16 +176,18 @@ foreach(resource_file ${RESOURCE_FILES})
 				list(GET line_split 0 variable_name)
 
 				if(NOT ${parsed_current_file_contents} MATCHES ${variable_name})
-					message(STATUS "Adding missing config option " ${variable_name} " to " ${resource_file})
+					# For backwards compatibility with older setup versions, dont add this option.
-					set(line_to_add ${line_to_add} ${line})
+					if(NOT ${variable_name} MATCHES "database_type")
+						message(STATUS "Adding missing config option " ${variable_name} " to " ${resource_file})
+						set(line_to_add ${line_to_add} ${line})
 
-					foreach(line_to_append ${line_to_add})
+						foreach(line_to_append ${line_to_add})
-						file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
+							file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
-					endforeach()
+						endforeach()
 
-					file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n")
+						file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n")
+					endif()
 				endif()
-
 				set(line_to_add "")
 			else()
 				set(line_to_add ${line_to_add} ${line})
@@ -213,21 +217,8 @@ foreach(file ${VANITY_FILES})
 endforeach()
 
 # Move our migrations for MasterServer to run
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/dlu/)
+file(REMOVE_RECURSE ${PROJECT_BINARY_DIR}/migrations)
-file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/dlu/*.sql)
+file(COPY ${CMAKE_SOURCE_DIR}/migrations DESTINATION ${CMAKE_BINARY_DIR})
-
-foreach(file ${SQL_FILES})
-	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${PROJECT_BINARY_DIR}/migrations/dlu/${file})
-endforeach()
-
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/cdserver/)
-file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/cdserver/*.sql)
-
-foreach(file ${SQL_FILES})
-	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/cdserver/${file} ${PROJECT_BINARY_DIR}/migrations/cdserver/${file})
-endforeach()
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
@@ -245,6 +236,8 @@ include_directories(
 
 	"dNet"
 
+	"dWeb"
+
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
@@ -257,8 +250,9 @@ include_directories(
 	"thirdparty/recastnavigation"
 	"thirdparty/SQLite"
 	"thirdparty/cpplinq"
-	"thirdparty/cpp-httplib"
 	"thirdparty/MD5"
+	"thirdparty/nlohmann"
+	"thirdparty/mongoose"
 )
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -310,9 +304,10 @@ add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)
 add_subdirectory(dPhysics)
 add_subdirectory(dServer)
+add_subdirectory(dWeb)
 
 # Create a list of common libraries shared between all binaries
-set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "MariaDB::ConnCpp" "magic_enum")
+set(COMMON_LIBRARIES glm::glm "dCommon" "dDatabase" "dNet" "raknet" "magic_enum")
 
 # Add platform specific common libraries
 if(UNIX)

CMakePresets.json

@@ -11,9 +11,6 @@
 			"displayName": "Default configure step",
 			"description": "Use 'build' dir and Unix makefiles",
 			"binaryDir": "${sourceDir}/build",
-			"environment": {
-				"DLU_CONFIG_DIR": "${sourceDir}/build"
-			},
 			"generator": "Unix Makefiles"
 		},
 		{

CMakeVariables.txt

@@ -1,5 +1,5 @@
-PROJECT_VERSION_MAJOR=2
+PROJECT_VERSION_MAJOR=3
-PROJECT_VERSION_MINOR=3
+PROJECT_VERSION_MINOR=0
 PROJECT_VERSION_PATCH=0
 
 # Debugging

Dockerfile

@@ -11,7 +11,12 @@ COPY --chmod=0500 ./build.sh /app/
 
 RUN sed -i 's/MARIADB_CONNECTOR_COMPILE_JOBS__=.*/MARIADB_CONNECTOR_COMPILE_JOBS__=2/' /app/CMakeVariables.txt 
 
-RUN ./build.sh
+RUN --mount=type=cache,target=/app/build,id=build-cache \
+    mkdir -p /app/build /tmp/persisted-build && \
+    cd /app/build && \
+    cmake .. && \
+    make -j$(nproc --ignore 1) && \
+    cp -r /app/build/* /tmp/persisted-build/
 
 FROM debian:12 as runtime
 
@@ -23,23 +28,23 @@ RUN --mount=type=cache,id=build-apt-cache,target=/var/cache/apt \
     rm -rf /var/lib/apt/lists/*
 
 # Grab libraries and load them
-COPY --from=build /app/build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
+COPY --from=build /tmp/persisted-build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
 RUN ldconfig
 
 # Server bins
-COPY --from=build /app/build/*Server /app/
+COPY --from=build /tmp/persisted-build/*Server /app/
 
 # Necessary suplimentary files
-COPY --from=build /app/build/*.ini /app/configs/
+COPY --from=build /tmp/persisted-build/*.ini /app/configs/
-COPY --from=build /app/build/vanity/*.* /app/vanity/
+COPY --from=build /tmp/persisted-build/vanity/*.* /app/vanity/
-COPY --from=build /app/build/navmeshes /app/navmeshes
+COPY --from=build /tmp/persisted-build/navmeshes /app/navmeshes
-COPY --from=build /app/build/migrations /app/migrations
+COPY --from=build /tmp/persisted-build/migrations /app/migrations
-COPY --from=build /app/build/*.dcf /app/
+COPY --from=build /tmp/persisted-build/*.dcf /app/
 
 # backup of config and vanity files to copy to the host incase 
 # of a mount clobbering the copy from above
-COPY --from=build /app/build/*.ini /app/default-configs/ 
+COPY --from=build /tmp/persisted-build/*.ini /app/default-configs/ 
-COPY --from=build /app/build/vanity/*.* /app/default-vanity/
+COPY --from=build /tmp/persisted-build/vanity/*.* /app/default-vanity/
 
 # needed as the container runs with the root user
 # and therefore sudo doesn't exist

README.md

@@ -13,21 +13,35 @@ Darkflame Universe is licensed under AGPLv3, please read [LICENSE](LICENSE). Som
 * You must disclose any changes you make to the code when you distribute it
 * Hosting a server for others counts as distribution
 
-## Disclaimers
-### Setup difficulty
-Throughout the entire build and setup process a level of familiarity with the command line and preferably a Unix-like development environment is greatly advantageous.
-
 ### Hosting a server
 We do not recommend hosting public servers. Darkflame Universe is intended for small scale deployment, for example within a group of friends. It has not been tested for large scale deployment which comes with additional security risks.
 
 ### Supply of resource files
 Darkflame Universe is a server emulator and does not distribute any LEGO® Universe files. A separate game client is required to setup this server emulator and play the game, which we cannot supply. Users are strongly suggested to refer to the safe checksums listed [here](#verifying-your-client-files) to see if a client will work.
 
-## Step by step walkthrough for a single-player server
+## Setting up a single player server
-If you would like a setup for a single player server only on a Windows machine, use the [Native Windows Setup Guide by HailStorm](https://gist.github.com/HailStorm32/169df65a47a104199b5cc57d10fa57de) and skip this README.
+* If you don't know what WSL is, skip this warning.
+	Warning: WSL version 1 does NOT support using sqlite as a database due to how it handles filesystem synchronization.
+	You must use Version 2 if you must run the server under WSL. Not doing so will result in save data loss.
+* Single player installs now no longer require building the server from source or installing development tools.
+* Download the [latest windows release](https://github.com/DarkflameUniverse/DarkflameServer/releases) (or whichever release you need) and extract the files into a folder inside your client. Note that this setup is expecting that when double clicking the folder that you put in the same folder as `legouniverse.exe`, the file `MasterServer.exe` is in there.
+* You should be able to see the folder with the server files in the same folder as `legouniverse.exe`.
+* Go into the server files folder and open `sharedconfig.ini`. Find the line that says `client_location` and put `..` after it so the line reads `client_location=..`.
+* To run the server, double-click `MasterServer.exe`.
+* You will be asked to create an account the first time you run the server. After you have created the account, the server will shutdown and need to be restarted.
+* To connect to the server, either delete the file `boot.cfg` which is found in your LEGO Universe client, rename the file `boot.cfg` to something else or follow the steps [here](#allowing-a-user-to-connect-to-your-server) if you wish to keep the file.
+* When shutting down the server, it is highly recommended to click the `MasterServer.exe` window and hold `ctrl` while pressing `c` to stop the server.
+* We are working on a way to make it so when you close the game, the server stops automatically alongside when you open the game, the server starts automatically.
+* If you are not setting a server up on mac, you can ignore this note
+* Note: you'll need to allow through System Preferences `AuthServer`, `ChatServer`, `MasterServer`, `WorldServer` and `libmariadbcpp.dylib` to run.  The initial pop-up will block it due to the binaries being unsigned, after allowing them to run the servers will run as normal.
 
-## Steps to setup server
+<font size="32">**If you are not planning on hosting a server for others, working in the codebase or wanting to use MariaDB for a database, you can stop reading here.**</font>
+
+If you would like to use a MariaDB as a database instead of the default of sqlite, follow the steps [here](#database-setup).
+
+# Steps to setup a development environment
 * [Clone this repository](#clone-the-repository)
+* [Setting up a development environment](#setting-up-a-development-environment)
 * [Install dependencies](#install-dependencies)
 * [Database setup](#database-setup)
 * [Build the server](#build-the-server)
@@ -39,6 +53,13 @@ If you would like a setup for a single player server only on a Windows machine,
 * [User Guide](#user-guide)
 * [Docker](#docker)
 
+## Disclaimers
+### Setup difficulty
+Throughout the entire build and setup process a level of familiarity with the command line and preferably a Unix-like development environment is greatly advantageous.
+
+## Step by step walkthrough for building a single-player Windows server from source
+If you would like a setup for a single player server only on a Windows machine built from source, use the [Native Windows Setup Guide by HailStorm](https://gist.github.com/HailStorm32/169df65a47a104199b5cc57d10fa57de) and skip this README.
+
 ## Clone the repository
 If you are on Windows, you will need to download and install git from [here](https://git-scm.com/download/win)
 
@@ -49,9 +70,15 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 ## Install dependencies
 
+### Required compiler versions
+- g++11 or greater
+- MSVC unchecked
+- clang unchecked
+- appleclang unchecked
+
 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (<font size="4">**version 3.25**</font> up to <font size="4">**version 3.31**</font>!).
 
 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.
@@ -73,7 +100,7 @@ sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-serve
 ```
 
 #### Required CMake version
-This project uses <font size="4">**CMake version 3.25**</font> or higher and as such you will need to ensure you have this version installed.
+This project uses <font size="4">**CMake version 3.25**</font> up to <font size="4">**version 3.31**</font> 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
@@ -160,7 +187,8 @@ Now that you are logged in, run the following commands.
 ```bash
 # Creates a user for this computer which uses a password and grant said user all privileges.
 # Change mydarkflameuser to a custom username and password to a custom password. 
-GRANT ALL ON *.* TO 'mydarkflameuser'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
+CREATE USER 'mydarkflameuser'@'localhost' IDENTIFIED BY 'password';
+GRANT ALL ON *.* TO 'mydarkflameuser'@'localhost' WITH GRANT OPTION;
 FLUSH PRIVILEGES;
 
 # Then create a database for Darkflame Universe to use.
@@ -183,6 +211,7 @@ If you would like to build the server faster, append `-j<number>` where number i
 ### Notes
 Depending on your operating system, you may need to adjust some pre-processor defines in [CMakeVariables.txt](./CMakeVariables.txt) before building:
 * If you are on MacOS, ensure OPENSSL_ROOT_DIR is pointing to the openssl root directory.
+* By default it should be set to the correct directory.
 * If you are using a Darkflame Universe client, ensure `client_net_version` in `build/sharedconfig.ini` is changed to 171023.
 
 ## Configuring your server
@@ -205,28 +234,41 @@ Navigate to `build/sharedconfig.ini` and fill in the following fields:
 * `chatconfig.ini` contains a port option.
 * `masterconfig.ini` contains options related to permissions you want to run your servers with.
 * `sharedconfig.ini` contains several options that are shared across all servers
-* `worldconfig.ini` contains several options to turn on QOL improvements should you want them. If you would like the most vanilla experience possible, you will need to turn some of these settings off.
+* `worldconfig.ini` contains several options to turn on Quality of Life improvements should you want them. If you would like the most vanilla experience possible, you will need to turn some of these settings off.
 
 ## Verify your setup
-Your build directory should now look like this:
+Your build directory should contain at a minimum all of the following files.
-* AuthServer
+All listed files are required for a server to start.
-* ChatServer
+`ini` files can be located at the environment variable `DLU_CONFIG_DIR` and do not need to be located in this directory.
-* MasterServer
+(windows will have .exe at the end of the executables):
-* WorldServer
-* authconfig.ini
-* chatconfig.ini
-* masterconfig.ini
 * sharedconfig.ini
+* AuthServer(.exe)
+* authconfig.ini
+* ChatServer(.exe)
+* chatconfig.ini
+* MasterServer(.exe)
+* masterconfig.ini
+* WorldServer(.exe)
 * worldconfig.ini
-* ...
+* blocklist.dcf
+* migrations
+* vanity
+* navmeshes
+* 1 of the following lists based on platform
+	* windows
+		* libmariadb.dll
+		* mariadbcpp.dll
+		* zlib.dll
+	* MacOS
+		* libmariadbcpp.dylib
+	* *nix
+		* libmariadbcpp.so
 
 ## Running the server
-If everything has been configured correctly you should now be able to run the `MasterServer` binary which is located in the `build` directory. Darkflame Universe utilizes port numbers under 1024, so under Linux you either have to give the `AuthServer` binary network permissions or run it under sudo.
+If everything has been configured correctly you should now be able to run the `MasterServer` binary which is located in the `build` directory. Darkflame Universe utilizes port numbers under 1024, so under Linux you have to give the `AuthServer` binary network permissions by running the following command:
-To give `AuthServer` network permissions and not require sudo, run the following command
 ```bash
 sudo setcap 'cap_net_bind_service=+ep' AuthServer
 ```
-and then go to `build/masterconfig.ini` and change `use_sudo_auth` to 0.
 
 ### Linux Service
 If you are running this on a linux based system, it will use your terminal to run the program interactively, preventing you using it for other tasks and requiring it to be open to run the server.  
@@ -266,8 +308,8 @@ systemctl stop darkflame.service
 journalctl -xeu darkflame.service
 ```
 
-### First admin user
+### First user or adding more users.
-Run `MasterServer -a` to get prompted to create an admin account. This method is only intended for the system administrator as a means to get started, do NOT use this method to create accounts for other users!
+The first time you run `MasterServer`, you will be prompted to create an account. To create more accounts from the command line, `MasterServer -a` to get prompted to create an admin account. This method is only intended for the system administrator as a means to get started, do NOT use this method to create accounts for other users!
 
 ### Account management tool (Nexus Dashboard)
 **If you are just using this server for yourself, you can skip setting up Nexus Dashboard**
@@ -283,14 +325,22 @@ While a character has a gmlevel of anything but `0`, some gameplay behavior will
 Some changes to the client `boot.cfg` file are needed to play on your server.
 
 ## Allowing a user to connect to your server
+**ALL OF THESE CHANGES ARE REQUIRED. PLEASE FULLY READ THIS SECTION**
+
 To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
-* Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
+* Open `boot.cfg` in a text editor and locate the line `UGCUSE3DSERVICES=7:`
-* Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
-* Next locate the line `UGCUSE3DSERVICES=7:`
 * Ensure the number after the 7 is a `0`
+* Alternatively, remove the line with `UGCUSE3DSERVICES` altogether
+* Next locate where it says `AUTHSERVERIP=0:`
+* Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
 * Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
 * Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.
+As an example, here is what the boot.cfg is required to contain for a server with the ip 12.34.56.78
+```cfg
+AUTHSERVERIP=0:12.34.56.78,
+UGCUSE3DSERVICES=7:0
+```
 
 ## Updating your server
 To update your server to the latest version navigate to your cloned directory
@@ -307,6 +357,10 @@ Now follow the [build](#build-the-server) section for your system and your serve
 ## In-game commands
 * A list of all in-game commands can be found [here](./docs/Commands.md).
 
+## Chat Web API
+* The Chat server has an API that can be enabled via `chatconfig.ini`.
+* You can view the OpenAPI doc for the API here [here](./docs/ChatWebAPI.yaml).
+
 ## Verifying your client files
 
 ### LEGO® Universe 1.10.64
@@ -371,7 +425,7 @@ at once. For that:
 - Download the [.env.example](.env.example) file and place it next to `client` with the file name `.env`
   - You may get warnings that this name starts with a dot, acknowledge those, this is intentional. Depending on your operating system, you may need to activate showing hidden files (e.g. Ctrl-H in Gnome on Linux) and/or file extensions ("File name extensions" in the "View" tab on Windows).
   - Update the `ACCOUNT_MANAGER_SECRET` and `MARIADB_PASSWORD` with strong random passwords.
-    - Use a password generator like <https://keygen.io>
+    - Use a password generator <https://gchq.github.io/CyberChef/#recipe=Pseudo-Random_Number_Generator(256,'Hex')>
     - Avoid `:` and `@` characters
     - Once the database user is created, changing the password will not update it, so the server will just fail to connect.
   - Set `EXTERNAL_IP` to your LAN IP or public IP if you want to host the game for friends & family

cmake/FindGoogleTest.cmake

@@ -6,6 +6,8 @@ FetchContent_Declare(
 	googletest
 	GIT_REPOSITORY https://github.com/google/googletest.git
 	GIT_TAG release-1.12.1
+	GIT_PROGRESS TRUE
+	GIT_SHALLOW 1
 )
 
 # For Windows: Prevent overriding the parent project's compiler/linker settings

dAuthServer/AuthServer.cpp

@@ -20,14 +20,13 @@
 
 //Auth includes:
 #include "AuthPackets.h"
-#include "eConnectionType.h"
+#include "ServiceType.h"
 #include "MessageType/Server.h"
 #include "MessageType/Auth.h"
 
 #include "Game.h"
 #include "Server.h"
 
-
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -53,6 +52,7 @@ int main(int argc, char** argv) {
 	//Create all the objects we need to run our service:
 	Server::SetupLogger("AuthServer");
 	if (!Game::logger) return EXIT_FAILURE;
+	Game::config->LogSettings();
 
 	LOG("Starting Auth server...");
 	LOG("Version: %s", PROJECT_VERSION);
@@ -60,7 +60,7 @@ int main(int argc, char** argv) {
 
 	try {
 		Database::Connect();
-	} catch (sql::SQLException& ex) {
+	} catch (std::exception& ex) {
 		LOG("Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("AuthServer");
 		delete Game::server;
@@ -71,12 +71,15 @@ int main(int argc, char** argv) {
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1500;
+	std::string masterPassword;
 
 	auto masterInfo = Database::Get()->GetMasterInfo();
 	if (masterInfo) {
 		masterIP = masterInfo->ip;
 		masterPort = masterInfo->port;
+		masterPassword = masterInfo->password;
 	}
+
 	LOG("Master is at %s:%d", masterIP.c_str(), masterPort);
 
 	Game::randomEngine = std::mt19937(time(0));
@@ -90,7 +93,7 @@ int main(int argc, char** argv) {
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;
 
-	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth, Game::config, &Game::lastSignal);
+	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServiceType::AUTH, Game::config, &Game::lastSignal, masterPassword);
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
@@ -165,11 +168,11 @@ void HandlePacket(Packet* packet) {
 	if (packet->length < 4) return;
 
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
+		if (static_cast<ServiceType>(packet->data[1]) == ServiceType::COMMON) {
 			if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
-		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
+		} else if (static_cast<ServiceType>(packet->data[1]) == ServiceType::AUTH) {
 			if (static_cast<MessageType::Auth>(packet->data[3]) == MessageType::Auth::LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}

dAuthServer/CMakeLists.txt

@@ -1,7 +1,4 @@
 add_executable(AuthServer "AuthServer.cpp")
-
 target_link_libraries(AuthServer ${COMMON_LIBRARIES} dServer)
-
 target_include_directories(AuthServer PRIVATE ${PROJECT_SOURCE_DIR}/dServer)
-
 add_compile_definitions(AuthServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")

dChatFilter/CMakeLists.txt

@@ -1,4 +1,4 @@
 set(DCHATFILTER_SOURCES "dChatFilter.cpp")
 
 add_library(dChatFilter STATIC ${DCHATFILTER_SOURCES})
-target_link_libraries(dChatFilter dDatabase)
+target_link_libraries(dChatFilter dDatabase glm::glm)

dChatFilter/dChatFilter.cpp

@@ -105,7 +105,7 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowLis
 	}
 }
 
-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
+std::set<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 (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
@@ -114,7 +114,7 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 	std::string segment;
 	std::regex reg("(!*|\\?*|\\;*|\\.*|\\,*)");
 
-	std::vector<std::pair<uint8_t, uint8_t>> listOfBadSegments = std::vector<std::pair<uint8_t, uint8_t>>();
+	std::set<std::pair<uint8_t, uint8_t>> listOfBadSegments;
 
 	uint32_t position = 0;
 
@@ -127,17 +127,17 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 		size_t hash = CalculateHash(segment);
 
 		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
-			listOfBadSegments.emplace_back(position, originalSegment.length());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		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());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		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());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		position += originalSegment.length() + 1;

dChatFilter/dChatFilter.h

@@ -24,7 +24,7 @@ public:
 	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);
+	std::set<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/CMakeLists.txt

@@ -1,16 +1,19 @@
 set(DCHATSERVER_SOURCES
 	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
+	"ChatJSONUtils.cpp"
+	"ChatWeb.cpp"
 	"PlayerContainer.cpp"
+	"TeamContainer.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
-target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
+target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter" "${PROJECT_SOURCE_DIR}/dWeb")
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
 add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
+target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer" "${PROJECT_SOURCE_DIR}/dChatFilter")
 
-target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
+target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter glm::glm)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose dWeb)
 

dChatServer/ChatIgnoreList.cpp

@@ -12,12 +12,12 @@
 // not allowing teams, rejecting DMs, friends requets etc.
 // 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) {
+void WriteOutgoingReplyHeader(RakNet::BitStream& bitStream, const LWOOBJID& receivingPlayer, const MessageType::Client type) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT,  MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receivingPlayer);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, type);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, type);
 }
 
 void ChatIgnoreList::GetIgnoreList(Packet* packet) {
@@ -34,7 +34,7 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 	if (!receiver.ignoredPlayers.empty()) {
 		LOG_DEBUG("Player %llu already has an ignore list, but is requesting it again.", playerId);
 	} else {
-		auto ignoreList = Database::Get()->GetIgnoreList(static_cast<uint32_t>(playerId));
+		auto ignoreList = Database::Get()->GetIgnoreList(playerId);
 		if (ignoreList.empty()) {
 			LOG_DEBUG("Player %llu has no ignores", playerId);
 			return;
@@ -43,14 +43,13 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 		for (auto& ignoredPlayer : ignoreList) {
 			receiver.ignoredPlayers.emplace_back(ignoredPlayer.name, ignoredPlayer.id);
 			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::PERSISTENT);
 		}
 	}
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::GET_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, MessageType::Client::GET_IGNORE_LIST_RESPONSE);
 
-	bitStream.Write<uint8_t>(false); // Probably is Is Free Trial, but we don't care about that
+	bitStream.Write<uint8_t>(false); // Is Free Trial, but we don't care about that
 	bitStream.Write<uint16_t>(0); // literally spacing due to struct alignment
 
 	bitStream.Write<uint16_t>(receiver.ignoredPlayers.size());
@@ -86,7 +85,7 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 	std::string toIgnoreStr = toIgnoreName.GetAsString();
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::ADD_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, MessageType::Client::ADD_IGNORE_RESPONSE);
 
 	// Check if the player exists
 	LWOOBJID ignoredPlayerId = LWOOBJID_EMPTY;
@@ -114,9 +113,8 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 		}
 
 		if (ignoredPlayerId != LWOOBJID_EMPTY) {
-			Database::Get()->AddIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(ignoredPlayerId));
+			Database::Get()->AddIgnore(playerId, ignoredPlayerId);
 			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::PERSISTENT);
 
 			receiver.ignoredPlayers.emplace_back(toIgnoreStr, ignoredPlayerId);
 			LOG_DEBUG("Player %llu is ignoring %s", playerId, toIgnoreStr.c_str());
@@ -157,11 +155,11 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 		return;
 	}
 
-	Database::Get()->RemoveIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(toRemove->playerId));
+	Database::Get()->RemoveIgnore(playerId, toRemove->playerId);
 	receiver.ignoredPlayers.erase(toRemove, receiver.ignoredPlayers.end());
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::REMOVE_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, MessageType::Client::REMOVE_IGNORE_RESPONSE);
 
 	bitStream.Write<int8_t>(0);
 	LUWString playerNameSend(removedIgnoreStr, 33);

dChatServer/ChatIgnoreList.h

@@ -5,17 +5,16 @@ struct Packet;
 
 #include <cstdint>
 
+/**
+ * @brief The ignore list allows players to ignore someone silently. Requests will generally be blocked by the client, but they should also be checked
+ * on the server as well so the sender can get a generic error code in response.
+ *
+ */
 namespace ChatIgnoreList {
 	void GetIgnoreList(Packet* packet);
 	void AddIgnore(Packet* packet);
 	void RemoveIgnore(Packet* packet);
 
-	enum class Response : uint8_t {
-		ADD_IGNORE = 32,
-		REMOVE_IGNORE = 33,
-		GET_IGNORE = 34,
-	};
-
 	enum class AddResponse : uint8_t {
 		SUCCESS,
 		ALREADY_IGNORED,

dChatServer/ChatJSONUtils.cpp

@@ -0,0 +1,49 @@
+#include "ChatJSONUtils.h"
+
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+void to_json(json& data, const PlayerData& playerData) {
+	data["id"] = playerData.playerID;
+	data["name"] = playerData.playerName;
+	data["gm_level"] = playerData.gmLevel;
+	data["muted"] = playerData.GetIsMuted();
+
+	auto& zoneID = data["zone_id"];
+	zoneID["map_id"] = playerData.zoneID.GetMapID();
+	zoneID["instance_id"] = playerData.zoneID.GetInstanceID();
+	zoneID["clone_id"] = playerData.zoneID.GetCloneID();
+}
+
+void to_json(json& data, const PlayerContainer& playerContainer) {
+	data = json::array();
+	for (auto& playerData : playerContainer.GetAllPlayers()) {
+		if (playerData.first == LWOOBJID_EMPTY) continue;
+		data.push_back(playerData.second);
+	}
+}
+
+void to_json(json& data, const TeamData& teamData) {
+	data["id"] = teamData.teamID;
+	data["loot_flag"] = teamData.lootFlag;
+	data["local"] = teamData.local;
+
+	auto& leader = Game::playerContainer.GetPlayerData(teamData.leaderID);
+	data["leader"] = leader.playerName;
+
+	auto& members = data["members"];
+	for (auto& member : teamData.memberIDs) {
+		auto& playerData = Game::playerContainer.GetPlayerData(member);
+
+		if (!playerData) continue;
+		members.push_back(playerData);
+	}
+}
+
+void TeamContainer::to_json(json& data, const TeamContainer::Data& teamContainer) {
+	for (auto& teamData : TeamContainer::GetTeams()) {
+		if (!teamData) continue;
+		data.push_back(*teamData);
+	}
+}

dChatServer/ChatJSONUtils.h

@@ -0,0 +1,18 @@
+#ifndef __CHATJSONUTILS_H__
+#define __CHATJSONUTILS_H__
+
+#include "json_fwd.hpp"
+#include "PlayerContainer.h"
+#include "TeamContainer.h"
+
+/* Remember, to_json needs to be in the same namespace as the class its located in */
+
+void to_json(nlohmann::json& data, const PlayerData& playerData);
+void to_json(nlohmann::json& data, const PlayerContainer& playerContainer);
+void to_json(nlohmann::json& data, const TeamData& teamData);
+
+namespace TeamContainer {
+	void to_json(nlohmann::json& data, const TeamContainer::Data& teamData);
+};
+
+#endif // !__CHATJSONUTILS_H__

dChatServer/ChatPacketHandler.cpp

@@ -12,13 +12,14 @@
 #include "RakString.h"
 #include "dConfig.h"
 #include "eObjectBits.h"
-#include "eConnectionType.h"
+#include "ServiceType.h"
 #include "MessageType/Chat.h"
 #include "MessageType/Client.h"
 #include "MessageType/Game.h"
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
 #include "ChatPackets.h"
+#include "TeamContainer.h"
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
@@ -34,7 +35,6 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = friendData.friendID;
-		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
 		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
 
 		fd.isBestFriend = friendData.isBestFriend; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
@@ -49,7 +49,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 			fd.zoneID = fr.zoneID;
 
 			//Since this friend is online, we need to update them on the fact that we've just logged in:
-			SendFriendUpdate(fr, player, 1, fd.isBestFriend);
+			if (player.isLogin) SendFriendUpdate(fr, player, 1, fd.isBestFriend);
 		} else {
 			fd.isOnline = false;
 			fd.zoneID = LWOZONEID();
@@ -60,11 +60,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::GET_FRIENDS_LIST_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
 	bitStream.Write<uint16_t>(player.friends.size());
@@ -73,7 +73,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		data.Serialize(bitStream);
 	}
 
-	SystemAddress sysAddr = player.sysAddr;
+	SystemAddress sysAddr = player.worldServerSysAddr;
 	SEND_PACKET;
 }
 
@@ -103,7 +103,8 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		return;
 	};
 
-	auto& requestee = Game::playerContainer.GetPlayerDataMutable(playerName);
+	// Intentional copy
+	PlayerData requestee = Game::playerContainer.GetPlayerData(playerName);
 
 	// Check if player is online first
 	if (isBestFriendRequest && !requestee) {
@@ -121,7 +122,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			requesteeFriendData.isOnline = false;
 			requesteeFriendData.zoneID = requestor.zoneID;
 			requestee.friends.push_back(requesteeFriendData);
-			requestee.sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
+			requestee.worldServerSysAddr = UNASSIGNED_SYSTEM_ADDRESS;
 			break;
 		}
 	}
@@ -140,7 +141,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 	// Prevent GM friend spam
 	// If the player we are trying to be friends with is not a civilian and we are a civilian, abort the process
-	if (requestee.gmLevel > eGameMasterLevel::CIVILIAN && requestor.gmLevel == eGameMasterLevel::CIVILIAN ) {
+	if (requestee.gmLevel > eGameMasterLevel::CIVILIAN && requestor.gmLevel == eGameMasterLevel::CIVILIAN) {
 		SendFriendResponse(requestor, requestee, eAddFriendResponseType::MYTHRAN);
 		return;
 	}
@@ -159,9 +160,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 			// Set the bits
 			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
 			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
 
 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@@ -188,24 +187,29 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				Database::Get()->SetBestFriendStatus(requestorPlayerID, requestee.playerID, bestFriendStatus);
 				// Sent the best friend update here if the value is 3
 				if (bestFriendStatus == 3U) {
-					requestee.countOfBestFriends += 1;
+					if (requestee.worldServerSysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee, requestor, eAddFriendResponseType::ACCEPTED, false, true);
-					requestor.countOfBestFriends += 1;
+					if (requestor.worldServerSysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::ACCEPTED, false, true);
-					if (requestee.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee, requestor, eAddFriendResponseType::ACCEPTED, false, true);
+
-					if (requestor.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::ACCEPTED, false, true);
 					for (auto& friendData : requestor.friends) {
 						if (friendData.friendID == requestee.playerID) {
 							friendData.isBestFriend = true;
 						}
 					}
-					for (auto& friendData : requestee.friends) {
+					requestor.countOfBestFriends += 1;
-						if (friendData.friendID == requestor.playerID) {
+
-							friendData.isBestFriend = true;
+					auto& toModify = Game::playerContainer.GetPlayerDataMutable(playerName);
+					if (toModify) {
+						for (auto& friendData : toModify.friends) {
+							if (friendData.friendID == requestor.playerID) {
+								friendData.isBestFriend = true;
+							}
 						}
+						toModify.countOfBestFriends += 1;
 					}
 				}
 			}
 		} else {
-			if (requestor.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::WAITINGAPPROVAL, true, true);
+			if (requestor.worldServerSysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
 		auto maxFriends = Game::playerContainer.GetMaxNumberOfFriends();
@@ -311,7 +315,6 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}
 
 	// Convert friendID to LWOOBJID
-	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
 	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
 
 	Database::Get()->RemoveFriend(playerID, friendID);
@@ -368,17 +371,17 @@ void ChatPacketHandler::HandleWho(Packet* packet) {
 	bool online = player;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(request.requestor);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::WHO_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::WHO_RESPONSE);
 	bitStream.Write<uint8_t>(online);
 	bitStream.Write(player.zoneID.GetMapID());
 	bitStream.Write(player.zoneID.GetInstanceID());
 	bitStream.Write(player.zoneID.GetCloneID());
 	bitStream.Write(request.playerName);
 
-	SystemAddress sysAddr = sender.sysAddr;
+	SystemAddress sysAddr = sender.worldServerSysAddr;
 	SEND_PACKET;
 }
 
@@ -391,17 +394,17 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	if (!sender) return;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(request.requestor);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::SHOW_ALL_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::SHOW_ALL_RESPONSE);
 	bitStream.Write<uint8_t>(!request.displayZoneData && !request.displayIndividualPlayers);
 	bitStream.Write(Game::playerContainer.GetPlayerCount());
 	bitStream.Write(Game::playerContainer.GetSimCount());
 	bitStream.Write<uint8_t>(request.displayIndividualPlayers);
 	bitStream.Write<uint8_t>(request.displayZoneData);
-	if (request.displayZoneData || request.displayIndividualPlayers){
+	if (request.displayZoneData || request.displayIndividualPlayers) {
-		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
+		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));
@@ -412,7 +415,7 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 			}
 		}
 	}
-	SystemAddress sysAddr = sender.sysAddr;
+	SystemAddress sysAddr = sender.worldServerSysAddr;
 	SEND_PACKET;
 }
 
@@ -441,7 +444,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 
 	switch (channel) {
 	case eChatChannel::TEAM: {
-		auto* team = Game::playerContainer.GetTeam(playerID);
+		auto* team = TeamContainer::GetTeam(playerID);
 		if (team == nullptr) return;
 
 		for (const auto memberId : team->memberIDs) {
@@ -513,12 +516,34 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	SendPrivateChatMessage(sender, receiver, sender, message, eChatChannel::GENERAL, eChatMessageResponseCode::NOTFRIENDS);
 }
 
+void ChatPacketHandler::OnAchievementNotify(RakNet::BitStream& bitstream, const SystemAddress& sysAddr) {
+	ChatPackets::AchievementNotify notify{};
+	notify.Deserialize(bitstream);
+	const auto& playerData = Game::playerContainer.GetPlayerData(notify.earnerName.GetAsString());
+	if (!playerData) return;
+
+	for (const auto& myFriend : playerData.friends) {
+		auto& friendData = Game::playerContainer.GetPlayerData(myFriend.friendID);
+		if (friendData) {
+			notify.targetPlayerName.string = GeneralUtils::ASCIIToUTF16(friendData.playerName);
+			LOG_DEBUG("Sending achievement notify to %s", notify.targetPlayerName.GetAsString().c_str());
+
+			RakNet::BitStream worldStream;
+			BitStreamUtils::WriteHeader(worldStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+			worldStream.Write(friendData.playerID);
+			notify.WriteHeader(worldStream);
+			notify.Serialize(worldStream);
+			Game::server->Send(worldStream, friendData.worldServerSysAddr, false);
+		}
+	}
+}
+
 void ChatPacketHandler::SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(routeTo.playerID);
 
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::PRIVATE_CHAT_MESSAGE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::PRIVATE_CHAT_MESSAGE);
 	bitStream.Write(sender.playerID);
 	bitStream.Write(channel);
 	bitStream.Write<uint32_t>(0); // not used
@@ -531,387 +556,7 @@ void ChatPacketHandler::SendPrivateChatMessage(const PlayerData& sender, const P
 	bitStream.Write(responseCode);
 	bitStream.Write(message);
 
-	SystemAddress sysAddr = routeTo.sysAddr;
+	SystemAddress sysAddr = routeTo.worldServerSysAddr;
-	SEND_PACKET;
-}
-
-
-void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-
-	LWOOBJID playerID;
-	LUWString invitedPlayer;
-
-	inStream.Read(playerID);
-	inStream.IgnoreBytes(4);
-	inStream.Read(invitedPlayer);
-
-	const auto& player = Game::playerContainer.GetPlayerData(playerID);
-
-	if (!player) return;
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-
-	if (team == nullptr) {
-		team = Game::playerContainer.CreateTeam(playerID);
-	}
-
-	const auto& other = Game::playerContainer.GetPlayerData(invitedPlayer.GetAsString());
-
-	if (!other) return;
-
-	if (Game::playerContainer.GetTeam(other.playerID) != nullptr) {
-		return;
-	}
-
-	if (team->memberIDs.size() > 3) {
-		// no more teams greater than 4
-
-		LOG("Someone tried to invite a 5th player to a team");
-		return;
-	}
-
-	SendTeamInvite(other, player);
-
-	LOG("Got team invite: %llu -> %s", playerID, invitedPlayer.GetAsString().c_str());
-}
-
-void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	inStream.Read(playerID);
-	uint32_t size = 0;
-	inStream.Read(size);
-	char declined = 0;
-	inStream.Read(declined);
-	LWOOBJID leaderID = LWOOBJID_EMPTY;
-	inStream.Read(leaderID);
-
-	LOG("Accepted invite: %llu -> %llu (%d)", playerID, leaderID, declined);
-
-	if (declined) {
-		return;
-	}
-
-	auto* team = Game::playerContainer.GetTeam(leaderID);
-
-	if (team == nullptr) {
-		LOG("Failed to find team for leader (%llu)", leaderID);
-
-		team = Game::playerContainer.GetTeam(playerID);
-	}
-
-	if (team == nullptr) {
-		LOG("Failed to find team for player (%llu)", playerID);
-		return;
-	}
-
-	Game::playerContainer.AddMember(team, playerID);
-}
-
-void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	inStream.Read(playerID);
-	uint32_t size = 0;
-	inStream.Read(size);
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-
-	LOG("(%llu) leaving team", playerID);
-
-	if (team != nullptr) {
-		Game::playerContainer.RemoveMember(team, playerID, false, false, true);
-	}
-}
-
-void ChatPacketHandler::HandleTeamKick(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	LUWString kickedPlayer;
-
-	inStream.Read(playerID);
-	inStream.IgnoreBytes(4);
-	inStream.Read(kickedPlayer);
-
-
-	LOG("(%llu) kicking (%s) from team", playerID, kickedPlayer.GetAsString().c_str());
-
-	const auto& kicked = Game::playerContainer.GetPlayerData(kickedPlayer.GetAsString());
-
-	LWOOBJID kickedId = LWOOBJID_EMPTY;
-
-	if (kicked) {
-		kickedId = kicked.playerID;
-	} else {
-		kickedId = Game::playerContainer.GetId(kickedPlayer.string);
-	}
-
-	if (kickedId == LWOOBJID_EMPTY) return;
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-
-	if (team != nullptr) {
-		if (team->leaderID != playerID || team->leaderID == kickedId) return;
-
-		Game::playerContainer.RemoveMember(team, kickedId, false, true, false);
-	}
-}
-
-void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	LUWString promotedPlayer;
-
-	inStream.Read(playerID);
-	inStream.IgnoreBytes(4);
-	inStream.Read(promotedPlayer);
-
-	LOG("(%llu) promoting (%s) to team leader", playerID, promotedPlayer.GetAsString().c_str());
-
-	const auto& promoted = Game::playerContainer.GetPlayerData(promotedPlayer.GetAsString());
-
-	if (!promoted) return;
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-
-	if (team != nullptr) {
-		if (team->leaderID != playerID) return;
-
-		Game::playerContainer.PromoteMember(team, promoted.playerID);
-	}
-}
-
-void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	inStream.Read(playerID);
-	uint32_t size = 0;
-	inStream.Read(size);
-
-	char option;
-	inStream.Read(option);
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-
-	if (team != nullptr) {
-		if (team->leaderID != playerID) return;
-
-		team->lootFlag = option;
-
-		Game::playerContainer.TeamStatusUpdate(team);
-
-		Game::playerContainer.UpdateTeamsOnWorld(team, false);
-	}
-}
-
-void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID = LWOOBJID_EMPTY;
-	inStream.Read(playerID);
-
-	auto* team = Game::playerContainer.GetTeam(playerID);
-	const auto& data = Game::playerContainer.GetPlayerData(playerID);
-
-	if (team != nullptr && data) {
-		if (team->local && data.zoneID.GetMapID() != team->zoneId.GetMapID() && data.zoneID.GetCloneID() != team->zoneId.GetCloneID()) {
-			Game::playerContainer.RemoveMember(team, playerID, false, false, true, true);
-
-			return;
-		}
-
-		if (team->memberIDs.size() <= 1 && !team->local) {
-			Game::playerContainer.DisbandTeam(team);
-
-			return;
-		}
-
-		if (!team->local) {
-			ChatPacketHandler::SendTeamSetLeader(data, team->leaderID);
-		} else {
-			ChatPacketHandler::SendTeamSetLeader(data, LWOOBJID_EMPTY);
-		}
-
-		Game::playerContainer.TeamStatusUpdate(team);
-
-		const auto leaderName = GeneralUtils::UTF8ToUTF16(data.playerName);
-
-		for (const auto memberId : team->memberIDs) {
-			const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
-
-			if (memberId == playerID) continue;
-
-			const auto memberName = Game::playerContainer.GetName(memberId);
-
-			if (otherMember) {
-				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data.playerID, data.zoneID);
-			}
-			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
-		}
-
-		Game::playerContainer.UpdateTeamsOnWorld(team, false);
-	}
-}
-
-void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::TEAM_INVITE);
-
-	bitStream.Write(LUWString(sender.playerName.c_str()));
-	bitStream.Write(sender.playerID);
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_INVITE_CONFIRM);
-
-	bitStream.Write(bLeaderIsFreeTrial);
-	bitStream.Write(i64LeaderID);
-	bitStream.Write(i64LeaderZoneID);
-	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
-	bitStream.Write(ucLootFlag);
-	bitStream.Write(ucNumOfOtherPlayers);
-	bitStream.Write(ucResponseCode);
-	bitStream.Write<uint32_t>(wsLeaderName.size());
-	for (const auto character : wsLeaderName) {
-		bitStream.Write(character);
-	}
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_GET_STATUS_RESPONSE);
-
-	bitStream.Write(i64LeaderID);
-	bitStream.Write(i64LeaderZoneID);
-	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
-	bitStream.Write(ucLootFlag);
-	bitStream.Write(ucNumOfOtherPlayers);
-	bitStream.Write<uint32_t>(wsLeaderName.size());
-	for (const auto character : wsLeaderName) {
-		bitStream.Write(character);
-	}
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_SET_LEADER);
-
-	bitStream.Write(i64PlayerID);
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_ADD_PLAYER);
-
-	bitStream.Write(bIsFreeTrial);
-	bitStream.Write(bLocal);
-	bitStream.Write(bNoLootOnDeath);
-	bitStream.Write(i64PlayerID);
-	bitStream.Write<uint32_t>(wsPlayerName.size());
-	for (const auto character : wsPlayerName) {
-		bitStream.Write(character);
-	}
-	bitStream.Write1();
-	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
-		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
-	}
-	bitStream.Write(zoneID);
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_REMOVE_PLAYER);
-
-	bitStream.Write(bDisband);
-	bitStream.Write(bIsKicked);
-	bitStream.Write(bIsLeaving);
-	bitStream.Write(bLocal);
-	bitStream.Write(i64LeaderID);
-	bitStream.Write(i64PlayerID);
-	bitStream.Write<uint32_t>(wsPlayerName.size());
-	for (const auto character : wsPlayerName) {
-		bitStream.Write(character);
-	}
-
-	SystemAddress sysAddr = receiver.sysAddr;
-	SEND_PACKET;
-}
-
-void ChatPacketHandler::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
-	bitStream.Write(receiver.playerID);
-
-	//portion that will get routed:
-	CMSGHEADER;
-
-	bitStream.Write(receiver.playerID);
-	bitStream.Write(MessageType::Game::TEAM_SET_OFF_WORLD_FLAG);
-
-	bitStream.Write(i64PlayerID);
-	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
-		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
-	}
-	bitStream.Write(zoneID);
-
-	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
@@ -930,11 +575,11 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(friendData.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::UPDATE_FRIEND_NOTIFY);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData.playerName.c_str();
@@ -953,7 +598,7 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 	bitStream.Write<uint8_t>(isBestFriend); //isBFF
 	bitStream.Write<uint8_t>(0); //isFTP
 
-	SystemAddress sysAddr = friendData.sysAddr;
+	SystemAddress sysAddr = friendData.worldServerSysAddr;
 	SEND_PACKET;
 }
 
@@ -967,28 +612,28 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 	}
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::ADD_FRIEND_REQUEST);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::ADD_FRIEND_REQUEST);
 	bitStream.Write(LUWString(sender.playerName));
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
-	SystemAddress sysAddr = receiver.sysAddr;
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
 	SEND_PACKET;
 }
 
 void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	// Portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::ADD_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
-	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender.sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
+	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender.worldServerSysAddr != UNASSIGNED_SYSTEM_ADDRESS);
 	// Then write the player name
 	bitStream.Write(LUWString(sender.playerName));
 	// Then if this is an acceptance code, write the following extra info.
@@ -998,20 +643,20 @@ void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const Pla
 		bitStream.Write(isBestFriendRequest); //isBFF
 		bitStream.Write<uint8_t>(0); //isFTP
 	}
-	SystemAddress sysAddr = receiver.sysAddr;
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
 	SEND_PACKET;
 }
 
 void ChatPacketHandler::SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::REMOVE_FRIEND_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	bitStream.Write(LUWString(personToRemove));
 
-	SystemAddress sysAddr = receiver.sysAddr;
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
 	SEND_PACKET;
 }

dChatServer/ChatPacketHandler.h

@@ -35,13 +35,13 @@ enum class eChatChannel : uint8_t {
 
 
 enum class eChatMessageResponseCode : uint8_t {
-    SENT = 0,
+	SENT = 0,
-    NOTONLINE,
+	NOTONLINE,
-    GENERALERROR,
+	GENERALERROR,
-    RECEIVEDNEWWHISPER,
+	RECEIVEDNEWWHISPER,
-    NOTFRIENDS,
+	NOTFRIENDS,
-    SENDERFREETRIAL,
+	SENDERFREETRIAL,
-    RECEIVERFREETRIAL,
+	RECEIVERFREETRIAL,
 };
 
 namespace ChatPacketHandler {
@@ -52,30 +52,14 @@ namespace ChatPacketHandler {
 	void HandleGMLevelUpdate(Packet* packet);
 	void HandleWho(Packet* packet);
 	void HandleShowAll(Packet* packet);
-
 	void HandleChatMessage(Packet* packet);
 	void HandlePrivateChatMessage(Packet* packet);
-	void SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode);
 
-	void HandleTeamInvite(Packet* packet);
+	void OnAchievementNotify(RakNet::BitStream& bitstream, const SystemAddress& sysAddr);
-	void HandleTeamInviteResponse(Packet* packet);
-	void HandleTeamLeave(Packet* packet);
-	void HandleTeamKick(Packet* packet);
-	void HandleTeamPromote(Packet* packet);
-	void HandleTeamLootOption(Packet* packet);
-	void HandleTeamStatusRequest(Packet* packet);
-
-	void SendTeamInvite(const PlayerData& receiver, const PlayerData& sender);
-	void SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName);
-	void SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName);
-	void SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID);
-	void SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID);
-	void SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName);
-	void SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID);
 
 	//FriendData is the player we're SENDING this stuff to. Player is the friend that changed state.
 	void SendFriendUpdate(const PlayerData& friendData, const PlayerData& playerData, uint8_t notifyType, uint8_t isBestFriend);
-
+	void SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode);
 	void SendFriendRequest(const PlayerData& receiver, const PlayerData& sender);
 	void SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
 	void SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful);

dChatServer/ChatServer.cpp

@@ -13,13 +13,14 @@
 #include "Diagnostics.h"
 #include "AssetManager.h"
 #include "BinaryPathFinder.h"
-#include "eConnectionType.h"
+#include "ServiceType.h"
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
 #include "MessageType/Chat.h"
 #include "MessageType/World.h"
 #include "ChatIgnoreList.h"
 #include "StringifiedEnum.h"
+#include "TeamContainer.h"
 
 #include "Game.h"
 #include "Server.h"
@@ -28,6 +29,8 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
+#include "ChatWeb.h"
+
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -56,6 +59,7 @@ int main(int argc, char** argv) {
 	//Create all the objects we need to run our service:
 	Server::SetupLogger("ChatServer");
 	if (!Game::logger) return EXIT_FAILURE;
+	Game::config->LogSettings();
 
 	//Read our config:
 
@@ -74,28 +78,44 @@ int main(int argc, char** argv) {
 		Game::assetManager = new AssetManager(clientPath);
 	} catch (std::runtime_error& ex) {
 		LOG("Got an error while setting up assets: %s", ex.what());
-
+		delete Game::logger;
+		delete Game::config;
 		return EXIT_FAILURE;
 	}
 
 	//Connect to the MySQL Database
 	try {
 		Database::Connect();
-	} catch (sql::SQLException& ex) {
+	} catch (std::exception& ex) {
 		LOG("Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("ChatServer");
-		delete Game::server;
 		delete Game::logger;
+		delete Game::config;
 		return EXIT_FAILURE;
 	}
 
+	// setup the chat api web server
+	const uint32_t web_server_port = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("web_server_port")).value_or(2005);
+	if (Game::config->GetValue("web_server_enabled") == "1" && !Game::web.Startup("localhost", web_server_port)) {
+		// if we want the web server and it fails to start, exit
+		LOG("Failed to start web server, shutting down.");
+		Database::Destroy("ChatServer");
+		delete Game::logger;
+		delete Game::config;
+		return EXIT_FAILURE;
+	}
+
+	if (Game::web.IsEnabled()) ChatWeb::RegisterRoutes();
+
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1000;
+	std::string masterPassword;
 	auto masterInfo = Database::Get()->GetMasterInfo();
 	if (masterInfo) {
 		masterIP = masterInfo->ip;
 		masterPort = masterInfo->port;
+		masterPassword = masterInfo->password;
 	}
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	std::string ourIP = "localhost";
@@ -104,7 +124,7 @@ int main(int argc, char** argv) {
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;
 
-	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::lastSignal);
+	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServiceType::CHAT, Game::config, &Game::lastSignal, masterPassword);
 
 	const bool dontGenerateDCF = GeneralUtils::TryParse<bool>(Game::config->GetValue("dont_generate_dcf")).value_or(false);
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", dontGenerateDCF);
@@ -122,6 +142,8 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
+	auto lastTime = std::chrono::high_resolution_clock::now();
+
 	Game::logger->Flush(); // once immediately before main loop
 	while (!Game::ShouldShutdown()) {
 		//Check if we're still connected to master:
@@ -132,7 +154,11 @@ int main(int argc, char** argv) {
 				break; //Exit our loop, shut down.
 		} else framesSinceMasterDisconnect = 0;
 
-		//In world we'd update our other systems here.
+		const auto currentTime = std::chrono::high_resolution_clock::now();
+		const float deltaTime = std::chrono::duration<float>(currentTime - lastTime).count();
+		lastTime = currentTime;
+
+		Game::playerContainer.Update(deltaTime);
 
 		//Check for packets here:
 		Game::server->ReceiveFromMaster(); //ReceiveFromMaster also handles the master packets if needed.
@@ -143,6 +169,9 @@ int main(int argc, char** argv) {
 			packet = nullptr;
 		}
 
+		// Check and handle web requests:
+		if (Game::web.IsEnabled()) Game::web.ReceiveRequests();
+
 		//Push our log every 30s:
 		if (framesSinceLastFlush >= logFlushTime) {
 			Game::logger->Flush();
@@ -168,12 +197,16 @@ int main(int argc, char** argv) {
 		t += std::chrono::milliseconds(chatFrameDelta); //Chat can run at a lower "fps"
 		std::this_thread::sleep_until(t);
 	}
-
+	Game::playerContainer.Shutdown();
+	TeamContainer::Shutdown();
 	//Delete our objects here:
 	Database::Destroy("ChatServer");
 	delete Game::server;
+	Game::server = nullptr;
 	delete Game::logger;
+	Game::logger = nullptr;
 	delete Game::config;
+	Game::config = nullptr;
 
 	return EXIT_SUCCESS;
 }
@@ -189,158 +222,163 @@ void HandlePacket(Packet* packet) {
 	CINSTREAM;
 	inStream.SetReadOffset(BYTES_TO_BITS(1));
 
-	eConnectionType connection;
+	ServiceType connection;
-	MessageType::Chat chatMessageID;
-
 	inStream.Read(connection);
-	if (connection != eConnectionType::CHAT) return;
+	if (connection != ServiceType::CHAT) return;
+
+	MessageType::Chat chatMessageID;
 	inStream.Read(chatMessageID);
 
+	// Our packing byte wasnt there? Probably a false packet
+	if (inStream.GetNumberOfUnreadBits() < 8) return;
+	inStream.IgnoreBytes(1);
+
 	switch (chatMessageID) {
-		case MessageType::Chat::GM_MUTE:
+	case MessageType::Chat::GM_MUTE:
-			Game::playerContainer.MuteUpdate(packet);
+		Game::playerContainer.MuteUpdate(packet);
-			break;
+		break;
 
-		case MessageType::Chat::CREATE_TEAM:
+	case MessageType::Chat::CREATE_TEAM:
-			Game::playerContainer.CreateTeamServer(packet);
+		TeamContainer::CreateTeamServer(packet);
-			break;
+		break;
 
-		case MessageType::Chat::GET_FRIENDS_LIST:
+	case MessageType::Chat::GET_FRIENDS_LIST:
-			ChatPacketHandler::HandleFriendlistRequest(packet);
+		ChatPacketHandler::HandleFriendlistRequest(packet);
-			break;
+		break;
 
-		case MessageType::Chat::GET_IGNORE_LIST:
+	case MessageType::Chat::GET_IGNORE_LIST:
-			ChatIgnoreList::GetIgnoreList(packet);
+		ChatIgnoreList::GetIgnoreList(packet);
-			break;
+		break;
 
-		case MessageType::Chat::ADD_IGNORE:
+	case MessageType::Chat::ADD_IGNORE:
-			ChatIgnoreList::AddIgnore(packet);
+		ChatIgnoreList::AddIgnore(packet);
-			break;
+		break;
 
-		case MessageType::Chat::REMOVE_IGNORE:
+	case MessageType::Chat::REMOVE_IGNORE:
-			ChatIgnoreList::RemoveIgnore(packet);
+		ChatIgnoreList::RemoveIgnore(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_GET_STATUS:
+	case MessageType::Chat::TEAM_GET_STATUS:
-			ChatPacketHandler::HandleTeamStatusRequest(packet);
+		TeamContainer::HandleTeamStatusRequest(packet);
-			break;
+		break;
 
-		case MessageType::Chat::ADD_FRIEND_REQUEST:
+	case MessageType::Chat::ADD_FRIEND_REQUEST:
-			//this involves someone sending the initial request, the response is below, response as in from the other player.
+		//this involves someone sending the initial request, the response is below, response as in from the other player.
-			//We basically just check to see if this player is online or not and route the packet.
+		//We basically just check to see if this player is online or not and route the packet.
-			ChatPacketHandler::HandleFriendRequest(packet);
+		ChatPacketHandler::HandleFriendRequest(packet);
-			break;
+		break;
 
-		case MessageType::Chat::ADD_FRIEND_RESPONSE:
+	case MessageType::Chat::ADD_FRIEND_RESPONSE:
-			//This isn't the response a server sent, rather it is a player's response to a received request.
+		//This isn't the response a server sent, rather it is a player's response to a received request.
-			//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
+		//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
-			ChatPacketHandler::HandleFriendResponse(packet);
+		ChatPacketHandler::HandleFriendResponse(packet);
-			break;
+		break;
 
-		case MessageType::Chat::REMOVE_FRIEND:
+	case MessageType::Chat::REMOVE_FRIEND:
-			ChatPacketHandler::HandleRemoveFriend(packet);
+		ChatPacketHandler::HandleRemoveFriend(packet);
-			break;
+		break;
 
-		case MessageType::Chat::GENERAL_CHAT_MESSAGE:
+	case MessageType::Chat::GENERAL_CHAT_MESSAGE:
-			ChatPacketHandler::HandleChatMessage(packet);
+		ChatPacketHandler::HandleChatMessage(packet);
-			break;
+		break;
 
-		case MessageType::Chat::PRIVATE_CHAT_MESSAGE:
+	case MessageType::Chat::PRIVATE_CHAT_MESSAGE:
-			//This message is supposed to be echo'd to both the sender and the receiver
+		//This message is supposed to be echo'd to both the sender and the receiver
-			//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
+		//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
-			ChatPacketHandler::HandlePrivateChatMessage(packet);
+		ChatPacketHandler::HandlePrivateChatMessage(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_INVITE:
+	case MessageType::Chat::TEAM_INVITE:
-			ChatPacketHandler::HandleTeamInvite(packet);
+		TeamContainer::HandleTeamInvite(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_INVITE_RESPONSE:
+	case MessageType::Chat::TEAM_INVITE_RESPONSE:
-			ChatPacketHandler::HandleTeamInviteResponse(packet);
+		TeamContainer::HandleTeamInviteResponse(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_LEAVE:
+	case MessageType::Chat::TEAM_LEAVE:
-			ChatPacketHandler::HandleTeamLeave(packet);
+		TeamContainer::HandleTeamLeave(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_SET_LEADER:
+	case MessageType::Chat::TEAM_SET_LEADER:
-			ChatPacketHandler::HandleTeamPromote(packet);
+		TeamContainer::HandleTeamPromote(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_KICK:
+	case MessageType::Chat::TEAM_KICK:
-			ChatPacketHandler::HandleTeamKick(packet);
+		TeamContainer::HandleTeamKick(packet);
-			break;
+		break;
 
-		case MessageType::Chat::TEAM_SET_LOOT:
+	case MessageType::Chat::TEAM_SET_LOOT:
-			ChatPacketHandler::HandleTeamLootOption(packet);
+		TeamContainer::HandleTeamLootOption(packet);
-			break;
+		break;
-		case MessageType::Chat::GMLEVEL_UPDATE:
+	case MessageType::Chat::GMLEVEL_UPDATE:
-			ChatPacketHandler::HandleGMLevelUpdate(packet);
+		ChatPacketHandler::HandleGMLevelUpdate(packet);
-			break;
+		break;
-		case MessageType::Chat::LOGIN_SESSION_NOTIFY:
+	case MessageType::Chat::LOGIN_SESSION_NOTIFY:
-			Game::playerContainer.InsertPlayer(packet);
+		Game::playerContainer.InsertPlayer(packet);
-			break;
+		break;
-		case MessageType::Chat::GM_ANNOUNCE:{
+	case MessageType::Chat::GM_ANNOUNCE:
-			// we just forward this packet to every connected server
+		// we just forward this packet to every connected server
-			inStream.ResetReadPointer();
+		inStream.ResetReadPointer();
-			Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
+		Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
-			}
+		break;
-			break;
+	case MessageType::Chat::UNEXPECTED_DISCONNECT:
-		case MessageType::Chat::UNEXPECTED_DISCONNECT:
+		Game::playerContainer.ScheduleRemovePlayer(packet);
-			Game::playerContainer.RemovePlayer(packet);
+		break;
-			break;
+	case MessageType::Chat::WHO:
-		case MessageType::Chat::WHO:
+		ChatPacketHandler::HandleWho(packet);
-			ChatPacketHandler::HandleWho(packet);
+		break;
-			break;
+	case MessageType::Chat::SHOW_ALL:
-		case MessageType::Chat::SHOW_ALL:
+		ChatPacketHandler::HandleShowAll(packet);
-			ChatPacketHandler::HandleShowAll(packet);
+		break;
-			break;
+	case MessageType::Chat::ACHIEVEMENT_NOTIFY:
-		case MessageType::Chat::USER_CHANNEL_CHAT_MESSAGE:
+		ChatPacketHandler::OnAchievementNotify(inStream, packet->systemAddress);
-		case MessageType::Chat::WORLD_DISCONNECT_REQUEST:
+		break;
-		case MessageType::Chat::WORLD_PROXIMITY_RESPONSE:
+	case MessageType::Chat::USER_CHANNEL_CHAT_MESSAGE:
-		case MessageType::Chat::WORLD_PARCEL_RESPONSE:
+	case MessageType::Chat::WORLD_DISCONNECT_REQUEST:
-		case MessageType::Chat::TEAM_MISSED_INVITE_CHECK:
+	case MessageType::Chat::WORLD_PROXIMITY_RESPONSE:
-		case MessageType::Chat::GUILD_CREATE:
+	case MessageType::Chat::WORLD_PARCEL_RESPONSE:
-		case MessageType::Chat::GUILD_INVITE:
+	case MessageType::Chat::TEAM_MISSED_INVITE_CHECK:
-		case MessageType::Chat::GUILD_INVITE_RESPONSE:
+	case MessageType::Chat::GUILD_CREATE:
-		case MessageType::Chat::GUILD_LEAVE:
+	case MessageType::Chat::GUILD_INVITE:
-		case MessageType::Chat::GUILD_KICK:
+	case MessageType::Chat::GUILD_INVITE_RESPONSE:
-		case MessageType::Chat::GUILD_GET_STATUS:
+	case MessageType::Chat::GUILD_LEAVE:
-		case MessageType::Chat::GUILD_GET_ALL:
+	case MessageType::Chat::GUILD_KICK:
-		case MessageType::Chat::BLUEPRINT_MODERATED:
+	case MessageType::Chat::GUILD_GET_STATUS:
-		case MessageType::Chat::BLUEPRINT_MODEL_READY:
+	case MessageType::Chat::GUILD_GET_ALL:
-		case MessageType::Chat::PROPERTY_READY_FOR_APPROVAL:
+	case MessageType::Chat::BLUEPRINT_MODERATED:
-		case MessageType::Chat::PROPERTY_MODERATION_CHANGED:
+	case MessageType::Chat::BLUEPRINT_MODEL_READY:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED:
+	case MessageType::Chat::PROPERTY_READY_FOR_APPROVAL:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED_REPORT:
+	case MessageType::Chat::PROPERTY_MODERATION_CHANGED:
-		case MessageType::Chat::MAIL:
+	case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED:
-		case MessageType::Chat::WORLD_INSTANCE_LOCATION_REQUEST:
+	case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED_REPORT:
-		case MessageType::Chat::REPUTATION_UPDATE:
+	case MessageType::Chat::MAIL:
-		case MessageType::Chat::SEND_CANNED_TEXT:
+	case MessageType::Chat::WORLD_INSTANCE_LOCATION_REQUEST:
-		case MessageType::Chat::CHARACTER_NAME_CHANGE_REQUEST:
+	case MessageType::Chat::REPUTATION_UPDATE:
-		case MessageType::Chat::CSR_REQUEST:
+	case MessageType::Chat::SEND_CANNED_TEXT:
-		case MessageType::Chat::CSR_REPLY:
+	case MessageType::Chat::CHARACTER_NAME_CHANGE_REQUEST:
-		case MessageType::Chat::GM_KICK:
+	case MessageType::Chat::CSR_REQUEST:
-		case MessageType::Chat::WORLD_ROUTE_PACKET:
+	case MessageType::Chat::CSR_REPLY:
-		case MessageType::Chat::GET_ZONE_POPULATIONS:
+	case MessageType::Chat::GM_KICK:
-		case MessageType::Chat::REQUEST_MINIMUM_CHAT_MODE:
+	case MessageType::Chat::WORLD_ROUTE_PACKET:
-		case MessageType::Chat::MATCH_REQUEST:
+	case MessageType::Chat::GET_ZONE_POPULATIONS:
-		case MessageType::Chat::UGCMANIFEST_REPORT_MISSING_FILE:
+	case MessageType::Chat::REQUEST_MINIMUM_CHAT_MODE:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_FILE:
+	case MessageType::Chat::MATCH_REQUEST:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
+	case MessageType::Chat::UGCMANIFEST_REPORT_MISSING_FILE:
-		case MessageType::Chat::UGCC_REQUEST:
+	case MessageType::Chat::UGCMANIFEST_REPORT_DONE_FILE:
-		case MessageType::Chat::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
+	case MessageType::Chat::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
-		case MessageType::Chat::ACHIEVEMENT_NOTIFY:
+	case MessageType::Chat::UGCC_REQUEST:
-		case MessageType::Chat::GM_CLOSE_PRIVATE_CHAT_WINDOW:
+	case MessageType::Chat::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
-		case MessageType::Chat::PLAYER_READY:
+	case MessageType::Chat::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		case MessageType::Chat::GET_DONATION_TOTAL:
+	case MessageType::Chat::PLAYER_READY:
-		case MessageType::Chat::UPDATE_DONATION:
+	case MessageType::Chat::GET_DONATION_TOTAL:
-		case MessageType::Chat::PRG_CSR_COMMAND:
+	case MessageType::Chat::UPDATE_DONATION:
-		case MessageType::Chat::HEARTBEAT_REQUEST_FROM_WORLD:
+	case MessageType::Chat::PRG_CSR_COMMAND:
-		case MessageType::Chat::UPDATE_FREE_TRIAL_STATUS:
+	case MessageType::Chat::HEARTBEAT_REQUEST_FROM_WORLD:
-			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
+	case MessageType::Chat::UPDATE_FREE_TRIAL_STATUS:
-			break;
+		LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
-		default:
+		break;
-			LOG("Unknown CHAT Message id: %i", chatMessageID);
+	default:
+		LOG("Unknown CHAT Message id: %i", chatMessageID);
 	}
 }

dChatServer/ChatWeb.cpp

@@ -0,0 +1,133 @@
+#include "ChatWeb.h"
+
+#include "Logger.h"
+#include "Game.h"
+#include "json.hpp"
+#include "dCommonVars.h"
+#include "MessageType/Chat.h"
+#include "dServer.h"
+#include "dConfig.h"
+#include "PlayerContainer.h"
+#include "GeneralUtils.h"
+#include "eHTTPMethod.h"
+#include "magic_enum.hpp"
+#include "ChatPackets.h"
+#include "StringifiedEnum.h"
+#include "Database.h"
+#include "ChatJSONUtils.h"
+#include "JSONUtils.h"
+#include "eGameMasterLevel.h"
+#include "dChatFilter.h"
+#include "TeamContainer.h"
+
+using json = nlohmann::json;
+
+void HandleHTTPPlayersRequest(HTTPReply& reply, std::string body) {
+	const json data = Game::playerContainer;
+	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
+	reply.message = data.empty() ? "{\"error\":\"No Players Online\"}" : data.dump();
+}
+
+void HandleHTTPTeamsRequest(HTTPReply& reply, std::string body) {
+	const json data = TeamContainer::GetTeamContainer();
+	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
+	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
+}
+
+void HandleHTTPAnnounceRequest(HTTPReply& reply, std::string body) {
+	auto data = GeneralUtils::TryParse<json>(body);
+	if (!data) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid JSON\"}";
+		return;
+	}
+
+	const auto& good_data = data.value();
+	auto check = JSONUtils::CheckRequiredData(good_data, { "title", "message" });
+	if (!check.empty()) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = check;
+	} else {
+
+		ChatPackets::Announcement announcement;
+		announcement.title = good_data["title"];
+		announcement.message = good_data["message"];
+		announcement.Broadcast();
+
+		reply.status = eHTTPStatusCode::OK;
+		reply.message = "{\"status\":\"Announcement Sent\"}";
+	}
+}
+
+void HandleWSChat(mg_connection* connection, json data) {
+	auto check = JSONUtils::CheckRequiredData(data, { "user", "message", "gmlevel", "zone" });
+	if (!check.empty()) {
+		LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
+	} else {
+		const auto user = data["user"].get<std::string>();
+		const auto message = data["message"].get<std::string>();
+		const auto gmlevel = GeneralUtils::TryParse<eGameMasterLevel>(data["gmlevel"].get<std::string>()).value_or(eGameMasterLevel::CIVILIAN);
+		const auto zone = data["zone"].get<uint32_t>();
+
+		const auto filter_check = Game::chatFilter->IsSentenceOkay(message, gmlevel);
+		if (!filter_check.empty()) {
+			LOG_DEBUG("Chat message \"%s\" from %s was not allowed", message.c_str(), user.c_str());
+			data["error"] = "Chat message blocked by filter";
+			data["filtered"] = json::array();
+			for (const auto& [start, len] : filter_check) {
+				data["filtered"].push_back(message.substr(start, len));
+			}
+			mg_ws_send(connection, data.dump().c_str(), data.dump().size(), WEBSOCKET_OP_TEXT);
+			return;
+		}
+		LOG("%s: %s", user.c_str(), message.c_str());
+		
+		// TODO: Implement chat message handling from websocket message
+
+	}
+}
+
+namespace ChatWeb {
+	void RegisterRoutes() {
+		
+		// REST API v1 routes
+
+		std::string v1_route = "/api/v1/";
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "players",
+			.method = eHTTPMethod::GET,
+			.handle = HandleHTTPPlayersRequest
+		});
+
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "teams",
+			.method = eHTTPMethod::GET,
+			.handle = HandleHTTPTeamsRequest
+		});
+
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "announce",
+			.method = eHTTPMethod::POST,
+			.handle = HandleHTTPAnnounceRequest
+		});
+
+		// WebSocket Events Handlers
+
+		// Game::web.RegisterWSEvent({
+		// 	.name = "chat",
+		// 	.handle = HandleWSChat
+		// });
+
+		// WebSocket subscriptions
+
+		Game::web.RegisterWSSubscription("player");
+	}
+
+	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType) {
+		json data;
+		data["player_data"] = player;
+		data["update_type"] = magic_enum::enum_name(activityType);
+		Game::web.SendWSMessage("player", data);
+	}
+}
+

dChatServer/ChatWeb.h

@@ -0,0 +1,19 @@
+#ifndef __CHATWEB_H__
+#define __CHATWEB_H__
+
+#include <string>
+#include <functional>
+
+#include "Web.h"
+#include "PlayerContainer.h"
+#include "IActivityLog.h"
+#include "ChatPacketHandler.h"
+
+namespace ChatWeb {
+	void RegisterRoutes();
+	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType);
+};
+
+
+#endif // __CHATWEB_H__
+

dChatServer/PlayerContainer.cpp

@@ -8,10 +8,12 @@
 #include "GeneralUtils.h"
 #include "BitStreamUtils.h"
 #include "Database.h"
-#include "eConnectionType.h"
+#include "ServiceType.h"
 #include "ChatPackets.h"
 #include "dConfig.h"
 #include "MessageType/Chat.h"
+#include "ChatWeb.h"
+#include "TeamContainer.h"
 
 void PlayerContainer::Initialize() {
 	m_MaxNumberOfBestFriends =
@@ -32,7 +34,10 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 		return;
 	}
 
+	auto isLogin = !m_Players.contains(playerId);
 	auto& data = m_Players[playerId];
+	data = PlayerData();
+	data.isLogin = isLogin;
 	data.playerID = playerId;
 
 	uint32_t len;
@@ -49,21 +54,41 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	if (!inStream.Read(data.zoneID)) return;
 	if (!inStream.Read(data.muteExpire)) return;
 	if (!inStream.Read(data.gmLevel)) return;
-	data.sysAddr = packet->systemAddress;
+	data.worldServerSysAddr = 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());
+	ChatWeb::SendWSPlayerUpdate(data, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone);
 
-	Database::Get()->UpdateActivityLog(data.playerID, eActivityType::PlayerLoggedIn, data.zoneID.GetMapID());
+	Database::Get()->UpdateActivityLog(data.playerID, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone, data.zoneID.GetMapID());
+	m_PlayersToRemove.erase(playerId);
 }
 
-void PlayerContainer::RemovePlayer(Packet* packet) {
+void PlayerContainer::ScheduleRemovePlayer(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID;
+	LWOOBJID playerID{ LWOOBJID_EMPTY };
 	inStream.Read(playerID);
+	constexpr float updatePlayerOnLogoutTime = 20.0f;
+	if (playerID != LWOOBJID_EMPTY) m_PlayersToRemove.insert_or_assign(playerID, updatePlayerOnLogoutTime);
+}
 
+void PlayerContainer::Update(const float deltaTime) {
+	for (auto it = m_PlayersToRemove.begin(); it != m_PlayersToRemove.end();) {
+		auto& [id, time] = *it;
+		time -= deltaTime;
+
+		if (time <= 0.0f) {
+			RemovePlayer(id);
+			it = m_PlayersToRemove.erase(it);
+		} else {
+			++it;
+		}
+	}
+}
+
+void PlayerContainer::RemovePlayer(const LWOOBJID playerID) {
 	//Before they get kicked, we need to also send a message to their friends saying that they disconnected.
 	const auto& player = GetPlayerData(playerID);
 
@@ -77,7 +102,7 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		if (fd) ChatPacketHandler::SendFriendUpdate(fd, player, 0, fr.isBestFriend);
 	}
 
-	auto* team = GetTeam(playerID);
+	auto* team = TeamContainer::GetTeam(playerID);
 
 	if (team != nullptr) {
 		const auto memberName = GeneralUtils::UTF8ToUTF16(player.playerName);
@@ -87,10 +112,12 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 
 			if (!otherMember) continue;
 
-			ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, playerID, { 0, 0, 0 });
+			TeamContainer::SendTeamSetOffWorldFlag(otherMember, playerID, { 0, 0, 0 });
 		}
 	}
 
+	ChatWeb::SendWSPlayerUpdate(player, eActivityType::PlayerLoggedOut);
+
 	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);
@@ -118,43 +145,9 @@ void PlayerContainer::MuteUpdate(Packet* packet) {
 	BroadcastMuteUpdate(playerID, expire);
 }
 
-void PlayerContainer::CreateTeamServer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID;
-	inStream.Read(playerID);
-	size_t membersSize = 0;
-	inStream.Read(membersSize);
-
-	if (membersSize >= 4) {
-		LOG("Tried to create a team with more than 4 players");
-		return;
-	}
-
-	std::vector<LWOOBJID> members;
-
-	members.reserve(membersSize);
-
-	for (size_t i = 0; i < membersSize; i++) {
-		LWOOBJID member;
-		inStream.Read(member);
-		members.push_back(member);
-	}
-
-	LWOZONEID zoneId;
-
-	inStream.Read(zoneId);
-
-	auto* team = CreateLocalTeam(members);
-
-	if (team != nullptr) {
-		team->zoneId = zoneId;
-		UpdateTeamsOnWorld(team, false);
-	}
-}
-
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_MUTE);
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::GM_MUTE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -162,221 +155,6 @@ void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 }
 
-TeamData* PlayerContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
-	if (members.empty()) {
-		return nullptr;
-	}
-
-	TeamData* newTeam = nullptr;
-
-	for (const auto member : members) {
-		auto* team = GetTeam(member);
-
-		if (team != nullptr) {
-			RemoveMember(team, member, false, false, true);
-		}
-
-		if (newTeam == nullptr) {
-			newTeam = CreateTeam(member, true);
-		} else {
-			AddMember(newTeam, member);
-		}
-	}
-
-	newTeam->lootFlag = 1;
-
-	TeamStatusUpdate(newTeam);
-
-	return newTeam;
-}
-
-TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
-	auto* team = new TeamData();
-
-	team->teamID = ++m_TeamIDCounter;
-	team->leaderID = leader;
-	team->local = local;
-
-	mTeams.push_back(team);
-
-	AddMember(team, leader);
-
-	return team;
-}
-
-TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) {
-	for (auto* team : mTeams) {
-		if (std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID) == team->memberIDs.end()) continue;
-
-		return team;
-	}
-
-	return nullptr;
-}
-
-void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) {
-	if (team->memberIDs.size() >= 4) {
-		LOG("Tried to add player to team that already had 4 players");
-		const auto& player = GetPlayerData(playerID);
-		if (!player) return;
-		ChatPackets::SendSystemMessage(player.sysAddr, u"The teams is full! You have not been added to a team!");
-		return;
-	}
-
-	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
-
-	if (index != team->memberIDs.end()) return;
-
-	team->memberIDs.push_back(playerID);
-
-	const auto& leader = GetPlayerData(team->leaderID);
-	const auto& member = GetPlayerData(playerID);
-
-	if (!leader || !member) return;
-
-	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
-	const auto memberName = GeneralUtils::UTF8ToUTF16(member.playerName);
-
-	ChatPacketHandler::SendTeamInviteConfirm(member, false, leader.playerID, leader.zoneID, team->lootFlag, 0, 0, leaderName);
-
-	if (!team->local) {
-		ChatPacketHandler::SendTeamSetLeader(member, leader.playerID);
-	} else {
-		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
-	}
-
-	UpdateTeamsOnWorld(team, false);
-
-	for (const auto memberId : team->memberIDs) {
-		const auto& otherMember = GetPlayerData(memberId);
-
-		if (otherMember == member) continue;
-
-		const auto otherMemberName = GetName(memberId);
-
-		ChatPacketHandler::SendTeamAddPlayer(member, false, team->local, false, memberId, otherMemberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
-
-		if (otherMember) {
-			ChatPacketHandler::SendTeamAddPlayer(otherMember, false, team->local, false, member.playerID, memberName, member.zoneID);
-		}
-	}
-}
-
-void PlayerContainer::RemoveMember(TeamData* team, LWOOBJID playerID, bool disband, bool kicked, bool leaving, bool silent) {
-	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
-
-	if (index == team->memberIDs.end()) return;
-
-	const auto& member = GetPlayerData(playerID);
-
-	if (member && !silent) {
-		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
-	}
-
-	const auto memberName = GetName(playerID);
-
-	for (const auto memberId : team->memberIDs) {
-		if (silent && memberId == playerID) {
-			continue;
-		}
-
-		const auto& otherMember = GetPlayerData(memberId);
-
-		if (!otherMember) continue;
-
-		ChatPacketHandler::SendTeamRemovePlayer(otherMember, disband, kicked, leaving, false, team->leaderID, playerID, memberName);
-	}
-
-	team->memberIDs.erase(index);
-
-	UpdateTeamsOnWorld(team, false);
-
-	if (team->memberIDs.size() <= 1) {
-		DisbandTeam(team);
-	} else {
-		if (playerID == team->leaderID) {
-			PromoteMember(team, team->memberIDs[0]);
-		}
-	}
-}
-
-void PlayerContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) {
-	team->leaderID = newLeader;
-
-	for (const auto memberId : team->memberIDs) {
-		const auto& otherMember = GetPlayerData(memberId);
-
-		if (!otherMember) continue;
-
-		ChatPacketHandler::SendTeamSetLeader(otherMember, newLeader);
-	}
-}
-
-void PlayerContainer::DisbandTeam(TeamData* team) {
-	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
-
-	if (index == mTeams.end()) return;
-
-	for (const auto memberId : team->memberIDs) {
-		const auto& otherMember = GetPlayerData(memberId);
-
-		if (!otherMember) continue;
-
-		const auto memberName = GeneralUtils::UTF8ToUTF16(otherMember.playerName);
-
-		ChatPacketHandler::SendTeamSetLeader(otherMember, LWOOBJID_EMPTY);
-		ChatPacketHandler::SendTeamRemovePlayer(otherMember, true, false, false, team->local, team->leaderID, otherMember.playerID, memberName);
-	}
-
-	UpdateTeamsOnWorld(team, true);
-
-	mTeams.erase(index);
-
-	delete team;
-}
-
-void PlayerContainer::TeamStatusUpdate(TeamData* team) {
-	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
-
-	if (index == mTeams.end()) return;
-
-	const auto& leader = GetPlayerData(team->leaderID);
-
-	if (!leader) return;
-
-	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
-
-	for (const auto memberId : team->memberIDs) {
-		const auto& otherMember = GetPlayerData(memberId);
-
-		if (!otherMember) continue;
-
-		if (!team->local) {
-			ChatPacketHandler::SendTeamStatus(otherMember, team->leaderID, leader.zoneID, team->lootFlag, 0, leaderName);
-		}
-	}
-
-	UpdateTeamsOnWorld(team, false);
-}
-
-void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::TEAM_GET_STATUS);
-
-	bitStream.Write(team->teamID);
-	bitStream.Write(deleteTeam);
-
-	if (!deleteTeam) {
-		bitStream.Write(team->lootFlag);
-		bitStream.Write<char>(team->memberIDs.size());
-		for (const auto memberID : team->memberIDs) {
-			bitStream.Write(memberID);
-		}
-	}
-
-	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
-}
-
 std::u16string PlayerContainer::GetName(LWOOBJID playerID) {
 	const auto iter = m_Names.find(playerID);
 
@@ -417,3 +195,12 @@ const PlayerData& PlayerContainer::GetPlayerData(const LWOOBJID& playerID) {
 const PlayerData& PlayerContainer::GetPlayerData(const std::string& playerName) {
 	return GetPlayerDataMutable(playerName);
 }
+
+void PlayerContainer::Shutdown() {
+	m_Players.erase(LWOOBJID_EMPTY);
+	while (!m_Players.empty()) {
+		const auto& [id, playerData] = *m_Players.begin();
+		Database::Get()->UpdateActivityLog(id, eActivityType::PlayerLoggedOut, playerData.zoneID.GetMapID());
+		m_Players.erase(m_Players.begin());
+	}
+}

dChatServer/PlayerContainer.h

@@ -9,6 +9,8 @@
 
 enum class eGameMasterLevel : uint8_t;
 
+struct TeamData;
+
 struct IgnoreData {
 	IgnoreData(const std::string& name, const LWOOBJID& id) : playerName{ name }, playerId{ id } {}
 	inline bool operator==(const std::string& other) const noexcept {
@@ -36,7 +38,7 @@ struct PlayerData {
 		return muteExpire == 1 || muteExpire > time(NULL);
 	}
 
-	SystemAddress sysAddr{};
+	SystemAddress worldServerSysAddr{};
 	LWOZONEID zoneID{};
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	time_t muteExpire = 0;
@@ -46,8 +48,10 @@ struct PlayerData {
 	std::vector<IgnoreData> ignoredPlayers;
 	eGameMasterLevel gmLevel = static_cast<eGameMasterLevel>(0); // CIVILLIAN
 	bool isFTP = false;
+	bool isLogin = false;
 };
 
+
 struct TeamData {
 	TeamData();
 	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
@@ -62,38 +66,31 @@ class PlayerContainer {
 public:
 	void Initialize();
 	void InsertPlayer(Packet* packet);
-	void RemovePlayer(Packet* packet);
+	void ScheduleRemovePlayer(Packet* packet);
+	void RemovePlayer(const LWOOBJID playerID);
 	void MuteUpdate(Packet* packet);
-	void CreateTeamServer(Packet* packet);
 	void BroadcastMuteUpdate(LWOOBJID player, time_t time);
+	void Shutdown();
 
 	const PlayerData& GetPlayerData(const LWOOBJID& playerID);
 	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);
-	TeamData* GetTeam(LWOOBJID playerID);
-	void AddMember(TeamData* team, LWOOBJID playerID);
-	void RemoveMember(TeamData* team, LWOOBJID playerID, bool disband, bool kicked, bool leaving, bool silent = false);
-	void PromoteMember(TeamData* team, LWOOBJID newLeader);
-	void DisbandTeam(TeamData* team);
-	void TeamStatusUpdate(TeamData* team);
-	void UpdateTeamsOnWorld(TeamData* team, bool deleteTeam);
 	std::u16string GetName(LWOOBJID playerID);
 	LWOOBJID GetId(const std::u16string& playerName);
+	void Update(const float deltaTime);
+
+	uint32_t GetPlayerCount() { return m_PlayerCount; };
+	uint32_t GetSimCount() { return m_SimCount; };
+	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() const { return m_Players; };
 	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
 	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
+	bool PlayerBeingRemoved(const LWOOBJID playerID) { return m_PlayersToRemove.contains(playerID); }
 
 private:
-	LWOOBJID m_TeamIDCounter = 0;
 	std::map<LWOOBJID, PlayerData> m_Players;
-	std::vector<TeamData*> mTeams;
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
+	std::map<LWOOBJID, float> m_PlayersToRemove;
 	uint32_t m_MaxNumberOfBestFriends = 5;
 	uint32_t m_MaxNumberOfFriends = 50;
 	uint32_t m_PlayerCount = 0;

dChatServer/TeamContainer.cpp

@@ -0,0 +1,669 @@
+#include "TeamContainer.h"
+
+#include "ChatPackets.h"
+
+#include "MessageType/Chat.h"
+#include "MessageType/Game.h"
+
+#include "ChatPacketHandler.h"
+#include "PlayerContainer.h"
+
+namespace {
+	TeamContainer::Data g_TeamContainer{};
+	LWOOBJID g_TeamIDCounter = 0;
+}
+
+const TeamContainer::Data& TeamContainer::GetTeamContainer() {
+	return g_TeamContainer;
+}
+
+std::vector<TeamData*>& TeamContainer::GetTeamsMut() {
+	return g_TeamContainer.mTeams;
+}
+
+const std::vector<TeamData*>& TeamContainer::GetTeams() {
+	return GetTeamsMut();
+}
+
+void TeamContainer::Shutdown() {
+	for (auto* team : g_TeamContainer.mTeams) if (team) delete team;
+}
+
+void TeamContainer::HandleTeamInvite(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+
+	LWOOBJID playerID;
+	LUWString invitedPlayer;
+
+	inStream.Read(playerID);
+	inStream.IgnoreBytes(4);
+	inStream.Read(invitedPlayer);
+
+	const auto& player = Game::playerContainer.GetPlayerData(playerID);
+
+	if (!player) return;
+
+	auto* team = GetTeam(playerID);
+
+	if (team == nullptr) {
+		team = CreateTeam(playerID);
+	}
+
+	const auto& other = Game::playerContainer.GetPlayerData(invitedPlayer.GetAsString());
+
+	if (!other) return;
+
+	if (GetTeam(other.playerID) != nullptr) {
+		return;
+	}
+
+	if (team->memberIDs.size() > 3) {
+		// no more teams greater than 4
+
+		LOG("Someone tried to invite a 5th player to a team");
+		return;
+	}
+
+	SendTeamInvite(other, player);
+
+	LOG("Got team invite: %llu -> %s", playerID, invitedPlayer.GetAsString().c_str());
+
+	bool failed = false;
+	for (const auto& ignore : other.ignoredPlayers) {
+		if (ignore.playerId == player.playerID) {
+			failed = true;
+			break;
+		}
+	}
+
+	ChatPackets::TeamInviteInitialResponse response{};
+	response.inviteFailedToSend = failed;
+	response.playerName = invitedPlayer.string;
+	ChatPackets::SendRoutedMsg(response, playerID, player.worldServerSysAddr);
+}
+
+void TeamContainer::HandleTeamInviteResponse(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+	char declined = 0;
+	inStream.Read(declined);
+	LWOOBJID leaderID = LWOOBJID_EMPTY;
+	inStream.Read(leaderID);
+
+	LOG("Invite reponse received: %llu -> %llu (%d)", playerID, leaderID, declined);
+
+	if (declined) {
+		return;
+	}
+
+	auto* team = GetTeam(leaderID);
+
+	if (team == nullptr) {
+		LOG("Failed to find team for leader (%llu)", leaderID);
+
+		team = GetTeam(playerID);
+	}
+
+	if (team == nullptr) {
+		LOG("Failed to find team for player (%llu)", playerID);
+		return;
+	}
+
+	AddMember(team, playerID);
+}
+
+void TeamContainer::HandleTeamLeave(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+
+	auto* team = GetTeam(playerID);
+
+	LOG("(%llu) leaving team", playerID);
+
+	if (team != nullptr) {
+		RemoveMember(team, playerID, false, false, true);
+	}
+}
+
+void TeamContainer::HandleTeamKick(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	LUWString kickedPlayer;
+
+	inStream.Read(playerID);
+	inStream.IgnoreBytes(4);
+	inStream.Read(kickedPlayer);
+
+
+	LOG("(%llu) kicking (%s) from team", playerID, kickedPlayer.GetAsString().c_str());
+
+	const auto& kicked = Game::playerContainer.GetPlayerData(kickedPlayer.GetAsString());
+
+	LWOOBJID kickedId = LWOOBJID_EMPTY;
+
+	if (kicked) {
+		kickedId = kicked.playerID;
+	} else {
+		kickedId = Game::playerContainer.GetId(kickedPlayer.string);
+	}
+
+	if (kickedId == LWOOBJID_EMPTY) return;
+
+	auto* team = GetTeam(playerID);
+
+	if (team != nullptr) {
+		if (team->leaderID != playerID || team->leaderID == kickedId) return;
+
+		RemoveMember(team, kickedId, false, true, false);
+	}
+}
+
+void TeamContainer::HandleTeamPromote(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	LUWString promotedPlayer;
+
+	inStream.Read(playerID);
+	inStream.IgnoreBytes(4);
+	inStream.Read(promotedPlayer);
+
+	LOG("(%llu) promoting (%s) to team leader", playerID, promotedPlayer.GetAsString().c_str());
+
+	const auto& promoted = Game::playerContainer.GetPlayerData(promotedPlayer.GetAsString());
+
+	if (!promoted) return;
+
+	auto* team = GetTeam(playerID);
+
+	if (team != nullptr) {
+		if (team->leaderID != playerID) return;
+
+		PromoteMember(team, promoted.playerID);
+	}
+}
+
+void TeamContainer::HandleTeamLootOption(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+
+	char option;
+	inStream.Read(option);
+
+	auto* team = GetTeam(playerID);
+
+	if (team != nullptr) {
+		if (team->leaderID != playerID) return;
+
+		team->lootFlag = option;
+
+		TeamStatusUpdate(team);
+
+		UpdateTeamsOnWorld(team, false);
+	}
+}
+
+void TeamContainer::HandleTeamStatusRequest(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+
+	auto* team = GetTeam(playerID);
+	const auto& data = Game::playerContainer.GetPlayerData(playerID);
+
+	if (team != nullptr && data) {
+		LOG_DEBUG("Player %llu is requesting team status", playerID);
+		if (team->local && data.zoneID.GetMapID() != team->zoneId.GetMapID() && data.zoneID.GetCloneID() != team->zoneId.GetCloneID()) {
+			RemoveMember(team, playerID, false, false, false, true);
+
+			return;
+		}
+
+		if (team->memberIDs.size() <= 1 && !team->local) {
+			DisbandTeam(team, LWOOBJID_EMPTY, u"");
+
+			return;
+		}
+
+		if (!team->local) {
+			SendTeamSetLeader(data, team->leaderID);
+		} else {
+			SendTeamSetLeader(data, LWOOBJID_EMPTY);
+		}
+
+		TeamStatusUpdate(team);
+
+		const auto leaderName = GeneralUtils::UTF8ToUTF16(data.playerName);
+
+		for (const auto memberId : team->memberIDs) {
+			const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+			if (memberId == playerID) continue;
+
+			const auto memberName = Game::playerContainer.GetName(memberId);
+
+			if (otherMember) {
+				SendTeamSetOffWorldFlag(otherMember, data.playerID, data.zoneID);
+			}
+			SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
+		}
+
+		UpdateTeamsOnWorld(team, false);
+	}
+}
+
+void TeamContainer::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::TEAM_INVITE);
+
+	bitStream.Write(LUWString(sender.playerName.c_str()));
+	bitStream.Write(sender.playerID);
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::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, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_INVITE_CONFIRM);
+
+	bitStream.Write(bLeaderIsFreeTrial);
+	bitStream.Write(i64LeaderID);
+	bitStream.Write(i64LeaderZoneID);
+	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
+	bitStream.Write(ucLootFlag);
+	bitStream.Write(ucNumOfOtherPlayers);
+	bitStream.Write(ucResponseCode);
+	bitStream.Write<uint32_t>(wsLeaderName.size());
+	for (const auto character : wsLeaderName) {
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_GET_STATUS_RESPONSE);
+
+	bitStream.Write(i64LeaderID);
+	bitStream.Write(i64LeaderZoneID);
+	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
+	bitStream.Write(ucLootFlag);
+	bitStream.Write(ucNumOfOtherPlayers);
+	bitStream.Write<uint32_t>(wsLeaderName.size());
+	for (const auto character : wsLeaderName) {
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_SET_LEADER);
+
+	bitStream.Write(i64PlayerID);
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_ADD_PLAYER);
+
+	bitStream.Write(bIsFreeTrial);
+	bitStream.Write(bLocal);
+	bitStream.Write(bNoLootOnDeath);
+	bitStream.Write(i64PlayerID);
+	bitStream.Write<uint32_t>(wsPlayerName.size());
+	for (const auto character : wsPlayerName) {
+		bitStream.Write(character);
+	}
+	bitStream.Write1();
+	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
+		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
+	}
+	bitStream.Write(zoneID);
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_REMOVE_PLAYER);
+
+	bitStream.Write(bDisband);
+	bitStream.Write(bIsKicked);
+	bitStream.Write(bIsLeaving);
+	bitStream.Write(bLocal);
+	bitStream.Write(i64LeaderID);
+	bitStream.Write(i64PlayerID);
+	bitStream.Write<uint32_t>(wsPlayerName.size());
+	for (const auto character : wsPlayerName) {
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::WORLD_ROUTE_PACKET);
+	bitStream.Write(receiver.playerID);
+
+	//portion that will get routed:
+	CMSGHEADER;
+
+	bitStream.Write(receiver.playerID);
+	bitStream.Write(MessageType::Game::TEAM_SET_OFF_WORLD_FLAG);
+
+	bitStream.Write(i64PlayerID);
+	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
+		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
+	}
+	bitStream.Write(zoneID);
+
+	SystemAddress sysAddr = receiver.worldServerSysAddr;
+	SEND_PACKET;
+}
+
+void TeamContainer::CreateTeamServer(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID playerID;
+	inStream.Read(playerID);
+	size_t membersSize = 0;
+	inStream.Read(membersSize);
+
+	if (membersSize >= 4) {
+		LOG("Tried to create a team with more than 4 players");
+		return;
+	}
+
+	std::vector<LWOOBJID> members;
+
+	members.reserve(membersSize);
+
+	for (size_t i = 0; i < membersSize; i++) {
+		LWOOBJID member;
+		inStream.Read(member);
+		members.push_back(member);
+	}
+
+	LWOZONEID zoneId;
+
+	inStream.Read(zoneId);
+
+	auto* team = CreateLocalTeam(members);
+
+	if (team != nullptr) {
+		team->zoneId = zoneId;
+		UpdateTeamsOnWorld(team, false);
+	}
+}
+
+TeamData* TeamContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
+	if (members.empty()) {
+		return nullptr;
+	}
+
+	TeamData* newTeam = nullptr;
+
+	for (const auto member : members) {
+		auto* team = GetTeam(member);
+
+		if (team != nullptr) {
+			RemoveMember(team, member, false, false, true);
+		}
+
+		if (newTeam == nullptr) {
+			newTeam = CreateTeam(member, true);
+		} else {
+			AddMember(newTeam, member);
+		}
+	}
+
+	newTeam->lootFlag = 0;
+
+	TeamStatusUpdate(newTeam);
+
+	return newTeam;
+}
+
+TeamData* TeamContainer::CreateTeam(LWOOBJID leader, bool local) {
+	auto* team = new TeamData();
+
+	team->teamID = ++g_TeamIDCounter;
+	team->leaderID = leader;
+	team->local = local;
+
+	GetTeamsMut().push_back(team);
+
+	AddMember(team, leader);
+
+	return team;
+}
+
+TeamData* TeamContainer::GetTeam(LWOOBJID playerID) {
+	for (auto* team : GetTeams()) {
+		if (std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID) == team->memberIDs.end()) continue;
+
+		return team;
+	}
+
+	return nullptr;
+}
+
+void TeamContainer::AddMember(TeamData* team, LWOOBJID playerID) {
+	if (team->memberIDs.size() >= 4) {
+		LOG("Tried to add player to team that already had 4 players");
+		const auto& player = Game::playerContainer.GetPlayerData(playerID);
+		if (!player) return;
+		ChatPackets::SendSystemMessage(player.worldServerSysAddr, u"The teams is full! You have not been added to a team!");
+		return;
+	}
+
+	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
+
+	if (index != team->memberIDs.end()) return;
+
+	team->memberIDs.push_back(playerID);
+
+	const auto& leader = Game::playerContainer.GetPlayerData(team->leaderID);
+	const auto& member = Game::playerContainer.GetPlayerData(playerID);
+
+	if (!leader || !member) return;
+
+	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
+	const auto memberName = GeneralUtils::UTF8ToUTF16(member.playerName);
+
+	SendTeamInviteConfirm(member, false, leader.playerID, leader.zoneID, team->lootFlag, 0, 0, leaderName);
+
+	if (!team->local) {
+		SendTeamSetLeader(member, leader.playerID);
+	} else {
+		SendTeamSetLeader(member, LWOOBJID_EMPTY);
+	}
+
+	UpdateTeamsOnWorld(team, false);
+
+	for (const auto memberId : team->memberIDs) {
+		const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+		if (otherMember == member) continue;
+
+		const auto otherMemberName = Game::playerContainer.GetName(memberId);
+
+		SendTeamAddPlayer(member, false, team->local, false, memberId, otherMemberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
+
+		if (otherMember) {
+			SendTeamAddPlayer(otherMember, false, team->local, false, member.playerID, memberName, member.zoneID);
+		}
+	}
+}
+
+void TeamContainer::RemoveMember(TeamData* team, LWOOBJID causingPlayerID, bool disband, bool kicked, bool leaving, bool silent) {
+	LOG_DEBUG("Player %llu is leaving team %i", causingPlayerID, team->teamID);
+	const auto index = std::ranges::find(team->memberIDs, causingPlayerID);
+
+	if (index == team->memberIDs.end()) return;
+
+	team->memberIDs.erase(index);
+
+	const auto& member = Game::playerContainer.GetPlayerData(causingPlayerID);
+
+	const auto causingMemberName = Game::playerContainer.GetName(causingPlayerID);
+
+	if (member && !silent) {
+		SendTeamRemovePlayer(member, disband, kicked, leaving, team->local, LWOOBJID_EMPTY, causingPlayerID, causingMemberName);
+	}
+
+	if (team->memberIDs.size() <= 1) {
+		DisbandTeam(team, causingPlayerID, causingMemberName);
+	} else /* team has enough members to be a team still */ {
+		team->leaderID = (causingPlayerID == team->leaderID) ? team->memberIDs[0] : team->leaderID;
+		for (const auto memberId : team->memberIDs) {
+			if (silent && memberId == causingPlayerID) {
+				continue;
+			}
+
+			const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+			if (!otherMember) continue;
+
+			SendTeamRemovePlayer(otherMember, disband, kicked, leaving, team->local, team->leaderID, causingPlayerID, causingMemberName);
+		}
+
+		UpdateTeamsOnWorld(team, false);
+	}
+}
+
+void TeamContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) {
+	team->leaderID = newLeader;
+
+	for (const auto memberId : team->memberIDs) {
+		const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+		if (!otherMember) continue;
+
+		SendTeamSetLeader(otherMember, newLeader);
+	}
+}
+
+void TeamContainer::DisbandTeam(TeamData* team, const LWOOBJID causingPlayerID, const std::u16string& causingPlayerName) {
+	const auto index = std::ranges::find(GetTeams(), team);
+
+	if (index == GetTeams().end()) return;
+	LOG_DEBUG("Disbanding team %i", (*index)->teamID);
+
+	for (const auto memberId : team->memberIDs) {
+		const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+		if (!otherMember) continue;
+
+		SendTeamSetLeader(otherMember, LWOOBJID_EMPTY);
+		SendTeamRemovePlayer(otherMember, true, false, false, team->local, team->leaderID, causingPlayerID, causingPlayerName);
+	}
+
+	UpdateTeamsOnWorld(team, true);
+
+	GetTeamsMut().erase(index);
+
+	delete team;
+}
+
+void TeamContainer::TeamStatusUpdate(TeamData* team) {
+	const auto index = std::find(GetTeams().begin(), GetTeams().end(), team);
+
+	if (index == GetTeams().end()) return;
+
+	const auto& leader = Game::playerContainer.GetPlayerData(team->leaderID);
+
+	if (!leader) return;
+
+	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
+
+	for (const auto memberId : team->memberIDs) {
+		const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+
+		if (!otherMember) continue;
+
+		if (!team->local) {
+			SendTeamStatus(otherMember, team->leaderID, leader.zoneID, team->lootFlag, 0, leaderName);
+		}
+	}
+
+	UpdateTeamsOnWorld(team, false);
+}
+
+void TeamContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::TEAM_GET_STATUS);
+
+	bitStream.Write(team->teamID);
+	bitStream.Write(deleteTeam);
+
+	if (!deleteTeam) {
+		bitStream.Write(team->lootFlag);
+		bitStream.Write<char>(team->memberIDs.size());
+		for (const auto memberID : team->memberIDs) {
+			bitStream.Write(memberID);
+		}
+	}
+
+	Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+}

dChatServer/TeamContainer.h

@@ -0,0 +1,59 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef TEAMCONTAINER_H
+#define TEAMCONTAINER_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "dCommonVars.h"
+
+struct Packet;
+struct PlayerData;
+struct TeamData;
+
+namespace TeamContainer {
+	struct Data {
+		std::vector<TeamData*> mTeams;
+	};
+
+	void Shutdown();
+
+	void HandleTeamInvite(Packet* packet);
+	void HandleTeamInviteResponse(Packet* packet);
+	void HandleTeamLeave(Packet* packet);
+	void HandleTeamKick(Packet* packet);
+	void HandleTeamPromote(Packet* packet);
+	void HandleTeamLootOption(Packet* packet);
+	void HandleTeamStatusRequest(Packet* packet);
+
+	void SendTeamInvite(const PlayerData& receiver, const PlayerData& sender);
+	void SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName);
+	void SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName);
+	void SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID);
+	void SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID);
+
+	/* Sends a message to the provided `receiver` with information about the updated team. If `i64LeaderID` is not LWOOBJID_EMPTY, the client will update the leader to that new playerID. */
+	void SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName);
+	void SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID);
+
+	void CreateTeamServer(Packet* packet);
+
+	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
+	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
+	TeamData* GetTeam(LWOOBJID playerID);
+	void AddMember(TeamData* team, LWOOBJID playerID);
+	void RemoveMember(TeamData* team, LWOOBJID playerID, bool disband, bool kicked, bool leaving, bool silent = false);
+	void PromoteMember(TeamData* team, LWOOBJID newLeader);
+	void DisbandTeam(TeamData* team, const LWOOBJID causingPlayerID, const std::u16string& causingPlayerName);
+	void TeamStatusUpdate(TeamData* team);
+	void UpdateTeamsOnWorld(TeamData* team, bool deleteTeam);
+
+	const TeamContainer::Data& GetTeamContainer();
+	std::vector<TeamData*>& GetTeamsMut();
+	const std::vector<TeamData*>& GetTeams();
+};
+
+#endif //!TEAMCONTAINER_H

dCommon/Amf3.h

@@ -5,6 +5,7 @@
 #include "Logger.h"
 #include "Game.h"
 
+#include <type_traits>
 #include <unordered_map>
 #include <vector>
 
@@ -39,6 +40,7 @@ public:
 // AMFValue template class instantiations
 template <typename ValueType>
 class AMFValue : public AMFBaseValue {
+	static_assert(!std::is_same_v<ValueType, std::string_view>, "AMFValue cannot be instantiated with std::string_view");
 public:
 	AMFValue() = default;
 	AMFValue(const ValueType value) : m_Data{ value } {}
@@ -51,6 +53,15 @@ public:
 
 	void SetValue(const ValueType value) { m_Data = value; }
 
+	AMFValue<ValueType>& operator=(const AMFValue<ValueType>& other) {
+		return operator=(other.m_Data);
+	}
+
+	AMFValue<ValueType>& operator=(const ValueType& other) {
+		m_Data = other;
+		return *this;
+	}
+
 protected:
 	ValueType m_Data;
 };
@@ -210,13 +221,17 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const std::string_view key, std::unique_ptr<AMFBaseValue> value) {
+	template<typename AmfType>
+	AmfType& Insert(const std::string_view key, std::unique_ptr<AmfType> value) {
 		const auto element = m_Associative.find(key);
+		auto& toReturn = *value;
 		if (element != m_Associative.cend() && element->second) {
 			element->second = std::move(value);
 		} else {
 			m_Associative.emplace(key, std::move(value));
 		}
+
+		return toReturn;
 	}
 
 	/**
@@ -228,11 +243,15 @@ public:
 	 * @param key The key to associate with the value
 	 * @param value The value to insert
 	 */
-	void Insert(const size_t index, std::unique_ptr<AMFBaseValue> value) {
+	template<typename AmfType>
+	AmfType& Insert(const size_t index, std::unique_ptr<AmfType> value) {
+		auto& toReturn = *value;
 		if (index >= m_Dense.size()) {
 			m_Dense.resize(index + 1);
 		}
+
 		m_Dense.at(index) = std::move(value);
+		return toReturn;
 	}
 
 	/**
@@ -257,10 +276,10 @@ public:
 	 *
 	 * @param key The key to remove from the associative portion
 	 */
-	void Remove(const std::string& key, const bool deleteValue = true) {
+	void Remove(const std::string& key) {
 		const AMFAssociative::const_iterator it = m_Associative.find(key);
 		if (it != m_Associative.cend()) {
-			if (deleteValue) m_Associative.erase(it);
+			m_Associative.erase(it);
 		}
 	}
 
@@ -343,6 +362,33 @@ public:
 		return index < m_Dense.size() ? m_Dense.at(index).get() : nullptr;
 	}
 
+	void Reset() {
+		m_Associative.clear();
+		m_Dense.clear();
+	}
+
+	template<typename AmfType = AMFArrayValue>
+	AmfType& PushDebug(const std::string_view name) {
+		auto* value = PushArray();
+		value->Insert("name", name.data());
+		return value->Insert<AmfType>("value", std::make_unique<AmfType>());
+	}
+
+	AMFArrayValue& PushDebug(const NiPoint3& point) {
+		PushDebug<AMFDoubleValue>("X") = point.x;
+		PushDebug<AMFDoubleValue>("Y") = point.y;
+		PushDebug<AMFDoubleValue>("Z") = point.z;
+		return *this;
+	}
+
+	AMFArrayValue& PushDebug(const NiQuaternion& rot) {
+		PushDebug<AMFDoubleValue>("W") = rot.w;
+		PushDebug<AMFDoubleValue>("X") = rot.x;
+		PushDebug<AMFDoubleValue>("Y") = rot.y;
+		PushDebug<AMFDoubleValue>("Z") = rot.z;
+		return *this;
+	}
+
 private:
 	/**
 	 * The associative portion.  These values are key'd with strings to an AMFValue.

dCommon/BinaryIO.cpp

@@ -2,16 +2,25 @@
 #include <string>
 
 //For reading null-terminated strings
-std::string BinaryIO::ReadString(std::istream& instream) {
+template<typename StringType>
-	std::string toReturn;
+StringType ReadString(std::istream& instream) {
-	char buffer;
+	StringType toReturn{};
+	typename StringType::value_type buffer{};
 
 	BinaryIO::BinaryRead(instream, buffer);
 
 	while (buffer != 0x00) {
 		toReturn += buffer;
-		BinaryRead(instream, buffer);
+		BinaryIO::BinaryRead(instream, buffer);
 	}
 
 	return toReturn;
 }
+
+std::string BinaryIO::ReadString(std::istream& instream) {
+	return ::ReadString<std::string>(instream);
+}
+
+std::u8string BinaryIO::ReadU8String(std::istream& instream) {
+	return ::ReadString<std::u8string>(instream);
+}

dCommon/BinaryIO.h

@@ -65,6 +65,8 @@ namespace BinaryIO {
 
 	std::string ReadString(std::istream& instream);
 
+	std::u8string ReadU8String(std::istream& instream);
+
 	inline bool DoesFileExist(const std::string& name) {
 		std::ifstream f(name.c_str());
 		return f.good();

dCommon/BrickByBrickFix.cpp

@@ -8,6 +8,7 @@
 
 #include "Database.h"
 #include "Game.h"
+#include "Sd0.h"
 #include "ZCompression.h"
 #include "Logger.h"
 
@@ -44,10 +45,10 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 				}
 
 				// Ignore the valgrind warning about uninitialized values.  These are discarded later when we know the actual uncompressed size.
-				std::unique_ptr<uint8_t[]> uncompressedChunk(new uint8_t[ZCompression::MAX_SD0_CHUNK_SIZE]);
+				std::unique_ptr<uint8_t[]> uncompressedChunk(new uint8_t[Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE]);
 				int32_t err{};
 				int32_t actualUncompressedSize = ZCompression::Decompress(
-					compressedChunk.get(), chunkSize, uncompressedChunk.get(), ZCompression::MAX_SD0_CHUNK_SIZE, err);
+					compressedChunk.get(), chunkSize, uncompressedChunk.get(), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
 
 				if (actualUncompressedSize != -1) {
 					uint32_t previousSize = completeUncompressedModel.size();
@@ -117,13 +118,13 @@ uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 			}
 
 			std::string outputString(sd0ConvertedModel.get(), oldLxfmlSizeWithHeader);
-			std::istringstream outputStringStream(outputString);
+			std::stringstream outputStringStream(outputString);
 
 			try {
 				Database::Get()->UpdateUgcModelData(model.id, outputStringStream);
 				LOG("Updated model %i to sd0", model.id);
 				updatedModels++;
-			} catch (sql::SQLException exception) {
+			} catch (std::exception& exception) {
 				LOG("Failed to update model %i.  This model should be inspected manually to see why."
 					"The database error is %s", model.id, exception.what());
 			}

dCommon/CMakeLists.txt

@@ -16,6 +16,11 @@ set(DCOMMON_SOURCES
 		"BrickByBrickFix.cpp"
 		"BinaryPathFinder.cpp"
 		"FdbToSqlite.cpp"
+		"JSONUtils.cpp"
+		"TinyXmlUtils.cpp"
+		"Sd0.cpp"
+		"Lxfml.cpp"
+		"LxfmlBugged.cpp"
 )
 
 # Workaround for compiler bug where the optimized code could result in a memcpy of 0 bytes, even though that isnt possible.
@@ -37,7 +42,6 @@ target_include_directories(dCommon
 	"${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)
@@ -50,6 +54,8 @@ elseif (WIN32)
 		zlib
 		URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
 		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
+		GIT_PROGRESS TRUE
+		GIT_SHALLOW 1
 	)
 
 	# Disable warning about no project version.
@@ -70,5 +76,6 @@ else ()
 endif ()
 
 target_link_libraries(dCommon
+	PUBLIC glm::glm
 	PRIVATE ZLIB::ZLIB bcrypt tinyxml2
 	INTERFACE dDatabase)

dCommon/DluAssert.h

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #ifdef _DEBUG
-#	define DluAssert(expression) assert(expression)
+#	define DluAssert(expression) do { assert(expression); } while(0)
 #else
 #	define DluAssert(expression)
 #endif

dCommon/FdbToSqlite.cpp

@@ -65,13 +65,14 @@ int64_t FdbToSqlite::Convert::ReadInt64(std::istream& cdClientBuffer) {
 	return value;
 }
 
+// cdclient is encoded in latin1
 std::string FdbToSqlite::Convert::ReadString(std::istream& cdClientBuffer) {
 	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
-	auto readString = BinaryIO::ReadString(cdClientBuffer);
+	const auto readString = BinaryIO::ReadU8String(cdClientBuffer);
 
 	cdClientBuffer.seekg(prevPosition);
-	return readString;
+	return GeneralUtils::Latin1ToUTF8(readString);
 }
 
 int32_t FdbToSqlite::Convert::SeekPointer(std::istream& cdClientBuffer) {

dCommon/GeneralUtils.cpp

@@ -7,6 +7,10 @@
 #include <filesystem>
 #include <map>
 
+#include "json.hpp"
+
+using json = nlohmann::json;
+
 template <typename T>
 static inline size_t MinSize(const size_t size, const std::basic_string_view<T> string) {
 	if (size == SIZE_MAX || size > string.size()) {
@@ -167,6 +171,15 @@ std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view string, const s
 	return ret;
 }
 
+std::string GeneralUtils::Latin1ToUTF8(const std::u8string_view string, const size_t size) {
+	std::string toReturn{};
+
+	for (const auto u : string) {
+		PushUTF8CodePoint(toReturn, u);
+	}
+	return toReturn;
+}
+
 //! Converts a (potentially-ill-formed) UTF-16 string to UTF-8
 //! See: <http://simonsapin.github.io/wtf-8/#decoding-ill-formed-utf-16>
 std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const size_t size) {
@@ -175,9 +188,9 @@ std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const si
 	ret.reserve(newSize);
 
 	for (size_t i = 0; i < newSize; ++i) {
-		const char16_t u = string[i];
+		const auto u = string[i];
 		if (IsLeadSurrogate(u) && (i + 1) < newSize) {
-			const char16_t next = string[i + 1];
+			const auto next = string[i + 1];
 			if (IsTrailSurrogate(next)) {
 				i += 1;
 				const char32_t cp = 0x10000
@@ -291,11 +304,12 @@ std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
 
 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{};
+	std::map<uint32_t, std::string> filenames{};
 	for (const auto& t : std::filesystem::directory_iterator(folder)) {
-        auto filename = t.path().filename().string();
+		if (t.is_directory() || t.is_symlink()) continue;
-        const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
+		auto filename = t.path().filename().string();
-        filenames.emplace(index, std::move(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.
@@ -317,6 +331,17 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 	return sortedFiles;
 }
 
+template<>
+[[nodiscard]] std::optional<json> GeneralUtils::TryParse(std::string_view str) {
+	try {
+		return json::parse(str);
+	} catch (const std::exception& e) {
+		return std::nullopt;
+	} catch (...) {
+		return std::nullopt;
+	}
+}
+
 #if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
 // MacOS floating-point parse function specializations

dCommon/GeneralUtils.h

@@ -3,6 +3,7 @@
 // C++
 #include <charconv>
 #include <cstdint>
+#include <cmath>
 #include <ctime>
 #include <functional>
 #include <optional>
@@ -18,6 +19,9 @@
 #include "dPlatforms.h"
 #include "Game.h"
 #include "Logger.h"
+#include "DluAssert.h"
+
+#include <glm/ext/vector_float3.hpp>
 
 enum eInventoryType : uint32_t;
 enum class eObjectBits : size_t;
@@ -51,6 +55,14 @@ namespace GeneralUtils {
 		bool _NextUTF8Char(std::string_view& slice, uint32_t& out);
 	}
 
+	//! Converts a Latin1 string to a UTF-8 string
+	/*!
+	  \param string The string to convert
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
+	  \return An UTF-8 representation of the string
+	 */
+	std::string Latin1ToUTF8(const std::u8string_view string, const size_t size = SIZE_MAX);
+
 	//! Converts a UTF-16 string to a UTF-8 string
 	/*!
 	  \param string The string to convert
@@ -137,7 +149,7 @@ namespace GeneralUtils {
 	template <typename... Bases>
 	struct overload : Bases... {
 		using is_transparent = void;
-		using Bases::operator() ... ;
+		using Bases::operator() ...;
 	};
 
 	struct char_pointer_hash {
@@ -193,6 +205,10 @@ namespace GeneralUtils {
 		return isParsed ? static_cast<T>(result) : std::optional<T>{};
 	}
 
+	template<typename T>
+		requires(!Numeric<T>)
+	[[nodiscard]] std::optional<T> TryParse(std::string_view str);
+
 #if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
 	// MacOS floating-point parse helper function specializations
@@ -209,7 +225,7 @@ namespace GeneralUtils {
 	*/
 	template <std::floating_point T>
 	[[nodiscard]] std::optional<T> TryParse(std::string_view str) noexcept
-	try {
+		try {
 		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
 
 		size_t parseNum;
@@ -231,7 +247,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_view strX, const std::string_view strY, const std::string_view strZ) {
+	[[nodiscard]] std::optional<T> 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;
 
@@ -239,7 +255,7 @@ namespace GeneralUtils {
 		if (!y) return std::nullopt;
 
 		const auto z = TryParse<float>(strZ);
-		return z ? std::make_optional<NiPoint3>(x.value(), y.value(), z.value()) : std::nullopt;
+		return z ? std::make_optional<T>(x.value(), y.value(), z.value()) : std::nullopt;
 	}
 
 	/**
@@ -248,8 +264,8 @@ 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::span<const std::string> str) {
+	[[nodiscard]] std::optional<T> TryParse(const std::span<const std::string> str) {
-		return (str.size() == 3) ? TryParse<NiPoint3>(str[0], str[1], str[2]) : std::nullopt;
+		return (str.size() == 3) ? TryParse<T>(str[0], str[1], str[2]) : std::nullopt;
 	}
 
 	template <typename T>
@@ -287,6 +303,12 @@ namespace GeneralUtils {
 		return T();
 	}
 
+	template<typename Container>
+	inline Container::value_type GetRandomElement(const Container& container) {
+		DluAssert(!container.empty());
+		return container[GenerateRandomNumber<typename Container::size_type>(0, container.size() - 1)];
+	}
+
 	/**
 	 * Casts the value of an enum entry to its underlying type
 	 * @param entry Enum entry to cast
@@ -311,4 +333,28 @@ namespace GeneralUtils {
 
 		return GenerateRandomNumber<T>(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
 	}
+
+	// https://www.quora.com/How-do-you-round-to-specific-increments-like-0-5-in-C
+	// Rounds to the nearest floating point value specified.
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
+	T RountToNearestEven(const T value, const T modulus) {
+		const auto modulo = std::fmod(value, modulus);
+		const auto abs_modulo_2 = std::abs(modulo * 2);
+		const auto abs_modulus = std::abs(modulus);
+
+		bool round_away_from_zero = false;
+		if (abs_modulo_2 > abs_modulus) {
+			round_away_from_zero = true;
+		} else if (abs_modulo_2 == abs_modulus) {
+			const auto trunc_quot = std::floor(std::abs(value / modulus));
+			const auto odd = std::fmod(trunc_quot, T{ 2 }) != 0;
+			round_away_from_zero = odd;
+		}
+
+		if (round_away_from_zero) {
+			return value + (std::copysign(modulus, value) - modulo);
+		} else {
+			return value - modulo;
+		}
+	}
 }

dCommon/JSONUtils.cpp

@@ -0,0 +1,17 @@
+#include "JSONUtils.h"
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+std::string JSONUtils::CheckRequiredData(const json& data, const std::vector<std::string>& requiredData) {
+	json check;
+	check["error"] = json::array();
+	for (const auto& required : requiredData) {
+		if (!data.contains(required)) {
+			check["error"].push_back("Missing Parameter: " + required);
+		} else if (data[required] == "") {
+			check["error"].push_back("Empty Parameter: " + required);
+		}
+	}
+	return check["error"].empty() ? "" : check.dump();
+}

dCommon/JSONUtils.h

@@ -0,0 +1,11 @@
+#ifndef _JSONUTILS_H_
+#define _JSONUTILS_H_
+
+#include "json_fwd.hpp"
+
+namespace JSONUtils {
+	// check required fields in json data
+	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
+}
+
+#endif // _JSONUTILS_H_

dCommon/LDFFormat.h

@@ -83,6 +83,12 @@ public:
 		this->value = value;
 	}
 
+	//! Initializer
+	LDFData(const std::string& key, const T& value) {
+		this->key = GeneralUtils::ASCIIToUTF16(key);
+		this->value = value;
+	}
+
 	//! Destructor
 	~LDFData(void) override {}
 

dCommon/Logger.cpp

@@ -96,3 +96,17 @@ bool Logger::GetLogToConsole() const {
 	}
 	return toReturn;
 }
+
+FuncEntry::FuncEntry(const char* funcName, const char* fileName, const uint32_t line) {
+	m_FuncName = funcName;
+	if (!m_FuncName) m_FuncName = "Unknown";
+	m_Line = line;
+	m_FileName = fileName;
+	LOG("--> %s::%s:%i", m_FileName, m_FuncName, m_Line);
+}
+
+FuncEntry::~FuncEntry() {
+	if (!m_FuncName || !m_FileName) return;
+
+	LOG("<-- %s::%s:%i", m_FileName, m_FuncName, m_Line);
+}

dCommon/Logger.h

@@ -29,8 +29,21 @@ constexpr const char* GetFileNameFromAbsolutePath(const char* path) {
 // they will not be valid constexpr and will be evaluated at runtime instead of compile time!
 // The full string is still stored in the binary, however the offset of the filename in the absolute paths
 // is used in the instruction instead of the start of the absolute path.
-#define LOG(message, ...) do { auto str = FILENAME_AND_LINE; Game::logger->Log(str, message, ##__VA_ARGS__); } while(0)
+#define LOG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->Log(str_, message, ##__VA_ARGS__); } while(0)
-#define LOG_DEBUG(message, ...) do { auto str = FILENAME_AND_LINE; Game::logger->LogDebug(str, message, ##__VA_ARGS__); } while(0)
+#define LOG_DEBUG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->LogDebug(str_, message, ##__VA_ARGS__); } while(0)
+
+// Place this right at the start of a function. Will log a message when called and then once you leave the function.
+#define LOG_ENTRY auto str_ = GetFileNameFromAbsolutePath(__FILE__); FuncEntry funcEntry_(__FUNCTION__, str_, __LINE__)
+
+class FuncEntry {
+public:
+	FuncEntry(const char* funcName, const char* fileName, const uint32_t line);
+	~FuncEntry();
+private:
+	const char* m_FuncName = nullptr;
+	const char* m_FileName = nullptr;
+	uint32_t m_Line = 0;
+};
 
 // Writer class for writing data to files.
 class Writer {

dCommon/Lxfml.cpp

@@ -0,0 +1,510 @@
+#include "Lxfml.h"
+
+#include "GeneralUtils.h"
+#include "StringifiedEnum.h"
+#include "TinyXmlUtils.h"
+
+#include <ranges>
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <sstream>
+
+namespace {
+	// The base LXFML xml file to use when creating new models.
+	std::string g_base = R"(<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<LXFML versionMajor="5" versionMinor="0">
+<Meta>
+    <Application name="LEGO Universe" versionMajor="0" versionMinor="0"/>
+    <Brand name="LEGOUniverse"/>
+    <BrickSet version="457"/>
+</Meta>
+<Bricks>
+</Bricks>
+<RigidSystems>
+</RigidSystems>
+<GroupSystems>
+    <GroupSystem>
+    </GroupSystem>
+</GroupSystems>
+</LXFML>)";
+}
+
+Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoint3& curPosition) {
+	Result toReturn;
+	
+	// Handle empty or invalid input
+	if (data.empty()) {
+		return toReturn;
+	}
+	
+	tinyxml2::XMLDocument doc;
+	// Use length-based parsing to avoid expensive string copy
+	const auto err = doc.Parse(data.data(), data.size());
+	if (err != tinyxml2::XML_SUCCESS) {
+		return toReturn;
+	}
+
+	TinyXmlUtils::DocumentReader reader(doc);
+	std::map<std::string/* refID */, std::string> transformations;
+
+	auto lxfml = reader["LXFML"];
+	if (!lxfml) {
+		return toReturn;
+	}
+
+	// First get all the positions of bricks
+	for (const auto& brick : lxfml["Bricks"]) {
+		const auto* part = brick.FirstChildElement("Part");
+		while (part) {
+			const auto* bone = part->FirstChildElement("Bone");
+			if (bone) {
+				auto* transformation = bone->Attribute("transformation");
+				if (transformation) {
+					auto* refID = bone->Attribute("refID");
+					if (refID) transformations[refID] = transformation;
+				}
+			}
+			part = part->NextSiblingElement("Part");
+		}
+	}
+
+	// These points are well out of bounds for an actual player
+	NiPoint3 lowest{ 10'000.0f, 10'000.0f, 10'000.0f };
+	NiPoint3 highest{ -10'000.0f, -10'000.0f, -10'000.0f };
+
+	NiPoint3 delta = NiPoint3Constant::ZERO;
+	if (curPosition == NiPoint3Constant::ZERO) {
+		// Calculate the lowest and highest points on the entire model
+		for (const auto& transformation : transformations | std::views::values) {
+			auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) continue;
+	
+		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
+		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
+		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
+			
+		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) continue;
+		
+		auto x = xOpt.value();
+		auto y = yOpt.value();
+		auto z = zOpt.value();
+		if (x < lowest.x) lowest.x = x;
+		if (y < lowest.y) lowest.y = y;
+			if (z < lowest.z) lowest.z = z;
+
+			if (highest.x < x) highest.x = x;
+			if (highest.y < y) highest.y = y;
+			if (highest.z < z) highest.z = z;
+		}
+
+		delta = (highest - lowest) / 2.0f;
+	} else {
+		lowest = curPosition;
+		highest = curPosition;
+		delta = NiPoint3Constant::ZERO;
+	}
+
+	auto newRootPos = lowest + delta;
+
+	// Need to snap this chosen position to the nearest valid spot
+	// on the LEGO grid
+	newRootPos.x = GeneralUtils::RountToNearestEven(newRootPos.x, 0.8f);
+	newRootPos.z = GeneralUtils::RountToNearestEven(newRootPos.z, 0.8f);
+
+	// Clamp the Y to the lowest point on the model 
+	newRootPos.y = lowest.y;
+
+	// Adjust all positions to account for the new origin
+	for (auto& transformation : transformations | std::views::values) {
+		auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) {
+			continue;
+		}
+
+		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
+		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
+		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
+		
+		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) {
+			continue;
+		}		
+		auto x = xOpt.value() - newRootPos.x + curPosition.x;
+		auto y = yOpt.value() - newRootPos.y + curPosition.y;
+		auto z = zOpt.value() - newRootPos.z + curPosition.z;
+		std::stringstream stream;
+		for (int i = 0; i < 9; i++) {
+			stream << split[i];
+			stream << ',';
+		}
+		stream << x << ',' << y << ',' << z;
+		transformation = stream.str();
+	}
+
+	// Finally write the new transformation back into the lxfml
+	for (auto& brick : lxfml["Bricks"]) {
+		auto* part = brick.FirstChildElement("Part");
+		while (part) {
+			auto* bone = part->FirstChildElement("Bone");
+			if (bone) {
+				auto* transformation = bone->Attribute("transformation");
+				if (transformation) {
+					auto* refID = bone->Attribute("refID");
+					if (refID) {
+						bone->SetAttribute("transformation", transformations[refID].c_str());
+					}
+				}
+			}
+			part = part->NextSiblingElement("Part");
+		}
+	}
+
+	tinyxml2::XMLPrinter printer;
+	doc.Print(&printer);
+
+	toReturn.lxfml = printer.CStr();
+	toReturn.center = newRootPos;
+	return toReturn;
+}
+
+// Deep-clone an XMLElement (attributes, text, and child elements) into a target document
+// with maximum depth protection to prevent infinite loops
+static tinyxml2::XMLElement* CloneElementDeep(const tinyxml2::XMLElement* src, tinyxml2::XMLDocument& dstDoc, int maxDepth = 100) {
+	if (!src || maxDepth <= 0) return nullptr;
+	auto* dst = dstDoc.NewElement(src->Name());
+
+	// copy attributes
+	for (const tinyxml2::XMLAttribute* attr = src->FirstAttribute(); attr; attr = attr->Next()) {
+		dst->SetAttribute(attr->Name(), attr->Value());
+	}
+
+	// copy children (elements and text)
+	for (const tinyxml2::XMLNode* child = src->FirstChild(); child; child = child->NextSibling()) {
+		if (const tinyxml2::XMLElement* childElem = child->ToElement()) {
+			// Recursively clone child elements with decremented depth
+			auto* clonedChild = CloneElementDeep(childElem, dstDoc, maxDepth - 1);
+			if (clonedChild) dst->InsertEndChild(clonedChild);
+		} else if (const tinyxml2::XMLText* txt = child->ToText()) {
+			auto* n = dstDoc.NewText(txt->Value());
+			dst->InsertEndChild(n);
+		} else if (const tinyxml2::XMLComment* c = child->ToComment()) {
+			auto* n = dstDoc.NewComment(c->Value());
+			dst->InsertEndChild(n);
+		}
+	}
+
+	return dst;
+}
+
+std::vector<Lxfml::Result> Lxfml::Split(const std::string_view data, const NiPoint3& curPosition) {
+	std::vector<Result> results;
+	
+	// Handle empty or invalid input
+	if (data.empty()) {
+		return results;
+	}
+	
+	// Prevent processing extremely large inputs that could cause hangs
+	if (data.size() > 10000000) { // 10MB limit
+		return results;
+	}
+	
+	tinyxml2::XMLDocument doc;
+	// Use length-based parsing to avoid expensive string copy
+	const auto err = doc.Parse(data.data(), data.size());
+	if (err != tinyxml2::XML_SUCCESS) {
+		return results;
+	}
+
+	auto* lxfml = doc.FirstChildElement("LXFML");
+	if (!lxfml) {
+		return results;
+	}
+
+	// Build maps: partRef -> Part element, partRef -> Brick element, boneRef -> partRef, brickRef -> Brick element
+	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToPart;
+	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToBrick;
+	std::unordered_map<std::string, std::string> boneRefToPartRef;
+	std::unordered_map<std::string, tinyxml2::XMLElement*> brickByRef;
+
+	auto* bricksParent = lxfml->FirstChildElement("Bricks");
+	if (bricksParent) {
+		for (auto* brick = bricksParent->FirstChildElement("Brick"); brick; brick = brick->NextSiblingElement("Brick")) {
+			const char* brickRef = brick->Attribute("refID");
+			if (brickRef) brickByRef.emplace(std::string(brickRef), brick);
+			for (auto* part = brick->FirstChildElement("Part"); part; part = part->NextSiblingElement("Part")) {
+				const char* partRef = part->Attribute("refID");
+				if (partRef) {
+					partRefToPart.emplace(std::string(partRef), part);
+					partRefToBrick.emplace(std::string(partRef), brick);
+				}
+				auto* bone = part->FirstChildElement("Bone");
+				if (bone) {
+					const char* boneRef = bone->Attribute("refID");
+					if (boneRef) boneRefToPartRef.emplace(std::string(boneRef), partRef ? std::string(partRef) : std::string());
+				}
+			}
+		}
+	}
+
+	// Collect RigidSystem elements
+	std::vector<tinyxml2::XMLElement*> rigidSystems;
+	auto* rigidSystemsParent = lxfml->FirstChildElement("RigidSystems");
+	if (rigidSystemsParent) {
+		for (auto* rs = rigidSystemsParent->FirstChildElement("RigidSystem"); rs; rs = rs->NextSiblingElement("RigidSystem")) {
+			rigidSystems.push_back(rs);
+		}
+	}
+
+	// Collect top-level groups (immediate children of GroupSystem)
+	std::vector<tinyxml2::XMLElement*> groupRoots;
+	auto* groupSystemsParent = lxfml->FirstChildElement("GroupSystems");
+	if (groupSystemsParent) {
+		for (auto* gs = groupSystemsParent->FirstChildElement("GroupSystem"); gs; gs = gs->NextSiblingElement("GroupSystem")) {
+			for (auto* group = gs->FirstChildElement("Group"); group; group = group->NextSiblingElement("Group")) {
+				groupRoots.push_back(group);
+			}
+		}
+	}
+
+	// Track used bricks and rigidsystems
+	std::unordered_set<std::string> usedBrickRefs;
+	std::unordered_set<tinyxml2::XMLElement*> usedRigidSystems;
+
+	// Track used groups to avoid processing them twice
+	std::unordered_set<tinyxml2::XMLElement*> usedGroups;
+
+	// Helper to create output document from sets of brick refs and rigidsystem pointers
+	auto makeOutput = [&](const std::unordered_set<std::string>& bricksToInclude, const std::vector<tinyxml2::XMLElement*>& rigidSystemsToInclude, const std::vector<tinyxml2::XMLElement*>& groupsToInclude = {}) {
+		tinyxml2::XMLDocument outDoc;
+		outDoc.Parse(g_base.c_str());
+		auto* outRoot = outDoc.FirstChildElement("LXFML");
+		auto* outBricks = outRoot->FirstChildElement("Bricks");
+		auto* outRigidSystems = outRoot->FirstChildElement("RigidSystems");
+		auto* outGroupSystems = outRoot->FirstChildElement("GroupSystems");
+
+		// clone and insert bricks
+		for (const auto& bref : bricksToInclude) {
+			auto it = brickByRef.find(bref);
+			if (it == brickByRef.end()) continue;
+			tinyxml2::XMLElement* cloned = CloneElementDeep(it->second, outDoc);
+			if (cloned) outBricks->InsertEndChild(cloned);
+		}
+
+		// clone and insert rigidsystems
+		for (auto* rsPtr : rigidSystemsToInclude) {
+			tinyxml2::XMLElement* cloned = CloneElementDeep(rsPtr, outDoc);
+			if (cloned) outRigidSystems->InsertEndChild(cloned);
+		}
+
+		// clone and insert group(s) if requested
+		if (outGroupSystems && !groupsToInclude.empty()) {
+			// clear default children
+			while (outGroupSystems->FirstChild()) outGroupSystems->DeleteChild(outGroupSystems->FirstChild());
+			// create a GroupSystem element and append requested groups
+			auto* newGS = outDoc.NewElement("GroupSystem");
+			for (auto* gptr : groupsToInclude) {
+				tinyxml2::XMLElement* clonedG = CloneElementDeep(gptr, outDoc);
+				if (clonedG) newGS->InsertEndChild(clonedG);
+			}
+			outGroupSystems->InsertEndChild(newGS);
+		}
+
+		// Print to string
+		tinyxml2::XMLPrinter printer;
+		outDoc.Print(&printer);
+		// Normalize position and compute center using existing helper
+		std::string xmlString = printer.CStr();
+		if (xmlString.size() > 5000000) { // 5MB limit for normalization
+			Result emptyResult;
+			emptyResult.lxfml = xmlString;
+			return emptyResult;
+		}
+		auto normalized = NormalizePosition(xmlString, curPosition);
+		return normalized;
+	};
+
+	// 1) Process groups (each top-level Group becomes one output; nested groups are included)
+	for (auto* groupRoot : groupRoots) {
+		// Skip if this group was already processed as part of another group
+		if (usedGroups.find(groupRoot) != usedGroups.end()) continue;
+
+		// Helper to collect all partRefs in a group's subtree
+		std::function<void(const tinyxml2::XMLElement*, std::unordered_set<std::string>&)> collectParts = [&](const tinyxml2::XMLElement* g, std::unordered_set<std::string>& partRefs) {
+			if (!g) return;
+			const char* partAttr = g->Attribute("partRefs");
+			if (partAttr) {
+				for (auto& tok : GeneralUtils::SplitString(partAttr, ',')) partRefs.insert(tok);
+			}
+			for (auto* child = g->FirstChildElement("Group"); child; child = child->NextSiblingElement("Group")) collectParts(child, partRefs);
+		};
+
+		// Collect all groups that need to be merged into this output
+		std::vector<tinyxml2::XMLElement*> groupsToInclude{ groupRoot };
+		usedGroups.insert(groupRoot);
+
+		// Build initial sets of bricks and boneRefs from the starting group
+		std::unordered_set<std::string> partRefs;
+		collectParts(groupRoot, partRefs);
+
+		std::unordered_set<std::string> bricksIncluded;
+		std::unordered_set<std::string> boneRefsIncluded;
+		for (const auto& pref : partRefs) {
+			auto pit = partRefToBrick.find(pref);
+			if (pit != partRefToBrick.end()) {
+				const char* bref = pit->second->Attribute("refID");
+				if (bref) bricksIncluded.insert(std::string(bref));
+			}
+			auto partIt = partRefToPart.find(pref);
+			if (partIt != partRefToPart.end()) {
+				auto* bone = partIt->second->FirstChildElement("Bone");
+				if (bone) {
+					const char* bref = bone->Attribute("refID");
+					if (bref) boneRefsIncluded.insert(std::string(bref));
+				}
+			}
+		}
+
+		// Iteratively include any RigidSystems that reference any boneRefsIncluded
+		// and check if those rigid systems' bricks span other groups
+		bool changed = true;
+		std::vector<tinyxml2::XMLElement*> rigidSystemsToInclude;
+		int maxIterations = 1000; // Safety limit to prevent infinite loops
+		int iteration = 0;
+		while (changed && iteration < maxIterations) {
+			changed = false;
+			iteration++;
+
+			// First, expand rigid systems based on current boneRefsIncluded
+			for (auto* rs : rigidSystems) {
+				if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
+				// parse boneRefs of this rigid system (from its <Rigid> children)
+				bool intersects = false;
+				std::vector<std::string> rsBoneRefs;
+				for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
+					const char* battr = rigid->Attribute("boneRefs");
+					if (!battr) continue;
+					for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
+						rsBoneRefs.push_back(tok);
+						if (boneRefsIncluded.find(tok) != boneRefsIncluded.end()) intersects = true;
+					}
+				}
+				if (!intersects) continue;
+				// include this rigid system and all boneRefs it references
+				usedRigidSystems.insert(rs);
+				rigidSystemsToInclude.push_back(rs);
+				for (const auto& br : rsBoneRefs) {
+					boneRefsIncluded.insert(br);
+					auto bpIt = boneRefToPartRef.find(br);
+					if (bpIt != boneRefToPartRef.end()) {
+						auto partRef = bpIt->second;
+						auto pbIt = partRefToBrick.find(partRef);
+						if (pbIt != partRefToBrick.end()) {
+							const char* bref = pbIt->second->Attribute("refID");
+							if (bref && bricksIncluded.insert(std::string(bref)).second) changed = true;
+						}
+					}
+				}
+			}
+
+			// Second, check if the newly included bricks span any other groups
+			// If so, merge those groups into the current output
+			for (auto* otherGroup : groupRoots) {
+				if (usedGroups.find(otherGroup) != usedGroups.end()) continue;
+
+				// Collect partRefs from this other group
+				std::unordered_set<std::string> otherPartRefs;
+				collectParts(otherGroup, otherPartRefs);
+
+				// Check if any of these partRefs correspond to bricks we've already included
+				bool spansOtherGroup = false;
+				for (const auto& pref : otherPartRefs) {
+					auto pit = partRefToBrick.find(pref);
+					if (pit != partRefToBrick.end()) {
+						const char* bref = pit->second->Attribute("refID");
+						if (bref && bricksIncluded.find(std::string(bref)) != bricksIncluded.end()) {
+							spansOtherGroup = true;
+							break;
+						}
+					}
+				}
+
+				if (spansOtherGroup) {
+					// Merge this group into the current output
+					usedGroups.insert(otherGroup);
+					groupsToInclude.push_back(otherGroup);
+					changed = true;
+
+					// Add all partRefs, boneRefs, and bricks from this group
+					for (const auto& pref : otherPartRefs) {
+						auto pit = partRefToBrick.find(pref);
+						if (pit != partRefToBrick.end()) {
+							const char* bref = pit->second->Attribute("refID");
+							if (bref) bricksIncluded.insert(std::string(bref));
+						}
+						auto partIt = partRefToPart.find(pref);
+						if (partIt != partRefToPart.end()) {
+							auto* bone = partIt->second->FirstChildElement("Bone");
+							if (bone) {
+								const char* bref = bone->Attribute("refID");
+								if (bref) boneRefsIncluded.insert(std::string(bref));
+							}
+						}
+					}
+				}
+			}
+		}
+		
+		if (iteration >= maxIterations) {
+			// Iteration limit reached, stop processing to prevent infinite loops
+			// The file is likely malformed, so just skip further processing
+			return results;
+		}		
+		// include bricks from bricksIncluded into used set
+		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
+
+		// make output doc and push result (include all merged groups' XML)
+		auto normalized = makeOutput(bricksIncluded, rigidSystemsToInclude, groupsToInclude);
+		results.push_back(normalized);
+	}
+
+	// 2) Process remaining RigidSystems (each becomes its own file)
+	for (auto* rs : rigidSystems) {
+		if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
+		std::unordered_set<std::string> bricksIncluded;
+		// collect boneRefs referenced by this rigid system
+		for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
+			const char* battr = rigid->Attribute("boneRefs");
+			if (!battr) continue;
+			for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
+				auto bpIt = boneRefToPartRef.find(tok);
+				if (bpIt != boneRefToPartRef.end()) {
+					auto partRef = bpIt->second;
+					auto pbIt = partRefToBrick.find(partRef);
+					if (pbIt != partRefToBrick.end()) {
+						const char* bref = pbIt->second->Attribute("refID");
+						if (bref) bricksIncluded.insert(std::string(bref));
+					}
+				}
+			}
+		}
+		// mark used
+		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
+		usedRigidSystems.insert(rs);
+
+		std::vector<tinyxml2::XMLElement*> rsVec{ rs };
+		auto normalized = makeOutput(bricksIncluded, rsVec);
+		results.push_back(normalized);
+	}
+
+	// 3) Any remaining bricks not included become their own files
+	for (const auto& [bref, brickPtr] : brickByRef) {
+		if (usedBrickRefs.find(bref) != usedBrickRefs.end()) continue;
+		std::unordered_set<std::string> bricksIncluded{ bref };
+		auto normalized = makeOutput(bricksIncluded, {});
+		results.push_back(normalized);
+		usedBrickRefs.insert(bref);
+	}
+
+	return results;
+}

dCommon/Lxfml.h

@@ -0,0 +1,29 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef LXFML_H
+#define LXFML_H
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "NiPoint3.h"
+
+namespace Lxfml {
+	struct Result {
+		std::string lxfml;
+		NiPoint3 center;
+	};
+
+	// Normalizes a LXFML model to be positioned relative to its local 0, 0, 0 rather than a game worlds 0, 0, 0.
+	// Returns a struct of its new center and the updated LXFML containing these edits.
+	[[nodiscard]] Result NormalizePosition(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
+	[[nodiscard]] std::vector<Result> Split(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
+
+	// these are only for the migrations due to a bug in one of the implementations.
+	[[nodiscard]] Result NormalizePositionOnlyFirstPart(const std::string_view data);
+	[[nodiscard]] Result NormalizePositionAfterFirstPart(const std::string_view data, const NiPoint3& position);
+};
+
+#endif //!LXFML_H

dCommon/LxfmlBugged.cpp

@@ -0,0 +1,210 @@
+#include "Lxfml.h"
+
+#include "GeneralUtils.h"
+#include "StringifiedEnum.h"
+#include "TinyXmlUtils.h"
+
+#include <ranges>
+
+// this file should not be touched
+
+Lxfml::Result Lxfml::NormalizePositionOnlyFirstPart(const std::string_view data) {
+	Result toReturn;
+	tinyxml2::XMLDocument doc;
+	const auto err = doc.Parse(data.data());
+	if (err != tinyxml2::XML_SUCCESS) {
+		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
+		return toReturn;
+	}
+
+	TinyXmlUtils::DocumentReader reader(doc);
+	std::map<std::string/* refID */, std::string> transformations;
+
+	auto lxfml = reader["LXFML"];
+	if (!lxfml) {
+		LOG("Failed to find LXFML element.");
+		return toReturn;
+	}
+
+	// First get all the positions of bricks
+	for (const auto& brick : lxfml["Bricks"]) {
+		const auto* part = brick.FirstChildElement("Part");
+		if (part) {
+			const auto* bone = part->FirstChildElement("Bone");
+			if (bone) {
+				auto* transformation = bone->Attribute("transformation");
+				if (transformation) {
+					auto* refID = bone->Attribute("refID");
+					if (refID) transformations[refID] = transformation;
+				}
+			}
+		}
+	}
+
+	// These points are well out of bounds for an actual player
+	NiPoint3 lowest{ 10'000.0f, 10'000.0f, 10'000.0f };
+	NiPoint3 highest{ -10'000.0f, -10'000.0f, -10'000.0f };
+
+	// Calculate the lowest and highest points on the entire model
+	for (const auto& transformation : transformations | std::views::values) {
+		auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) {
+			LOG("Not enough in the split?");
+			continue;
+		}
+
+		auto x = GeneralUtils::TryParse<float>(split[9]).value();
+		auto y = GeneralUtils::TryParse<float>(split[10]).value();
+		auto z = GeneralUtils::TryParse<float>(split[11]).value();
+		if (x < lowest.x) lowest.x = x;
+		if (y < lowest.y) lowest.y = y;
+		if (z < lowest.z) lowest.z = z;
+
+		if (highest.x < x) highest.x = x;
+		if (highest.y < y) highest.y = y;
+		if (highest.z < z) highest.z = z;
+	}
+
+	auto delta = (highest - lowest) / 2.0f;
+	auto newRootPos = lowest + delta;
+
+	// Clamp the Y to the lowest point on the model 
+	newRootPos.y = lowest.y;
+
+	// Adjust all positions to account for the new origin
+	for (auto& transformation : transformations | std::views::values) {
+		auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) {
+			LOG("Not enough in the split?");
+			continue;
+		}
+
+		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x;
+		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
+		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
+		std::stringstream stream;
+		for (int i = 0; i < 9; i++) {
+			stream << split[i];
+			stream << ',';
+		}
+		stream << x << ',' << y << ',' << z;
+		transformation = stream.str();
+	}
+
+	// Finally write the new transformation back into the lxfml
+	for (auto& brick : lxfml["Bricks"]) {
+		auto* part = brick.FirstChildElement("Part");
+		if (part) {
+			auto* bone = part->FirstChildElement("Bone");
+			if (bone) {
+				auto* transformation = bone->Attribute("transformation");
+				if (transformation) {
+					auto* refID = bone->Attribute("refID");
+					if (refID) {
+						bone->SetAttribute("transformation", transformations[refID].c_str());
+					}
+				}
+			}
+		}
+	}
+
+	tinyxml2::XMLPrinter printer;
+	doc.Print(&printer);
+
+	toReturn.lxfml = printer.CStr();
+	toReturn.center = newRootPos;
+	return toReturn;
+}
+
+Lxfml::Result Lxfml::NormalizePositionAfterFirstPart(const std::string_view data, const NiPoint3& position) {
+	Result toReturn;
+	tinyxml2::XMLDocument doc;
+	const auto err = doc.Parse(data.data());
+	if (err != tinyxml2::XML_SUCCESS) {
+		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
+		return toReturn;
+	}
+
+	TinyXmlUtils::DocumentReader reader(doc);
+	std::map<std::string/* refID */, std::string> transformations;
+
+	auto lxfml = reader["LXFML"];
+	if (!lxfml) {
+		LOG("Failed to find LXFML element.");
+		return toReturn;
+	}
+
+	// First get all the positions of bricks
+	for (const auto& brick : lxfml["Bricks"]) {
+		const auto* part = brick.FirstChildElement("Part");
+		bool firstPart = true;
+		while (part) {
+			if (firstPart) {
+				firstPart = false;
+			} else {
+				LOG("Found extra bricks");
+				const auto* bone = part->FirstChildElement("Bone");
+				if (bone) {
+					auto* transformation = bone->Attribute("transformation");
+					if (transformation) {
+						auto* refID = bone->Attribute("refID");
+						if (refID) transformations[refID] = transformation;
+					}
+				}
+			}
+			part = part->NextSiblingElement("Part");
+		}
+	}
+
+	auto newRootPos = position;
+
+	// Adjust all positions to account for the new origin
+	for (auto& transformation : transformations | std::views::values) {
+		auto split = GeneralUtils::SplitString(transformation, ',');
+		if (split.size() < 12) {
+			LOG("Not enough in the split?");
+			continue;
+		}
+
+		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x;
+		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
+		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
+		std::stringstream stream;
+		for (int i = 0; i < 9; i++) {
+			stream << split[i];
+			stream << ',';
+		}
+		stream << x << ',' << y << ',' << z;
+		transformation = stream.str();
+	}
+
+	// Finally write the new transformation back into the lxfml
+	for (auto& brick : lxfml["Bricks"]) {
+		auto* part = brick.FirstChildElement("Part");
+		bool firstPart = true;
+		while (part) {
+			if (firstPart) {
+				firstPart = false;
+			} else {
+				auto* bone = part->FirstChildElement("Bone");
+				if (bone) {
+					auto* transformation = bone->Attribute("transformation");
+					if (transformation) {
+						auto* refID = bone->Attribute("refID");
+						if (refID) {
+							bone->SetAttribute("transformation", transformations[refID].c_str());
+						}
+					}
+				}
+			}
+			part = part->NextSiblingElement("Part");
+		}
+	}
+
+	tinyxml2::XMLPrinter printer;
+	doc.Print(&printer);
+
+	toReturn.lxfml = printer.CStr();
+	toReturn.center = newRootPos;
+	return toReturn;
+}

dCommon/NiPoint3.h

@@ -6,10 +6,14 @@
   \brief Defines a point in space in XYZ coordinates
  */
 
+
 class NiPoint3;
-class NiQuaternion;
 typedef NiPoint3 Vector3;       //!< The Vector3 class is technically the NiPoint3 class, but typedef'd for clarity in some cases
 
+#include <glm/ext/vector_float3.hpp>
+
+#include "NiQuaternion.h"
+
 //! A custom class the defines a point in space
 class NiPoint3 {
 public:
@@ -21,6 +25,12 @@ public:
 	//! Initializer
 	constexpr NiPoint3() = default;
 
+	constexpr NiPoint3(const glm::vec3& vec) noexcept
+		: x{ vec.x }
+		, y{ vec.y }
+		, z{ vec.z } {
+	}
+
 	//! Initializer
 	/*!
 	  \param x The x coordinate

dCommon/NiPoint3.inl

@@ -4,6 +4,7 @@
 #endif
 
 #include "NiQuaternion.h"
+#include <glm/ext/quaternion_float.hpp>
 
 // MARK: Getters / Setters
 

dCommon/NiQuaternion.cpp

@@ -3,37 +3,18 @@
 // C++
 #include <cmath>
 
+#include <glm/gtx/quaternion.hpp>
+
 // MARK: Member Functions
 
-Vector3 NiQuaternion::GetEulerAngles() const {
+Vector3 QuatUtils::Euler(const NiQuaternion& quat) {
-	Vector3 angles;
+	return glm::eulerAngles(quat);
-
-	// roll (x-axis rotation)
-	const float sinr_cosp = 2 * (w * x + y * z);
-	const float cosr_cosp = 1 - 2 * (x * x + y * y);
-	angles.x = std::atan2(sinr_cosp, cosr_cosp);
-
-	// pitch (y-axis rotation)
-	const float sinp = 2 * (w * y - z * x);
-
-	if (std::abs(sinp) >= 1) {
-		angles.y = std::copysign(3.14 / 2, sinp); // use 90 degrees if out of range
-	} else {
-		angles.y = std::asin(sinp);
-	}
-
-	// yaw (z-axis rotation)
-	const float siny_cosp = 2 * (w * z + x * y);
-	const float cosy_cosp = 1 - 2 * (y * y + z * z);
-	angles.z = std::atan2(siny_cosp, cosy_cosp);
-
-	return angles;
 }
 
 // MARK: Helper Functions
 
 //! Look from a specific point in space to another point in space (Y-locked)
-NiQuaternion NiQuaternion::LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint) {
+NiQuaternion QuatUtils::LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint) {
 	//To make sure we don't orient around the X/Z axis:
 	NiPoint3 source = sourcePoint;
 	NiPoint3 dest = destPoint;
@@ -51,11 +32,11 @@ NiQuaternion NiQuaternion::LookAt(const NiPoint3& sourcePoint, const NiPoint3& d
 	NiPoint3 vecB = vecA.CrossProduct(posZ);
 
 	if (vecB.DotProduct(forwardVector) < 0) rotAngle = -rotAngle;
-	return NiQuaternion::CreateFromAxisAngle(vecA, rotAngle);
+	return glm::angleAxis(rotAngle, glm::vec3{vecA.x, vecA.y, vecA.z});
 }
 
 //! Look from a specific point in space to another point in space
-NiQuaternion NiQuaternion::LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint) {
+NiQuaternion QuatUtils::LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint) {
 	NiPoint3 forwardVector = NiPoint3(destPoint - sourcePoint).Unitize();
 
 	NiPoint3 posZ = NiPoint3Constant::UNIT_Z;
@@ -67,37 +48,26 @@ NiQuaternion NiQuaternion::LookAtUnlocked(const NiPoint3& sourcePoint, const NiP
 	NiPoint3 vecB = vecA.CrossProduct(posZ);
 
 	if (vecB.DotProduct(forwardVector) < 0) rotAngle = -rotAngle;
-	return NiQuaternion::CreateFromAxisAngle(vecA, rotAngle);
+	return glm::angleAxis(rotAngle, glm::vec3{vecA.x, vecA.y, vecA.z});
 }
 
 //! Creates a Quaternion from a specific axis and angle relative to that axis
-NiQuaternion NiQuaternion::CreateFromAxisAngle(const Vector3& axis, float angle) {
+NiQuaternion QuatUtils::AxisAngle(const Vector3& axis, float angle) {
-	float halfAngle = angle * 0.5f;
+	return glm::angleAxis(angle, glm::vec3(axis.x, axis.y, axis.z));
-	float s = static_cast<float>(sin(halfAngle));
-
-	NiQuaternion q;
-	q.x = axis.GetX() * s;
-	q.y = axis.GetY() * s;
-	q.z = axis.GetZ() * s;
-	q.w = static_cast<float>(cos(halfAngle));
-
-	return q;
 }
 
-NiQuaternion NiQuaternion::FromEulerAngles(const NiPoint3& eulerAngles) {
+NiQuaternion QuatUtils::FromEuler(const NiPoint3& eulerAngles) {
-	// Abbreviations for the various angular functions
+	return glm::quat(glm::vec3(eulerAngles.x, eulerAngles.y, eulerAngles.z));
-	float cy = cos(eulerAngles.z * 0.5);
+}
-	float sy = sin(eulerAngles.z * 0.5);
+
-	float cp = cos(eulerAngles.y * 0.5);
+Vector3 QuatUtils::Forward(const NiQuaternion& quat) {
-	float sp = sin(eulerAngles.y * 0.5);
+	return quat * glm::vec3(0, 0, 1);
-	float cr = cos(eulerAngles.x * 0.5);
+}
-	float sr = sin(eulerAngles.x * 0.5);
+
-
+Vector3 QuatUtils::Up(const NiQuaternion& quat) {
-	NiQuaternion q;
+	return quat * glm::vec3(0, 1, 0);
-	q.w = cr * cp * cy + sr * sp * sy;
+}
-	q.x = sr * cp * cy - cr * sp * sy;
+
-	q.y = cr * sp * cy + sr * cp * sy;
+Vector3 QuatUtils::Right(const NiQuaternion& quat) {
-	q.z = cr * cp * sy - sr * sp * cy;
+	return quat * glm::vec3(1, 0, 0);
-
-	return q;
 }

dCommon/NiQuaternion.h

@@ -1,158 +1,27 @@
-#ifndef __NIQUATERNION_H__
+#ifndef NIQUATERNION_H
-#define __NIQUATERNION_H__
+#define NIQUATERNION_H
 
 // Custom Classes
 #include "NiPoint3.h"
 
-/*!
+#define GLM_FORCE_QUAT_DATA_WXYZ
-  \file NiQuaternion.hpp
-  \brief Defines a quaternion in space in WXYZ coordinates
- */
 
-class NiQuaternion;
+#include <glm/ext/quaternion_float.hpp>
-typedef NiQuaternion Quaternion;        //!< A typedef for a shorthand version of NiQuaternion
 
-//! A class that defines a rotation in space
+using Quaternion = glm::quat;
-class NiQuaternion {
+using NiQuaternion = Quaternion;
-public:
-	float w{ 1 };            //!< The w coordinate
-	float x{ 0 };            //!< The x coordinate
-	float y{ 0 };            //!< The y coordinate
-	float z{ 0 };            //!< The z coordinate
 
-
+namespace QuatUtils {
-	//! The initializer
+	constexpr NiQuaternion IDENTITY = glm::identity<NiQuaternion>();
-	constexpr NiQuaternion() = default;
+	Vector3 Forward(const NiQuaternion& quat);
-
+	Vector3 Up(const NiQuaternion& quat);
-	//! The initializer
+	Vector3 Right(const NiQuaternion& quat);
-	/*!
+	NiQuaternion LookAt(const NiPoint3& from, const NiPoint3& to);
-	  \param w The w coordinate
+	NiQuaternion LookAtUnlocked(const NiPoint3& from, const NiPoint3& to);
-	  \param x The x coordinate
+	Vector3 Euler(const NiQuaternion& quat);
-	  \param y The y coordinate
+	NiQuaternion AxisAngle(const Vector3& axis, float angle);
-	  \param z The z coordinate
+	NiQuaternion FromEuler(const NiPoint3& eulerAngles);
-	 */
+	constexpr float PI_OVER_180 = glm::pi<float>() / 180.0f;
-	constexpr NiQuaternion(const float w, const float x, const float y, const float z) noexcept
-		: w{ w }
-		, x{ x }
-		, y{ y }
-		, z{ z } {
-	}
-
-	// MARK: Setters / Getters
-
-	//! Gets the W coordinate
-	/*!
-	  \return The w coordinate
-	 */
-	[[nodiscard]] constexpr float GetW() const noexcept;
-
-	//! Sets the W coordinate
-	/*!
-	  \param w The w coordinate
-	 */
-	constexpr void SetW(const float w) noexcept;
-
-	//! Gets the X coordinate
-	/*!
-	  \return The x coordinate
-	 */
-	[[nodiscard]] constexpr float GetX() const noexcept;
-
-	//! Sets the X coordinate
-	/*!
-	  \param x The x coordinate
-	 */
-	constexpr void SetX(const float x) noexcept;
-
-	//! Gets the Y coordinate
-	/*!
-	  \return The y coordinate
-	 */
-	[[nodiscard]] constexpr float GetY() const noexcept;
-
-	//! Sets the Y coordinate
-	/*!
-	  \param y The y coordinate
-	 */
-	constexpr void SetY(const float y) noexcept;
-
-	//! Gets the Z coordinate
-	/*!
-	  \return The z coordinate
-	 */
-	[[nodiscard]] constexpr float GetZ() const noexcept;
-
-	//! Sets the Z coordinate
-	/*!
-	  \param z The z coordinate
-	 */
-	constexpr void SetZ(const float z) noexcept;
-
-	// MARK: Member Functions
-
-	//! Returns the forward vector from the quaternion
-	/*!
-	  \return The forward vector of the quaternion
-	 */
-	[[nodiscard]] constexpr Vector3 GetForwardVector() const noexcept;
-
-	//! Returns the up vector from the quaternion
-	/*!
-	  \return The up vector fo the quaternion
-	 */
-	[[nodiscard]] constexpr Vector3 GetUpVector() const noexcept;
-
-	//! Returns the right vector from the quaternion
-	/*!
-	  \return The right vector of the quaternion
-	 */
-	[[nodiscard]] constexpr Vector3 GetRightVector() const noexcept;
-
-	[[nodiscard]] Vector3 GetEulerAngles() const;
-
-	// MARK: Operators
-
-	//! Operator to check for equality
-	constexpr bool operator==(const NiQuaternion& rot) const noexcept;
-
-	//! Operator to check for inequality
-	constexpr bool operator!=(const NiQuaternion& rot) const noexcept;
-
-	// MARK: Helper Functions
-
-	//! Look from a specific point in space to another point in space (Y-locked)
-	/*!
-	  \param sourcePoint The source location
-	  \param destPoint The destination location
-	  \return The Quaternion with the rotation towards the destination
-	 */
-	[[nodiscard]] static NiQuaternion LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
-
-	//! Look from a specific point in space to another point in space
-	/*!
-	  \param sourcePoint The source location
-	  \param destPoint The destination location
-	  \return The Quaternion with the rotation towards the destination
-	 */
-	[[nodiscard]] static NiQuaternion LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
-
-	//! Creates a Quaternion from a specific axis and angle relative to that axis
-	/*!
-	  \param axis The axis that is used
-	  \param angle The angle relative to this axis
-	  \return A quaternion created from the axis and angle
-	 */
-	[[nodiscard]] static NiQuaternion CreateFromAxisAngle(const Vector3& axis, float angle);
-
-	[[nodiscard]] static NiQuaternion FromEulerAngles(const NiPoint3& eulerAngles);
 };
 
-// Static Variables
+#endif // !NIQUATERNION_H
-namespace NiQuaternionConstant {
-	constexpr NiQuaternion IDENTITY(1, 0, 0, 0);
-}
-
-// Include constexpr and inline function definitions in a seperate file for readability
-#include "NiQuaternion.inl"
-
-#endif // !__NIQUATERNION_H__

dCommon/NiQuaternion.inl

@@ -1,75 +0,0 @@
-#pragma once
-#ifndef __NIQUATERNION_H__
-#error "This should only be included inline in NiQuaternion.h: Do not include directly!"
-#endif
-
-// MARK: Setters / Getters
-
-//! Gets the W coordinate
-constexpr float NiQuaternion::GetW() const noexcept {
-	return this->w;
-}
-
-//! Sets the W coordinate
-constexpr void NiQuaternion::SetW(const float w) noexcept {
-	this->w = w;
-}
-
-//! Gets the X coordinate
-constexpr float NiQuaternion::GetX() const noexcept {
-	return this->x;
-}
-
-//! Sets the X coordinate
-constexpr void NiQuaternion::SetX(const float x) noexcept {
-	this->x = x;
-}
-
-//! Gets the Y coordinate
-constexpr float NiQuaternion::GetY() const noexcept {
-	return this->y;
-}
-
-//! Sets the Y coordinate
-constexpr void NiQuaternion::SetY(const float y) noexcept {
-	this->y = y;
-}
-
-//! Gets the Z coordinate
-constexpr float NiQuaternion::GetZ() const noexcept {
-	return this->z;
-}
-
-//! Sets the Z coordinate
-constexpr void NiQuaternion::SetZ(const float z) noexcept {
-	this->z = z;
-}
-
-// MARK: Member Functions
-
-//! Returns the forward vector from the quaternion
-constexpr Vector3 NiQuaternion::GetForwardVector() const noexcept {
-	return Vector3(2 * (x * z + w * y), 2 * (y * z - w * x), 1 - 2 * (x * x + y * y));
-}
-
-//! Returns the up vector from the quaternion
-constexpr Vector3 NiQuaternion::GetUpVector() const noexcept {
-	return Vector3(2 * (x * y - w * z), 1 - 2 * (x * x + z * z), 2 * (y * z + w * x));
-}
-
-//! Returns the right vector from the quaternion
-constexpr Vector3 NiQuaternion::GetRightVector() const noexcept {
-	return Vector3(1 - 2 * (y * y + z * z), 2 * (x * y + w * z), 2 * (x * z - w * y));
-}
-
-// MARK: Operators
-
-//! Operator to check for equality
-constexpr bool NiQuaternion::operator==(const NiQuaternion& rot) const noexcept {
-	return rot.x == this->x && rot.y == this->y && rot.z == this->z && rot.w == this->w;
-}
-
-//! Operator to check for inequality
-constexpr bool NiQuaternion::operator!=(const NiQuaternion& rot) const noexcept {
-	return !(*this == rot);
-}

dCommon/PositionUpdate.h

@@ -24,7 +24,7 @@ struct LocalSpaceInfo {
 
 struct PositionUpdate {
 	NiPoint3 position = NiPoint3Constant::ZERO;
-	NiQuaternion rotation = NiQuaternionConstant::IDENTITY;
+	NiQuaternion rotation = QuatUtils::IDENTITY;
 	bool onGround = false;
 	bool onRail = false;
 	NiPoint3 velocity = NiPoint3Constant::ZERO;

dCommon/Sd0.cpp

@@ -0,0 +1,150 @@
+#include "Sd0.h"
+
+#include <array>
+#include <ranges>
+
+#include "BinaryIO.h"
+
+#include "Game.h"
+#include "Logger.h"
+
+#include "ZCompression.h"
+
+// Insert header if on first buffer
+void WriteHeader(Sd0::BinaryBuffer& chunk) {
+	chunk.push_back(Sd0::SD0_HEADER[0]);
+	chunk.push_back(Sd0::SD0_HEADER[1]);
+	chunk.push_back(Sd0::SD0_HEADER[2]);
+	chunk.push_back(Sd0::SD0_HEADER[3]);
+	chunk.push_back(Sd0::SD0_HEADER[4]);
+}
+
+// Write the size of the buffer to a chunk
+void WriteSize(Sd0::BinaryBuffer& chunk, uint32_t chunkSize) {
+	for (int i = 0; i < 4; i++) {
+		char toPush = chunkSize & 0xff;
+		chunkSize = chunkSize >> 8;
+		chunk.push_back(toPush);
+	}
+}
+
+int32_t GetDataOffset(bool firstBuffer) {
+	return firstBuffer ? 9 : 4;
+}
+
+Sd0::Sd0(std::istream& buffer) {
+	char header[5]{};
+
+	// Check if this is an sd0 buffer. It's possible we may be handed a zlib buffer directly due to old code so check for that too.
+	if (!BinaryIO::BinaryRead(buffer, header) || memcmp(header, SD0_HEADER, sizeof(header)) != 0) {
+		LOG("Failed to read SD0 header %i %i %i %i %i %i %i", buffer.good(), buffer.tellg(), header[0], header[1], header[2], header[3], header[4]);
+		LOG_DEBUG("This may be a zlib buffer directly? Trying again assuming its a zlib buffer.");
+		auto& firstChunk = m_Chunks.emplace_back();
+		WriteHeader(firstChunk);
+		buffer.seekg(0, std::ios::end);
+		uint32_t bufferSize = buffer.tellg();
+		buffer.seekg(0, std::ios::beg);
+		WriteSize(firstChunk, bufferSize);
+		firstChunk.resize(firstChunk.size() + bufferSize);
+		auto* dataStart = reinterpret_cast<char*>(firstChunk.data() + GetDataOffset(true));
+		if (!buffer.read(dataStart, bufferSize)) {
+			m_Chunks.pop_back();
+			LOG("Failed to read %u bytes from chunk %i", bufferSize, m_Chunks.size() - 1);
+		}
+		return;
+	}
+
+	while (buffer && buffer.peek() != std::istream::traits_type::eof()) {
+		uint32_t chunkSize{};
+		if (!BinaryIO::BinaryRead(buffer, chunkSize)) {
+			LOG("Failed to read chunk size from stream %lld %zu", buffer.tellg(), m_Chunks.size());
+			break;
+		}
+		auto& chunk = m_Chunks.emplace_back();
+		bool firstBuffer = m_Chunks.size() == 1;
+		auto dataOffset = GetDataOffset(firstBuffer);
+
+		// Insert header if on first buffer
+		if (firstBuffer) {
+			WriteHeader(chunk);
+		}
+
+		WriteSize(chunk, chunkSize);
+
+		chunk.resize(chunkSize + dataOffset);
+		auto* dataStart = reinterpret_cast<char*>(chunk.data() + dataOffset);
+		if (!buffer.read(dataStart, chunkSize)) {
+			m_Chunks.pop_back();
+			LOG("Failed to read %u bytes from chunk %i", chunkSize, m_Chunks.size() - 1);
+			break;
+		}
+	}
+}
+
+void Sd0::FromData(const uint8_t* data, size_t bufferSize) {
+	const auto originalBufferSize = bufferSize;
+	if (bufferSize == 0) return;
+
+	m_Chunks.clear();
+	while (bufferSize > 0) {
+		const auto numToCopy = std::min(MAX_UNCOMPRESSED_CHUNK_SIZE, bufferSize);
+		const auto* startOffset = data + originalBufferSize - bufferSize;
+		bufferSize -= numToCopy;
+		std::array<uint8_t, MAX_UNCOMPRESSED_CHUNK_SIZE> compressedChunk;
+		const auto compressedSize = ZCompression::Compress(
+			startOffset, numToCopy,
+			compressedChunk.data(), compressedChunk.size());
+
+		auto& chunk = m_Chunks.emplace_back();
+		bool firstBuffer = m_Chunks.size() == 1;
+		auto dataOffset = GetDataOffset(firstBuffer);
+
+		if (firstBuffer) {
+			WriteHeader(chunk);
+		}
+
+		WriteSize(chunk, compressedSize);
+
+		chunk.resize(compressedSize + dataOffset);
+		memcpy(chunk.data() + dataOffset, compressedChunk.data(), compressedSize);
+	}
+
+}
+
+std::string Sd0::GetAsStringUncompressed() const {
+	std::string toReturn;
+	bool first = true;
+	uint32_t totalSize{};
+	for (const auto& chunk : m_Chunks) {
+		auto dataOffset = GetDataOffset(first);
+		first = false;
+		const auto chunkSize = chunk.size();
+
+		auto oldSize = toReturn.size();
+		toReturn.resize(oldSize + MAX_UNCOMPRESSED_CHUNK_SIZE);
+		int32_t error{};
+		const auto uncompressedSize = ZCompression::Decompress(
+			chunk.data() + dataOffset, chunkSize - dataOffset,
+			reinterpret_cast<uint8_t*>(toReturn.data()) + oldSize, MAX_UNCOMPRESSED_CHUNK_SIZE,
+			error);
+
+		totalSize += uncompressedSize;
+	}
+
+	toReturn.resize(totalSize);
+	return toReturn;
+}
+
+std::stringstream Sd0::GetAsStream() const {
+	std::stringstream toReturn;
+
+	for (const auto& chunk : m_Chunks) {
+		toReturn.write(reinterpret_cast<const char*>(chunk.data()), chunk.size());
+	}
+
+	return toReturn;
+}
+
+const std::vector<Sd0::BinaryBuffer>& Sd0::GetAsVector() const {
+	return m_Chunks;
+}

dCommon/Sd0.h

@@ -0,0 +1,42 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef SD0_H
+#define SD0_H
+
+#include <fstream>
+#include <vector>
+
+// Sd0 is comprised of multiple zlib compressed buffers stored in a row.
+// The format starts with a SD0 header (see SD0_HEADER) followed by the size of a zlib buffer, and then the zlib buffer itself.
+// This repeats until end of file
+class Sd0 {
+public:
+	using BinaryBuffer = std::vector<uint8_t>;
+
+	static inline const char* SD0_HEADER = "sd0\x01\xff";
+
+	/**
+	 * @brief Max size of an inflated sd0 zlib chunk
+	 */
+	static constexpr inline size_t MAX_UNCOMPRESSED_CHUNK_SIZE = 1024 * 256;
+
+	// Read the input buffer into an internal chunk stream to be used later
+	Sd0(std::istream& buffer);
+
+	// Uncompresses the entire Sd0 buffer and returns it as a string
+	[[nodiscard]] std::string GetAsStringUncompressed() const;
+
+	// Gets the Sd0 buffer as a stream in its raw compressed form
+	[[nodiscard]] std::stringstream GetAsStream() const;
+
+	// Gets the Sd0 buffer as a vector in its raw compressed form
+	[[nodiscard]] const std::vector<BinaryBuffer>& GetAsVector() const;
+
+	// Compress data into a Sd0 buffer
+	void FromData(const uint8_t* data, size_t bufferSize);
+private:
+	std::vector<BinaryBuffer> m_Chunks{};
+};
+
+#endif //!SD0_H

dCommon/TinyXmlUtils.cpp

@@ -0,0 +1,37 @@
+#include "TinyXmlUtils.h"
+
+#include <tinyxml2.h>
+
+using namespace TinyXmlUtils;
+
+Element DocumentReader::operator[](const std::string_view elem) const {
+	return Element(m_Doc.FirstChildElement(elem.empty() ? nullptr : elem.data()), elem);
+}
+
+Element::Element(tinyxml2::XMLElement* xmlElem, const std::string_view elem) :
+	m_IteratedName{ elem },
+	m_Elem{ xmlElem } {
+}
+
+Element Element::operator[](const std::string_view elem) const {
+	const auto* usedElem = elem.empty() ? nullptr : elem.data();
+	auto* toReturn = m_Elem ? m_Elem->FirstChildElement(usedElem) : nullptr;
+	return Element(toReturn, m_IteratedName);
+}
+
+ElementIterator Element::begin() {
+	return ElementIterator(m_Elem ? m_Elem->FirstChildElement() : nullptr);
+}
+
+ElementIterator Element::end() {
+	return ElementIterator(nullptr);
+}
+
+ElementIterator::ElementIterator(tinyxml2::XMLElement* elem) :
+	m_CurElem{ elem } {
+}
+
+ElementIterator& ElementIterator::operator++() {
+	if (m_CurElem) m_CurElem = m_CurElem->NextSiblingElement();
+	return *this;
+}

dCommon/TinyXmlUtils.h

@@ -0,0 +1,66 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef TINYXMLUTILS_H
+#define TINYXMLUTILS_H
+
+#include <string>
+
+#include "DluAssert.h"
+
+#include <tinyxml2.h>
+
+namespace TinyXmlUtils {
+	// See cstdlib for iterator technicalities
+	struct ElementIterator {
+		ElementIterator(tinyxml2::XMLElement* elem);
+
+		ElementIterator& operator++();
+		[[nodiscard]] tinyxml2::XMLElement* operator->() { DluAssert(m_CurElem); return m_CurElem; }
+		[[nodiscard]] tinyxml2::XMLElement& operator*() { DluAssert(m_CurElem); return *m_CurElem; }
+
+		bool operator==(const ElementIterator& other) const { return other.m_CurElem == m_CurElem; }
+
+	private:
+		tinyxml2::XMLElement* m_CurElem{ nullptr };
+	};
+
+	// Wrapper class to act as an iterator over xml elements.
+	// All the normal rules that apply to Iterators in the std library apply here.
+	class Element {
+	public:
+		Element(tinyxml2::XMLElement* xmlElem, const std::string_view elem);
+
+		// The first child element of this element.
+		[[nodiscard]] ElementIterator begin();
+
+		// Always returns an ElementIterator which points to nullptr.
+		// TinyXml2 return NULL when you've reached the last child element so
+		// you can't do any funny one past end logic here.
+		[[nodiscard]] ElementIterator end();
+
+		// Get a child element
+		[[nodiscard]] Element operator[](const std::string_view elem) const;
+		[[nodiscard]] Element operator[](const char* elem) const { return operator[](std::string_view(elem)); };
+
+		// Whether or not data exists for this element
+		operator bool() const { return m_Elem != nullptr; }
+
+		[[nodiscard]] const tinyxml2::XMLElement* operator->() const { return m_Elem; }
+	private:
+		const char* GetElementName() const { return m_IteratedName.empty() ? nullptr : m_IteratedName.c_str(); }
+		const std::string m_IteratedName;
+		tinyxml2::XMLElement* m_Elem;
+	};
+
+	class DocumentReader {
+	public:
+		DocumentReader(tinyxml2::XMLDocument& doc) : m_Doc{ doc } {}
+
+		[[nodiscard]] Element operator[](const std::string_view elem) const;
+	private:
+		tinyxml2::XMLDocument& m_Doc;
+	};
+};
+
+#endif  //!TINYXMLUTILS_H

dCommon/ZCompression.h

@@ -8,11 +8,5 @@ namespace ZCompression {
 	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst);
 
 	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr);
-
-	/**
-	 * @brief Max size of an inflated sd0 zlib chunk
-	 *
-	 */
-	constexpr uint32_t MAX_SD0_CHUNK_SIZE = 1024 * 256;
 }
 

dCommon/dClient/AssetManager.cpp

@@ -6,6 +6,9 @@
 
 #include "zlib.h"
 
+constexpr uint32_t CRC32_INIT = 0xFFFFFFFF;
+constexpr auto NULL_TERMINATOR = std::string_view{"\0\0\0", 4};
+
 AssetManager::AssetManager(const std::filesystem::path& path) {
 	if (!std::filesystem::is_directory(path)) {
 		throw std::runtime_error("Attempted to load asset bundle (" + path.string() + ") however it is not a valid directory.");
@@ -18,12 +21,20 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 
 		m_RootPath = m_Path;
 		m_ResPath = (m_Path / "client" / "res");
-	} else if (std::filesystem::exists(m_Path / ".." / "versions") && std::filesystem::exists(m_Path / "res")) {
+	} else if (std::filesystem::exists(m_Path / "res" / "pack")) {
+		if (!std::filesystem::exists(m_Path / ".." / "versions")) {
+			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
+		}
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / "..");
 		m_ResPath = (m_Path / "res");
-	} else if (std::filesystem::exists(m_Path / "pack") && std::filesystem::exists(m_Path / ".." / ".." / "versions")) {
+	} else if (std::filesystem::exists(m_Path / "pack")) {
+		if (!std::filesystem::exists(m_Path / ".." / ".." / "versions")) {
+			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
+		}
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / ".." / "..");
@@ -48,6 +59,7 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 			break;
 		}
 		case eAssetBundleType::None:
+			[[fallthrough]];
 		case eAssetBundleType::Unpacked: {
 			break;
 		}
@@ -55,19 +67,10 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 }
 
 void AssetManager::LoadPackIndex() {
-	m_PackIndex = new PackIndex(m_RootPath);
+	m_PackIndex = PackIndex(m_RootPath);
 }
 
-std::filesystem::path AssetManager::GetResPath() {
+bool AssetManager::HasFile(std::string fixedName) const {
-	return m_ResPath;
-}
-
-eAssetBundleType AssetManager::GetAssetBundleType() {
-	return m_AssetBundleType;
-}
-
-bool AssetManager::HasFile(const char* name) {
-	auto fixedName = std::string(name);
 	std::transform(fixedName.begin(), fixedName.end(), fixedName.begin(), [](uint8_t c) { return std::tolower(c); });
 
 	// Special case for unpacked client have BrickModels in upper case
@@ -81,8 +84,7 @@ bool AssetManager::HasFile(const char* name) {
 	std::replace(fixedName.begin(), fixedName.end(), '/', '\\');
 	if (fixedName.rfind("client\\res\\", 0) != 0) fixedName = "client\\res\\" + fixedName;
 
-	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
+	const auto crc = crc32b(crc32b(CRC32_INIT, fixedName), NULL_TERMINATOR);
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -93,8 +95,7 @@ bool AssetManager::HasFile(const char* name) {
 	return false;
 }
 
-bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
+bool AssetManager::GetFile(std::string fixedName, char** data, uint32_t* len) const {
-	auto fixedName = std::string(name);
 	std::transform(fixedName.begin(), fixedName.end(), fixedName.begin(), [](uint8_t c) { return std::tolower(c); });
 	std::replace(fixedName.begin(), fixedName.end(), '\\', '/'); // On the off chance someone has the wrong slashes, force forward slashes
 
@@ -129,8 +130,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		fixedName = "client\\res\\" + fixedName;
 	}
 	int32_t packIndex = -1;
-	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
+	auto crc = crc32b(crc32b(CRC32_INIT, fixedName), NULL_TERMINATOR);
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -144,15 +144,13 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		return false;
 	}
 
-	auto packs = this->m_PackIndex->GetPacks();
+	const auto& pack = this->m_PackIndex->GetPacks().at(packIndex);
-	auto* pack = packs.at(packIndex);
+	const bool success = pack.ReadFileFromPack(crc, data, len);
-
-	bool success = pack->ReadFileFromPack(crc, data, len);
 
 	return success;
 }
 
-AssetStream AssetManager::GetFile(const char* name) {
+AssetStream AssetManager::GetFile(const char* name) const {
 	char* buf; uint32_t len;
 
 	bool success = this->GetFile(name, &buf, &len);
@@ -160,23 +158,15 @@ AssetStream AssetManager::GetFile(const char* name) {
 	return AssetStream(buf, len, success);
 }
 
-uint32_t AssetManager::crc32b(uint32_t base, uint8_t* message, size_t l) {
+uint32_t AssetManager::crc32b(uint32_t crc, const std::string_view message) {
-	size_t i, j;
+	for (const auto byte : message) {
-	uint32_t crc, msb;
-
-	crc = base;
-	for (i = 0; i < l; i++) {
 		// xor next byte to upper bits of crc
-		crc ^= (static_cast<unsigned int>(message[i]) << 24);
+		crc ^= (static_cast<uint32_t>(std::bit_cast<uint8_t>(byte)) << 24);
-		for (j = 0; j < 8; j++) { // Do eight times.
+		for (size_t _ = 0; _ < 8; _++) { // Do eight times.
-			msb = crc >> 31;
+			const uint32_t msb = crc >> 31;
 			crc <<= 1;
 			crc ^= (0 - msb) & 0x04C11DB7;
 		}
 	}
 	return crc; // don't complement crc on output
 }
-
-AssetManager::~AssetManager() {
-	delete m_PackIndex;
-}

dCommon/dClient/AssetManager.h

@@ -61,23 +61,35 @@ struct AssetStream : std::istream {
 class AssetManager {
 public:
 	AssetManager(const std::filesystem::path& path);
-	~AssetManager();
 
-	std::filesystem::path GetResPath();
+	[[nodiscard]]
-	eAssetBundleType GetAssetBundleType();
+	const std::filesystem::path& GetResPath() const {
+		return m_ResPath;
+	}
+	
+	[[nodiscard]]
+	eAssetBundleType GetAssetBundleType() const {
+		return m_AssetBundleType;
+	}
 
-	bool HasFile(const char* name);
+	[[nodiscard]]
-	bool GetFile(const char* name, char** data, uint32_t* len);
+	bool HasFile(std::string name) const;
-	AssetStream GetFile(const char* name);
+
+	[[nodiscard]]
+	bool GetFile(std::string name, char** data, uint32_t* len) const;
+
+	[[nodiscard]]
+	AssetStream GetFile(const char* name) const;
+
+	[[nodiscard]]
+	AssetStream GetFile(const std::string& name) const { return GetFile(name.c_str()); };
 
 private:
 	void LoadPackIndex();
 
 	// Modified crc algorithm (mpeg2)
 	// Reference: https://stackoverflow.com/questions/54339800/how-to-modify-crc-32-to-crc-32-mpeg-2
-	inline uint32_t crc32b(uint32_t base, uint8_t* message, size_t l);
+	static inline uint32_t crc32b(uint32_t crc, std::string_view message);
-
-	bool m_SuccessfullyLoaded;
 
 	std::filesystem::path m_Path;
 	std::filesystem::path m_RootPath;
@@ -85,5 +97,5 @@ private:
 
 	eAssetBundleType m_AssetBundleType = eAssetBundleType::None;
 
-	PackIndex* m_PackIndex;
+	std::optional<PackIndex> m_PackIndex;
 };

dCommon/dClient/Pack.cpp

@@ -1,6 +1,7 @@
 #include "Pack.h"
 
 #include "BinaryIO.h"
+#include "Sd0.h"
 #include "ZCompression.h"
 
 Pack::Pack(const std::filesystem::path& filePath) {
@@ -21,19 +22,20 @@ Pack::Pack(const std::filesystem::path& filePath) {
 
 	m_FileStream.seekg(recordCountPos, std::ios::beg);
 
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_RecordCount);
+	uint32_t recordCount = 0;
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, recordCount);
 
-	for (int i = 0; i < m_RecordCount; i++) {
+	m_Records.reserve(recordCount);
+	std::generate_n(std::back_inserter(m_Records), recordCount, [&] {
 		PackRecord record;
 		BinaryIO::BinaryRead<PackRecord>(m_FileStream, record);
-
+		return record;
-		m_Records.push_back(record);
+	});
-	}
 
 	m_FileStream.close();
 }
 
-bool Pack::HasFile(uint32_t crc) {
+bool Pack::HasFile(const uint32_t crc) const {
 	for (const auto& record : m_Records) {
 		if (record.m_Crc == crc) {
 			return true;
@@ -43,7 +45,7 @@ bool Pack::HasFile(uint32_t crc) {
 	return false;
 }
 
-bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
+bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) const {
 	// Time for some wacky C file reading for speed reasons
 
 	PackRecord pkRecord{};
@@ -105,7 +107,7 @@ bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
 		pos += size; // Move pointer position the amount of bytes read to the right
 
 		int32_t err;
-		currentReadPos += ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), ZCompression::MAX_SD0_CHUNK_SIZE, err);
+		currentReadPos += ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
 
 		free(chunk);
 	}

dCommon/dClient/Pack.h

@@ -24,16 +24,17 @@ struct PackRecord {
 class Pack {
 public:
 	Pack(const std::filesystem::path& filePath);
-	~Pack() = default;
 
-	bool HasFile(uint32_t crc);
+	[[nodiscard]]
-	bool ReadFileFromPack(uint32_t crc, char** data, uint32_t* len);
+	bool HasFile(uint32_t crc) const;
+
+	[[nodiscard]]
+	bool ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) const;
 private:
 	std::ifstream m_FileStream;
 	std::filesystem::path m_FilePath;
 
 	char m_Version[7];
 
-	uint32_t m_RecordCount;
 	std::vector<PackRecord> m_Records;
 };

dCommon/dClient/PackIndex.cpp

@@ -6,38 +6,32 @@
 PackIndex::PackIndex(const std::filesystem::path& filePath) {
 	m_FileStream = std::ifstream(filePath / "versions" / "primary.pki", std::ios::in | std::ios::binary);
 
+	uint32_t packPathCount = 0;
 	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_Version);
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_PackPathCount);
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, packPathCount);
 	
-	m_PackPaths.resize(m_PackPathCount);
+	m_PackPaths.resize(packPathCount);
 	for (auto& item : m_PackPaths) {
 		BinaryIO::ReadString<uint32_t>(m_FileStream, item, BinaryIO::ReadType::String);
 	}
 
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_PackFileIndexCount);
+	uint32_t packFileIndexCount = 0;
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, packFileIndexCount);
 
-	for (int i = 0; i < m_PackFileIndexCount; i++) {
+	m_PackFileIndices.reserve(packFileIndexCount);
+	std::generate_n(std::back_inserter(m_PackFileIndices), packFileIndexCount, [&] {
 		PackFileIndex packFileIndex;
 		BinaryIO::BinaryRead<PackFileIndex>(m_FileStream, packFileIndex);
-
+		return packFileIndex;
-		m_PackFileIndices.push_back(packFileIndex);
+	});
-	}
 
 	LOG("Loaded pack catalog with %i pack files and %i files", m_PackPaths.size(), m_PackFileIndices.size());
 
+	m_Packs.reserve(m_PackPaths.size());
 	for (auto& item : m_PackPaths) {
 		std::replace(item.begin(), item.end(), '\\', '/');
-
+		m_Packs.emplace_back(filePath / item);
-		auto* pack = new Pack(filePath / item);
-
-		m_Packs.push_back(pack);
 	}
 
 	m_FileStream.close();
 }
-
-PackIndex::~PackIndex() {
-	for (const auto* item : m_Packs) {
-		delete item;
-	}
-}

dCommon/dClient/PackIndex.h

@@ -21,20 +21,23 @@ struct PackFileIndex {
 class PackIndex {
 public:
 	PackIndex(const std::filesystem::path& filePath);
-	~PackIndex();
 
-	const std::vector<std::string>& GetPackPaths() { return m_PackPaths; }
+	[[nodiscard]]
-	const std::vector<PackFileIndex>& GetPackFileIndices() { return m_PackFileIndices; }
+	const std::vector<std::string>& GetPackPaths() const { return m_PackPaths; }
-	const std::vector<Pack*>& GetPacks() { return m_Packs; }
+
+	[[nodiscard]]
+	const std::vector<PackFileIndex>& GetPackFileIndices() const { return m_PackFileIndices; }
+
+	[[nodiscard]]
+	const std::vector<Pack>& GetPacks() const { return m_Packs; }
 private:
 	std::ifstream m_FileStream;
 
 	uint32_t m_Version;
 
-	uint32_t m_PackPathCount;
 	std::vector<std::string> m_PackPaths;
-	uint32_t m_PackFileIndexCount;
+
 	std::vector<PackFileIndex> m_PackFileIndices;
 
-	std::vector<Pack*> m_Packs;
+	std::vector<Pack> m_Packs;
 };

dCommon/dConfig.cpp

@@ -47,6 +47,8 @@ void dConfig::LoadConfig() {
 void dConfig::ReloadConfig() {
 	this->m_ConfigValues.clear();
 	LoadConfig();
+	for (const auto& handler : m_ConfigHandlers) handler();
+	LogSettings();
 }
 
 const std::string& dConfig::GetValue(std::string key) {
@@ -58,6 +60,18 @@ const std::string& dConfig::GetValue(std::string key) {
 	return this->m_ConfigValues[key];
 }
 
+void dConfig::AddConfigHandler(std::function<void()> handler) {
+	m_ConfigHandlers.push_back(handler);
+}
+
+void dConfig::LogSettings() const {
+	LOG("Configuration settings:");
+	for (const auto& [key, value] : m_ConfigValues) {
+		const auto& valueLog = key.find("password") != std::string::npos ? "<HIDDEN>" : value;
+		LOG("  %s = %s", key.c_str(), valueLog.c_str());
+	}
+}
+
 void dConfig::ProcessLine(const std::string& line) {
 	auto splitLoc = line.find('=');
 	auto key = line.substr(0, splitLoc);

dCommon/dConfig.h

@@ -1,5 +1,7 @@
 #pragma once
+
 #include <fstream>
+#include <functional>
 #include <map>
 #include <string>
 
@@ -29,10 +31,15 @@ public:
 	 * Reloads the config file to reset values
 	 */
 	void ReloadConfig();
+
+	// Adds a function to be called when the config is (re)loaded
+	void AddConfigHandler(std::function<void()> handler);
+	void LogSettings() const;
+
 private:
 	void ProcessLine(const std::string& line);
 
-private:
 	std::map<std::string, std::string> m_ConfigValues;
+	std::vector<std::function<void()>> m_ConfigHandlers;
 	std::string m_ConfigFilePath;
 };

dCommon/dEnums/MessageType/Game.h

@@ -957,6 +957,7 @@ namespace MessageType {
 		MODIFY_PLAYER_ZONE_STATISTIC = 1046,
 		APPLY_EXTERNAL_FORCE = 1049,
 		GET_APPLIED_EXTERNAL_FORCE = 1050,
+		ACTIVITY_NOTIFY = 1051,
 		ITEM_EQUIPPED = 1052,
 		ACTIVITY_STATE_CHANGE_REQUEST = 1053,
 		OVERRIDE_FRICTION = 1054,
@@ -1253,6 +1254,7 @@ namespace MessageType {
 		VEHICLE_NOTIFY_HIT_EXPLODER = 1385,
 		CHECK_NEAREST_ROCKET_LAUNCH_PRE_CONDITIONS = 1386,
 		REQUEST_NEAREST_ROCKET_LAUNCH_PRE_CONDITIONS = 1387,
+		CONFIGURE_RACING_CONTROL = 1388,
 		CONFIGURE_RACING_CONTROL_CLIENT = 1389,
 		NOTIFY_RACING_CLIENT = 1390,
 		RACING_PLAYER_HACK_CAR = 1391,

dCommon/dEnums/MessageType/Master.h

@@ -3,9 +3,7 @@
 
 namespace MessageType {
 	enum class Master : uint32_t {
-		REQUEST_PERSISTENT_ID = 1,
+		REQUEST_ZONE_TRANSFER = 1,
-		REQUEST_PERSISTENT_ID_RESPONSE,
-		REQUEST_ZONE_TRANSFER,
 		REQUEST_ZONE_TRANSFER_RESPONSE,
 		SERVER_INFO,
 		REQUEST_SESSION_KEY,

dCommon/dEnums/ServiceType.h

@@ -0,0 +1,14 @@
+#ifndef __SERVICETYPE__H__
+#define __SERVICETYPE__H__
+
+enum class ServiceType : uint16_t {
+	COMMON = 0,
+	AUTH,
+	CHAT,
+	WORLD = 4,
+	CLIENT,
+	MASTER,
+	UNKNOWN
+};
+
+#endif //!__SERVICETYPE__H__

dCommon/dEnums/dCommonVars.h

@@ -3,13 +3,14 @@
 #ifndef __DCOMMONVARS__H__
 #define __DCOMMONVARS__H__
 
+#include <compare>
 #include <cstdint>
-#include <string>
 #include <set>
+#include <string>
 #include "BitStream.h"
-#include "eConnectionType.h"
-#include "MessageType/Client.h"
 #include "BitStreamUtils.h"
+#include "MessageType/Client.h"
+#include "ServiceType.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
@@ -33,7 +34,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
 #define CINSTREAM_SKIP_HEADER CINSTREAM if (inStream.GetNumberOfUnreadBits() >= BYTES_TO_BITS(HEADER_SIZE)) inStream.IgnoreBytes(HEADER_SIZE); else inStream.IgnoreBits(inStream.GetNumberOfUnreadBits());
-#define CMSGHEADER BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::GAME_MSG);
+#define CMSGHEADER BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::GAME_MSG);
 #define SEND_PACKET Game::server->Send(bitStream, sysAddr, false);
 #define SEND_PACKET_BROADCAST Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 
@@ -98,6 +99,8 @@ public:
 	constexpr LWOZONEID() noexcept = default;
 	constexpr LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) noexcept { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
 	constexpr LWOZONEID(const LWOZONEID& replacement) noexcept { *this = replacement; }
+	constexpr bool operator==(const LWOZONEID&) const = default;
+	constexpr auto operator<=>(const LWOZONEID&) const = default;
 
 private:
 	LWOMAPID m_MapID = LWOMAPID_INVALID; //1000 for VE, 1100 for AG, etc...

dCommon/dEnums/eCharacterVersion.h

@@ -16,7 +16,11 @@ enum class eCharacterVersion : uint32_t {
 	VAULT_SIZE,
 	// Fixes speed base value in level component
 	SPEED_BASE,
-	UP_TO_DATE, // will become NJ_JAYMISSIONS
+	// Fixes nexus force explorer missions
+	NJ_JAYMISSIONS,
+	NEXUS_FORCE_EXPLORER, // Fixes pet ids in player inventories
+	PET_IDS, // Fixes pet ids in player inventories
+	UP_TO_DATE, // will become INVENTORY_PERSISTENT_IDS
 };
 
 #endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eConnectionType.h

@@ -1,13 +0,0 @@
-#ifndef __ECONNECTIONTYPE__H__
-#define __ECONNECTIONTYPE__H__
-
-enum class eConnectionType : uint16_t {
-	SERVER = 0,
-	AUTH,
-	CHAT,
-	WORLD = 4,
-	CLIENT,
-	MASTER
-};
-
-#endif  //!__ECONNECTIONTYPE__H__

dCommon/dEnums/eHTTPMethod.h

@@ -0,0 +1,28 @@
+#ifndef __EHTTPMETHODS__H__
+#define __EHTTPMETHODS__H__
+
+#include "dPlatforms.h"
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma push_macro("DELETE")
+#undef DELETE
+#endif
+
+enum class eHTTPMethod {
+	GET,
+	POST,
+	PUT,
+	DELETE,
+	HEAD,
+	CONNECT,
+	OPTIONS,
+	TRACE,
+	PATCH,
+	INVALID
+};
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma pop_macro("DELETE")
+#endif
+
+#endif // __EHTTPMETHODS__H__

dCommon/dEnums/eHTTPStatusCode.h

@@ -0,0 +1,72 @@
+#ifndef __EHTTPSTATUSCODE__H__
+#define __EHTTPSTATUSCODE__H__
+
+#include <cstdint>
+// verbose list of http codes
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+enum class eHTTPStatusCode : uint32_t {
+	CONTINUE = 100,
+	SWITCHING_PROTOCOLS = 101,
+	PROCESSING = 102,
+	EARLY_HINTS = 103,
+	OK = 200,
+	CREATED = 201,
+	ACCEPTED = 202,
+	NON_AUTHORITATIVE_INFORMATION = 203,
+	NO_CONTENT = 204,
+	RESET_CONTENT = 205,
+	PARTIAL_CONTENT = 206,
+	MULTI_STATUS = 207,
+	ALREADY_REPORTED = 208,
+	IM_USED = 226,
+	MULTIPLE_CHOICES = 300,
+	MOVED_PERMANENTLY = 301,
+	FOUND = 302,
+	SEE_OTHER = 303,
+	NOT_MODIFIED = 304,
+	USE_PROXY = 305,
+	SWITCH_PROXY = 306,
+	TEMPORARY_REDIRECT = 307,
+	PERMANENT_REDIRECT = 308,
+	BAD_REQUEST = 400,
+	UNAUTHORIZED = 401,
+	PAYMENT_REQUIRED = 402,
+	FORBIDDEN = 403,
+	NOT_FOUND = 404,
+	METHOD_NOT_ALLOWED = 405,
+	NOT_ACCEPTABLE = 406,
+	PROXY_AUTHENTICATION_REQUIRED = 407,
+	REQUEST_TIMEOUT = 408,
+	CONFLICT = 409,
+	GONE = 410,
+	LENGTH_REQUIRED = 411,
+	PRECONDITION_FAILED = 412,
+	PAYLOAD_TOO_LARGE = 413,
+	URI_TOO_LONG = 414,
+	UNSUPPORTED_MEDIA_TYPE = 415,
+	RANGE_NOT_SATISFIABLE = 416,
+	EXPECTATION_FAILED = 417,
+	I_AM_A_TEAPOT = 418,
+	MISDIRECTED_REQUEST = 421,
+	UNPROCESSABLE_ENTITY = 422,
+	LOCKED = 423,
+	FAILED_DEPENDENCY = 424,
+	UPGRADE_REQUIRED = 426,
+	PRECONDITION_REQUIRED = 428,
+	TOO_MANY_REQUESTS = 429,
+	REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+	UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+	INTERNAL_SERVER_ERROR = 500,
+	NOT_IMPLEMENTED = 501,
+	BAD_GATEWAY = 502,
+	SERVICE_UNAVAILABLE = 503,
+	GATEWAY_TIMEOUT = 504,
+	HTTP_VERSION_NOT_SUPPORTED = 505,
+	VARIANT_ALSO_NEGOTIATES = 506,
+	INSUFFICIENT_STORAGE = 507,
+	LOOP_DETECTED = 508,
+	NOT_EXTENDED = 510,
+	NETWORK_AUTHENTICATION_REQUIRED = 511
+};
+
+#endif // !__EHTTPSTATUSCODE__H__

dCommon/dEnums/eInventoryType.h

@@ -28,7 +28,8 @@ enum eInventoryType : uint32_t {
 	DONATION,
 	VAULT_MODELS,
 	ITEM_SETS, //internal, technically this is BankBehaviors.
-	INVALID // made up, for internal use!!!, Technically this called the ALL inventory.
+	INVALID, // made up, for internal use!!!, Technically this called the ALL inventory.
+	ALL, // Use this to search all inventories instead of a specific one.
 };
 
 class InventoryType {

dCommon/dEnums/eMissionState.h

@@ -50,7 +50,10 @@ enum class eMissionState : int {
 	/**
 	* The mission has been completed before and has now been completed again. Used for daily missions.
 	*/
-	COMPLETE_READY_TO_COMPLETE = 12
+	COMPLETE_READY_TO_COMPLETE = 12,
+
+	// The mission is failed (don't know where this is used)
+	FAILED = 16,
 };
 
 #endif  //!__MISSIONSTATE__H__

dCommon/dEnums/eObjectBits.h

@@ -1,13 +1,12 @@
-#ifndef __EOBJECTBITS__H__
+#ifndef EOBJECTBITS_H
-#define __EOBJECTBITS__H__
+#define EOBJECTBITS_H
 
 #include <cstdint>
 
 enum class eObjectBits : size_t {
-	PERSISTENT = 32,
 	CLIENT = 46,
 	SPAWNED = 58,
 	CHARACTER = 60
 };
 
-#endif  //!__EOBJECTBITS__H__
+#endif  //!EOBJECTBITS_H

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -102,7 +102,6 @@ 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) {
@@ -149,7 +148,7 @@ void CDClientManager::LoadValuesFromDatabase() {
 	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
 	CDTamingBuildPuzzleTable::Instance().LoadValuesFromDatabase();
 	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
-	CDZoneTableTable::Instance().LoadValuesFromDatabase();
+	CDZoneTableTable::LoadValuesFromDatabase();
 }
 
 void CDClientManager::LoadValuesFromDefaults() {

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp

@@ -1,6 +1,5 @@
 #include "CDActivitiesTable.h"
 
-
 void CDActivitiesTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
 	uint32_t size = 0;
@@ -56,3 +55,13 @@ std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActiviti
 
 	return data;
 }
+
+std::optional<const CDActivities> CDActivitiesTable::GetActivity(const uint32_t activityID) {
+	auto& entries = GetEntries();
+	for (const auto& entry : entries) {
+		if (entry.ActivityID == activityID) {
+			return entry;
+		}
+	}
+	return std::nullopt;
+}

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h

@@ -2,6 +2,7 @@
 
 // Custom Classes
 #include "CDTable.h"
+#include <optional>
 
 struct CDActivities {
 	uint32_t ActivityID;
@@ -31,4 +32,5 @@ public:
 
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
+	std::optional<const CDActivities> GetActivity(const uint32_t activityID);
 };

dDatabase/CDClientDatabase/CDClientTables/CDPlayerFlagsTable.cpp

@@ -0,0 +1,38 @@
+#include "CDPlayerFlagsTable.h"
+
+#include "CDClientDatabase.h"
+
+namespace CDPlayerFlagsTable {
+	Table entries;
+
+	void ReadEntry(CppSQLite3Query& table) {
+		Entry entry;
+		entry.sessionOnly = table.getIntField("SessionOnly") == 1;
+		entry.onlySetByServer = table.getIntField("OnlySetByServer") == 1;
+		entry.sessionZoneOnly = table.getIntField("SessionZoneOnly") == 1;
+		entries[table.getIntField("id")] = entry;
+	}
+
+	void LoadValuesFromDatabase() {
+		auto table = CDClientDatabase::ExecuteQuery("SELECT * FROM PlayerFlags;");
+
+		if (!table.eof()) {
+			do {
+				ReadEntry(table);
+			} while (!table.nextRow());
+		}
+	}
+
+	const std::optional<Entry> GetEntry(const FlagId flagId) {
+		if (!entries.contains(flagId)) {
+			auto table = CDClientDatabase::CreatePreppedStmt("SELECT * FROM PlayerFlags WHERE id = ?;");
+			table.bind(1, static_cast<int>(flagId));
+			auto result = table.execQuery();
+			if (!result.eof()) {
+				ReadEntry(result);
+			}
+		}
+
+		return entries[flagId];
+	}
+}

dDatabase/CDClientDatabase/CDClientTables/CDPlayerFlagsTable.h

@@ -0,0 +1,21 @@
+#ifndef CDPLAYERFLAGSTABLE_H
+#define CDPLAYERFLAGSTABLE_H
+
+#include <map>
+#include <optional>
+
+namespace CDPlayerFlagsTable {
+	struct Entry {
+		bool sessionOnly{};
+		bool onlySetByServer{};
+		bool sessionZoneOnly{};
+	};
+
+	using FlagId = uint32_t;
+	using Table = std::map<FlagId, std::optional<Entry>>;
+
+	void LoadValuesFromDatabase();
+	const std::optional<Entry> GetEntry(const FlagId flagId);
+};
+
+#endif  //!CDPLAYERFLAGSTABLE_H

dDatabase/CDClientDatabase/CDClientTables/CDZoneTableTable.cpp

@@ -1,67 +1,53 @@
 #include "CDZoneTableTable.h"
 
-void CDZoneTableTable::LoadValuesFromDatabase() {
+namespace CDZoneTableTable {
+	Table entries;
 
-	// First, get the size of the table
+	void LoadValuesFromDatabase() {
-	uint32_t size = 0;
+		// Get the data from the database
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ZoneTable");
+		auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ZoneTable");
-	while (!tableSize.eof()) {
+		while (!tableData.eof()) {
-		size = tableSize.getIntField(0, 0);
+			CDZoneTable entry;
+			entry.zoneID = tableData.getIntField("zoneID", -1);
+			entry.locStatus = tableData.getIntField("locStatus", -1);
+			entry.zoneName = tableData.getStringField("zoneName", "");
+			entry.scriptID = tableData.getIntField("scriptID", -1);
+			entry.ghostdistance_min = tableData.getFloatField("ghostdistance_min", -1.0f);
+			entry.ghostdistance = tableData.getFloatField("ghostdistance", -1.0f);
+			entry.population_soft_cap = tableData.getIntField("population_soft_cap", -1);
+			entry.population_hard_cap = tableData.getIntField("population_hard_cap", -1);
+			UNUSED(entry.DisplayDescription = tableData.getStringField("DisplayDescription", ""));
+			UNUSED(entry.mapFolder = tableData.getStringField("mapFolder", ""));
+			entry.smashableMinDistance = tableData.getFloatField("smashableMinDistance", -1.0f);
+			entry.smashableMaxDistance = tableData.getFloatField("smashableMaxDistance", -1.0f);
+			UNUSED(entry.mixerProgram = tableData.getStringField("mixerProgram", ""));
+			UNUSED(entry.clientPhysicsFramerate = tableData.getStringField("clientPhysicsFramerate", ""));
+			entry.serverPhysicsFramerate = tableData.getStringField("serverPhysicsFramerate", "");
+			entry.zoneControlTemplate = tableData.getIntField("zoneControlTemplate", -1);
+			entry.widthInChunks = tableData.getIntField("widthInChunks", -1);
+			entry.heightInChunks = tableData.getIntField("heightInChunks", -1);
+			entry.petsAllowed = tableData.getIntField("petsAllowed", -1) == 1 ? true : false;
+			entry.localize = tableData.getIntField("localize", -1) == 1 ? true : false;
+			entry.fZoneWeight = tableData.getFloatField("fZoneWeight", -1.0f);
+			UNUSED(entry.thumbnail = tableData.getStringField("thumbnail", ""));
+			entry.PlayerLoseCoinsOnDeath = tableData.getIntField("PlayerLoseCoinsOnDeath", -1) == 1 ? true : false;
+			entry.disableSaveLoc = tableData.getIntField("disableSaveLoc", -1) == 1 ? true : false;
+			entry.teamRadius = tableData.getFloatField("teamRadius", -1.0f);
+			UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
+			entry.mountsAllowed = tableData.getIntField("mountsAllowed", -1) == 1 ? true : false;
 
-		tableSize.nextRow();
+			entries[entry.zoneID] = entry;
+			tableData.nextRow();
+		}
 	}
 
-	tableSize.finalize();
+	//! Queries the table with a zoneID to find.
+	const CDZoneTable* Query(uint32_t zoneID) {
+		const auto& iter = entries.find(zoneID);
+		if (iter != entries.end()) {
+			return &iter->second;
+		}
 
-	// Now get the data
+		return nullptr;
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ZoneTable");
-	auto& entries = GetEntriesMutable();
-	while (!tableData.eof()) {
-		CDZoneTable entry;
-		entry.zoneID = tableData.getIntField("zoneID", -1);
-		entry.locStatus = tableData.getIntField("locStatus", -1);
-		entry.zoneName = tableData.getStringField("zoneName", "");
-		entry.scriptID = tableData.getIntField("scriptID", -1);
-		entry.ghostdistance_min = tableData.getFloatField("ghostdistance_min", -1.0f);
-		entry.ghostdistance = tableData.getFloatField("ghostdistance", -1.0f);
-		entry.population_soft_cap = tableData.getIntField("population_soft_cap", -1);
-		entry.population_hard_cap = tableData.getIntField("population_hard_cap", -1);
-		UNUSED(entry.DisplayDescription = tableData.getStringField("DisplayDescription", ""));
-		UNUSED(entry.mapFolder = tableData.getStringField("mapFolder", ""));
-		entry.smashableMinDistance = tableData.getFloatField("smashableMinDistance", -1.0f);
-		entry.smashableMaxDistance = tableData.getFloatField("smashableMaxDistance", -1.0f);
-		UNUSED(entry.mixerProgram = tableData.getStringField("mixerProgram", ""));
-		UNUSED(entry.clientPhysicsFramerate = tableData.getStringField("clientPhysicsFramerate", ""));
-		entry.serverPhysicsFramerate = tableData.getStringField("serverPhysicsFramerate", "");
-		entry.zoneControlTemplate = tableData.getIntField("zoneControlTemplate", -1);
-		entry.widthInChunks = tableData.getIntField("widthInChunks", -1);
-		entry.heightInChunks = tableData.getIntField("heightInChunks", -1);
-		entry.petsAllowed = tableData.getIntField("petsAllowed", -1) == 1 ? true : false;
-		entry.localize = tableData.getIntField("localize", -1) == 1 ? true : false;
-		entry.fZoneWeight = tableData.getFloatField("fZoneWeight", -1.0f);
-		UNUSED(entry.thumbnail = tableData.getStringField("thumbnail", ""));
-		entry.PlayerLoseCoinsOnDeath = tableData.getIntField("PlayerLoseCoinsOnDeath", -1) == 1 ? true : false;
-		entry.disableSaveLoc = tableData.getIntField("disableSaveLoc", -1) == 1 ? true : false;
-		entry.teamRadius = tableData.getFloatField("teamRadius", -1.0f);
-		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
-		entry.mountsAllowed = tableData.getIntField("mountsAllowed", -1) == 1 ? true : false;
-
-		entries.insert(std::make_pair(entry.zoneID, entry));
-		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
-
-//! Queries the table with a zoneID to find.
-const CDZoneTable* CDZoneTableTable::Query(uint32_t zoneID) {
-	auto& m_Entries = GetEntries();
-	const auto& iter = m_Entries.find(zoneID);
-
-	if (iter != m_Entries.end()) {
-		return &iter->second;
-	}
-
-	return nullptr;
-}
-

dDatabase/CDClientDatabase/CDClientTables/CDZoneTableTable.h

@@ -33,8 +33,8 @@ struct CDZoneTable {
 	bool mountsAllowed;                 //!< Whether or not mounts are allowed
 };
 
-class CDZoneTableTable : public CDTable<CDZoneTableTable, std::map<uint32_t, CDZoneTable>> {
+namespace CDZoneTableTable {
-public:
+	using Table = std::map<uint32_t, CDZoneTable>;
 	void LoadValuesFromDatabase();
 
 	// Queries the table with a zoneID to find.

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -25,6 +25,7 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDObjectsTable.cpp"
 	"CDPetComponentTable.cpp"
 	"CDPackageComponentTable.cpp"
+	"CDPlayerFlagsTable.cpp"
 	"CDPhysicsComponentTable.cpp"
 	"CDPropertyEntranceComponentTable.cpp"
 	"CDPropertyTemplateTable.cpp"

dDatabase/CDClientDatabase/CMakeLists.txt

@@ -15,7 +15,7 @@ target_include_directories(dDatabaseCDClient PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dCommon"
 	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
 )
-target_link_libraries(dDatabaseCDClient PRIVATE sqlite3)
+target_link_libraries(dDatabaseCDClient PRIVATE sqlite3 glm::glm)
 
 if (${CDCLIENT_CACHE_ALL})
 	add_compile_definitions(dDatabaseCDClient PRIVATE CDCLIENT_CACHE_ALL=${CDCLIENT_CACHE_ALL})

dDatabase/CMakeLists.txt

@@ -1,7 +1,14 @@
 add_subdirectory(CDClientDatabase)
 add_subdirectory(GameDatabase)
 
-add_library(dDatabase STATIC "MigrationRunner.cpp")
+add_library(dDatabase STATIC "MigrationRunner.cpp" "ModelNormalizeMigration.cpp")
+
+add_custom_target(conncpp_dylib
+	${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${PROJECT_BINARY_DIR})
+
+add_dependencies(dDatabase conncpp_dylib)
+
 target_include_directories(dDatabase PUBLIC ".")
 target_link_libraries(dDatabase
-	PUBLIC dDatabaseCDClient dDatabaseGame)
+	PUBLIC dDatabaseCDClient dDatabaseGame
+	PRIVATE glm::glm)

dDatabase/GameDatabase/CMakeLists.txt

@@ -8,6 +8,12 @@ foreach(file ${DDATABSE_DATABSES_MYSQL_SOURCES})
 	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "MySQL/${file}")
 endforeach()
 
+add_subdirectory(SQLite)
+
+foreach(file ${DDATABSE_DATABSES_SQLITE_SOURCES})
+	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "SQLite/${file}")
+endforeach()
+
 add_subdirectory(TestSQL)
 
 foreach(file ${DDATABSE_DATABSES_TEST_SQL_SOURCES})
@@ -16,13 +22,14 @@ endforeach()
 
 add_library(dDatabaseGame STATIC ${DDATABASE_GAMEDATABASE_SOURCES})
 target_include_directories(dDatabaseGame PUBLIC "."
-	"ITables" PRIVATE "MySQL" "TestSQL"
+	"ITables" PRIVATE "MySQL" "SQLite" "TestSQL"
 	"${PROJECT_SOURCE_DIR}/dCommon"
 	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
 )
+
 target_link_libraries(dDatabaseGame
-	PUBLIC MariaDB::ConnCpp
+	INTERFACE dCommon
-	INTERFACE dCommon)
+	PRIVATE sqlite3 MariaDB::ConnCpp glm::glm)
 
 # Glob together all headers that need to be precompiled
 file(

dDatabase/GameDatabase/Database.cpp

@@ -2,22 +2,46 @@
 #include "Game.h"
 #include "dConfig.h"
 #include "Logger.h"
-#include "MySQLDatabase.h"
 #include "DluAssert.h"
 
+#include "SQLiteDatabase.h"
+#include "MySQLDatabase.h"
+
+#include <ranges>
+
 #pragma warning (disable:4251) //Disables SQL warnings
 
 namespace {
 	GameDatabase* database = nullptr;
 }
 
+std::string Database::GetMigrationFolder() {
+	const std::set<std::string> validMysqlTypes = { "mysql", "mariadb", "maria" };
+	auto databaseType = Game::config->GetValue("database_type");
+	std::ranges::transform(databaseType, databaseType.begin(), ::tolower);
+	if (databaseType == "sqlite") return "sqlite";
+	else if (validMysqlTypes.contains(databaseType)) return "mysql";
+	else {
+		LOG("No database specified, using MySQL");
+		return "mysql";
+	}
+}
+
 void Database::Connect() {
 	if (database) {
 		LOG("Tried to connect to database when it's already connected!");
 		return;
 	}
 
-	database = new MySQLDatabase();
+	const auto databaseType = GetMigrationFolder();
+
+	if (databaseType == "sqlite") database = new SQLiteDatabase();
+	else if (databaseType == "mysql") database = new MySQLDatabase();
+	else {
+		LOG("Invalid database type specified in config, using MySQL");
+		database = new MySQLDatabase();
+	}
+
 	database->Connect();
 }
 

dDatabase/GameDatabase/Database.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <conncpp.hpp>
 
 #include "GameDatabase.h"
 
@@ -13,4 +12,6 @@ namespace Database {
 	// Used for assigning a test database as the handler for database logic.
 	// Do not use in production code.
 	void _setDatabase(GameDatabase* const db);
+
+	std::string GetMigrationFolder();
 };

dDatabase/GameDatabase/GameDatabase.h

@@ -24,14 +24,10 @@
 #include "IIgnoreList.h"
 #include "IAccountsRewardCodes.h"
 #include "IBehaviors.h"
-
+#include "IUgcModularBuild.h"
-namespace sql {
-	class Statement;
-	class PreparedStatement;
-};
 
 #ifdef _DEBUG
-#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (sql::SQLException& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
+#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (std::exception& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
 #else
 #  define DLU_SQL_TRY_CATCH_RETHROW(x) x
 #endif // _DEBUG
@@ -42,18 +38,17 @@ class GameDatabase :
 	public IPropertyContents, public IProperty, public IPetNames, public ICharXml,
 	public IMigrationHistory, public IUgc, public IFriends, public ICharInfo,
 	public IAccounts, public IActivityLog, public IAccountsRewardCodes, public IIgnoreList,
-	public IBehaviors {
+	public IBehaviors, public IUgcModularBuild {
 public:
 	virtual ~GameDatabase() = default;
 	// TODO: These should be made private.
 	virtual void Connect() = 0;
 	virtual void Destroy(std::string source = "") = 0;
 	virtual void ExecuteCustomQuery(const std::string_view query) = 0;
-	virtual sql::PreparedStatement* CreatePreppedStmt(const std::string& query) = 0;
 	virtual void Commit() = 0;
 	virtual bool GetAutoCommit() = 0;
 	virtual void SetAutoCommit(bool value) = 0;
-	virtual void DeleteCharacter(const uint32_t characterId) = 0;
+	virtual void DeleteCharacter(const LWOOBJID characterId) = 0;
 };
 
 #endif  //!__GAMEDATABASE__H__

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -14,6 +14,7 @@ public:
 		std::string bcryptPassword;
 		uint32_t id{};
 		uint32_t playKeyId{};
+		uint64_t muteExpire{};
 		bool banned{};
 		bool locked{};
 		eGameMasterLevel maxGmLevel{};
@@ -36,6 +37,8 @@ public:
 
 	// Update the GameMaster level of an account.
 	virtual void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) = 0;
+
+	virtual uint32_t GetAccountCount() = 0;
 };
 
 #endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -8,12 +8,13 @@
 enum class eActivityType : uint32_t {
 	PlayerLoggedIn,
 	PlayerLoggedOut,
+	PlayerChangedZone
 };
 
 class IActivityLog {
 public:
 	// Update the activity log for the given account.
-	virtual void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
+	virtual void UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
 };
 
 #endif  //!__IACTIVITYLOG__H__

dDatabase/GameDatabase/ITables/IBehaviors.h

@@ -8,15 +8,15 @@
 class IBehaviors {
 public:
 	struct Info {
-		int32_t behaviorId{};
+		LWOOBJID behaviorId{};
-		uint32_t characterId{};
+		LWOOBJID characterId{};
 		std::string behaviorInfo;
 	};
 
 	// This Add also takes care of updating if it exists.
 	virtual void AddBehavior(const Info& info) = 0;
-	virtual std::string GetBehavior(const int32_t behaviorId) = 0;
+	virtual std::string GetBehavior(const LWOOBJID behaviorId) = 0;
-	virtual void RemoveBehavior(const int32_t behaviorId) = 0;
+	virtual void RemoveBehavior(const LWOOBJID behaviorId) = 0;
 };
 
 #endif  //!IBEHAVIORS_H

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -11,7 +11,7 @@ public:
 		std::string clientVersion;
 		std::string otherPlayer;
 		std::string selection;
-		uint32_t characterId{};
+		LWOOBJID characterId{};
 	};
 
 	// Add a new bug report to the database.

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -14,7 +14,7 @@ public:
 	struct Info {
 		std::string name;
 		std::string pendingName;
-		uint32_t id{};
+		LWOOBJID id{};
 		uint32_t accountId{};
 		bool needsRename{};
 		LWOCLONEID cloneId{};
@@ -25,25 +25,27 @@ public:
 	virtual std::vector<std::string> GetApprovedCharacterNames() = 0;
 
 	// Get the character info for the given character id.
-	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) = 0;
+	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) = 0;
 
 	// Get the character info for the given character name.
 	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view name) = 0;
 	
 	// Get the character ids for the given account.
-	virtual std::vector<uint32_t> GetAccountCharacterIds(const uint32_t accountId) = 0;
+	virtual std::vector<LWOOBJID> GetAccountCharacterIds(const LWOOBJID accountId) = 0;
 
 	// Insert a new character into the database.
 	virtual void InsertNewCharacter(const ICharInfo::Info info) = 0;
 
 	// Set the name of the given character.
-	virtual void SetCharacterName(const uint32_t characterId, const std::string_view name) = 0;
+	virtual void SetCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
 
 	// Set the pending name of the given character.
-	virtual void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) = 0;
+	virtual void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
 
 	// Updates the given character ids last login to be right now.
-	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
+	virtual void UpdateLastLoggedInCharacter(const LWOOBJID characterId) = 0;
+
+	virtual bool IsNameInUse(const std::string_view name) = 0;
 };
 
 #endif  //!__ICHARINFO__H__

dDatabase/GameDatabase/ITables/ICharXml.h

@@ -8,13 +8,13 @@
 class ICharXml {
 public:
 	// Get the character xml for the given character id.
-	virtual std::string GetCharacterXml(const uint32_t charId) = 0;
+	virtual std::string GetCharacterXml(const LWOOBJID charId) = 0;
 
 	// Update the character xml for the given character id.
-	virtual void UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) = 0;
+	virtual void UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) = 0;
 
 	// Insert the character xml for the given character id.
-	virtual void InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) = 0;
+	virtual void InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) = 0;
 };
 
 #endif  //!__ICHARXML__H__

dDatabase/GameDatabase/ITables/ICommandLog.h

@@ -8,7 +8,7 @@ class ICommandLog {
 public:	
 
 	// Insert a new slash command log entry.
-	virtual void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) = 0;
+	virtual void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) = 0;
 };
 
 #endif  //!__ICOMMANDLOG__H__

dDatabase/GameDatabase/ITables/IFriends.h

@@ -8,25 +8,25 @@
 class IFriends {
 public:
 	struct BestFriendStatus {
-		uint32_t playerCharacterId{};
+		LWOOBJID playerCharacterId{};
-		uint32_t friendCharacterId{};
+		LWOOBJID friendCharacterId{};
 		uint32_t bestFriendStatus{};
 	};
 
 	// Get the friends list for the given character id.
-	virtual std::vector<FriendData> GetFriendsList(const uint32_t charId) = 0;
+	virtual std::vector<FriendData> GetFriendsList(const LWOOBJID charId) = 0;
 
 	// Get the best friend status for the given player and friend character ids.
-	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
 
 	// Set the best friend status for the given player and friend character ids.
-	virtual void SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) = 0;
+	virtual void SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId, const uint32_t bestFriendStatus) = 0;
 
 	// Add a friend to the given character id.
-	virtual void AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+	virtual void AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
 
 	// Remove a friend from the given character id.
-	virtual void RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
+	virtual void RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
 };
 
 #endif  //!__IFRIENDS__H__