WIP

Co-authored-by: Daniel Seiler <me@xiphoseer.de>

.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

.gitignore

@@ -6,7 +6,6 @@ docker/configs
 # Third party libraries
 thirdparty/mysql/
 thirdparty/mysql_linux/
-CMakeVariables.txt
 
 # Build folders
 build/

.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

@@ -175,16 +175,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})
-					set(line_to_add ${line_to_add} ${line})
+					# For backwards compatibility with older setup versions, dont add this option.
+					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})
-						file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
-					endforeach()
+						foreach(line_to_append ${line_to_add})
+							file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n" ${line_to_append})
+						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})
@@ -214,21 +216,8 @@ foreach(file ${VANITY_FILES})
 endforeach()
 
 # Move our migrations for MasterServer to run
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/migrations/dlu/)
-file(GLOB SQL_FILES ${CMAKE_SOURCE_DIR}/migrations/dlu/*.sql)
-
-foreach(file ${SQL_FILES})
-	get_filename_component(file ${file} NAME)
-	configure_file(${CMAKE_SOURCE_DIR}/migrations/dlu/${file} ${PROJECT_BINARY_DIR}/migrations/dlu/${file})
-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()
+file(REMOVE_RECURSE ${PROJECT_BINARY_DIR}/migrations)
+file(COPY ${CMAKE_SOURCE_DIR}/migrations DESTINATION ${CMAKE_BINARY_DIR})
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
@@ -258,8 +247,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)

CMakeVariables.txt

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

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
-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.
+## Setting up a single player server
+* 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,6 +70,12 @@ 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!).
@@ -183,6 +210,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 +233,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:
-* AuthServer
-* ChatServer
-* MasterServer
-* WorldServer
-* authconfig.ini
-* chatconfig.ini
-* masterconfig.ini
+Your build directory should contain at a minimum all of the following files.
+All listed files are required for a server to start.
+`ini` files can be located at the environment variable `DLU_CONFIG_DIR` and do not need to be located in this directory.
+(windows will have .exe at the end of the executables):
 * 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.
-To give `AuthServer` network permissions and not require sudo, run the following command
+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:
 ```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 +307,8 @@ systemctl stop darkflame.service
 journalctl -xeu darkflame.service
 ```
 
-### First admin user
-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!
+### First user or adding more 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**
@@ -289,8 +330,14 @@ To connect to a server follow these steps:
 * 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
 * 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 +354,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 +422,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

dAuthServer/AuthServer.cpp

@@ -27,7 +27,6 @@
 #include "Game.h"
 #include "Server.h"
 
-
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;

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}\"")

dChatServer/CMakeLists.txt

@@ -2,6 +2,9 @@ set(DCHATSERVER_SOURCES
 	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
 	"PlayerContainer.cpp"
+	"ChatWebAPI.cpp"
+	"JSONUtils.cpp"
+	"CSRCommandHandler.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
@@ -12,5 +15,5 @@ add_library(dChatServer ${DCHATSERVER_SOURCES})
 target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
 
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose)
 

dChatServer/CSRCommandHandler.cpp

@@ -0,0 +1,353 @@
+#include "CSRCommandHandler.h"
+#include "eCSRCommand.h"
+#include "eHTTPStatusCode.h"
+#include "JSONUtils.h"
+#include "magic_enum.hpp"
+#include "json.hpp"
+
+void CSRCommandHandler::HandleCSRCommand(HTTPReply& reply, const json& data) {
+	auto check = JSONUtils::CheckRequiredData(data, { "command" });
+	if (!check.empty()) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = check;
+	} else {
+		// get command from json
+		std::string command_string = data["command"];
+		// upper
+		std::transform(command_string.begin(), command_string.end(), command_string.begin(), ::toupper);
+		eCSRCommand command = magic_enum::enum_cast<eCSRCommand>(command_string).value_or(eCSRCommand::INVALID);
+		
+		switch (command) {
+		case eCSRCommand::QUERY_SERVER_STATUS:
+			QueryServerStatus(reply, data);
+			break;
+		case eCSRCommand::QUERY_CHARACTER_LOCATION:
+			QueryCharacterLocation(reply, data);
+			break;
+		case eCSRCommand::QUERY_CHARACTER_ONLINE_STATUS:
+			QueryCharacterOnlineStatus(reply, data);
+			break;
+		case eCSRCommand::INVENTORY_ADD_ITEM:
+			InventoryAddItem(reply, data);
+			break;
+		case eCSRCommand::INVENTORY_DELETE_ITEM:
+			InventoryDeleteItem(reply, data);
+			break;
+		case eCSRCommand::MODERATE_MUTE_ACCOUNT:
+			ModerateMuteAccount(reply, data);
+			break;
+		case eCSRCommand::MODERATE_BAN_ACCOUNT:
+			ModerateBanAccount(reply, data);
+			break;
+		case eCSRCommand::MODERATE_EDUCATE_CHARACTER:
+			ModerateEducateCharacter(reply, data);
+			break;
+		case eCSRCommand::MODERATE_KICK_CHARACTER:
+			ModerateKickCharacter(reply, data);
+			break;
+		case eCSRCommand::MODERATE_WARN_CHARACTER:
+			ModerateWarnCharacter(reply, data);
+			break;
+		case eCSRCommand::MODERATE_RENAME_CHARACTER:
+			ModerateRenameCharacter(reply, data);
+			break;
+		case eCSRCommand::MODERATE_DELETE_CHARACTER_FRIEND:
+			ModerateDeleteCharacterFriend(reply, data);
+			break;
+		case eCSRCommand::MODERATE_KILL_CHARACTER:
+			ModerateKillCharacter(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_HEALTH:
+			UpdateCharacterHealth(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_ARMOR:
+			UpdateCharacterArmor(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_IMAGINATION:
+			UpdateCharacterImagination(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_MAX_HEALTH:
+			UpdateCharacterMaxHealth(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_MAX_ARMOR:
+			UpdateCharacterMaxArmor(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_MAX_IMAGINATION:
+			UpdateCharacterMaxImagination(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_CURRENCY:
+			UpdateCharacterCurrency(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_REPUTATION:
+			UpdateCharacterReputation(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_LEGO_SCORE:
+			UpdateCharacterLegoScore(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_EMOTES:
+			UpdateCharacterEmotes(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_ADD_ACHIEVEMENT:
+			UpdateCharacterAddAchievement(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_COMPLETE_ACHIEVEMENT:
+			UpdateCharacterCompleteAchievement(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_REMOVE_ACHIEVEMENT:
+			UpdateCharacterRemoveAchievement(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_POSITION_OFFLINE:
+			UpdateCharacterPositionOffline(reply, data);
+			break;
+		case eCSRCommand::UPDATE_CHARACTER_INV_SLOT_AMOUNT:
+			UpdateCharacterInvSlotAmount(reply, data);
+			break;
+		case eCSRCommand::UTILITY_SAVE_CHARACTER:
+			UtilitySaveCharacter(reply, data);
+			break;
+		case eCSRCommand::UTILITY_SEND_MAIL:
+			UtilitySendMail(reply, data);
+			break;
+		case eCSRCommand::UTILITY_GIVE_ITEM_TO_ALL_PLAYERS_ONLINE:
+			UtilityGiveItemToAllPlayersOnline(reply, data);
+			break;
+		case eCSRCommand::METRICS_CONFIGURE:
+			MetricsConfigure(reply, data);
+			break;
+		case eCSRCommand::DISABLE_ZONE:
+			DisableZone(reply, data);
+			break;
+		case eCSRCommand::INIT_DONATION_AMOUNT:
+			InitDonationAmount(reply, data);
+			break;
+		case eCSRCommand::KILL_SERVERS_COUNTDOWN:
+			KillServersCountdown(reply, data);
+			break;
+		case eCSRCommand::DISABLE_FAQ:
+			DisableFAQ(reply, data);
+			break;
+		case eCSRCommand::THROTTLEQUEUE:
+			ThrottleQueue(reply, data);
+			break;
+		case eCSRCommand::GATEGM_ACCESS:
+			GateGMAccess(reply, data);
+			break;
+		case eCSRCommand::RECONNECT_CRISP:
+			ReconnectCrisp(reply, data);
+			break;
+		case eCSRCommand::MODERATE_KICK_ACCOUNT:
+			ModerateKickAccount(reply, data);
+			break;
+		case eCSRCommand::TOGGLE_CRISP_SERVER:
+			ToggleCrispServer(reply, data);
+			break;
+		case eCSRCommand::QUICK_DRAIN_SERVER:
+			QuickDrainServer(reply, data);
+			break;
+		case eCSRCommand::QUICK_DRAIN_SERVER_RENEW:
+			QuickDrainServerRenew(reply, data);
+			break;
+		case eCSRCommand::REPLICATE_CHARACTER:
+			ReplicateCharacter(reply, data);
+			break;
+		case eCSRCommand::GET_SERVER_STATUS:
+			GetServerStatus(reply);
+			break;
+		case eCSRCommand::RELOAD_SERVER_INIS:
+			ReloadServerINIs(reply);
+			break;
+		case eCSRCommand::INVALID:
+		default:
+			reply.status = eHTTPStatusCode::BAD_REQUEST;
+			reply.message = "{\"error\":\"Invalid Command\"}";
+			break;
+		}
+	}
+}
+
+void CSRCommandHandler::QueryServerStatus(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::QueryCharacterLocation(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::QueryCharacterOnlineStatus(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::InventoryAddItem(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::InventoryDeleteItem(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateMuteAccount(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateBanAccount(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateEducateCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateKickCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateWarnCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateRenameCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateDeleteCharacterFriend(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateKillCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterHealth(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterArmor(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterImagination(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterMaxHealth(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterMaxArmor(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterMaxImagination(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterCurrency(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterReputation(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterLegoScore(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterEmotes(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterAddAchievement(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterCompleteAchievement(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterRemoveAchievement(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterPositionOffline(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UpdateCharacterInvSlotAmount(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UtilitySaveCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UtilitySendMail(HTTPReply& reply, const json& data) {
+	
+
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::UtilityGiveItemToAllPlayersOnline(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::MetricsConfigure(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::DisableZone(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::InitDonationAmount(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::KillServersCountdown(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::DisableFAQ(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ThrottleQueue(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::GateGMAccess(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ReconnectCrisp(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ModerateKickAccount(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ToggleCrispServer(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::QuickDrainServer(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::QuickDrainServerRenew(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ReplicateCharacter(HTTPReply& reply, const json& data) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::GetServerStatus(HTTPReply& reply) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}
+void CSRCommandHandler::ReloadServerINIs(HTTPReply& reply) {
+	reply.status = eHTTPStatusCode::NOT_IMPLEMENTED;
+	reply.message = "{\"error\":\"Not Implemented\"}";
+}

dChatServer/CSRCommandHandler.h

@@ -0,0 +1,62 @@
+#ifndef __CSR_COMMAND_HANDLER__H__
+#define __CSR_COMMAND_HANDLER__H__
+
+#include <optional>
+#include "json_fwd.hpp"
+
+using json = nlohmann::json;
+struct HTTPReply;
+
+
+namespace CSRCommandHandler {
+	void HandleCSRCommand(HTTPReply& reply, const json& data);
+
+	void QueryServerStatus(HTTPReply& reply, const json& data);
+	void QueryCharacterLocation(HTTPReply& reply, const json& data);
+	void QueryCharacterOnlineStatus(HTTPReply& reply, const json& data);
+	void InventoryAddItem(HTTPReply& reply, const json& data);
+	void InventoryDeleteItem(HTTPReply& reply, const json& data);
+	void ModerateMuteAccount(HTTPReply& reply, const json& data);
+	void ModerateBanAccount(HTTPReply& reply, const json& data);
+	void ModerateEducateCharacter(HTTPReply& reply, const json& data);
+	void ModerateKickCharacter(HTTPReply& reply, const json& data);
+	void ModerateWarnCharacter(HTTPReply& reply, const json& data);
+	void ModerateRenameCharacter(HTTPReply& reply, const json& data);
+	void ModerateDeleteCharacterFriend(HTTPReply& reply, const json& data);
+	void ModerateKillCharacter(HTTPReply& reply, const json& data);
+	void UpdateCharacterHealth(HTTPReply& reply, const json& data);
+	void UpdateCharacterArmor(HTTPReply& reply, const json& data);
+	void UpdateCharacterImagination(HTTPReply& reply, const json& data);
+	void UpdateCharacterMaxHealth(HTTPReply& reply, const json& data);
+	void UpdateCharacterMaxArmor(HTTPReply& reply, const json& data);
+	void UpdateCharacterMaxImagination(HTTPReply& reply, const json& data);
+	void UpdateCharacterCurrency(HTTPReply& reply, const json& data);
+	void UpdateCharacterReputation(HTTPReply& reply, const json& data);
+	void UpdateCharacterLegoScore(HTTPReply& reply, const json& data);
+	void UpdateCharacterEmotes(HTTPReply& reply, const json& data);
+	void UpdateCharacterAddAchievement(HTTPReply& reply, const json& data);
+	void UpdateCharacterCompleteAchievement(HTTPReply& reply, const json& data);
+	void UpdateCharacterRemoveAchievement(HTTPReply& reply, const json& data);
+	void UpdateCharacterPositionOffline(HTTPReply& reply, const json& data);
+	void UpdateCharacterInvSlotAmount(HTTPReply& reply, const json& data);
+	void UtilitySaveCharacter(HTTPReply& reply, const json& data);
+	void UtilitySendMail(HTTPReply& reply, const json& data);
+	void UtilityGiveItemToAllPlayersOnline(HTTPReply& reply, const json& data);
+	void MetricsConfigure(HTTPReply& reply, const json& data);
+	void DisableZone(HTTPReply& reply, const json& data);
+	void InitDonationAmount(HTTPReply& reply, const json& data);
+	void KillServersCountdown(HTTPReply& reply, const json& data);
+	void DisableFAQ(HTTPReply& reply, const json& data);
+	void ThrottleQueue(HTTPReply& reply, const json& data);
+	void GateGMAccess(HTTPReply& reply, const json& data);
+	void ReconnectCrisp(HTTPReply& reply, const json& data);
+	void ModerateKickAccount(HTTPReply& reply, const json& data);
+	void ToggleCrispServer(HTTPReply& reply, const json& data);
+	void QuickDrainServer(HTTPReply& reply, const json& data);
+	void QuickDrainServerRenew(HTTPReply& reply, const json& data);
+	void ReplicateCharacter(HTTPReply& reply, const json& data);
+	void GetServerStatus(HTTPReply& reply);
+	void ReloadServerINIs(HTTPReply& reply);
+};
+
+#endif // !__CSR_COMMAND_HANDLER__H__

dChatServer/ChatPacketHandler.cpp

@@ -29,33 +29,35 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	auto& player = Game::playerContainer.GetPlayerDataMutable(playerID);
 	if (!player) return;
 
-	auto friendsList = Database::Get()->GetFriendsList(playerID);
-	for (const auto& friendData : friendsList) {
-		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);
+	if (player.friends.empty()) {
+		auto friendsList = Database::Get()->GetFriendsList(playerID);
+		for (const auto& friendData : friendsList) {
+			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
-		if (fd.isBestFriend) player.countOfBestFriends += 1;
-		fd.friendName = friendData.friendName;
+			fd.isBestFriend = friendData.isBestFriend; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
+			if (fd.isBestFriend) player.countOfBestFriends += 1;
+			fd.friendName = friendData.friendName;
 
-		//Now check if they're online:
-		const auto& fr = Game::playerContainer.GetPlayerData(fd.friendID);
+			//Now check if they're online:
+			const auto& fr = Game::playerContainer.GetPlayerData(fd.friendID);
 
-		if (fr) {
-			fd.isOnline = true;
-			fd.zoneID = fr.zoneID;
+			if (fr) {
+				fd.isOnline = true;
+				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);
-		} else {
-			fd.isOnline = false;
-			fd.zoneID = LWOZONEID();
+				//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);
+			} else {
+				fd.isOnline = false;
+				fd.zoneID = LWOZONEID();
+			}
+
+			player.friends.push_back(fd);
 		}
-
-		player.friends.push_back(fd);
 	}
 
 	//Now, we need to send the friendlist to the server they came from:
@@ -140,7 +142,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;
 	}
@@ -400,8 +402,8 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	bitStream.Write(Game::playerContainer.GetSimCount());
 	bitStream.Write<uint8_t>(request.displayIndividualPlayers);
 	bitStream.Write<uint8_t>(request.displayZoneData);
-	if (request.displayZoneData || request.displayIndividualPlayers){
-		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
+	if (request.displayZoneData || request.displayIndividualPlayers) {
+		for (auto& [playerID, playerData] : Game::playerContainer.GetAllPlayers()) {
 			if (!playerData) continue;
 			bitStream.Write<uint8_t>(0); // structure packing
 			if (request.displayIndividualPlayers) bitStream.Write(LUWString(playerData.playerName));

dChatServer/ChatServer.cpp

@@ -28,6 +28,8 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
+#include "ChatWebAPI.h"
+
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -122,6 +124,13 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
+
+	bool web_server_enabled = Game::config->GetValue("web_server_enabled") == "1";
+	ChatWebAPI chatwebapi;
+	if (web_server_enabled) chatwebapi.Listen();
+
+	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 +141,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 +156,11 @@ int main(int argc, char** argv) {
 			packet = nullptr;
 		}
 
+		//Check and handle web requests:
+		if (web_server_enabled) {
+			chatwebapi.ReceiveRequests();
+		}
+
 		//Push our log every 30s:
 		if (framesSinceLastFlush >= logFlushTime) {
 			Game::logger->Flush();
@@ -168,7 +186,7 @@ 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();
 	//Delete our objects here:
 	Database::Destroy("ChatServer");
 	delete Game::server;
@@ -197,150 +215,149 @@ void HandlePacket(Packet* packet) {
 	inStream.Read(chatMessageID);
 
 	switch (chatMessageID) {
-		case MessageType::Chat::GM_MUTE:
-			Game::playerContainer.MuteUpdate(packet);
-			break;
+	case MessageType::Chat::GM_MUTE:
+		Game::playerContainer.MuteUpdate(packet);
+		break;
 
-		case MessageType::Chat::CREATE_TEAM:
-			Game::playerContainer.CreateTeamServer(packet);
-			break;
+	case MessageType::Chat::CREATE_TEAM:
+		Game::playerContainer.CreateTeamServer(packet);
+		break;
 
-		case MessageType::Chat::GET_FRIENDS_LIST:
-			ChatPacketHandler::HandleFriendlistRequest(packet);
-			break;
+	case MessageType::Chat::GET_FRIENDS_LIST:
+		ChatPacketHandler::HandleFriendlistRequest(packet);
+		break;
 
-		case MessageType::Chat::GET_IGNORE_LIST:
-			ChatIgnoreList::GetIgnoreList(packet);
-			break;
+	case MessageType::Chat::GET_IGNORE_LIST:
+		ChatIgnoreList::GetIgnoreList(packet);
+		break;
 
-		case MessageType::Chat::ADD_IGNORE:
-			ChatIgnoreList::AddIgnore(packet);
-			break;
+	case MessageType::Chat::ADD_IGNORE:
+		ChatIgnoreList::AddIgnore(packet);
+		break;
 
-		case MessageType::Chat::REMOVE_IGNORE:
-			ChatIgnoreList::RemoveIgnore(packet);
-			break;
+	case MessageType::Chat::REMOVE_IGNORE:
+		ChatIgnoreList::RemoveIgnore(packet);
+		break;
 
-		case MessageType::Chat::TEAM_GET_STATUS:
-			ChatPacketHandler::HandleTeamStatusRequest(packet);
-			break;
+	case MessageType::Chat::TEAM_GET_STATUS:
+		ChatPacketHandler::HandleTeamStatusRequest(packet);
+		break;
 
-		case MessageType::Chat::ADD_FRIEND_REQUEST:
-			//this involves someone sending the initial request, the response is below, response as in from the other player.
-			//We basically just check to see if this player is online or not and route the packet.
-			ChatPacketHandler::HandleFriendRequest(packet);
-			break;
+	case MessageType::Chat::ADD_FRIEND_REQUEST:
+		//this involves someone sending the initial request, the response is below, response as in from the other player.
+		//We basically just check to see if this player is online or not and route the packet.
+		ChatPacketHandler::HandleFriendRequest(packet);
+		break;
 
-		case MessageType::Chat::ADD_FRIEND_RESPONSE:
-			//This isn't the response a server sent, rather it is a player's response to a received request.
-			//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
-			ChatPacketHandler::HandleFriendResponse(packet);
-			break;
+	case MessageType::Chat::ADD_FRIEND_RESPONSE:
+		//This isn't the response a server sent, rather it is a player's response to a received request.
+		//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
+		ChatPacketHandler::HandleFriendResponse(packet);
+		break;
 
-		case MessageType::Chat::REMOVE_FRIEND:
-			ChatPacketHandler::HandleRemoveFriend(packet);
-			break;
+	case MessageType::Chat::REMOVE_FRIEND:
+		ChatPacketHandler::HandleRemoveFriend(packet);
+		break;
 
-		case MessageType::Chat::GENERAL_CHAT_MESSAGE:
-			ChatPacketHandler::HandleChatMessage(packet);
-			break;
+	case MessageType::Chat::GENERAL_CHAT_MESSAGE:
+		ChatPacketHandler::HandleChatMessage(packet);
+		break;
 
-		case MessageType::Chat::PRIVATE_CHAT_MESSAGE:
-			//This message is supposed to be echo'd to both the sender and the receiver
-			//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
-			ChatPacketHandler::HandlePrivateChatMessage(packet);
-			break;
+	case MessageType::Chat::PRIVATE_CHAT_MESSAGE:
+		//This message is supposed to be echo'd to both the sender and the receiver
+		//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
+		ChatPacketHandler::HandlePrivateChatMessage(packet);
+		break;
 
-		case MessageType::Chat::TEAM_INVITE:
-			ChatPacketHandler::HandleTeamInvite(packet);
-			break;
+	case MessageType::Chat::TEAM_INVITE:
+		ChatPacketHandler::HandleTeamInvite(packet);
+		break;
 
-		case MessageType::Chat::TEAM_INVITE_RESPONSE:
-			ChatPacketHandler::HandleTeamInviteResponse(packet);
-			break;
+	case MessageType::Chat::TEAM_INVITE_RESPONSE:
+		ChatPacketHandler::HandleTeamInviteResponse(packet);
+		break;
 
-		case MessageType::Chat::TEAM_LEAVE:
-			ChatPacketHandler::HandleTeamLeave(packet);
-			break;
+	case MessageType::Chat::TEAM_LEAVE:
+		ChatPacketHandler::HandleTeamLeave(packet);
+		break;
 
-		case MessageType::Chat::TEAM_SET_LEADER:
-			ChatPacketHandler::HandleTeamPromote(packet);
-			break;
+	case MessageType::Chat::TEAM_SET_LEADER:
+		ChatPacketHandler::HandleTeamPromote(packet);
+		break;
 
-		case MessageType::Chat::TEAM_KICK:
-			ChatPacketHandler::HandleTeamKick(packet);
-			break;
+	case MessageType::Chat::TEAM_KICK:
+		ChatPacketHandler::HandleTeamKick(packet);
+		break;
 
-		case MessageType::Chat::TEAM_SET_LOOT:
-			ChatPacketHandler::HandleTeamLootOption(packet);
-			break;
-		case MessageType::Chat::GMLEVEL_UPDATE:
-			ChatPacketHandler::HandleGMLevelUpdate(packet);
-			break;
-		case MessageType::Chat::LOGIN_SESSION_NOTIFY:
-			Game::playerContainer.InsertPlayer(packet);
-			break;
-		case MessageType::Chat::GM_ANNOUNCE:{
-			// we just forward this packet to every connected server
-			inStream.ResetReadPointer();
-			Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
-			}
-			break;
-		case MessageType::Chat::UNEXPECTED_DISCONNECT:
-			Game::playerContainer.RemovePlayer(packet);
-			break;
-		case MessageType::Chat::WHO:
-			ChatPacketHandler::HandleWho(packet);
-			break;
-		case MessageType::Chat::SHOW_ALL:
-			ChatPacketHandler::HandleShowAll(packet);
-			break;
-		case MessageType::Chat::USER_CHANNEL_CHAT_MESSAGE:
-		case MessageType::Chat::WORLD_DISCONNECT_REQUEST:
-		case MessageType::Chat::WORLD_PROXIMITY_RESPONSE:
-		case MessageType::Chat::WORLD_PARCEL_RESPONSE:
-		case MessageType::Chat::TEAM_MISSED_INVITE_CHECK:
-		case MessageType::Chat::GUILD_CREATE:
-		case MessageType::Chat::GUILD_INVITE:
-		case MessageType::Chat::GUILD_INVITE_RESPONSE:
-		case MessageType::Chat::GUILD_LEAVE:
-		case MessageType::Chat::GUILD_KICK:
-		case MessageType::Chat::GUILD_GET_STATUS:
-		case MessageType::Chat::GUILD_GET_ALL:
-		case MessageType::Chat::BLUEPRINT_MODERATED:
-		case MessageType::Chat::BLUEPRINT_MODEL_READY:
-		case MessageType::Chat::PROPERTY_READY_FOR_APPROVAL:
-		case MessageType::Chat::PROPERTY_MODERATION_CHANGED:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED:
-		case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED_REPORT:
-		case MessageType::Chat::MAIL:
-		case MessageType::Chat::WORLD_INSTANCE_LOCATION_REQUEST:
-		case MessageType::Chat::REPUTATION_UPDATE:
-		case MessageType::Chat::SEND_CANNED_TEXT:
-		case MessageType::Chat::CHARACTER_NAME_CHANGE_REQUEST:
-		case MessageType::Chat::CSR_REQUEST:
-		case MessageType::Chat::CSR_REPLY:
-		case MessageType::Chat::GM_KICK:
-		case MessageType::Chat::WORLD_ROUTE_PACKET:
-		case MessageType::Chat::GET_ZONE_POPULATIONS:
-		case MessageType::Chat::REQUEST_MINIMUM_CHAT_MODE:
-		case MessageType::Chat::MATCH_REQUEST:
-		case MessageType::Chat::UGCMANIFEST_REPORT_MISSING_FILE:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_FILE:
-		case MessageType::Chat::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
-		case MessageType::Chat::UGCC_REQUEST:
-		case MessageType::Chat::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
-		case MessageType::Chat::ACHIEVEMENT_NOTIFY:
-		case MessageType::Chat::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		case MessageType::Chat::PLAYER_READY:
-		case MessageType::Chat::GET_DONATION_TOTAL:
-		case MessageType::Chat::UPDATE_DONATION:
-		case MessageType::Chat::PRG_CSR_COMMAND:
-		case MessageType::Chat::HEARTBEAT_REQUEST_FROM_WORLD:
-		case MessageType::Chat::UPDATE_FREE_TRIAL_STATUS:
-			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
-			break;
-		default:
-			LOG("Unknown CHAT Message id: %i", chatMessageID);
+	case MessageType::Chat::TEAM_SET_LOOT:
+		ChatPacketHandler::HandleTeamLootOption(packet);
+		break;
+	case MessageType::Chat::GMLEVEL_UPDATE:
+		ChatPacketHandler::HandleGMLevelUpdate(packet);
+		break;
+	case MessageType::Chat::LOGIN_SESSION_NOTIFY:
+		Game::playerContainer.InsertPlayer(packet);
+		break;
+	case MessageType::Chat::GM_ANNOUNCE:
+		// we just forward this packet to every connected server
+		inStream.ResetReadPointer();
+		Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
+		break;
+	case MessageType::Chat::UNEXPECTED_DISCONNECT:
+		Game::playerContainer.ScheduleRemovePlayer(packet);
+		break;
+	case MessageType::Chat::WHO:
+		ChatPacketHandler::HandleWho(packet);
+		break;
+	case MessageType::Chat::SHOW_ALL:
+		ChatPacketHandler::HandleShowAll(packet);
+		break;
+	case MessageType::Chat::USER_CHANNEL_CHAT_MESSAGE:
+	case MessageType::Chat::WORLD_DISCONNECT_REQUEST:
+	case MessageType::Chat::WORLD_PROXIMITY_RESPONSE:
+	case MessageType::Chat::WORLD_PARCEL_RESPONSE:
+	case MessageType::Chat::TEAM_MISSED_INVITE_CHECK:
+	case MessageType::Chat::GUILD_CREATE:
+	case MessageType::Chat::GUILD_INVITE:
+	case MessageType::Chat::GUILD_INVITE_RESPONSE:
+	case MessageType::Chat::GUILD_LEAVE:
+	case MessageType::Chat::GUILD_KICK:
+	case MessageType::Chat::GUILD_GET_STATUS:
+	case MessageType::Chat::GUILD_GET_ALL:
+	case MessageType::Chat::BLUEPRINT_MODERATED:
+	case MessageType::Chat::BLUEPRINT_MODEL_READY:
+	case MessageType::Chat::PROPERTY_READY_FOR_APPROVAL:
+	case MessageType::Chat::PROPERTY_MODERATION_CHANGED:
+	case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED:
+	case MessageType::Chat::PROPERTY_BUILDMODE_CHANGED_REPORT:
+	case MessageType::Chat::MAIL:
+	case MessageType::Chat::WORLD_INSTANCE_LOCATION_REQUEST:
+	case MessageType::Chat::REPUTATION_UPDATE:
+	case MessageType::Chat::SEND_CANNED_TEXT:
+	case MessageType::Chat::CHARACTER_NAME_CHANGE_REQUEST:
+	case MessageType::Chat::CSR_REQUEST:
+	case MessageType::Chat::CSR_REPLY:
+	case MessageType::Chat::GM_KICK:
+	case MessageType::Chat::WORLD_ROUTE_PACKET:
+	case MessageType::Chat::GET_ZONE_POPULATIONS:
+	case MessageType::Chat::REQUEST_MINIMUM_CHAT_MODE:
+	case MessageType::Chat::MATCH_REQUEST:
+	case MessageType::Chat::UGCMANIFEST_REPORT_MISSING_FILE:
+	case MessageType::Chat::UGCMANIFEST_REPORT_DONE_FILE:
+	case MessageType::Chat::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
+	case MessageType::Chat::UGCC_REQUEST:
+	case MessageType::Chat::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
+	case MessageType::Chat::ACHIEVEMENT_NOTIFY:
+	case MessageType::Chat::GM_CLOSE_PRIVATE_CHAT_WINDOW:
+	case MessageType::Chat::PLAYER_READY:
+	case MessageType::Chat::GET_DONATION_TOTAL:
+	case MessageType::Chat::UPDATE_DONATION:
+	case MessageType::Chat::PRG_CSR_COMMAND:
+	case MessageType::Chat::HEARTBEAT_REQUEST_FROM_WORLD:
+	case MessageType::Chat::UPDATE_FREE_TRIAL_STATUS:
+		LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
+		break;
+	default:
+		LOG("Unknown CHAT Message id: %i", chatMessageID);
 	}
 }

dChatServer/ChatWebAPI.cpp

@@ -0,0 +1,209 @@
+#include "ChatWebAPI.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 "JSONUtils.h"
+#include "eHTTPMethod.h"
+#include "eHTTPStatusCode.h"
+#include "magic_enum.hpp"
+#include "ChatPackets.h"
+#include "StringifiedEnum.h"
+#include "eCSRCommand.h"
+#include "CSRCommandHandler.h"
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma push_macro("DELETE")
+#undef DELETE
+#endif
+
+using json = nlohmann::json;
+
+typedef struct mg_connection mg_connection;
+typedef struct mg_http_message mg_http_message;
+
+namespace {
+	const std::string root_path = "/api/v1/";
+	const char* json_content_type = "Content-Type: application/json\r\n";
+}
+
+void HandlePlayersRequest(HTTPReply& reply) {
+	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 HandleTeamsRequest(HTTPReply& reply) {
+	const json data = Game::playerContainer.GetTeamContainer();
+	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
+	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
+}
+
+void HandleInvalidRoute(HTTPReply& reply) {
+	reply.status = eHTTPStatusCode::NOT_FOUND;
+	reply.message = "{\"error\":\"Invalid Route\"}";
+}
+
+void HandleGET(HTTPReply& reply, const ChatWebAPI::eRoute& route , const std::string& body) {
+	switch (route) {
+		case ChatWebAPI::eRoute::PLAYERS:
+			HandlePlayersRequest(reply);
+			break;
+		case ChatWebAPI::eRoute::TEAMS:
+			HandleTeamsRequest(reply);
+			break;
+		case ChatWebAPI::eRoute::INVALID:
+		default:
+			HandleInvalidRoute(reply);
+			break;
+	}
+}
+
+void HandleAnnounceRequest(HTTPReply& reply, const std::optional<json>& data) {
+	if (!JSONUtils::Validate(data, reply)) 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.Send();
+
+		reply.status = eHTTPStatusCode::OK;
+		reply.message = "{\"status\":\"Announcement Sent\"}";
+	}
+}
+
+void HandleCSRCommandRequest(HTTPReply& reply, const std::optional<json>& data) {
+	if (!JSONUtils::Validate(data, reply)) return;
+
+	const auto& good_data = data.value();
+	auto check = JSONUtils::CheckRequiredData(good_data, { "command" });
+	if (!check.empty()) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = check;
+	} else {
+		CSRCommandHandler::HandleCSRCommand(reply, good_data);
+	}
+}
+
+void HandlePOST(HTTPReply& reply, const ChatWebAPI::eRoute& route , const std::string& body) {
+	auto data = GeneralUtils::TryParse<json>(body);
+	switch (route) {
+		case ChatWebAPI::eRoute::ANNOUNCE:
+			HandleAnnounceRequest(reply, data.value());
+			break;
+		case ChatWebAPI::eRoute::CSR:
+			HandleCSRCommandRequest(reply, data.value());
+			break;
+		case ChatWebAPI::eRoute::INVALID:
+		default:
+			HandleInvalidRoute(reply);
+			break;
+	}
+}
+
+void HandleHTTPMessage(mg_connection* connection, const mg_http_message* http_msg) {
+	HTTPReply reply;
+	
+	if (!http_msg) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid Request\"}";
+	} else {
+		
+		// convert method from cstring to std string
+		std::string method_string(http_msg->method.buf, http_msg->method.len);
+		// get mehtod from mg to enum
+		const eHTTPMethod method = magic_enum::enum_cast<eHTTPMethod>(method_string).value_or(eHTTPMethod::INVALID);
+
+		// convert uri from cstring to std string
+		std::string uri(http_msg->uri.buf, http_msg->uri.len);
+		// check for root path
+		if (uri.find(root_path) == 0) {
+			// remove root path from uri
+			uri.erase(0, root_path.length());
+			// convert uri to uppercase
+			std::transform(uri.begin(), uri.end(), uri.begin(), ::toupper);
+			// convert uri string to route enum
+			ChatWebAPI::eRoute route = magic_enum::enum_cast<ChatWebAPI::eRoute>(uri).value_or(ChatWebAPI::eRoute::INVALID);
+			// convert body from cstring to std string
+			std::string body(http_msg->body.buf, http_msg->body.len);
+
+			switch (method) {
+			case eHTTPMethod::GET:
+				HandleGET(reply, route, body);
+				break;
+			case eHTTPMethod::POST:
+				HandlePOST(reply, route, body);
+				break;
+			case eHTTPMethod::PUT:	
+			case eHTTPMethod::DELETE:
+			case eHTTPMethod::HEAD:	
+			case eHTTPMethod::CONNECT:
+			case eHTTPMethod::OPTIONS:
+			case eHTTPMethod::TRACE:
+			case eHTTPMethod::PATCH:
+			case eHTTPMethod::INVALID:
+			default:
+				reply.status = eHTTPStatusCode::METHOD_NOT_ALLOWED;
+				reply.message = "{\"error\":\"Invalid Method\"}";
+				break;
+			}
+		}
+	}
+	mg_http_reply(connection, static_cast<int>(reply.status), json_content_type, reply.message.c_str());
+}
+
+
+void HandleRequests(mg_connection* connection, int request, void* request_data) {
+	switch (request) {
+		case MG_EV_HTTP_MSG:
+			HandleHTTPMessage(connection, static_cast<mg_http_message*>(request_data));
+			break;
+		default:
+			break;
+	}
+}
+
+#ifdef DARKFLAME_PLATFORM_WIN32
+#pragma pop_macro("DELETE")
+#endif
+
+ChatWebAPI::ChatWebAPI() {
+	mg_log_set(MG_LL_NONE);
+	mg_mgr_init(&mgr);  // Initialize event manager
+}
+
+ChatWebAPI::~ChatWebAPI() {
+	mg_mgr_free(&mgr);
+}
+
+void ChatWebAPI::Listen() {
+	// make listen address
+	std::string listen_ip = Game::config->GetValue("web_server_listen_ip");
+	if (listen_ip == "localhost") listen_ip = "127.0.0.1";
+
+	const std::string& listen_port = Game::config->GetValue("web_server_listen_port");
+	const std::string& listen_address = "http://" + listen_ip + ":" + listen_port;
+	LOG("Starting web server on %s", listen_address.c_str());
+
+	// Create HTTP listener
+	if (!mg_http_listen(&mgr, listen_address.c_str(), HandleRequests, NULL)) {
+		LOG("Failed to create web server listener");
+	}
+}
+
+void ChatWebAPI::ReceiveRequests() {
+	mg_mgr_poll(&mgr, 15);
+}

dChatServer/ChatWebAPI.h

@@ -0,0 +1,30 @@
+#ifndef CHATWEBAPI_H
+#define CHATWEBAPI_H
+
+#include "mongoose.h"
+
+typedef struct mg_mgr mg_mgr;
+
+class ChatWebAPI {
+public:
+	ChatWebAPI();
+	~ChatWebAPI();
+	void ReceiveRequests();
+	void Listen();
+	enum class eRoute {
+		// GET
+		PLAYERS,
+		TEAMS,
+		// POST
+		ANNOUNCE,
+		CSR,
+		// INVALID
+		INVALID
+	};
+private:
+	mg_mgr mgr;
+
+
+};
+
+#endif

dChatServer/JSONUtils.cpp

@@ -0,0 +1,68 @@
+#include "JSONUtils.h"
+
+#include "json.hpp"
+#include "eHTTPStatusCode.h"
+
+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 = playerContainer.GetAllPlayers();
+}
+
+void to_json(json& data, const TeamContainer& teamContainer) {
+	for (auto& teamData : Game::playerContainer.GetTeams()) {
+		if (!teamData) continue;
+		data.push_back(*teamData);
+	}
+}
+
+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);
+	}
+}
+
+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();
+}
+
+bool JSONUtils::Validate(const std::optional<json>& data, HTTPReply& reply) {
+	if (!data) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid JSON\"}";
+		return false;
+	}
+	return true;
+}

dChatServer/JSONUtils.h

@@ -0,0 +1,24 @@
+#ifndef __JSONUTILS_H__
+#define __JSONUTILS_H__
+
+#include "json_fwd.hpp"
+#include "PlayerContainer.h"
+#include "eHTTPStatusCode.h"
+
+struct HTTPReply {
+	eHTTPStatusCode status = eHTTPStatusCode::NOT_FOUND;
+	std::string message = "{\"error\":\"Not Found\"}";
+};
+
+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 TeamContainer& teamData);
+void to_json(nlohmann::json& data, const TeamData& teamData);
+
+namespace JSONUtils {
+	// check required data for reqeust
+	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
+	bool Validate(const std::optional<nlohmann::json>& data, HTTPReply& reply);
+}
+
+#endif // __JSONUTILS_H__

dChatServer/PlayerContainer.cpp

@@ -57,13 +57,32 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
 
 	Database::Get()->UpdateActivityLog(data.playerID, eActivityType::PlayerLoggedIn, 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);
 
@@ -197,7 +216,7 @@ TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
 	team->leaderID = leader;
 	team->local = local;
 
-	mTeams.push_back(team);
+	GetTeamsMut().push_back(team);
 
 	AddMember(team, leader);
 
@@ -205,7 +224,7 @@ TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
 }
 
 TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) {
-	for (auto* team : mTeams) {
+	for (auto* team : GetTeams()) {
 		if (std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID) == team->memberIDs.end()) continue;
 
 		return team;
@@ -313,9 +332,9 @@ void PlayerContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) {
 }
 
 void PlayerContainer::DisbandTeam(TeamData* team) {
-	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
+	const auto index = std::find(GetTeams().begin(), GetTeams().end(), team);
 
-	if (index == mTeams.end()) return;
+	if (index == GetTeams().end()) return;
 
 	for (const auto memberId : team->memberIDs) {
 		const auto& otherMember = GetPlayerData(memberId);
@@ -330,15 +349,15 @@ void PlayerContainer::DisbandTeam(TeamData* team) {
 
 	UpdateTeamsOnWorld(team, true);
 
-	mTeams.erase(index);
+	GetTeamsMut().erase(index);
 
 	delete team;
 }
 
 void PlayerContainer::TeamStatusUpdate(TeamData* team) {
-	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
+	const auto index = std::find(GetTeams().begin(), GetTeams().end(), team);
 
-	if (index == mTeams.end()) return;
+	if (index == GetTeams().end()) return;
 
 	const auto& leader = GetPlayerData(team->leaderID);
 
@@ -417,3 +436,13 @@ 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());
+	}
+	for (auto* team : GetTeams()) if (team) delete team;
+}

dChatServer/PlayerContainer.h

@@ -9,6 +9,12 @@
 
 enum class eGameMasterLevel : uint8_t;
 
+struct TeamData;
+
+struct TeamContainer {
+	std::vector<TeamData*> mTeams;
+};
+
 struct IgnoreData {
 	IgnoreData(const std::string& name, const LWOOBJID& id) : playerName{ name }, playerId{ id } {}
 	inline bool operator==(const std::string& other) const noexcept {
@@ -48,6 +54,7 @@ struct PlayerData {
 	bool isFTP = false;
 };
 
+
 struct TeamData {
 	TeamData();
 	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
@@ -62,10 +69,12 @@ 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);
@@ -73,7 +82,7 @@ public:
 	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; };
+	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() const { return m_Players; };
 
 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -88,12 +97,19 @@ public:
 	LWOOBJID GetId(const std::u16string& playerName);
 	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
 	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
+	const TeamContainer& GetTeamContainer() { return teamContainer; }
+	std::vector<TeamData*>& GetTeamsMut() { return teamContainer.mTeams; };
+	const std::vector<TeamData*>& GetTeams() { return GetTeamsMut(); };
+
+	void Update(const float deltaTime);
+	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;
+	TeamContainer teamContainer{};
 	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;

dCommon/BinaryIO.cpp

@@ -2,16 +2,25 @@
 #include <string>
 
 //For reading null-terminated strings
-std::string BinaryIO::ReadString(std::istream& instream) {
-	std::string toReturn;
-	char buffer;
+template<typename StringType>
+StringType ReadString(std::istream& instream) {
+	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/CMakeLists.txt

@@ -37,7 +37,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)

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();
-        const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
-        filenames.emplace(index, std::move(filename));
+		if (t.is_directory() || t.is_symlink()) continue;
+		auto filename = t.path().filename().string();
+		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

@@ -51,6 +51,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
@@ -193,6 +201,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

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/eCSRCommand.h

@@ -0,0 +1,54 @@
+#ifndef __ECSRCOMMAND__H__
+#define __ECSRCOMMAND__H__
+
+enum class eCSRCommand {
+	QUERY_SERVER_STATUS,
+	QUERY_CHARACTER_LOCATION,
+	QUERY_CHARACTER_ONLINE_STATUS,
+	INVENTORY_ADD_ITEM,
+	INVENTORY_DELETE_ITEM,
+	MODERATE_MUTE_ACCOUNT,
+	MODERATE_BAN_ACCOUNT,
+	MODERATE_EDUCATE_CHARACTER,
+	MODERATE_KICK_CHARACTER,
+	MODERATE_WARN_CHARACTER,
+	MODERATE_RENAME_CHARACTER,
+	MODERATE_DELETE_CHARACTER_FRIEND,
+	MODERATE_KILL_CHARACTER,
+	UPDATE_CHARACTER_HEALTH,
+	UPDATE_CHARACTER_ARMOR,
+	UPDATE_CHARACTER_IMAGINATION,
+	UPDATE_CHARACTER_MAX_HEALTH,
+	UPDATE_CHARACTER_MAX_ARMOR,
+	UPDATE_CHARACTER_MAX_IMAGINATION,
+	UPDATE_CHARACTER_CURRENCY,
+	UPDATE_CHARACTER_REPUTATION,
+	UPDATE_CHARACTER_LEGO_SCORE,
+	UPDATE_CHARACTER_EMOTES,
+	UPDATE_CHARACTER_ADD_ACHIEVEMENT,
+	UPDATE_CHARACTER_COMPLETE_ACHIEVEMENT,
+	UPDATE_CHARACTER_REMOVE_ACHIEVEMENT,
+	UPDATE_CHARACTER_POSITION_OFFLINE,
+	UPDATE_CHARACTER_INV_SLOT_AMOUNT,
+	UTILITY_SAVE_CHARACTER,
+	UTILITY_SEND_MAIL,
+	UTILITY_GIVE_ITEM_TO_ALL_PLAYERS_ONLINE,
+	METRICS_CONFIGURE,
+	DISABLE_ZONE,
+	INIT_DONATION_AMOUNT,
+	KILL_SERVERS_COUNTDOWN,
+	DISABLE_FAQ,
+	THROTTLEQUEUE,
+	GATEGM_ACCESS,
+	RECONNECT_CRISP,
+	MODERATE_KICK_ACCOUNT,
+	TOGGLE_CRISP_SERVER,
+	QUICK_DRAIN_SERVER,
+	QUICK_DRAIN_SERVER_RENEW,
+	REPLICATE_CHARACTER,
+	GET_SERVER_STATUS,
+	RELOAD_SERVER_INIS,
+	INVALID
+};
+
+#endif // !__ECSRCOMMAND__H__

dCommon/dEnums/eHTTPMethod.h

@@ -0,0 +1,26 @@
+#ifndef __EHTTPMETHODS__H__
+#define __EHTTPMETHODS__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__

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)
 
 # 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

@@ -12,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

@@ -26,13 +26,8 @@
 #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
@@ -50,7 +45,6 @@ public:
 	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;

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -36,6 +36,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/ILeaderboard.h

@@ -14,7 +14,7 @@ public:
 		uint32_t lastPlayedTimestamp{};
 		float primaryScore{};
 		float secondaryScore{};
-		uint32_t tertiaryScore{};
+		float tertiaryScore{};
 		uint32_t numWins{};
 		uint32_t numTimesPlayed{};
 		uint32_t ranking{};
@@ -41,6 +41,7 @@ public:
 	virtual void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
 	virtual void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
 	virtual void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) = 0;
+	virtual void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) = 0;
 };
 
 #endif  //!__ILEADERBOARD__H__

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -14,6 +14,7 @@ namespace {
 };
 
 void MySQLDatabase::Connect() {
+	LOG("Using MySQL database");
 	driver = sql::mariadb::get_driver_instance();
 
 	// The mariadb connector is *supposed* to handle unix:// and pipe:// prefixes to hostName, but there are bugs where
@@ -67,7 +68,7 @@ void MySQLDatabase::ExecuteCustomQuery(const std::string_view query) {
 
 sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& query) {
 	if (!con) {
-		Connect();
+		Database::Get()->Connect();
 		LOG("Trying to reconnect to MySQL");
 	}
 
@@ -76,7 +77,7 @@ sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& quer
 
 		con = nullptr;
 
-		Connect();
+		Database::Get()->Connect();
 		LOG("Trying to reconnect to MySQL from invalid or closed connection");
 	}
 

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -30,7 +30,6 @@ public:
 	void Connect() override;
 	void Destroy(std::string source = "") override;
 
-	sql::PreparedStatement* CreatePreppedStmt(const std::string& query) override;
 	void Commit() override;
 	bool GetAutoCommit() override;
 	void SetAutoCommit(bool value) override;
@@ -122,8 +121,11 @@ public:
 	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
 	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
 	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
+	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
+	uint32_t GetAccountCount() override;
 private:
 
 	// Generic query functions that can be used for any query.

dDatabase/GameDatabase/MySQL/Tables/Accounts.cpp

@@ -39,3 +39,8 @@ void MySQLDatabase::InsertNewAccount(const std::string_view username, const std:
 void MySQLDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) {
 	ExecuteUpdate("UPDATE accounts SET gm_level = ? WHERE id = ?;", static_cast<int32_t>(gmLevel), accountId);
 }
+
+uint32_t MySQLDatabase::GetAccountCount() {
+	auto res = ExecuteSelect("SELECT COUNT(*) as count FROM accounts;");
+	return res->next() ? res->getUInt("count") : 0;
+}

dDatabase/GameDatabase/MySQL/Tables/Leaderboard.cpp

@@ -68,6 +68,10 @@ void MySQLDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId,
 		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
 }
 
+void MySQLDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}
+
 std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
 	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
 	auto res = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -56,6 +56,7 @@ std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(co
 			params.playerId
 		);
 		if (count->next()) {
+			if (!result) result = IProperty::PropertyEntranceResult();
 			result->totalEntriesMatchingQuery = count->getUInt("count");
 		}
 	} else {
@@ -109,11 +110,13 @@ std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(co
 			params.playerSort
 		);
 		if (count->next()) {
+			if (!result) result = IProperty::PropertyEntranceResult();
 			result->totalEntriesMatchingQuery = count->getUInt("count");
 		}
 	}
 
 	while (properties->next()) {
+		if (!result) result = IProperty::PropertyEntranceResult();
 		auto& entry = result->entries.emplace_back();
 		entry.id = properties->getUInt64("id");
 		entry.ownerId = properties->getUInt64("owner_id");

dDatabase/GameDatabase/SQLite/CMakeLists.txt

@@ -0,0 +1,11 @@
+SET(DDATABSE_DATABSES_SQLITE_SOURCES
+	"SQLiteDatabase.cpp"
+)
+
+add_subdirectory(Tables)
+
+foreach(file ${DDATABASES_DATABASES_SQLITE_TABLES_SOURCES})
+	set(DDATABSE_DATABSES_SQLITE_SOURCES ${DDATABSE_DATABSES_SQLITE_SOURCES} "Tables/${file}")
+endforeach()
+
+set(DDATABSE_DATABSES_SQLITE_SOURCES ${DDATABSE_DATABSES_SQLITE_SOURCES} PARENT_SCOPE)

dDatabase/GameDatabase/SQLite/SQLiteDatabase.cpp

@@ -0,0 +1,81 @@
+#include "SQLiteDatabase.h"
+
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "Logger.h"
+#include "dPlatforms.h"
+#include "BinaryPathFinder.h"
+
+// Static Variables
+
+// Status Variables
+namespace {
+	CppSQLite3DB* con = nullptr;
+	bool isConnected = false;
+};
+
+void SQLiteDatabase::Connect() {
+	LOG("Using SQLite database");
+	con = new CppSQLite3DB();
+	const auto path = BinaryPathFinder::GetBinaryDir() / Game::config->GetValue("sqlite_database_path");
+
+	if (!std::filesystem::exists(path)) {
+		LOG("Creating sqlite path %s", path.string().c_str());
+		std::filesystem::create_directories(path.parent_path());
+	}
+
+	con->open(path.string().c_str());
+	isConnected = true;
+
+	// Make sure wal is enabled for the database.
+	con->execQuery("PRAGMA journal_mode = WAL;");
+}
+
+void SQLiteDatabase::Destroy(std::string source) {
+	if (!con) return;
+
+	if (source.empty()) LOG("Destroying SQLite connection!");
+	else LOG("Destroying SQLite connection from %s!", source.c_str());
+
+	con->close();
+	delete con;
+	con = nullptr;
+}
+
+void SQLiteDatabase::ExecuteCustomQuery(const std::string_view query) {
+	con->compileStatement(query.data()).execDML();
+}
+
+CppSQLite3Statement SQLiteDatabase::CreatePreppedStmt(const std::string& query) {
+	return con->compileStatement(query.c_str());
+}
+
+void SQLiteDatabase::Commit() {
+	if (!con->IsAutoCommitOn()) con->compileStatement("COMMIT;").execDML();
+}
+
+bool SQLiteDatabase::GetAutoCommit() {
+	return con->IsAutoCommitOn();
+}
+
+void SQLiteDatabase::SetAutoCommit(bool value) {
+	if (value) {
+		if (GetAutoCommit()) con->compileStatement("BEGIN;").execDML();
+	} else {
+		if (!GetAutoCommit()) con->compileStatement("COMMIT;").execDML();
+	}
+}
+
+void SQLiteDatabase::DeleteCharacter(const uint32_t characterId) {
+	ExecuteDelete("DELETE FROM charxml WHERE id=?;", characterId);
+	ExecuteDelete("DELETE FROM command_log WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM friends WHERE player_id=? OR friend_id=?;", characterId, characterId);
+	ExecuteDelete("DELETE FROM leaderboard WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM properties_contents WHERE property_id IN (SELECT id FROM properties WHERE owner_id=?);", characterId);
+	ExecuteDelete("DELETE FROM properties WHERE owner_id=?;", characterId);
+	ExecuteDelete("DELETE FROM ugc WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM activity_log WHERE character_id=?;", characterId);
+	ExecuteDelete("DELETE FROM mail WHERE receiver_id=?;", characterId);
+	ExecuteDelete("DELETE FROM charinfo WHERE id=?;", characterId);
+}

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -0,0 +1,270 @@
+#ifndef SQLITEDATABASE_H
+#define SQLITEDATABASE_H
+
+#include "CppSQLite3.h"
+
+#include "GameDatabase.h"
+
+using PreppedStmtRef = CppSQLite3Statement&;
+
+// Purposefully no definition for this to provide linker errors in the case someone tries to
+// bind a parameter to a type that isn't defined.
+template<typename ParamType>
+inline void SetParam(PreppedStmtRef stmt, const int index, const ParamType param);
+
+// This is a function to set each parameter in a prepared statement.
+// This is accomplished with a combination of parameter packing and Fold Expressions.
+// The constexpr if statement is used to prevent the compiler from trying to call SetParam with 0 arguments.
+template<typename... Args>
+void SetParams(PreppedStmtRef stmt, Args&&... args) {
+	if constexpr (sizeof...(args) != 0) {
+		int i = 1;
+		(SetParam(stmt, i++, args), ...);
+	}
+}
+
+class SQLiteDatabase : public GameDatabase {
+public:
+	void Connect() override;
+	void Destroy(std::string source = "") override;
+
+	void Commit() override;
+	bool GetAutoCommit() override;
+	void SetAutoCommit(bool value) override;
+	void ExecuteCustomQuery(const std::string_view query) override;
+
+	// Overloaded queries
+	std::optional<IServers::MasterInfo> GetMasterInfo() override;
+
+	std::vector<std::string> GetApprovedCharacterNames() override;
+
+	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
+
+	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
+	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
+	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
+	void DeleteUgcModelData(const LWOOBJID& modelId) override;
+	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
+	std::vector<IUgc::Model> GetAllUgcModels() override;
+	void CreateMigrationHistoryTable() override;
+	bool IsMigrationRun(const std::string_view str) override;
+	void InsertMigration(const std::string_view str) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
+	std::string GetCharacterXml(const uint32_t accountId) override;
+	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
+	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
+	void InsertNewCharacter(const ICharInfo::Info info) override;
+	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
+	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
+	void DeleteCharacter(const uint32_t characterId) override;
+	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
+	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
+	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
+	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
+	void UpdatePropertyModerationInfo(const IProperty::Info& info) override;
+	void UpdatePropertyDetails(const IProperty::Info& info) override;
+	void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) override;
+	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
+	void RemoveUnreferencedUgcModels() override;
+	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
+	void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
+	void RemoveModel(const LWOOBJID& modelId) override;
+	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
+	void InsertNewBugReport(const IBugReports::Info& info) override;
+	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
+	void InsertNewMail(const IMail::MailInfo& mail) override;
+	void InsertNewUgcModel(
+		std::istringstream& sd0Data,
+		const uint32_t blueprintId,
+		const uint32_t accountId,
+		const uint32_t characterId) override;
+	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
+	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
+	void MarkMailRead(const uint64_t mailId) override;
+	void DeleteMail(const uint64_t mailId) override;
+	void ClaimMailItem(const uint64_t mailId) override;
+	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
+	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
+	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
+	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
+	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
+	void SetMasterIp(const std::string_view ip, const uint32_t port) override;
+	std::optional<uint32_t> GetCurrentPersistentId() override;
+	void InsertDefaultPersistentId() override;
+	void UpdatePersistentId(const uint32_t id) override;
+	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
+	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
+	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
+	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
+	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
+	void AddBehavior(const IBehaviors::Info& info) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t characterId) override;
+	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
+	std::optional<IProperty::PropertyEntranceResult> GetProperties(const IProperty::PropertyLookup& params) override;
+	std::vector<ILeaderboard::Entry> GetDescendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override;
+	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override;
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
+	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
+	void DeleteUgcBuild(const LWOOBJID bigId) override;
+	uint32_t GetAccountCount() override;
+private:
+	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
+
+	// Generic query functions that can be used for any query.
+	// Return type may be different depending on the query, so it is up to the caller to check the return type.
+	// The first argument is the query string, and the rest are the parameters to bind to the query.
+	// The return type is a unique_ptr to the result set, which is deleted automatically when it goes out of scope
+	template<typename... Args>
+	inline std::pair<CppSQLite3Statement, CppSQLite3Query> ExecuteSelect(const std::string& query, Args&&... args) {
+		std::pair<CppSQLite3Statement, CppSQLite3Query> toReturn;
+		toReturn.first = CreatePreppedStmt(query);
+		SetParams(toReturn.first, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(toReturn.second = toReturn.first.execQuery());
+		return toReturn;
+	}
+
+	template<typename... Args>
+	inline void ExecuteDelete(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(preppedStmt.execDML());
+	}
+
+	template<typename... Args>
+	inline int32_t ExecuteUpdate(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt.execDML());
+	}
+
+	template<typename... Args>
+	inline int ExecuteInsert(const std::string& query, Args&&... args) {
+		auto preppedStmt = CreatePreppedStmt(query);
+		SetParams(preppedStmt, std::forward<Args>(args)...);
+		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt.execDML());
+	}
+};
+
+// Below are each of the definitions of SetParam for each supported type.
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::string_view param) {
+	LOG("%s", param.data());
+	stmt.bind(index, param.data());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const char* param) {
+	LOG("%s", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::string param) {
+	LOG("%s", param.c_str());
+	stmt.bind(index, param.c_str());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int8_t param) {
+	LOG("%u", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint8_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int16_t param) {
+	LOG("%u", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint16_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint32_t param) {
+	LOG("%u", param);
+	stmt.bind(index, static_cast<int32_t>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int32_t param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const int64_t param) {
+	LOG("%llu", param);
+	stmt.bind(index, static_cast<sqlite_int64>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const uint64_t param) {
+	LOG("%llu", param);
+	stmt.bind(index, static_cast<sqlite_int64>(param));
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const float param) {
+	LOG("%f", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const double param) {
+	LOG("%f", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const bool param) {
+	LOG("%d", param);
+	stmt.bind(index, param);
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::istream* param) {
+	LOG("Blob");
+	// This is the one time you will ever see me use const_cast.
+	std::stringstream stream;
+	stream << param->rdbuf();
+	stmt.bind(index, reinterpret_cast<const unsigned char*>(stream.str().c_str()), stream.str().size());
+}
+
+template<>
+inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
+	if (param) {
+		LOG("%d", param.value());
+		stmt.bind(index, static_cast<int>(param.value()));
+	} else {
+		LOG("Null");
+		stmt.bindNull(index);
+	}
+}
+
+#endif  //!SQLITEDATABASE_H

dDatabase/GameDatabase/SQLite/Tables/Accounts.cpp

@@ -0,0 +1,49 @@
+#include "SQLiteDatabase.h"
+
+#include "eGameMasterLevel.h"
+#include "Database.h"
+
+std::optional<IAccounts::Info> SQLiteDatabase::GetAccountInfo(const std::string_view username) {
+	auto [_, result] = ExecuteSelect("SELECT * FROM accounts WHERE name = ? LIMIT 1", username);
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	IAccounts::Info toReturn;
+	toReturn.id = result.getIntField("id");
+	toReturn.maxGmLevel = static_cast<eGameMasterLevel>(result.getIntField("gm_level"));
+	toReturn.bcryptPassword = result.getStringField("password");
+	toReturn.banned = result.getIntField("banned");
+	toReturn.locked = result.getIntField("locked");
+	toReturn.playKeyId = result.getIntField("play_key_id");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) {
+	ExecuteUpdate("UPDATE accounts SET mute_expire = ? WHERE id = ?;", timeToUnmute, accountId);
+}
+
+void SQLiteDatabase::UpdateAccountBan(const uint32_t accountId, const bool banned) {
+	ExecuteUpdate("UPDATE accounts SET banned = ? WHERE id = ?;", banned, accountId);
+}
+
+void SQLiteDatabase::UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) {
+	ExecuteUpdate("UPDATE accounts SET password = ? WHERE id = ?;", bcryptpassword, accountId);
+}
+
+void SQLiteDatabase::InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) {
+	ExecuteInsert("INSERT INTO accounts (name, password, gm_level) VALUES (?, ?, ?);", username, bcryptpassword, static_cast<int32_t>(eGameMasterLevel::OPERATOR));
+}
+
+void SQLiteDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) {
+	ExecuteUpdate("UPDATE accounts SET gm_level = ? WHERE id = ?;", static_cast<int32_t>(gmLevel), accountId);
+}
+
+uint32_t SQLiteDatabase::GetAccountCount() {
+	auto [_, res] = ExecuteSelect("SELECT COUNT(*) as count FROM accounts;");
+	if (res.eof()) return 0;
+
+	return res.getIntField("count");
+}

dDatabase/GameDatabase/SQLite/Tables/AccountsRewardCodes.cpp

@@ -0,0 +1,17 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) {
+	ExecuteInsert("INSERT OR IGNORE INTO accounts_rewardcodes (account_id, rewardcode) VALUES (?, ?);", account_id, reward_code);
+}
+
+std::vector<uint32_t> SQLiteDatabase::GetRewardCodesByAccountID(const uint32_t account_id) {
+	auto [_, result] = ExecuteSelect("SELECT rewardcode FROM accounts_rewardcodes WHERE account_id = ?;", account_id);
+
+	std::vector<uint32_t> toReturn;
+	while (!result.eof()) {
+		toReturn.push_back(result.getIntField("rewardcode"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/ActivityLog.cpp

@@ -0,0 +1,6 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
+	ExecuteInsert("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);",
+		characterId, static_cast<uint32_t>(activityType), static_cast<uint32_t>(time(NULL)), mapId);
+}

dDatabase/GameDatabase/SQLite/Tables/Behaviors.cpp

@@ -0,0 +1,19 @@
+#include "IBehaviors.h"
+
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::AddBehavior(const IBehaviors::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO behaviors (behavior_info, character_id, behavior_id) VALUES (?, ?, ?) ON CONFLICT(behavior_id) DO UPDATE SET behavior_info = ?",
+		info.behaviorInfo, info.characterId, info.behaviorId, info.behaviorInfo
+	);
+}
+
+void SQLiteDatabase::RemoveBehavior(const int32_t behaviorId) {
+	ExecuteDelete("DELETE FROM behaviors WHERE behavior_id = ?", behaviorId);
+}
+
+std::string SQLiteDatabase::GetBehavior(const int32_t behaviorId) {
+	auto [_, result] = ExecuteSelect("SELECT behavior_info FROM behaviors WHERE behavior_id = ?", behaviorId);
+	return !result.eof() ? result.getStringField("behavior_info") : "";
+}

dDatabase/GameDatabase/SQLite/Tables/BugReports.cpp

@@ -0,0 +1,6 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertNewBugReport(const IBugReports::Info& info) {
+	ExecuteInsert("INSERT INTO `bug_reports`(body, client_version, other_player_id, selection, reporter_id) VALUES (?, ?, ?, ?, ?)",
+		info.body, info.clientVersion, info.otherPlayer, info.selection, info.characterId);
+}

dDatabase/GameDatabase/SQLite/Tables/CMakeLists.txt

@@ -0,0 +1,26 @@
+set(DDATABASES_DATABASES_SQLITE_TABLES_SOURCES
+	"Accounts.cpp"
+	"AccountsRewardCodes.cpp"
+	"ActivityLog.cpp"
+	"Behaviors.cpp"
+	"BugReports.cpp"
+	"CharInfo.cpp"
+	"CharXml.cpp"
+	"CommandLog.cpp"
+	"Friends.cpp"
+	"IgnoreList.cpp"
+	"Leaderboard.cpp"
+	"Mail.cpp"
+	"MigrationHistory.cpp"
+	"ObjectIdTracker.cpp"
+	"PetNames.cpp"
+	"PlayerCheatDetections.cpp"
+	"PlayKeys.cpp"
+	"Property.cpp"
+	"PropertyContents.cpp"
+	"Servers.cpp"
+	"Ugc.cpp"
+	"UgcModularBuild.cpp"
+	PARENT_SCOPE
+)
+

dDatabase/GameDatabase/SQLite/Tables/CharInfo.cpp

@@ -0,0 +1,79 @@
+#include "SQLiteDatabase.h"
+
+std::vector<std::string> SQLiteDatabase::GetApprovedCharacterNames() {
+	auto [_, result] = ExecuteSelect("SELECT name FROM charinfo;");
+
+	std::vector<std::string> toReturn;
+
+	while (!result.eof()) {
+		toReturn.push_back(result.getStringField("name"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> CharInfoFromQueryResult(CppSQLite3Query stmt) {
+	if (stmt.eof()) {
+		return std::nullopt;
+	}
+
+	ICharInfo::Info toReturn;
+
+	toReturn.id = stmt.getIntField("id");
+	toReturn.name = stmt.getStringField("name");
+	toReturn.pendingName = stmt.getStringField("pending_name");
+	toReturn.needsRename = stmt.getIntField("needs_rename");
+	toReturn.cloneId = stmt.getInt64Field("prop_clone_id");
+	toReturn.accountId = stmt.getIntField("account_id");
+	toReturn.permissionMap = static_cast<ePermissionMap>(stmt.getIntField("permission_map"));
+
+	return toReturn;
+}
+
+std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const uint32_t charId) {
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId).second
+	);
+}
+
+std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const std::string_view name) {
+	return CharInfoFromQueryResult(
+		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE name = ? LIMIT 1;", name).second
+	);
+}
+
+std::vector<uint32_t> SQLiteDatabase::GetAccountCharacterIds(const uint32_t accountId) {
+	auto [_, result] = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
+
+	std::vector<uint32_t> toReturn;
+	while (!result.eof()) {
+		toReturn.push_back(result.getIntField("id"));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+void SQLiteDatabase::InsertNewCharacter(const ICharInfo::Info info) {
+	ExecuteInsert(
+		"INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`, `prop_clone_id`) VALUES (?,?,?,?,?,?,(SELECT IFNULL(MAX(`prop_clone_id`), 0) + 1 FROM `charinfo`))",
+		info.id,
+		info.accountId,
+		info.name,
+		info.pendingName,
+		false,
+		static_cast<uint32_t>(time(NULL)));
+}
+
+void SQLiteDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET name = ?, pending_name = '', needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void SQLiteDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
+	ExecuteUpdate("UPDATE charinfo SET pending_name = ?, needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
+}
+
+void SQLiteDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
+	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ?;", static_cast<uint32_t>(time(NULL)), characterId);
+}

dDatabase/GameDatabase/SQLite/Tables/CharXml.cpp

@@ -0,0 +1,19 @@
+#include "SQLiteDatabase.h"
+
+std::string SQLiteDatabase::GetCharacterXml(const uint32_t charId) {
+	auto [_, result] = ExecuteSelect("SELECT xml_data FROM charxml WHERE id = ? LIMIT 1;", charId);
+
+	if (result.eof()) {
+		return "";
+	}
+
+	return result.getStringField("xml_data");
+}
+
+void SQLiteDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
+	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
+}
+
+void SQLiteDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
+	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
+}

dDatabase/GameDatabase/SQLite/Tables/CommandLog.cpp

@@ -0,0 +1,5 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
+	ExecuteInsert("INSERT INTO command_log (character_id, command) VALUES (?, ?);", characterId, command);
+}

dDatabase/GameDatabase/SQLite/Tables/Friends.cpp

@@ -0,0 +1,73 @@
+#include "SQLiteDatabase.h"
+
+std::vector<FriendData> SQLiteDatabase::GetFriendsList(const uint32_t charId) {
+	auto [_, friendsList] = ExecuteSelect(
+		R"QUERY(
+			SELECT fr.requested_player AS player, best_friend AS bff, ci.name AS name FROM 
+			(
+				SELECT CASE 
+				WHEN player_id = ? THEN friend_id 
+				WHEN friend_id = ? THEN player_id 
+				END AS requested_player, best_friend FROM friends
+			) AS fr 
+			JOIN charinfo AS ci ON ci.id = fr.requested_player 
+			WHERE fr.requested_player IS NOT NULL AND fr.requested_player != ?;
+		)QUERY", charId, charId, charId);
+
+	std::vector<FriendData> toReturn;
+
+	while (!friendsList.eof()) {
+		FriendData fd;
+		fd.friendID = friendsList.getIntField("player");
+		fd.isBestFriend = friendsList.getIntField("bff") == 3; // 0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
+		fd.friendName = friendsList.getStringField("name");
+
+		toReturn.push_back(fd);
+		friendsList.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	auto [_, result] = ExecuteSelect("SELECT * FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	IFriends::BestFriendStatus toReturn;
+	toReturn.playerCharacterId = result.getIntField("player_id");
+	toReturn.friendCharacterId = result.getIntField("friend_id");
+	toReturn.bestFriendStatus = result.getIntField("best_friend");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
+	ExecuteUpdate("UPDATE friends SET best_friend = ? WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);",
+		bestFriendStatus,
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}
+
+void SQLiteDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	ExecuteInsert("INSERT OR IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
+}
+
+void SQLiteDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+	ExecuteDelete("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);",
+		playerCharacterId,
+		friendCharacterId,
+		friendCharacterId,
+		playerCharacterId
+	);
+}

dDatabase/GameDatabase/SQLite/Tables/IgnoreList.cpp

@@ -0,0 +1,22 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IIgnoreList::Info> SQLiteDatabase::GetIgnoreList(const uint32_t playerId) {
+	auto [_, result] = ExecuteSelect("SELECT ci.name AS name, il.ignored_player_id AS ignore_id FROM ignore_list AS il JOIN charinfo AS ci ON il.ignored_player_id = ci.id WHERE il.player_id = ?", playerId);
+
+	std::vector<IIgnoreList::Info> ignoreList;
+
+	while (!result.eof()) {
+		ignoreList.push_back(IIgnoreList::Info{ result.getStringField("name"), static_cast<uint32_t>(result.getIntField("ignore_id")) });
+		result.nextRow();
+	}
+
+	return ignoreList;
+}
+
+void SQLiteDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteInsert("INSERT OR IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
+}
+
+void SQLiteDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteDelete("DELETE FROM ignore_list WHERE player_id = ? AND ignored_player_id = ?", playerId, ignoredPlayerId);
+}

dDatabase/GameDatabase/SQLite/Tables/Leaderboard.cpp

@@ -0,0 +1,91 @@
+#include "SQLiteDatabase.h"
+
+#include "Game.h"
+#include "Logger.h"
+#include "dConfig.h"
+
+std::optional<uint32_t> SQLiteDatabase::GetDonationTotal(const uint32_t activityId) {
+	auto [_, donation_total] = ExecuteSelect("SELECT SUM(primaryScore) as donation_total FROM leaderboard WHERE game_id = ?;", activityId);
+
+	if (donation_total.eof()) {
+		return std::nullopt;
+	}
+
+	return donation_total.getIntField("donation_total");
+}
+
+std::vector<ILeaderboard::Entry> ProcessQuery(CppSQLite3Query& rows) {
+	std::vector<ILeaderboard::Entry> entries;
+
+	while (!rows.eof()) {
+		auto& entry = entries.emplace_back();
+
+		entry.charId = rows.getIntField("character_id");
+		entry.lastPlayedTimestamp = rows.getIntField("lp_unix");
+		entry.primaryScore = rows.getFloatField("primaryScore");
+		entry.secondaryScore = rows.getFloatField("secondaryScore");
+		entry.tertiaryScore = rows.getFloatField("tertiaryScore");
+		entry.numWins = rows.getIntField("numWins");
+		entry.numTimesPlayed = rows.getIntField("timesPlayed");
+		entry.name = rows.getStringField("char_name");
+		// entry.ranking is never set because its calculated in leaderboard in code.
+		rows.nextRow();
+	}
+
+	return entries;
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetDescendingLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetAscendingLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore ASC, secondaryscore ASC, tertiaryScore ASC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetAgsLeaderboard(const uint32_t activityId) {
+	auto query = Game::config->GetValue("classic_survival_scoring") != "1" ? 
+	"SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore DESC, tertiaryScore DESC, last_played ASC;" : 
+	"SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY secondaryscore DESC, primaryscore DESC, tertiaryScore DESC, last_played ASC;";
+	auto [_, result] = ExecuteSelect(query, activityId);
+	return ProcessQuery(result);
+}
+
+std::vector<ILeaderboard::Entry> SQLiteDatabase::GetNsLeaderboard(const uint32_t activityId) {
+	auto [_, result] = ExecuteSelect("SELECT *, CAST(strftime('%s', last_played) as INT) as lp_unix, ci.name as char_name FROM leaderboard lb JOIN charinfo ci on ci.id = lb.character_id where game_id = ? ORDER BY primaryscore DESC, secondaryscore ASC, tertiaryScore DESC, last_played ASC;", activityId);
+	return ProcessQuery(result);
+}
+
+void SQLiteDatabase::SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("INSERT INTO leaderboard (primaryScore, secondaryScore, tertiaryScore, character_id, game_id, last_played) VALUES (?,?,?,?,?,CURRENT_TIMESTAMP) ;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+void SQLiteDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
+	ExecuteInsert("UPDATE leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;",
+		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
+}
+
+std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
+	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
+	auto [_, res] = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+	if (!res.eof()) {
+		toReturn = ILeaderboard::Score{
+			.primaryScore = static_cast<float>(res.getFloatField("primaryScore")),
+			.secondaryScore = static_cast<float>(res.getFloatField("secondaryScore")),
+			.tertiaryScore = static_cast<float>(res.getFloatField("tertiaryScore"))
+		};
+	}
+
+	return toReturn;
+}
+
+void SQLiteDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET numWins = numWins + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}
+
+void SQLiteDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
+	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
+}

dDatabase/GameDatabase/SQLite/Tables/Mail.cpp

@@ -0,0 +1,83 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertNewMail(const IMail::MailInfo& mail) {
+	ExecuteInsert(
+		"INSERT INTO `mail` "
+		"(`sender_id`, `sender_name`, `receiver_id`, `receiver_name`, `time_sent`, `subject`, `body`, `attachment_id`, `attachment_lot`, `attachment_subkey`, `attachment_count`, `was_read`)"
+		" VALUES (?,?,?,?,?,?,?,?,?,?,?,0)",
+		mail.senderId,
+		mail.senderUsername,
+		mail.receiverId,
+		mail.recipient,
+		static_cast<uint32_t>(time(NULL)),
+		mail.subject,
+		mail.body,
+		mail.itemID,
+		mail.itemLOT,
+		0,
+		mail.itemCount);
+}
+
+std::vector<IMail::MailInfo> SQLiteDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+	auto [_, res] = ExecuteSelect(
+		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
+		" FROM mail WHERE receiver_id=? limit ?;",
+		characterId, numberOfMail);
+
+	std::vector<IMail::MailInfo> toReturn;
+
+	while (!res.eof()) {
+		IMail::MailInfo mail;
+		mail.id = res.getInt64Field("id");
+		mail.subject = res.getStringField("subject");
+		mail.body = res.getStringField("body");
+		mail.senderUsername = res.getStringField("sender_name");
+		mail.itemID = res.getIntField("attachment_id");
+		mail.itemLOT = res.getIntField("attachment_lot");
+		mail.itemSubkey = res.getIntField("attachment_subkey");
+		mail.itemCount = res.getIntField("attachment_count");
+		mail.timeSent = res.getInt64Field("time_sent");
+		mail.wasRead = res.getIntField("was_read");
+
+		toReturn.push_back(std::move(mail));
+		res.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::optional<IMail::MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
+	auto [_, res] = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
+
+	if (res.eof()) {
+		return std::nullopt;
+	}
+
+	IMail::MailInfo toReturn;
+	toReturn.itemLOT = res.getIntField("attachment_lot");
+	toReturn.itemCount = res.getIntField("attachment_count");
+
+	return toReturn;
+}
+
+uint32_t SQLiteDatabase::GetUnreadMailCount(const uint32_t characterId) {
+	auto [_, res] = ExecuteSelect("SELECT COUNT(*) AS number_unread FROM mail WHERE receiver_id=? AND was_read=0;", characterId);
+
+	if (res.eof()) {
+		return 0;
+	}
+
+	return res.getIntField("number_unread");
+}
+
+void SQLiteDatabase::MarkMailRead(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET was_read=1 WHERE id=?;", mailId);
+}
+
+void SQLiteDatabase::ClaimMailItem(const uint64_t mailId) {
+	ExecuteUpdate("UPDATE mail SET attachment_lot=0 WHERE id=?;", mailId);
+}
+
+void SQLiteDatabase::DeleteMail(const uint64_t mailId) {
+	ExecuteDelete("DELETE FROM mail WHERE id=?;", mailId);
+}

dDatabase/GameDatabase/SQLite/Tables/MigrationHistory.cpp

@@ -0,0 +1,13 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::CreateMigrationHistoryTable() {
+	ExecuteInsert("CREATE TABLE IF NOT EXISTS migration_history (name TEXT NOT NULL, date DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP);");
+}
+
+bool SQLiteDatabase::IsMigrationRun(const std::string_view str) {
+	return !ExecuteSelect("SELECT name FROM migration_history WHERE name = ?;", str).second.eof();
+}
+
+void SQLiteDatabase::InsertMigration(const std::string_view str) {
+	ExecuteInsert("INSERT INTO migration_history (name) VALUES (?);", str);
+}

dDatabase/GameDatabase/SQLite/Tables/ObjectIdTracker.cpp

@@ -0,0 +1,17 @@
+#include "SQLiteDatabase.h"
+
+std::optional<uint32_t> SQLiteDatabase::GetCurrentPersistentId() {
+	auto [_, result] = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
+	if (result.eof()) {
+		return std::nullopt;
+	}
+	return result.getIntField("last_object_id");
+}
+
+void SQLiteDatabase::InsertDefaultPersistentId() {
+	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
+}
+
+void SQLiteDatabase::UpdatePersistentId(const uint32_t newId) {
+	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
+}

dDatabase/GameDatabase/SQLite/Tables/PetNames.cpp

@@ -0,0 +1,26 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO `pet_names` (`id`, `pet_name`, `approved`) VALUES (?, ?, ?) "
+		"ON CONFLICT(id) DO UPDATE SET pet_name = ?, approved = ?;",
+		petId,
+		info.petName,
+		info.approvalStatus,
+		info.petName,
+		info.approvalStatus);
+}
+
+std::optional<IPetNames::Info> SQLiteDatabase::GetPetNameInfo(const LWOOBJID& petId) {
+	auto [_, result] = ExecuteSelect("SELECT pet_name, approved FROM pet_names WHERE id = ? LIMIT 1;", petId);
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	IPetNames::Info toReturn;
+	toReturn.petName = result.getStringField("pet_name");
+	toReturn.approvalStatus = result.getIntField("approved");
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/PlayKeys.cpp

@@ -0,0 +1,11 @@
+#include "SQLiteDatabase.h"
+
+std::optional<bool> SQLiteDatabase::IsPlaykeyActive(const int32_t playkeyId) {
+	auto [_, keyCheckRes] = ExecuteSelect("SELECT active FROM `play_keys` WHERE id=?", playkeyId);
+
+	if (keyCheckRes.eof()) {
+		return std::nullopt;
+	}
+
+	return keyCheckRes.getIntField("active");
+}

dDatabase/GameDatabase/SQLite/Tables/PlayerCheatDetections.cpp

@@ -0,0 +1,7 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertCheatDetection(const IPlayerCheatDetections::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO player_cheat_detections (account_id, name, violation_msg, violation_system_address) VALUES (?, ?, ?, ?)",
+		info.userId, info.username, info.extraMessage, info.systemAddress);
+}

dDatabase/GameDatabase/SQLite/Tables/Property.cpp

@@ -0,0 +1,195 @@
+#include "SQLiteDatabase.h"
+#include "ePropertySortType.h"
+
+std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(const IProperty::PropertyLookup& params) {
+	std::optional<IProperty::PropertyEntranceResult> result;
+	std::string query;
+	std::pair<CppSQLite3Statement, CppSQLite3Query> propertiesRes;
+
+	if (params.sortChoice == SORT_TYPE_FEATURED || params.sortChoice == SORT_TYPE_FRIENDS) {
+		query = R"QUERY(
+		FROM properties as p
+		JOIN charinfo as ci
+		ON ci.prop_clone_id = p.clone_id
+		where p.zone_id = ?
+		AND (
+			p.description LIKE ?
+		    OR p.name LIKE ?
+		    OR ci.name LIKE ?
+		)
+		AND p.privacy_option >= ?
+		AND p.owner_id IN (
+			SELECT fr.requested_player AS player FROM (
+				SELECT CASE 
+				WHEN player_id = ? THEN friend_id 
+				WHEN friend_id = ? THEN player_id 
+				END AS requested_player FROM friends
+			) AS fr 
+			JOIN charinfo AS ci ON ci.id = fr.requested_player 
+			WHERE fr.requested_player IS NOT NULL AND fr.requested_player != ?
+		) ORDER BY ci.name ASC
+		)QUERY";
+		const auto completeQuery = "SELECT p.* " + query + " LIMIT ? OFFSET ?;";
+		propertiesRes = ExecuteSelect(
+			completeQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.playerId,
+			params.playerId,
+			params.playerId,
+			params.numResults,
+			params.startIndex
+		);
+		const auto countQuery = "SELECT COUNT(*) as count" + query + ";";
+		auto [_, count] = ExecuteSelect(
+			countQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.playerId,
+			params.playerId,
+			params.playerId
+		);
+		if (!count.eof()) {
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
+		}
+	} else {
+		if (params.sortChoice == SORT_TYPE_REPUTATION) {
+			query = R"QUERY(
+			FROM properties as p
+			JOIN charinfo as ci
+			ON ci.prop_clone_id = p.clone_id
+			where p.zone_id = ?
+			AND (
+				p.description LIKE ?
+			    OR p.name LIKE ?
+			    OR ci.name LIKE ?
+			)
+			AND p.privacy_option >= ?
+			ORDER BY p.reputation DESC, p.last_updated DESC 
+			)QUERY";
+		} else {
+			query = R"QUERY(
+			FROM properties as p
+			JOIN charinfo as ci
+			ON ci.prop_clone_id = p.clone_id
+			where p.zone_id = ?
+			AND (
+				p.description LIKE ?
+			    OR p.name LIKE ?
+			    OR ci.name LIKE ?
+			)
+			AND p.privacy_option >= ?
+			ORDER BY p.last_updated DESC
+			)QUERY";
+		}
+		const auto completeQuery = "SELECT p.* " + query + " LIMIT ? OFFSET ?;";
+		propertiesRes = ExecuteSelect(
+			completeQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort,
+			params.numResults,
+			params.startIndex
+		);
+		const auto countQuery = "SELECT COUNT(*) as count" + query + ";";
+		auto [_, count] = ExecuteSelect(
+			countQuery,
+			params.mapId,
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			"%" + params.searchString + "%",
+			params.playerSort
+		);
+		if (!count.eof()) {
+			result = IProperty::PropertyEntranceResult();
+			result->totalEntriesMatchingQuery = count.getIntField("count");
+		}
+	}
+
+	auto& [_, properties] = propertiesRes;
+	if (!properties.eof() && !result.has_value()) result = IProperty::PropertyEntranceResult();
+	while (!properties.eof()) {
+		auto& entry = result->entries.emplace_back();
+		entry.id = properties.getInt64Field("id");
+		entry.ownerId = properties.getInt64Field("owner_id");
+		entry.cloneId = properties.getInt64Field("clone_id");
+		entry.name = properties.getStringField("name");
+		entry.description = properties.getStringField("description");
+		entry.privacyOption = properties.getIntField("privacy_option");
+		entry.rejectionReason = properties.getStringField("rejection_reason");
+		entry.lastUpdatedTime = properties.getIntField("last_updated");
+		entry.claimedTime = properties.getIntField("time_claimed");
+		entry.reputation = properties.getIntField("reputation");
+		entry.modApproved = properties.getIntField("mod_approved");
+		entry.performanceCost = properties.getFloatField("performance_cost");
+		properties.nextRow();
+	}
+
+	return result;
+}
+
+std::optional<IProperty::Info> SQLiteDatabase::GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) {
+	auto [_, propertyEntry] = ExecuteSelect(
+		"SELECT id, owner_id, clone_id, name, description, privacy_option, rejection_reason, last_updated, time_claimed, reputation, mod_approved, performance_cost "
+		"FROM properties WHERE zone_id = ? AND clone_id = ?;", mapId, cloneId);
+
+	if (propertyEntry.eof()) {
+		return std::nullopt;
+	}
+
+	IProperty::Info toReturn;
+	toReturn.id = propertyEntry.getInt64Field("id");
+	toReturn.ownerId = propertyEntry.getInt64Field("owner_id");
+	toReturn.cloneId = propertyEntry.getInt64Field("clone_id");
+	toReturn.name = propertyEntry.getStringField("name");
+	toReturn.description = propertyEntry.getStringField("description");
+	toReturn.privacyOption = propertyEntry.getIntField("privacy_option");
+	toReturn.rejectionReason = propertyEntry.getStringField("rejection_reason");
+	toReturn.lastUpdatedTime = propertyEntry.getIntField("last_updated");
+	toReturn.claimedTime = propertyEntry.getIntField("time_claimed");
+	toReturn.reputation = propertyEntry.getIntField("reputation");
+	toReturn.modApproved = propertyEntry.getIntField("mod_approved");
+	toReturn.performanceCost = propertyEntry.getFloatField("performance_cost");
+
+	return toReturn;
+}
+
+void SQLiteDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET privacy_option = ?, rejection_reason = ?, mod_approved = ? WHERE id = ?;",
+		info.privacyOption,
+		info.rejectionReason,
+		info.modApproved,
+		info.id);
+}
+
+void SQLiteDatabase::UpdatePropertyDetails(const IProperty::Info& info) {
+	ExecuteUpdate("UPDATE properties SET name = ?, description = ? WHERE id = ?;", info.name, info.description, info.id);
+}
+
+void SQLiteDatabase::UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) {
+	ExecuteUpdate("UPDATE properties SET performance_cost = ? WHERE zone_id = ? AND clone_id = ?;", performanceCost, zoneId.GetMapID(), zoneId.GetCloneID());
+}
+
+void SQLiteDatabase::InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) {
+	auto insertion = ExecuteInsert(
+		"INSERT INTO properties"
+		" (id, owner_id, template_id, clone_id, name, description, zone_id, rent_amount, rent_due, privacy_option, last_updated, time_claimed, rejection_reason, reputation, performance_cost)"
+		" VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, 0, CAST(strftime('%s', 'now') as INT), CAST(strftime('%s', 'now') as INT), '', 0, 0.0)",
+		info.id,
+		info.ownerId,
+		templateId,
+		zoneId.GetCloneID(),
+		info.name,
+		info.description,
+		zoneId.GetMapID()
+	);
+}

dDatabase/GameDatabase/SQLite/Tables/PropertyContents.cpp

@@ -0,0 +1,65 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IPropertyContents::Model> SQLiteDatabase::GetPropertyModels(const LWOOBJID& propertyId) {
+	auto [_, result] = ExecuteSelect(
+		"SELECT id, lot, x, y, z, rx, ry, rz, rw, ugc_id, "
+		"behavior_1, behavior_2, behavior_3, behavior_4, behavior_5 "
+		"FROM properties_contents WHERE property_id = ?;", propertyId);
+
+	std::vector<IPropertyContents::Model> toReturn;
+	while (!result.eof()) {
+		IPropertyContents::Model model;
+		model.id = result.getInt64Field("id");
+		model.lot = static_cast<LOT>(result.getIntField("lot"));
+		model.position.x = result.getFloatField("x");
+		model.position.y = result.getFloatField("y");
+		model.position.z = result.getFloatField("z");
+		model.rotation.w = result.getFloatField("rw");
+		model.rotation.x = result.getFloatField("rx");
+		model.rotation.y = result.getFloatField("ry");
+		model.rotation.z = result.getFloatField("rz");
+		model.ugcId = result.getInt64Field("ugc_id");
+		model.behaviors[0] = result.getIntField("behavior_1");
+		model.behaviors[1] = result.getIntField("behavior_2");
+		model.behaviors[2] = result.getIntField("behavior_3");
+		model.behaviors[3] = result.getIntField("behavior_4");
+		model.behaviors[4] = result.getIntField("behavior_5");
+
+		toReturn.push_back(std::move(model));
+		result.nextRow();
+	}
+	return toReturn;
+}
+
+void SQLiteDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) {
+	try {
+		ExecuteInsert(
+			"INSERT INTO properties_contents"
+			"(id, property_id, ugc_id, lot, x, y, z, rx, ry, rz, rw, model_name, model_description, behavior_1, behavior_2, behavior_3, behavior_4, behavior_5)"
+			"VALUES (?,  ?,           ?,      ?,   ?, ?, ?, ?,  ?,  ?,  ?,  ?,    ?,           ?,          ?,          ?,          ?,          ?)",
+			//       1,  2,           3,      4,   5, 6, 7, 8,  9,  10, 11, 12,   13,          14,         15,         16,         17          18
+			model.id, propertyId, model.ugcId == 0 ? std::nullopt : std::optional(model.ugcId), static_cast<uint32_t>(model.lot),
+			model.position.x, model.position.y, model.position.z, model.rotation.x, model.rotation.y, model.rotation.z, model.rotation.w,
+			name, "", // Model description.  TODO implement this.
+			model.behaviors[0], // behavior 1
+			model.behaviors[1], // behavior 2
+			model.behaviors[2], // behavior 3
+			model.behaviors[3], // behavior 4
+			model.behaviors[4] // behavior 5
+		);
+	} catch (std::exception& e) {
+		LOG("Error inserting new property model: %s", e.what());
+	}
+}
+
+void SQLiteDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
+	ExecuteUpdate(
+		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
+		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
+		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w,
+		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, propertyId);
+}
+
+void SQLiteDatabase::RemoveModel(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
+}

dDatabase/GameDatabase/SQLite/Tables/Servers.cpp

@@ -0,0 +1,23 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::SetMasterIp(const std::string_view ip, const uint32_t port) {
+	// We only want our 1 entry anyways, so we can just delete all and reinsert the one we want
+	// since it would be two queries anyways.
+	ExecuteDelete("DELETE FROM servers;");
+	ExecuteInsert("INSERT INTO `servers` (`name`, `ip`, `port`, `state`, `version`) VALUES ('master', ?, ?, 0, 171022)", ip, port);
+}
+
+std::optional<IServers::MasterInfo> SQLiteDatabase::GetMasterInfo() {
+	auto [_, result] = ExecuteSelect("SELECT ip, port FROM servers WHERE name='master' LIMIT 1;");
+
+	if (result.eof()) {
+		return std::nullopt;
+	}
+
+	MasterInfo toReturn;
+
+	toReturn.ip = result.getStringField("ip");
+	toReturn.port = result.getIntField("port");
+
+	return toReturn;
+}

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

@@ -0,0 +1,72 @@
+#include "SQLiteDatabase.h"
+
+std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId) {
+	auto [_, result] = ExecuteSelect(
+		"SELECT lxfml, u.id FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
+		propertyId);
+
+	std::vector<IUgc::Model> toReturn;
+
+	while (!result.eof()) {
+		IUgc::Model model;
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		model.id = result.getInt64Field("id");
+		toReturn.push_back(std::move(model));
+		result.nextRow();
+	}
+
+	return toReturn;
+}
+
+std::vector<IUgc::Model> SQLiteDatabase::GetAllUgcModels() {
+	auto [_, result] = ExecuteSelect("SELECT id, lxfml FROM ugc;");
+
+	std::vector<IUgc::Model> models;
+	while (!result.eof()) {
+		IUgc::Model model;
+		model.id = result.getInt64Field("id");
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		models.push_back(std::move(model));
+		result.nextRow();
+	}
+
+	return models;
+}
+
+void SQLiteDatabase::RemoveUnreferencedUgcModels() {
+	ExecuteDelete("DELETE FROM ugc WHERE id NOT IN (SELECT ugc_id FROM properties_contents WHERE ugc_id IS NOT NULL);");
+}
+
+void SQLiteDatabase::InsertNewUgcModel(
+	std::istringstream& sd0Data, // cant be const sad
+	const uint32_t blueprintId,
+	const uint32_t accountId,
+	const uint32_t characterId) {
+	const std::istream stream(sd0Data.rdbuf());
+	ExecuteInsert(
+		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
+		blueprintId,
+		accountId,
+		characterId,
+		0,
+		&stream,
+		false,
+		"weedeater.lxfml"
+	);
+}
+
+void SQLiteDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
+	ExecuteDelete("DELETE FROM ugc WHERE id = ?;", modelId);
+	ExecuteDelete("DELETE FROM properties_contents WHERE ugc_id = ?;", modelId);
+}
+
+void SQLiteDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
+	const std::istream stream(lxfml.rdbuf());
+	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
+}

dDatabase/GameDatabase/SQLite/Tables/UgcModularBuild.cpp

@@ -0,0 +1,9 @@
+#include "SQLiteDatabase.h"
+
+void SQLiteDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) {
+	ExecuteInsert("INSERT INTO ugc_modular_build (ugc_id, ldf_config, character_id) VALUES (?,?,?)", bigId, modules, characterId);
+}
+
+void SQLiteDatabase::DeleteUgcBuild(const LWOOBJID bigId) {
+	ExecuteDelete("DELETE FROM ugc_modular_build WHERE ugc_id = ?;", bigId);
+}

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -8,10 +8,6 @@ void TestSQLDatabase::Destroy(std::string source) {
 
 }
 
-sql::PreparedStatement* TestSQLDatabase::CreatePreppedStmt(const std::string& query) {
-	return nullptr;
-}
-
 void TestSQLDatabase::Commit() {
 
 }

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -7,7 +7,6 @@ class TestSQLDatabase : public GameDatabase {
 	void Connect() override;
 	void Destroy(std::string source = "") override;
 
-	sql::PreparedStatement* CreatePreppedStmt(const std::string& query) override;
 	void Commit() override;
 	bool GetAutoCommit() override;
 	void SetAutoCommit(bool value) override;
@@ -99,8 +98,10 @@ class TestSQLDatabase : public GameDatabase {
 	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override {};
 	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override { return {}; };
 	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override {};
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override {};
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
+	uint32_t GetAccountCount() override { return 0; };
 };
 
 #endif  //!TESTSQLDATABASE_H

dDatabase/MigrationRunner.cpp

@@ -10,9 +10,9 @@
 
 #include <fstream>
 
-Migration LoadMigration(std::string path) {
+Migration LoadMigration(std::string folder, std::string path) {
 	Migration migration{};
-	std::ifstream file(BinaryPathFinder::GetBinaryDir() / "migrations/" / path);
+	std::ifstream file(BinaryPathFinder::GetBinaryDir() / "migrations/" / folder / path);
 
 	if (file.is_open()) {
 		std::string line;
@@ -34,10 +34,19 @@ Migration LoadMigration(std::string path) {
 void MigrationRunner::RunMigrations() {
 	Database::Get()->CreateMigrationHistoryTable();
 
+	// has to be here because when moving the files to the new folder, the migration_history table is not updated so it will run them all again.
+	
+	const auto migrationFolder = Database::GetMigrationFolder();
+	if (!Database::Get()->IsMigrationRun("17_migration_for_migrations.sql") && migrationFolder == "mysql") {
+		LOG("Running migration: 17_migration_for_migrations.sql");
+		Database::Get()->ExecuteCustomQuery("UPDATE `migration_history` SET `name` = SUBSTR(`name`, 5) WHERE `name` LIKE \"dlu%\";");
+		Database::Get()->InsertMigration("17_migration_for_migrations.sql");
+	}
+
 	std::string finalSQL = "";
 	bool runSd0Migrations = false;
-	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/").string())) {
-		auto migration = LoadMigration("dlu/" + entry);
+	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/" / migrationFolder).string())) {
+		auto migration = LoadMigration("dlu/" + migrationFolder + "/", entry);
 
 		if (migration.data.empty()) {
 			continue;
@@ -46,7 +55,7 @@ void MigrationRunner::RunMigrations() {
 		if (Database::Get()->IsMigrationRun(migration.name)) continue;
 
 		LOG("Running migration: %s", migration.name.c_str());
-		if (migration.name == "dlu/5_brick_model_sd0.sql") {
+		if (migration.name == "5_brick_model_sd0.sql") {
 			runSd0Migrations = true;
 		} else {
 			finalSQL.append(migration.data.c_str());
@@ -86,10 +95,14 @@ void MigrationRunner::RunSQLiteMigrations() {
 	cdstmt.execQuery().finalize();
 	cdstmt.finalize();
 
-	Database::Get()->CreateMigrationHistoryTable();
+	if (CDClientDatabase::ExecuteQuery("select * from migration_history where name = \"7_migration_for_migrations.sql\";").eof()) {
+		LOG("Running migration: 7_migration_for_migrations.sql");
+		CDClientDatabase::ExecuteQuery("UPDATE `migration_history` SET `name` = SUBSTR(`name`, 10) WHERE `name` LIKE \"cdserver%\";");
+		CDClientDatabase::ExecuteQuery("INSERT INTO migration_history (name) VALUES (\"7_migration_for_migrations.sql\");");
+	}
 
 	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "migrations/cdserver/").string())) {
-		auto migration = LoadMigration("cdserver/" + entry);
+		auto migration = LoadMigration("cdserver/", entry);
 
 		if (migration.data.empty()) continue;
 

dGame/CMakeLists.txt

@@ -26,7 +26,6 @@ target_include_directories(dGameBase PUBLIC "." "dEntity"
 	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
-	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
 	# dPhysics
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Include"
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Include"

dGame/Character.cpp

@@ -296,6 +296,12 @@ void Character::SaveXMLToDatabase() {
 		flags->LinkEndChild(s);
 	}
 
+	if (GetPlayerFlag(ePlayerFlag::EQUPPED_TRIAL_FACTION_GEAR)) {
+		auto* s = m_Doc.NewElement("s");
+		s->SetAttribute("si", ePlayerFlag::EQUPPED_TRIAL_FACTION_GEAR);
+		flags->LinkEndChild(s);
+	}
+
 	SaveXmlRespawnCheckpoints();
 
 	//Call upon the entity to update our xmlDoc:
@@ -357,49 +363,62 @@ void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
 		}
 	}
 
-	// Calculate the index first
-	auto flagIndex = uint32_t(std::floor(flagId / 64));
-
-	const auto shiftedValue = 1ULL << flagId % 64;
-
-	auto it = m_PlayerFlags.find(flagIndex);
-
-	// Check if flag index exists
-	if (it != m_PlayerFlags.end()) {
-		// Update the value
-		if (value) {
-			it->second |= shiftedValue;
-		} else {
-			it->second &= ~shiftedValue;
-		}
+	if (flagId == EQUPPED_TRIAL_FACTION_GEAR || flagId == IS_NEWS_SCREEN_VISIBLE) {
+		if (value) m_SessionFlags.insert(flagId);
+		else m_SessionFlags.erase(flagId);
 	} else {
-		if (value) {
-			// Otherwise, insert the value
-			uint64_t flagValue = 0;
+		// Calculate the index first
+		auto flagIndex = uint32_t(std::floor(flagId / 64));
 
-			flagValue |= shiftedValue;
+		const auto shiftedValue = 1ULL << flagId % 64;
 
-			m_PlayerFlags.insert(std::make_pair(flagIndex, flagValue));
+		auto it = m_PlayerFlags.find(flagIndex);
+
+		// Check if flag index exists
+		if (it != m_PlayerFlags.end()) {
+			// Update the value
+			if (value) {
+				it->second |= shiftedValue;
+			} else {
+				it->second &= ~shiftedValue;
+			}
+		} else {
+			if (value) {
+				// Otherwise, insert the value
+				uint64_t flagValue = 0;
+
+				flagValue |= shiftedValue;
+
+				m_PlayerFlags.insert(std::make_pair(flagIndex, flagValue));
+			}
 		}
 	}
-
 	// Notify the client that a flag has changed server-side
 	GameMessages::SendNotifyClientFlagChange(m_ObjectID, flagId, value, m_ParentUser->GetSystemAddress());
 }
 
 bool Character::GetPlayerFlag(const uint32_t flagId) const {
-	// Calculate the index first
-	const auto flagIndex = uint32_t(std::floor(flagId / 64));
+	using enum ePlayerFlag;
 
-	const auto shiftedValue = 1ULL << flagId % 64;
+	bool toReturn = false; //by def, return false.
 
-	auto it = m_PlayerFlags.find(flagIndex);
-	if (it != m_PlayerFlags.end()) {
-		// Don't set the data if we don't have to
-		return (it->second & shiftedValue) != 0;
+	// TODO make actual session flag checker using flags table in database.
+	if (flagId == EQUPPED_TRIAL_FACTION_GEAR || flagId == IS_NEWS_SCREEN_VISIBLE) {
+		toReturn = m_SessionFlags.contains(flagId);
+	} else {
+		// Calculate the index first
+		const auto flagIndex = uint32_t(std::floor(flagId / 64));
+
+		const auto shiftedValue = 1ULL << flagId % 64;
+
+		auto it = m_PlayerFlags.find(flagIndex);
+		if (it != m_PlayerFlags.end()) {
+			// Don't set the data if we don't have to
+			toReturn = (it->second & shiftedValue) != 0;
+		}
 	}
 
-	return false; //by def, return false.
+	return toReturn;
 }
 
 void Character::SetRetroactiveFlags() {

dGame/Character.h

@@ -620,6 +620,12 @@ private:
 	 */
 	uint64_t m_LastLogin{};
 
+	/**
+	 * Flags only set for the duration of a session
+	 * 
+	 */
+	std::set<uint32_t> m_SessionFlags;
+
 	/**
 	 * The gameplay flags this character has (not just true values)
 	 */

dGame/Entity.cpp

@@ -97,6 +97,8 @@
 #include "CDSkillBehaviorTable.h"
 #include "CDZoneTableTable.h"
 
+#include <ranges>
+
 Observable<Entity*, const PositionUpdate&> Entity::OnPlayerPositionUpdate;
 
 Entity::Entity(const LWOOBJID& objectID, EntityInfo info, User* parentUser, Entity* parentEntity) {
@@ -286,8 +288,9 @@ void Entity::Initialize() {
 		AddComponent<PropertyEntranceComponent>(propertyEntranceComponentID);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CONTROLLABLE_PHYSICS) > 0) {
-		auto* controllablePhysics = AddComponent<ControllablePhysicsComponent>();
+	const int32_t controllablePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CONTROLLABLE_PHYSICS);
+	if (controllablePhysicsComponentID > 0) {
+		auto* controllablePhysics = AddComponent<ControllablePhysicsComponent>(controllablePhysicsComponentID);
 
 		if (m_Character) {
 			controllablePhysics->LoadFromXml(m_Character->GetXMLDoc());
@@ -330,16 +333,19 @@ void Entity::Initialize() {
 		AddComponent<SimplePhysicsComponent>(simplePhysicsComponentID);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS) > 0) {
-		AddComponent<RigidbodyPhantomPhysicsComponent>();
+	const int32_t rigidBodyPhantomPhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS);
+	if (rigidBodyPhantomPhysicsComponentID > 0) {
+		AddComponent<RigidbodyPhantomPhysicsComponent>(rigidBodyPhantomPhysicsComponentID);
 	}
 
-	if (markedAsPhantom || compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PHANTOM_PHYSICS) > 0) {
-		AddComponent<PhantomPhysicsComponent>()->SetPhysicsEffectActive(false);
+	const int32_t phantomPhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PHANTOM_PHYSICS);
+	if (markedAsPhantom || phantomPhysicsComponentID > 0) {
+		AddComponent<PhantomPhysicsComponent>(phantomPhysicsComponentID)->SetPhysicsEffectActive(false);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::HAVOK_VEHICLE_PHYSICS) > 0) {
-		auto* havokVehiclePhysicsComponent = AddComponent<HavokVehiclePhysicsComponent>();
+	const int32_t havokVehiclePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::HAVOK_VEHICLE_PHYSICS);
+	if (havokVehiclePhysicsComponentID > 0) {
+		auto* havokVehiclePhysicsComponent = AddComponent<HavokVehiclePhysicsComponent>(havokVehiclePhysicsComponentID);
 		havokVehiclePhysicsComponent->SetPosition(m_DefaultPosition);
 		havokVehiclePhysicsComponent->SetRotation(m_DefaultRotation);
 	}
@@ -769,6 +775,12 @@ void Entity::Initialize() {
 	// Hacky way to trigger these when the object has had a chance to get constructed
 	AddCallbackTimer(0, [this]() {
 		this->GetScript()->OnStartup(this);
+		if (this->m_ParentEntity) {
+			GameMessages::ChildLoaded childLoaded;
+			childLoaded.childID = this->m_ObjectID;
+			childLoaded.templateID = this->GetLOT();
+			this->m_ParentEntity->OnChildLoaded(childLoaded);
+		}
 		});
 
 	if (!m_Character && Game::entityManager->GetGhostingEnabled()) {
@@ -848,6 +860,9 @@ void Entity::Subscribe(LWOOBJID scriptObjId, CppScripts::Script* scriptToAdd, co
 		auto* destroyableComponent = GetComponent<DestroyableComponent>();
 		if (!destroyableComponent) return;
 		destroyableComponent->Subscribe(scriptObjId, scriptToAdd);
+	} else if (notificationName == "PlayerResurrectionFinished") {
+		LOG("Subscribing to PlayerResurrectionFinished");
+		m_Subscriptions[scriptObjId][notificationName] = scriptToAdd;
 	}
 }
 
@@ -856,6 +871,9 @@ void Entity::Unsubscribe(LWOOBJID scriptObjId, const std::string& notificationNa
 		auto* destroyableComponent = GetComponent<DestroyableComponent>();
 		if (!destroyableComponent) return;
 		destroyableComponent->Unsubscribe(scriptObjId);
+	} else if (notificationName == "PlayerResurrectionFinished") {
+		LOG("Unsubscribing from PlayerResurrectionFinished");
+		m_Subscriptions[scriptObjId].erase(notificationName);
 	}
 }
 
@@ -1487,6 +1505,27 @@ void Entity::OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16s
 	GetScript()->OnChoiceBoxResponse(this, sender, button, buttonIdentifier, identifier);
 }
 
+void Entity::OnActivityNotify(GameMessages::ActivityNotify& notify) {
+	GetScript()->OnActivityNotify(this, notify);
+}
+
+void Entity::OnShootingGalleryFire(GameMessages::ShootingGalleryFire& fire) {
+	GetScript()->OnShootingGalleryFire(*this, fire);
+}
+
+void Entity::OnChildLoaded(GameMessages::ChildLoaded& childLoaded) {
+	GetScript()->OnChildLoaded(*this, childLoaded);
+}
+
+void Entity::NotifyPlayerResurrectionFinished(GameMessages::PlayerResurrectionFinished& msg) {
+	for (const auto& [id, scriptList] : m_Subscriptions) {
+		auto it = scriptList.find("PlayerResurrectionFinished");
+		if (it == scriptList.end()) continue;
+
+		it->second->NotifyPlayerResurrectionFinished(*this, msg);
+	}
+}
+
 void Entity::RequestActivityExit(Entity* sender, LWOOBJID player, bool canceled) {
 	GetScript()->OnRequestActivityExit(sender, player, canceled);
 }
@@ -2161,7 +2200,19 @@ void Entity::SetRespawnPos(const NiPoint3& position) {
 	auto* characterComponent = GetComponent<CharacterComponent>();
 	if (characterComponent) characterComponent->SetRespawnPos(position);
 }
+
 void Entity::SetRespawnRot(const NiQuaternion& rotation) {
 	auto* characterComponent = GetComponent<CharacterComponent>();
 	if (characterComponent) characterComponent->SetRespawnRot(rotation);
 }
+
+int32_t Entity::GetCollisionGroup() const {
+	for (const auto* component : m_Components | std::views::values) {
+		auto* compToCheck = dynamic_cast<const PhysicsComponent*>(component);	
+		if (compToCheck) {
+			return compToCheck->GetCollisionGroup();
+		}
+	}
+
+	return 0;
+}

dGame/Entity.h

@@ -13,6 +13,13 @@
 #include "eKillType.h"
 #include "Observable.h"
 
+namespace GameMessages {
+	struct ActivityNotify;
+	struct ShootingGalleryFire;
+	struct ChildLoaded;
+	struct PlayerResurrectionFinished;
+};
+
 namespace Loot {
 	class Info;
 };
@@ -107,6 +114,11 @@ public:
 
 	const SystemAddress& GetSystemAddress() const;
 
+	// Returns the collision group for this entity.
+	// Because the collision group is stored on a base component, this will look for a physics component
+	// then return the collision group from that.
+	int32_t GetCollisionGroup() const;
+
 	/**
 	 * Setters
 	 */
@@ -205,6 +217,10 @@ public:
 	void OnZonePropertyModelRemoved(Entity* player);
 	void OnZonePropertyModelRemovedWhileEquipped(Entity* player);
 	void OnZonePropertyModelRotated(Entity* player);
+	void OnActivityNotify(GameMessages::ActivityNotify& notify);
+	void OnShootingGalleryFire(GameMessages::ShootingGalleryFire& notify);
+	void OnChildLoaded(GameMessages::ChildLoaded& childLoaded);
+	void NotifyPlayerResurrectionFinished(GameMessages::PlayerResurrectionFinished& msg);
 
 	void OnMessageBoxResponse(Entity* sender, int32_t button, const std::u16string& identifier, const std::u16string& userData);
 	void OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16string& buttonIdentifier, const std::u16string& identifier);
@@ -358,6 +374,9 @@ protected:
 	 * Collision
 	 */
 	std::vector<LWOOBJID> m_TargetsInPhantom;
+
+	// objectID of receiver and map of notification name to script
+	std::map<LWOOBJID, std::map<std::string, CppScripts::Script*>> m_Subscriptions;
 };
 
 /**

dGame/LeaderboardManager.cpp

@@ -95,7 +95,7 @@ void QueryToLdf(Leaderboard& leaderboard, const std::vector<ILeaderboard::Entry>
 			// Score:1
 			entry.push_back(new LDFData<int32_t>(u"Streak", leaderboardEntry.secondaryScore));
 			// Streak:1
-			entry.push_back(new LDFData<float>(u"HitPercentage", (leaderboardEntry.tertiaryScore / 100.0f)));
+			entry.push_back(new LDFData<float>(u"HitPercentage", leaderboardEntry.tertiaryScore));
 			// HitPercentage:3 between 0 and 1
 			break;
 		case Racing:
@@ -199,9 +199,9 @@ std::vector<ILeaderboard::Entry> FilterFriends(const std::vector<ILeaderboard::E
 	std::vector<ILeaderboard::Entry> friendsLeaderboard;
 	for (const auto& entry : leaderboard) {
 		const auto res = std::ranges::find_if(friendOfPlayer, [&entry, relatedPlayer](const FriendData& data) {
-			return entry.charId == data.friendID || entry.charId == relatedPlayer;
+			return entry.charId == data.friendID;
 			});
-		if (res != friendOfPlayer.cend()) {
+		if (res != friendOfPlayer.cend() || entry.charId == relatedPlayer) {
 			friendsLeaderboard.push_back(entry);
 		}
 	}
@@ -288,6 +288,8 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 
 		if (newHighScore) {
 			Database::Get()->UpdateScore(playerID, activityId, newScore);
+		} else {
+			Database::Get()->IncrementTimesPlayed(playerID, activityId);
 		}
 	} else {
 		Database::Get()->SaveScore(playerID, activityId, newScore);

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -16,6 +16,7 @@
 #include "DestroyableComponent.h"
 
 #include <algorithm>
+#include <ranges>
 #include <sstream>
 #include <vector>
 
@@ -27,7 +28,7 @@
 #include "CDPhysicsComponentTable.h"
 #include "dNavMesh.h"
 
-BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id): Component(parent) {
+BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id) : Component(parent) {
 	m_Target = LWOOBJID_EMPTY;
 	m_DirtyStateOrTarget = true;
 	m_State = AiState::spawn;
@@ -37,6 +38,7 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	m_Disabled = false;
 	m_SkillEntries = {};
 	m_SoftTimer = 5.0f;
+	m_ForcedTetherTime = 0.0f;
 
 	//Grab the aggro information from BaseCombatAI:
 	auto componentQuery = CDClientDatabase::CreatePreppedStmt(
@@ -170,6 +172,17 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 			GameMessages::SendStopFXEffect(m_Parent, true, "tether");
 			m_TetherEffectActive = false;
 		}
+		m_ForcedTetherTime -= deltaTime;
+		if (m_ForcedTetherTime >= 0) return;
+	}
+
+	for (auto entry = m_RemovedThreatList.begin(); entry != m_RemovedThreatList.end();) {
+		entry->second -= deltaTime;
+		if (entry->second <= 0.0f) {
+			entry = m_RemovedThreatList.erase(entry);
+		} else {
+			++entry;
+		}
 	}
 
 	if (m_SoftTimer <= 0.0f) {
@@ -287,40 +300,7 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 	}
 
 	if (!m_TetherEffectActive && m_OutOfCombat && (m_OutOfCombatTime -= deltaTime) <= 0) {
-		auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
-
-		if (destroyableComponent != nullptr && destroyableComponent->HasFaction(4)) {
-			auto serilizationRequired = false;
-
-			if (destroyableComponent->GetHealth() != destroyableComponent->GetMaxHealth()) {
-				destroyableComponent->SetHealth(destroyableComponent->GetMaxHealth());
-
-				serilizationRequired = true;
-			}
-
-			if (destroyableComponent->GetArmor() != destroyableComponent->GetMaxArmor()) {
-				destroyableComponent->SetArmor(destroyableComponent->GetMaxArmor());
-
-				serilizationRequired = true;
-			}
-
-			if (serilizationRequired) {
-				Game::entityManager->SerializeEntity(m_Parent);
-			}
-
-			GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), 6270, u"tether", "tether");
-
-			m_TetherEffectActive = true;
-
-			m_TetherTime = 3.0f;
-		}
-
-		// Speed towards start position
-		if (m_MovementAI != nullptr) {
-			m_MovementAI->SetHaltDistance(0);
-			m_MovementAI->SetMaxSpeed(m_PursuitSpeed);
-			m_MovementAI->SetDestination(m_StartPosition);
-		}
+		TetherLogic();
 
 		m_OutOfCombat = false;
 		m_OutOfCombatTime = 0.0f;
@@ -499,7 +479,7 @@ std::vector<LWOOBJID> BaseCombatAIComponent::GetTargetWithinAggroRange() const {
 
 		const auto distance = Vector3::DistanceSquared(m_Parent->GetPosition(), other->GetPosition());
 
-		if (distance > m_AggroRadius * m_AggroRadius) continue;
+		if (distance > m_AggroRadius * m_AggroRadius || m_RemovedThreatList.contains(id)) continue;
 
 		targets.push_back(id);
 	}
@@ -626,6 +606,7 @@ const NiPoint3& BaseCombatAIComponent::GetStartPosition() const {
 
 void BaseCombatAIComponent::ClearThreat() {
 	m_ThreatEntries.clear();
+	m_Target = LWOOBJID_EMPTY;
 
 	m_DirtyThreat = true;
 }
@@ -806,3 +787,55 @@ void BaseCombatAIComponent::Wake() {
 	m_dpEntity->SetSleeping(false);
 	m_dpEntityEnemy->SetSleeping(false);
 }
+
+void BaseCombatAIComponent::TetherLogic() {
+	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
+
+	if (destroyableComponent != nullptr && destroyableComponent->HasFaction(4)) {
+		auto serilizationRequired = false;
+
+		if (destroyableComponent->GetHealth() != destroyableComponent->GetMaxHealth()) {
+			destroyableComponent->SetHealth(destroyableComponent->GetMaxHealth());
+
+			serilizationRequired = true;
+		}
+
+		if (destroyableComponent->GetArmor() != destroyableComponent->GetMaxArmor()) {
+			destroyableComponent->SetArmor(destroyableComponent->GetMaxArmor());
+
+			serilizationRequired = true;
+		}
+
+		if (serilizationRequired) {
+			Game::entityManager->SerializeEntity(m_Parent);
+		}
+
+		GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), 6270, u"tether", "tether");
+
+		m_TetherEffectActive = true;
+
+		m_TetherTime = 3.0f;
+	}
+
+	// Speed towards start position
+	if (m_MovementAI != nullptr) {
+		m_MovementAI->SetHaltDistance(0);
+		m_MovementAI->SetMaxSpeed(m_PursuitSpeed);
+		m_MovementAI->SetDestination(m_StartPosition);
+	}
+}
+
+void BaseCombatAIComponent::ForceTether() {
+	SetTarget(LWOOBJID_EMPTY);
+	m_ThreatEntries.clear();
+	TetherLogic();
+	m_ForcedTetherTime = m_TetherTime;
+
+	SetAiState(AiState::aggro);
+}
+
+void BaseCombatAIComponent::IgnoreThreat(const LWOOBJID threat, const float value) {
+	m_RemovedThreatList[threat] = value;
+	SetThreat(threat, 0.0f);
+	m_Target = LWOOBJID_EMPTY;
+}

dGame/dComponents/BaseCombatAIComponent.h

@@ -224,6 +224,16 @@ public:
 	 */
 	void Wake();
 
+	// Force this entity to tether and ignore all other actions
+	void ForceTether();
+
+	// heals the entity to full health and armor
+	// and tethers them to their spawn point
+	void TetherLogic();
+
+	// Ignore a threat for a certain amount of time
+	void IgnoreThreat(const LWOOBJID target, const float time);
+
 private:
 	/**
 	 * Returns the current target or the target that currently is the largest threat to this entity
@@ -382,6 +392,12 @@ private:
 	 */
 	bool m_DirtyStateOrTarget = false;
 
+	// The amount of time the entity will be forced to tether for
+	float m_ForcedTetherTime = 0.0f;
+
+	// The amount of time a removed threat will be ignored for. 
+	std::map<LWOOBJID, float> m_RemovedThreatList;
+
 	/**
 	 * Whether the current entity is a mech enemy, needed as mechs tether radius works differently
 	 * @return whether this entity is a mech

dGame/dComponents/CMakeLists.txt

@@ -7,7 +7,6 @@ set(DGAME_DCOMPONENTS_SOURCES
 	"BuildBorderComponent.cpp"
 	"CharacterComponent.cpp"
 	"CollectibleComponent.cpp"
-	"Component.cpp"
 	"ControllablePhysicsComponent.cpp"
 	"DestroyableComponent.cpp"
 	"DonationVendorComponent.cpp"
@@ -65,7 +64,6 @@ target_include_directories(dComponents PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
 	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
-	"${PROJECT_SOURCE_DIR}/thirdparty/mariadb-connector-cpp/include"
 	# dPhysics (via dpWorld.h)
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Include"
 	"${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Include"

dGame/dComponents/Component.cpp

@@ -1,34 +0,0 @@
-#include "Component.h"
-
-
-Component::Component(Entity* parent) {
-	m_Parent = parent;
-}
-
-Component::~Component() {
-
-}
-
-Entity* Component::GetParent() const {
-	return m_Parent;
-}
-
-void Component::Update(float deltaTime) {
-
-}
-
-void Component::OnUse(Entity* originator) {
-
-}
-
-void Component::UpdateXml(tinyxml2::XMLDocument& doc) {
-
-}
-
-void Component::LoadFromXml(const tinyxml2::XMLDocument& doc) {
-
-}
-
-void Component::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
-
-}

dGame/dComponents/Component.h

@@ -1,6 +1,12 @@
 #pragma once
 
-#include "tinyxml2.h"
+namespace tinyxml2 {
+	class XMLDocument;
+}
+
+namespace RakNet {
+	class BitStream;
+}
 
 class Entity;
 
@@ -9,40 +15,40 @@ class Entity;
  */
 class Component {
 public:
-	Component(Entity* parent);
-	virtual ~Component();
+	Component(Entity* parent) : m_Parent{ parent } {}
+	virtual ~Component() = default;
 
 	/**
 	 * Gets the owner of this component
 	 * @return the owner of this component
 	 */
-	Entity* GetParent() const;
+	Entity* GetParent() const { return m_Parent; }
 
 	/**
 	 * Updates the component in the game loop
 	 * @param deltaTime time passed since last update
 	 */
-	virtual void Update(float deltaTime);
+	virtual void Update(float deltaTime) {}
 
 	/**
 	 * Event called when this component is being used, e.g. when some entity interacted with it
 	 * @param originator
 	 */
-	virtual void OnUse(Entity* originator);
+	virtual void OnUse(Entity* originator) {}
 
 	/**
 	 * Save data from this componennt to character XML
 	 * @param doc the document to write data to
 	 */
-	virtual void UpdateXml(tinyxml2::XMLDocument& doc);
+	virtual void UpdateXml(tinyxml2::XMLDocument& doc) {}
 
 	/**
 	 * Load base data for this component from character XML
 	 * @param doc the document to read data from
 	 */
-	virtual void LoadFromXml(const tinyxml2::XMLDocument& doc);
+	virtual void LoadFromXml(const tinyxml2::XMLDocument& doc) {}
 
-	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction);
+	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {}
 
 protected:
 

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -15,7 +15,7 @@
 #include "LevelProgressionComponent.h"
 #include "eStateChangeType.h"
 
-ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : PhysicsComponent(entity) {
+ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity, int32_t componentId) : PhysicsComponent(entity, componentId) {
 	m_Velocity = {};
 	m_AngularVelocity = {};
 	m_InJetpackMode = false;

dGame/dComponents/ControllablePhysicsComponent.h

@@ -23,7 +23,7 @@ class ControllablePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::CONTROLLABLE_PHYSICS;
 
-	ControllablePhysicsComponent(Entity* entity);
+	ControllablePhysicsComponent(Entity* entity, int32_t componentId);
 	~ControllablePhysicsComponent() override;
 
 	void Update(float deltaTime) override;

dGame/dComponents/HavokVehiclePhysicsComponent.cpp

@@ -1,7 +1,7 @@
 #include "HavokVehiclePhysicsComponent.h"
 #include "EntityManager.h"
 
-HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Velocity = NiPoint3Constant::ZERO;
 	m_AngularVelocity = NiPoint3Constant::ZERO;
 	m_IsOnGround = true;

dGame/dComponents/HavokVehiclePhysicsComponent.h

@@ -13,7 +13,7 @@ class HavokVehiclePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::HAVOK_VEHICLE_PHYSICS;
 
-	HavokVehiclePhysicsComponent(Entity* parentEntity);
+	HavokVehiclePhysicsComponent(Entity* parentEntity, int32_t componentId);
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/InventoryComponent.cpp

@@ -31,6 +31,7 @@
 #include "eStateChangeType.h"
 #include "eUseItemResponse.h"
 #include "Mail.h"
+#include "ProximityMonitorComponent.h"
 
 #include "CDComponentsRegistryTable.h"
 #include "CDInventoryComponentTable.h"
@@ -68,9 +69,10 @@ InventoryComponent::InventoryComponent(Entity* parent) : Component(parent) {
 	auto slot = 0u;
 
 	for (const auto& item : items) {
-		if (!item.equip || !Inventory::IsValidItem(item.itemid)) {
-			continue;
-		}
+		if (!Inventory::IsValidItem(item.itemid)) continue;
+		AddItem(item.itemid, item.count);
+
+		if (!item.equip) continue;
 
 		const LWOOBJID id = ObjectIDManager::GenerateObjectID();
 
@@ -829,6 +831,30 @@ void InventoryComponent::EquipItem(Item* item, const bool skipChecks) {
 				break;
 			}
 
+			return;
+		} else if (item->GetLot() == 8092) {
+			// Trying to equip a car
+			const auto proximityObjects = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::PROXIMITY_MONITOR);
+
+			// look for car instancers and check if we are in its setup range
+			for (auto* const entity : proximityObjects) {
+				if (!entity) continue;
+
+				auto* proximityMonitorComponent = entity->GetComponent<ProximityMonitorComponent>();
+				if (!proximityMonitorComponent) continue;
+
+				if (proximityMonitorComponent->IsInProximity("Interaction_Distance", m_Parent->GetObjectID())) {
+					// in the range of a car instancer
+					entity->OnUse(m_Parent);
+					GameMessages::UseItemOnClient itemMsg;
+					itemMsg.target = entity->GetObjectID();
+					itemMsg.itemLOT = item->GetLot();
+					itemMsg.itemToUse = item->GetId();
+					itemMsg.playerId = m_Parent->GetObjectID();
+					itemMsg.Send(m_Parent->GetSystemAddress());
+					break;
+				}
+			}
 			return;
 		}
 
@@ -1141,6 +1167,25 @@ void InventoryComponent::AddItemSkills(const LOT lot) {
 	SetSkill(slot, skill);
 }
 
+void InventoryComponent::FixInvisibleItems() {
+	const auto numberItemsLoadedPerFrame = 12.0f;
+	const auto callbackTime = 0.125f;
+	const auto arbitaryInventorySize = 300.0f; // max in live + dlu is less than 300, seems like a good number.
+	auto* const items = GetInventory(eInventoryType::ITEMS);
+	if (!items) return;
+
+	// Add an extra update to make sure the client can see all the items.
+	const auto something = static_cast<int32_t>(std::ceil(items->GetItems().size() / arbitaryInventorySize)) + 1;
+	LOG_DEBUG("Fixing invisible items with %i updates", something);
+
+	for (int32_t i = 1; i < something + 1; i++) {
+		// client loads 12 items every 1/8 seconds, we're adding a small hack to fix invisible inventory items due to closing the news screen too fast.
+		m_Parent->AddCallbackTimer((arbitaryInventorySize / numberItemsLoadedPerFrame) * callbackTime * i, [this]() {
+			GameMessages::SendUpdateInventoryUi(m_Parent->GetObjectID(), m_Parent->GetSystemAddress());
+			});
+	}
+}
+
 void InventoryComponent::RemoveItemSkills(const LOT lot) {
 	const auto info = Inventory::FindItemComponent(lot);
 

dGame/dComponents/InventoryComponent.h

@@ -404,6 +404,8 @@ public:
 	void UpdateGroup(const GroupUpdate& groupUpdate);
 	void RemoveGroup(const std::string& groupId);
 
+	void FixInvisibleItems();
+
 	~InventoryComponent() override;
 
 private:

dGame/dComponents/MovementAIComponent.cpp

@@ -265,6 +265,7 @@ void MovementAIComponent::PullToPoint(const NiPoint3& point) {
 
 void MovementAIComponent::SetPath(std::vector<PathWaypoint> path) {
 	if (path.empty()) return;
+	while (!m_CurrentPath.empty()) m_CurrentPath.pop();
 	std::for_each(path.rbegin(), path.rend() - 1, [this](const PathWaypoint& point) {
 		this->m_CurrentPath.push(point);
 		});

dGame/dComponents/PetComponent.cpp

@@ -524,7 +524,7 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 
 	GameMessages::SendRegisterPetDBID(m_Tamer, petSubKey, tamer->GetSystemAddress());
 
-	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::ACTIVITY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
+	inventoryComponent->AddItem(m_Parent->GetLOT(), 1, eLootSourceType::INVENTORY, eInventoryType::MODELS, {}, LWOOBJID_EMPTY, true, false, petSubKey);
 	auto* item = inventoryComponent->FindItemBySubKey(petSubKey, MODELS);
 
 	if (item == nullptr) {

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -27,7 +27,7 @@
 #include "dpShapeBox.h"
 #include "dpShapeSphere.h"
 
-PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 	m_Scale = m_Parent->GetDefaultScale();

dGame/dComponents/PhantomPhysicsComponent.h

@@ -30,7 +30,7 @@ class PhantomPhysicsComponent final : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::PHANTOM_PHYSICS;
 
-	PhantomPhysicsComponent(Entity* parent);
+	PhantomPhysicsComponent(Entity* parent, int32_t componentId);
 	~PhantomPhysicsComponent() override;
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;

dGame/dComponents/PhysicsComponent.cpp

@@ -14,10 +14,21 @@
 
 #include "EntityInfo.h"
 
-PhysicsComponent::PhysicsComponent(Entity* parent) : Component(parent) {
+PhysicsComponent::PhysicsComponent(Entity* parent, int32_t componentId) : Component(parent) {
 	m_Position = NiPoint3Constant::ZERO;
 	m_Rotation = NiQuaternionConstant::IDENTITY;
 	m_DirtyPosition = false;
+
+	CDPhysicsComponentTable* physicsComponentTable = CDClientManager::GetTable<CDPhysicsComponentTable>();
+
+	if (physicsComponentTable) {
+		auto* info = physicsComponentTable->GetByID(componentId);
+		if (info) {
+			m_CollisionGroup = info->collisionGroup;
+		}
+	}
+
+	if (m_Parent->HasVar(u"CollisionGroupID")) m_CollisionGroup = m_Parent->GetVar<int32_t>(u"CollisionGroupID");
 }
 
 void PhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
@@ -73,6 +84,10 @@ dpEntity* PhysicsComponent::CreatePhysicsEntity(eReplicaComponentType type) {
 	} else if (info->physicsAsset == "env\\env_won_fv_gas-blocking-volume.hkx") {
 		toReturn = new dpEntity(m_Parent->GetObjectID(), 390.496826f, 111.467964f, 600.821534f, true);
 		m_Position.y -= (111.467964f * m_Parent->GetDefaultScale()) / 2;
+	} else if (info->physicsAsset == "env\\GFTrack_DeathVolume1_CaveExit.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 112.416870f, 50.363434f, 87.679268f);
+	} else if (info->physicsAsset == "env\\GFTrack_DeathVolume2_RoadGaps.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 48.386536f, 50.363434f, 259.361755f);
 	} else {
 		// LOG_DEBUG("This one is supposed to have %s", info->physicsAsset.c_str());
 

dGame/dComponents/PhysicsComponent.h

@@ -15,7 +15,7 @@ class dpEntity;
 
 class PhysicsComponent : public Component {
 public:
-	PhysicsComponent(Entity* parent);
+	PhysicsComponent(Entity* parent, int32_t componentId);
 	virtual ~PhysicsComponent() = default;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
@@ -25,6 +25,9 @@ public:
 
 	const NiQuaternion& GetRotation() const { return m_Rotation; }
 	virtual void SetRotation(const NiQuaternion& rot) { if (m_Rotation == rot) return; m_Rotation = rot; m_DirtyPosition = true; }
+
+	int32_t GetCollisionGroup() const noexcept { return m_CollisionGroup; }
+	void SetCollisionGroup(int32_t group) noexcept { m_CollisionGroup = group; }
 protected:
 	dpEntity* CreatePhysicsEntity(eReplicaComponentType type);
 
@@ -37,6 +40,8 @@ protected:
 	NiQuaternion m_Rotation;
 
 	bool m_DirtyPosition;
+
+	int32_t m_CollisionGroup{};
 };
 
 #endif  //!__PHYSICSCOMPONENT__H__

dGame/dComponents/RacingControlComponent.cpp

@@ -35,7 +35,8 @@
 RacingControlComponent::RacingControlComponent(Entity* parent)
 	: Component(parent) {
 	m_PathName = u"MainPath";
-	m_RemainingLaps = 3;
+	m_NumberOfLaps = 3;
+	m_RemainingLaps = m_NumberOfLaps;
 	m_LeadingPlayer = LWOOBJID_EMPTY;
 	m_RaceBestTime = 0;
 	m_RaceBestLap = 0;
@@ -284,7 +285,7 @@ void RacingControlComponent::OnRacingClientReady(Entity* player) {
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void RacingControlComponent::OnRequestDie(Entity* player) {
+void RacingControlComponent::OnRequestDie(Entity* player, const std::u16string& deathType) {
 	// Sent by the client when they collide with something which should smash
 	// them.
 
@@ -300,8 +301,9 @@ void RacingControlComponent::OnRequestDie(Entity* player) {
 
 		if (!racingPlayer.noSmashOnReload) {
 			racingPlayer.smashedTimes++;
+			LOG("Death type %s", GeneralUtils::UTF16ToWTF8(deathType).c_str());
 			GameMessages::SendDie(vehicle, vehicle->GetObjectID(), LWOOBJID_EMPTY, true,
-				eKillType::VIOLENT, u"", 0, 0, 90.0f, false, true, 0);
+				eKillType::VIOLENT, deathType, 0, 0, 90.0f, false, true, 0);
 
 			auto* destroyableComponent = vehicle->GetComponent<DestroyableComponent>();
 			uint32_t respawnImagination = 0;
@@ -658,23 +660,9 @@ void RacingControlComponent::Update(float deltaTime) {
 					}
 				}
 
-				// Spawn imagination pickups
-				auto* minSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Min")[0];
-				auto* medSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Med")[0];
-				auto* maxSpawner = Game::zoneManager->GetSpawnersByName(
-					"ImaginationSpawn_Max")[0];
-
-				minSpawner->Activate();
-
-				if (m_LoadedPlayers > 2) {
-					medSpawner->Activate();
-				}
-
-				if (m_LoadedPlayers > 4) {
-					maxSpawner->Activate();
-				}
+				GameMessages::ZoneLoadedInfo zoneLoadInfo{};
+				zoneLoadInfo.maxPlayers = m_LoadedPlayers;
+				m_Parent->GetScript()->OnZoneLoadedInfo(m_Parent, zoneLoadInfo);
 
 				// Reset players to their start location, without smashing them
 				for (auto& player : m_RacingPlayers) {
@@ -764,7 +752,7 @@ void RacingControlComponent::Update(float deltaTime) {
 		// new checkpoint
 		uint32_t respawnIndex = 0;
 		for (const auto& waypoint : path->pathWaypoints) {
-			if (player.lap == 3) {
+			if (player.lap == m_NumberOfLaps) {
 				break;
 			}
 
@@ -835,7 +823,7 @@ void RacingControlComponent::Update(float deltaTime) {
 					// Progress lap time tasks
 					missionComponent->Progress(eMissionTaskType::RACING, lapTime.count(), static_cast<LWOOBJID>(eRacingTaskParam::LAP_TIME));
 
-					if (player.lap == 3) {
+					if (player.lap == m_NumberOfLaps) {
 						m_Finished++;
 						player.finished = m_Finished;
 
@@ -882,3 +870,20 @@ void RacingControlComponent::Update(float deltaTime) {
 		}
 	}
 }
+
+void RacingControlComponent::MsgConfigureRacingControl(const GameMessages::ConfigureRacingControl& msg) {
+	for (const auto& dataUnique : msg.racingSettings) {
+		if (!dataUnique) continue;
+		const auto* const data = dataUnique.get(); 
+		if (data->GetKey() == u"Race_PathName" && data->GetValueType() == LDF_TYPE_UTF_16) {
+			m_PathName = static_cast<const LDFData<std::u16string>*>(data)->GetValue();
+		} else if (data->GetKey() == u"activityID" && data->GetValueType() == LDF_TYPE_S32) {
+			m_ActivityID = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+		} else if (data->GetKey() == u"Number_of_Laps" && data->GetValueType() == LDF_TYPE_S32) {
+			m_NumberOfLaps = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+			m_RemainingLaps = m_NumberOfLaps;
+		} else if (data->GetKey() == u"Minimum_Players_for_Group_Achievements" && data->GetValueType() == LDF_TYPE_S32) {
+			m_MinimumPlayersForGroupAchievements = static_cast<const LDFData<int32_t>*>(data)->GetValue();
+		}
+	}
+}

dGame/dComponents/RacingControlComponent.h

@@ -135,7 +135,7 @@ public:
 	/**
 	 * Invoked when the client says it should be smashed.
 	 */
-	void OnRequestDie(Entity* player);
+	void OnRequestDie(Entity* player, const std::u16string& deathType = u"");
 
 	/**
 	 * Invoked when the player has finished respawning.
@@ -152,6 +152,8 @@ public:
 	 */
 	RacingPlayerInfo* GetPlayerData(LWOOBJID playerID);
 
+	void MsgConfigureRacingControl(const GameMessages::ConfigureRacingControl& msg);
+
 private:
 
 	/**
@@ -161,11 +163,13 @@ private:
 
 	/**
 	 * The paths that are followed for the camera scenes
+	 * Configurable in the ConfigureRacingControl msg with the key `Race_PathName`.
 	 */
 	std::u16string m_PathName;
 
 	/**
 	 * The ID of the activity for participating in this race
+	 * Configurable in the ConfigureRacingControl msg with the key `activityID`.
 	 */
 	uint32_t m_ActivityID;
 
@@ -245,5 +249,20 @@ private:
 	 * Value for message box response to know if we are exiting the race via the activity dialogue
 	 */
 	const int32_t m_ActivityExitConfirm = 1;
+
 	bool m_AllPlayersReady = false;
+
+	/**
+	 * @brief The number of laps in this race. Configurable in the ConfigureRacingControl msg
+	 * with the key `Number_of_Laps`.
+	 * 
+	 */
+	int32_t m_NumberOfLaps{ 3 };
+
+	/**
+	 * @brief The minimum number of players required to progress group achievements.
+	 * Configurable with the ConfigureRacingControl msg with the key `Minimum_Players_for_Group_Achievements`.
+	 * 
+	 */
+	int32_t m_MinimumPlayersForGroupAchievements{ 2 };
 };

dGame/dComponents/RigidbodyPhantomPhysicsComponent.cpp

@@ -12,7 +12,7 @@
 #include "dpShapeSphere.h"
 #include"EntityInfo.h"
 
-RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* parent, int32_t componentId) : PhysicsComponent(parent, componentId) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 	m_Scale = m_Parent->GetDefaultScale();

dGame/dComponents/RigidbodyPhantomPhysicsComponent.h

@@ -21,7 +21,7 @@ class RigidbodyPhantomPhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS;
 
-	RigidbodyPhantomPhysicsComponent(Entity* parent);
+	RigidbodyPhantomPhysicsComponent(Entity* parent, int32_t componentId);
 
 	void Update(const float deltaTime) override;
 

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -13,7 +13,7 @@
 
 #include "Entity.h"
 
-SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, uint32_t componentID) : PhysicsComponent(parent) {
+SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, int32_t componentID) : PhysicsComponent(parent, componentID) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
 

dGame/dComponents/SimplePhysicsComponent.h

@@ -30,7 +30,7 @@ class SimplePhysicsComponent : public PhysicsComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SIMPLE_PHYSICS;
 
-	SimplePhysicsComponent(Entity* parent, uint32_t componentID);
+	SimplePhysicsComponent(Entity* parent, int32_t componentID);
 	~SimplePhysicsComponent() override;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;

dGame/dComponents/SkillComponent.cpp

@@ -123,6 +123,11 @@ void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::B
 	behavior->Handle(sync_entry.context, bitStream, branch);
 
 	this->m_managedProjectiles.erase(this->m_managedProjectiles.begin() + index);
+
+	GameMessages::ActivityNotify notify;
+	notify.notification.push_back( std::make_unique<LDFData<int32_t>>(u"shot_done", sync_entry.skillId));
+
+	m_Parent->OnActivityNotify(notify);
 }
 
 void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, BehaviorContext* context, const BehaviorBranchContext& branch, const LOT lot) {
@@ -132,6 +137,7 @@ void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, Behav
 	entry.branchContext = branch;
 	entry.lot = lot;
 	entry.id = projectileId;
+	entry.skillId = context->skillID;
 
 	this->m_managedProjectiles.push_back(entry);
 }

dGame/dComponents/SkillComponent.h

@@ -40,6 +40,8 @@ struct ProjectileSyncEntry {
 
 	BehaviorBranchContext branchContext{ 0, 0 };
 
+	int32_t skillId{ 0 };
+
 	explicit ProjectileSyncEntry();
 };