conceptualizing

.env.example

@@ -7,16 +7,8 @@ NET_VERSION=171022
 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

@@ -4,8 +4,10 @@ RelWithDebInfo/
 docker/configs
 
 # Third party libraries
+thirdparty/magic_enum
 thirdparty/mysql/
 thirdparty/mysql_linux/
+CMakeVariables.txt
 
 # Build folders
 build/

.gitmodules

@@ -1,3 +1,6 @@
+[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
@@ -11,6 +14,3 @@
 	path = thirdparty/mariadb-connector-cpp
 	url = https://github.com/mariadb-corporation/mariadb-connector-cpp.git
 	ignore = dirty
-[submodule "thirdparty/magic_enum"]
-	path = thirdparty/magic_enum
-	url = https://github.com/Neargye/magic_enum.git

CMakeLists.txt

@@ -110,6 +110,23 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
 find_package(MariaDB)
 
+# Fetch third party dependencies
+set(DLU_THIRDPARTY_SOURCE_DIR ${CMAKE_SOURCE_DIR}/thirdparty)
+
+include(FetchContent)
+FetchContent_Declare(
+	magic_enum
+	SYSTEM
+	# SOURCE_DIR     ${DLU_THIRDPARTY_SOURCE_DIR}/magic_enum
+	GIT_REPOSITORY https://github.com/Neargye/magic_enum.git
+	GIT_TAG        v0.9.7
+)
+FetchContent_MakeAvailable(magic_enum)
+
+include(CMakePrintHelpers)
+cmake_print_properties(TARGETS magic_enum::magic_enum PROPERTIES
+                       INTERFACE_INCLUDE_DIRECTORIES)
+
 # Create a /resServer directory
 make_directory(${CMAKE_BINARY_DIR}/resServer)
 
@@ -175,18 +192,16 @@ foreach(resource_file ${RESOURCE_FILES})
 				list(GET line_split 0 variable_name)
 
 				if(NOT ${parsed_current_file_contents} MATCHES ${variable_name})
-					# 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})
+					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")
-					endif()
+					file(APPEND ${DLU_CONFIG_DIR}/${resource_file} "\n")
 				endif()
+
 				set(line_to_add "")
 			else()
 				set(line_to_add ${line_to_add} ${line})
@@ -216,8 +231,21 @@ foreach(file ${VANITY_FILES})
 endforeach()
 
 # Move our migrations for MasterServer to run
-file(REMOVE_RECURSE ${PROJECT_BINARY_DIR}/migrations)
-file(COPY ${CMAKE_SOURCE_DIR}/migrations DESTINATION ${CMAKE_BINARY_DIR})
+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()
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
@@ -241,15 +269,13 @@ include_directories(
 	"tests/dGameTests/dComponentsTests"
 
 	SYSTEM
-	"thirdparty/magic_enum/include/magic_enum"
 	"thirdparty/raknet/Source"
 	"thirdparty/tinyxml2"
 	"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)
@@ -293,6 +319,7 @@ file(
 # Add our library subdirectories for creation of the library object
 add_subdirectory(dCommon)
 add_subdirectory(dDatabase)
+add_subdirectory(dECS)
 add_subdirectory(dChatFilter)
 add_subdirectory(dNet)
 add_subdirectory(dScripts) # Add for dGame to use
@@ -303,7 +330,7 @@ add_subdirectory(dPhysics)
 add_subdirectory(dServer)
 
 # Create a list of common libraries shared between all binaries
-set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "magic_enum")
+set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "magic_enum::magic_enum")
 
 # Add platform specific common libraries
 if(UNIX)

CMakeVariables.txt

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

README.md

@@ -13,35 +13,21 @@ 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.
 
-## 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.
+## 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.
 
-<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
+## Steps to setup server
 * [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)
@@ -53,13 +39,6 @@ If you would like to use a MariaDB as a database instead of the default of sqlit
 * [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)
 
@@ -70,12 +49,6 @@ 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!).
@@ -210,7 +183,6 @@ 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
@@ -233,41 +205,28 @@ 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 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.
+* `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.
 
 ## Verify your setup
-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)
+Your build directory should now look like this:
+* AuthServer
+* ChatServer
+* MasterServer
+* WorldServer
 * authconfig.ini
-* ChatServer(.exe)
 * chatconfig.ini
-* MasterServer(.exe)
 * masterconfig.ini
-* WorldServer(.exe)
+* sharedconfig.ini
 * 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 have to give the `AuthServer` binary network permissions by running 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 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
 ```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.  
@@ -307,8 +266,8 @@ systemctl stop darkflame.service
 journalctl -xeu darkflame.service
 ```
 
-### 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!
+### 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!
 
 ### Account management tool (Nexus Dashboard)
 **If you are just using this server for yourself, you can skip setting up Nexus Dashboard**
@@ -330,14 +289,8 @@ 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
@@ -354,10 +307,6 @@ 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

dAuthServer/AuthServer.cpp

@@ -27,6 +27,7 @@
 #include "Game.h"
 #include "Server.h"
 
+
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -70,15 +71,12 @@ int main(int argc, char** argv) {
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1500;
-	std::string masterPassword;
 
 	auto masterInfo = Database::Get()->GetMasterInfo();
 	if (masterInfo) {
 		masterIP = masterInfo->ip;
 		masterPort = masterInfo->port;
-		masterPassword = masterInfo->password;
 	}
-
 	LOG("Master is at %s:%d", masterIP.c_str(), masterPort);
 
 	Game::randomEngine = std::mt19937(time(0));
@@ -92,7 +90,7 @@ int main(int argc, char** argv) {
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;
 
-	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth, Game::config, &Game::lastSignal, masterPassword);
+	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth, Game::config, &Game::lastSignal);
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();

dAuthServer/CMakeLists.txt

@@ -1,4 +1,7 @@
 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,8 +2,6 @@ set(DCHATSERVER_SOURCES
 	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
 	"PlayerContainer.cpp"
-	"ChatWebAPI.cpp"
-	"JSONUtils.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
@@ -14,5 +12,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 mongoose)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
 

dChatServer/ChatPacketHandler.cpp

@@ -49,7 +49,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 			fd.zoneID = fr.zoneID;
 
 			//Since this friend is online, we need to update them on the fact that we've just logged in:
-			if (player.isLogin) SendFriendUpdate(fr, player, 1, fd.isBestFriend);
+			SendFriendUpdate(fr, player, 1, fd.isBestFriend);
 		} else {
 			fd.isOnline = false;
 			fd.zoneID = LWOZONEID();
@@ -103,8 +103,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		return;
 	};
 
-	// Intentional copy
-	PlayerData requestee = Game::playerContainer.GetPlayerData(playerName);
+	auto& requestee = Game::playerContainer.GetPlayerDataMutable(playerName);
 
 	// Check if player is online first
 	if (isBestFriendRequest && !requestee) {
@@ -141,7 +140,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;
 	}
@@ -189,24 +188,19 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				Database::Get()->SetBestFriendStatus(requestorPlayerID, requestee.playerID, bestFriendStatus);
 				// Sent the best friend update here if the value is 3
 				if (bestFriendStatus == 3U) {
+					requestee.countOfBestFriends += 1;
+					requestor.countOfBestFriends += 1;
 					if (requestee.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee, requestor, eAddFriendResponseType::ACCEPTED, false, true);
 					if (requestor.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::ACCEPTED, false, true);
-
 					for (auto& friendData : requestor.friends) {
 						if (friendData.friendID == requestee.playerID) {
 							friendData.isBestFriend = true;
 						}
 					}
-					requestor.countOfBestFriends += 1;
-
-					auto& toModify = Game::playerContainer.GetPlayerDataMutable(playerName);
-					if (toModify) {
-						for (auto& friendData : toModify.friends) {
-							if (friendData.friendID == requestor.playerID) {
-								friendData.isBestFriend = true;
-							}
+					for (auto& friendData : requestee.friends) {
+						if (friendData.friendID == requestor.playerID) {
+							friendData.isBestFriend = true;
 						}
-						toModify.countOfBestFriends += 1;
 					}
 				}
 			}
@@ -406,8 +400,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,8 +28,6 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
-#include "ChatWebAPI.h"
-
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -76,8 +74,7 @@ int main(int argc, char** argv) {
 		Game::assetManager = new AssetManager(clientPath);
 	} catch (std::runtime_error& ex) {
 		LOG("Got an error while setting up assets: %s", ex.what());
-		delete Game::logger;
-		delete Game::config;
+
 		return EXIT_FAILURE;
 	}
 
@@ -87,32 +84,18 @@ int main(int argc, char** argv) {
 	} catch (std::exception& ex) {
 		LOG("Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("ChatServer");
+		delete Game::server;
 		delete Game::logger;
-		delete Game::config;
 		return EXIT_FAILURE;
 	}
 
-	// seyup the chat api web server
-	bool web_server_enabled = Game::config->GetValue("web_server_enabled") == "1";
-	ChatWebAPI chatwebapi;
-	if (web_server_enabled && !chatwebapi.Startup()){
-		// if we want the web api and it fails to start, exit
-		LOG("Failed to start web server, shutting down.");
-		Database::Destroy("ChatServer");
-		delete Game::logger;
-		delete Game::config;
-		return EXIT_FAILURE;
-	};
-
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1000;
-	std::string masterPassword;
 	auto masterInfo = Database::Get()->GetMasterInfo();
 	if (masterInfo) {
 		masterIP = masterInfo->ip;
 		masterPort = masterInfo->port;
-		masterPassword = masterInfo->password;
 	}
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	std::string ourIP = "localhost";
@@ -121,7 +104,7 @@ int main(int argc, char** argv) {
 	const auto externalIPString = Game::config->GetValue("external_ip");
 	if (!externalIPString.empty()) ourIP = externalIPString;
 
-	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::lastSignal, masterPassword);
+	Game::server = new dServer(ourIP, ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::lastSignal);
 
 	const bool dontGenerateDCF = GeneralUtils::TryParse<bool>(Game::config->GetValue("dont_generate_dcf")).value_or(false);
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", dontGenerateDCF);
@@ -139,8 +122,6 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
-	auto lastTime = std::chrono::high_resolution_clock::now();
-
 	Game::logger->Flush(); // once immediately before main loop
 	while (!Game::ShouldShutdown()) {
 		//Check if we're still connected to master:
@@ -151,11 +132,7 @@ int main(int argc, char** argv) {
 				break; //Exit our loop, shut down.
 		} else framesSinceMasterDisconnect = 0;
 
-		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);
+		//In world we'd update our other systems here.
 
 		//Check for packets here:
 		Game::server->ReceiveFromMaster(); //ReceiveFromMaster also handles the master packets if needed.
@@ -166,11 +143,6 @@ 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();
@@ -196,7 +168,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;
@@ -225,149 +197,150 @@ 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.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);
+		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);
 	}
 }

dChatServer/ChatWebAPI.cpp

@@ -1,196 +0,0 @@
-#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 "JSONUtils.h"
-#include "GeneralUtils.h"
-#include "eHTTPMethod.h"
-#include "magic_enum.hpp"
-#include "ChatPackets.h"
-#include "StringifiedEnum.h"
-#include "Database.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 char* json_content_type = "Content-Type: application/json\r\n";
-	std::map<std::pair<eHTTPMethod, std::string>, WebAPIHTTPRoute> Routes {};
-}
-
-bool ValidateAuthentication(const mg_http_message* http_msg) {
-	// TO DO: This is just a placeholder for now
-	// use tokens or something at a later point if we want to implement authentication
-	// bit using the listen bind address to limit external access is good enough to start with
-	return true;
-}
-
-bool ValidateJSON(std::optional<json> data, HTTPReply& reply) {
-	if (!data) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = "{\"error\":\"Invalid JSON\"}";
-		return false;
-	}
-	return true;
-}
-
-void HandlePlayersRequest(HTTPReply& reply, std::string body) {
-	const json data = Game::playerContainer;
-	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
-	reply.message = data.empty() ? "{\"error\":\"No Players Online\"}" : data.dump();
-}
-
-void HandleTeamsRequest(HTTPReply& reply, std::string body) {
-	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 HandleAnnounceRequest(HTTPReply& reply, std::string body) {
-	auto data = GeneralUtils::TryParse<json>(body);
-	if (!ValidateJSON(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 HandleInvalidRoute(HTTPReply& reply) {
-	reply.status = eHTTPStatusCode::NOT_FOUND;
-	reply.message = "{\"error\":\"Invalid Route\"}";
-}
-
-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 if (ValidateAuthentication(http_msg)) {
-		
-		// 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);
-		std::transform(uri.begin(), uri.end(), uri.begin(), ::tolower);
-
-		// convert body from cstring to std string
-		std::string body(http_msg->body.buf, http_msg->body.len);
-
-		
-		const auto routeItr = Routes.find({method, uri});
-
-		if (routeItr != Routes.end()) {
-			const auto& [_, route] = *routeItr;
-			route.handle(reply, body);
-		} else HandleInvalidRoute(reply);
-	} else {
-		reply.status = eHTTPStatusCode::UNAUTHORIZED;
-		reply.message = "{\"error\":\"Unauthorized\"}";
-	}
-	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;
-	}
-}
-
-void ChatWebAPI::RegisterHTTPRoutes(WebAPIHTTPRoute route) {
-	auto [_, success] = Routes.try_emplace({ route.method, route.path }, route);
-	if (!success) {
-		LOG_DEBUG("Failed to register route %s", route.path.c_str());
-	} else {
-		LOG_DEBUG("Registered route %s", route.path.c_str());
-	}
-}
-
-ChatWebAPI::ChatWebAPI() {
-	mg_log_set(MG_LL_NONE);
-	mg_mgr_init(&mgr);  // Initialize event manager
-}
-
-ChatWebAPI::~ChatWebAPI() {
-	mg_mgr_free(&mgr);
-}
-
-bool ChatWebAPI::Startup() {
-	// 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 on %s", listen_port.c_str());
-		return false;
-	}
-
-	// Register routes
-
-	// API v1 routes
-	std::string v1_route = "/api/v1/";
-	RegisterHTTPRoutes({
-		.path = v1_route + "players",
-		.method = eHTTPMethod::GET,
-		.handle = HandlePlayersRequest
-	});
-
-	RegisterHTTPRoutes({
-		.path = v1_route + "teams",
-		.method = eHTTPMethod::GET,
-		.handle = HandleTeamsRequest
-	});
-
-	RegisterHTTPRoutes({
-		.path = v1_route + "announce",
-		.method = eHTTPMethod::POST,
-		.handle = HandleAnnounceRequest
-	});
-	return true;
-}
-
-void ChatWebAPI::ReceiveRequests() {
-	mg_mgr_poll(&mgr, 15);
-}
-
-#ifdef DARKFLAME_PLATFORM_WIN32
-#pragma pop_macro("DELETE")
-#endif

dChatServer/ChatWebAPI.h

@@ -1,36 +0,0 @@
-#ifndef __CHATWEBAPI_H__
-#define __CHATWEBAPI_H__
-#include <string>
-#include <functional>
-
-#include "mongoose.h"
-#include "eHTTPStatusCode.h"
-
-enum class eHTTPMethod;
-
-typedef struct mg_mgr mg_mgr;
-
-struct HTTPReply {
-	eHTTPStatusCode status = eHTTPStatusCode::NOT_FOUND;
-	std::string message = "{\"error\":\"Not Found\"}";
-};
-
-struct WebAPIHTTPRoute {
-	std::string path;
-	eHTTPMethod method;
-	std::function<void(HTTPReply&, const std::string&)> handle;
-};
-
-class ChatWebAPI {
-public:
-	ChatWebAPI();
-	~ChatWebAPI();
-	void ReceiveRequests();
-	void RegisterHTTPRoutes(WebAPIHTTPRoute route);
-	bool Startup();
-private:
-	mg_mgr mgr;
-
-};
-
-#endif // __CHATWEBAPI_H__

dChatServer/JSONUtils.cpp

@@ -1,62 +0,0 @@
-#include "JSONUtils.h"
-
-#include "json.hpp"
-
-using json = nlohmann::json;
-
-void to_json(json& data, const PlayerData& playerData) {
-	data["id"] = playerData.playerID;
-	data["name"] = playerData.playerName;
-	data["gm_level"] = playerData.gmLevel;
-	data["muted"] = playerData.GetIsMuted();
-
-	auto& zoneID = data["zone_id"];
-	zoneID["map_id"] = playerData.zoneID.GetMapID();
-	zoneID["instance_id"] = playerData.zoneID.GetInstanceID();
-	zoneID["clone_id"] = playerData.zoneID.GetCloneID();
-}
-
-void to_json(json& data, const PlayerContainer& playerContainer) {
-	data = json::array();
-	for(auto& playerData : playerContainer.GetAllPlayers()) {
-		if (playerData.first == LWOOBJID_EMPTY) continue;
-		data.push_back(playerData.second);
-	}
-}
-
-void to_json(json& data, const 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();
-}

dChatServer/JSONUtils.h

@@ -1,17 +0,0 @@
-#ifndef __JSONUTILS_H__
-#define __JSONUTILS_H__
-
-#include "json_fwd.hpp"
-#include "PlayerContainer.h"
-
-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);
-}
-
-#endif // __JSONUTILS_H__

dChatServer/PlayerContainer.cpp

@@ -32,10 +32,7 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 		return;
 	}
 
-	auto isLogin = !m_Players.contains(playerId);
 	auto& data = m_Players[playerId];
-	data = PlayerData();
-	data.isLogin = isLogin;
 	data.playerID = playerId;
 
 	uint32_t len;
@@ -60,32 +57,13 @@ 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::ScheduleRemovePlayer(Packet* packet) {
+void PlayerContainer::RemovePlayer(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID{ LWOOBJID_EMPTY };
+	LWOOBJID playerID;
 	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);
 
@@ -219,7 +197,7 @@ TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
 	team->leaderID = leader;
 	team->local = local;
 
-	GetTeamsMut().push_back(team);
+	mTeams.push_back(team);
 
 	AddMember(team, leader);
 
@@ -227,7 +205,7 @@ TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
 }
 
 TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) {
-	for (auto* team : GetTeams()) {
+	for (auto* team : mTeams) {
 		if (std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID) == team->memberIDs.end()) continue;
 
 		return team;
@@ -335,9 +313,9 @@ void PlayerContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) {
 }
 
 void PlayerContainer::DisbandTeam(TeamData* team) {
-	const auto index = std::find(GetTeams().begin(), GetTeams().end(), team);
+	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
 
-	if (index == GetTeams().end()) return;
+	if (index == mTeams.end()) return;
 
 	for (const auto memberId : team->memberIDs) {
 		const auto& otherMember = GetPlayerData(memberId);
@@ -352,15 +330,15 @@ void PlayerContainer::DisbandTeam(TeamData* team) {
 
 	UpdateTeamsOnWorld(team, true);
 
-	GetTeamsMut().erase(index);
+	mTeams.erase(index);
 
 	delete team;
 }
 
 void PlayerContainer::TeamStatusUpdate(TeamData* team) {
-	const auto index = std::find(GetTeams().begin(), GetTeams().end(), team);
+	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
 
-	if (index == GetTeams().end()) return;
+	if (index == mTeams.end()) return;
 
 	const auto& leader = GetPlayerData(team->leaderID);
 
@@ -439,13 +417,3 @@ 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,12 +9,6 @@
 
 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 {
@@ -52,10 +46,8 @@ struct PlayerData {
 	std::vector<IgnoreData> ignoredPlayers;
 	eGameMasterLevel gmLevel = static_cast<eGameMasterLevel>(0); // CIVILLIAN
 	bool isFTP = false;
-	bool isLogin = false;
 };
 
-
 struct TeamData {
 	TeamData();
 	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
@@ -70,12 +62,10 @@ class PlayerContainer {
 public:
 	void Initialize();
 	void InsertPlayer(Packet* packet);
-	void ScheduleRemovePlayer(Packet* packet);
-	void RemovePlayer(const LWOOBJID playerID);
+	void RemovePlayer(Packet* packet);
 	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);
@@ -83,7 +73,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() const { return m_Players; };
+	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() { return m_Players; };
 
 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -98,19 +88,12 @@ public:
 	LWOOBJID GetId(const std::u16string& playerName);
 	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
 	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
-	const TeamContainer& GetTeamContainer() { return m_TeamContainer; }
-	std::vector<TeamData*>& GetTeamsMut() { return m_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;
-	TeamContainer m_TeamContainer{};
+	std::vector<TeamData*> mTeams;
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
-	std::map<LWOOBJID, float> m_PlayersToRemove;
 	uint32_t m_MaxNumberOfBestFriends = 5;
 	uint32_t m_MaxNumberOfFriends = 50;
 	uint32_t m_PlayerCount = 0;

dCommon/Amf3.h

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

dCommon/BinaryIO.cpp

@@ -2,25 +2,16 @@
 #include <string>
 
 //For reading null-terminated strings
-template<typename StringType>
-StringType ReadString(std::istream& instream) {
-	StringType toReturn{};
-	typename StringType::value_type buffer{};
+std::string BinaryIO::ReadString(std::istream& instream) {
+	std::string toReturn;
+	char buffer;
 
 	BinaryIO::BinaryRead(instream, buffer);
 
 	while (buffer != 0x00) {
 		toReturn += buffer;
-		BinaryIO::BinaryRead(instream, buffer);
+		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,8 +65,6 @@ 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,6 +37,7 @@ 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)
@@ -69,5 +70,6 @@ else ()
 endif ()
 
 target_link_libraries(dCommon
+	PUBLIC magic_enum::magic_enum
 	PRIVATE ZLIB::ZLIB bcrypt tinyxml2
 	INTERFACE dDatabase)

dCommon/FdbToSqlite.cpp

@@ -65,14 +65,13 @@ 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);
 
-	const auto readString = BinaryIO::ReadU8String(cdClientBuffer);
+	auto readString = BinaryIO::ReadString(cdClientBuffer);
 
 	cdClientBuffer.seekg(prevPosition);
-	return GeneralUtils::Latin1ToUTF8(readString);
+	return readString;
 }
 
 int32_t FdbToSqlite::Convert::SeekPointer(std::istream& cdClientBuffer) {

dCommon/GeneralUtils.cpp

@@ -7,10 +7,6 @@
 #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()) {
@@ -171,15 +167,6 @@ 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) {
@@ -188,9 +175,9 @@ std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const si
 	ret.reserve(newSize);
 
 	for (size_t i = 0; i < newSize; ++i) {
-		const auto u = string[i];
+		const char16_t u = string[i];
 		if (IsLeadSurrogate(u) && (i + 1) < newSize) {
-			const auto next = string[i + 1];
+			const char16_t next = string[i + 1];
 			if (IsTrailSurrogate(next)) {
 				i += 1;
 				const char32_t cp = 0x10000
@@ -304,12 +291,11 @@ 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)) {
-		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));
+        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.
@@ -331,17 +317,6 @@ 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,14 +51,6 @@ 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
@@ -201,10 +193,6 @@ 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

@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 
-#include "magic_enum.hpp"
+#include <magic_enum/magic_enum.hpp>
 
 namespace MessageType {
 	enum class Game : uint16_t {
@@ -957,7 +957,6 @@ 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,
@@ -1254,7 +1253,6 @@ 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,
@@ -1603,17 +1601,12 @@ namespace MessageType {
 		UPDATE_FORGED_ITEM = 1768,
 		CAN_ITEMS_BE_REFORGED = 1769,
 		NOTIFY_CLIENT_RAIL_START_FAILED = 1771,
-		GET_IS_ON_RAIL = 1772,
-
-		// DLU CUSTOM GAME MESSAGES, DO NOT NETWORK OR SEND TO CLIENTS (it wont do anything bad but still dont do it >:( )
-		CLEAR_SESSION_FLAGS = 2000,
-		SET_RETROACTIVE_FLAGS = 2001,
-		GAME_MESSAGES_END,
+		GET_IS_ON_RAIL = 1772
 	};
 }
 
 template <>
 struct magic_enum::customize::enum_range<MessageType::Game> {
 	static constexpr int min = 0;
-	static constexpr int max = static_cast<int>(MessageType::Game::GAME_MESSAGES_END) - 1;
+	static constexpr int max = 1772;
 };

dCommon/dEnums/MessageType/World.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 
-#include "magic_enum.hpp"
+#include <magic_enum/magic_enum.hpp>
 
 namespace MessageType {
 	enum class World : uint32_t {

dCommon/dEnums/StringifiedEnum.h

@@ -2,7 +2,7 @@
 #define __STRINGIFIEDENUM_H__
 
 #include <string>
-#include "magic_enum.hpp"
+#include <magic_enum/magic_enum.hpp>
 
 namespace StringifiedEnum {
 	template<typename T>

dCommon/dEnums/eHTTPMethod.h

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

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

dCommon/dEnums/eInventoryType.h

@@ -5,7 +5,7 @@
 
 #include <cstdint>
 
-#include "magic_enum.hpp"
+#include <magic_enum/magic_enum.hpp>
 
 static const uint8_t NUMBER_OF_INVENTORIES = 17;
 /**

dCommon/dEnums/eReplicaComponentType.h

@@ -62,7 +62,7 @@ enum class eReplicaComponentType : uint32_t {
 	SOUND_AMBIENT_2D,
 	SOUND_AMBIENT_3D,
 	PRECONDITION,
-	FLAG,
+	PLAYER_FLAG,
 	CUSTOM_BUILD_ASSEMBLY,
 	BASE_COMBAT_AI,
 	MODULE_ASSEMBLY,

dDatabase/CDClientDatabase/CDClientTables/CDPlayerFlagsTable.cpp

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

dDatabase/CDClientDatabase/CDClientTables/CDPlayerFlagsTable.h

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

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

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

dDatabase/CMakeLists.txt

@@ -2,12 +2,6 @@ add_subdirectory(CDClientDatabase)
 add_subdirectory(GameDatabase)
 
 add_library(dDatabase STATIC "MigrationRunner.cpp")
-
-add_custom_target(conncpp_dylib
-	${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${PROJECT_BINARY_DIR})
-
-add_dependencies(dDatabase conncpp_dylib)
-
 target_include_directories(dDatabase PUBLIC ".")
 target_link_libraries(dDatabase
-	PUBLIC dDatabaseCDClient dDatabaseGame)
+	PUBLIC magic_enum::magic_enum dDatabaseCDClient dDatabaseGame)

dDatabase/GameDatabase/CMakeLists.txt

@@ -8,12 +8,6 @@ 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})
@@ -22,14 +16,13 @@ endforeach()
 
 add_library(dDatabaseGame STATIC ${DDATABASE_GAMEDATABASE_SOURCES})
 target_include_directories(dDatabaseGame PUBLIC "."
-	"ITables" PRIVATE "MySQL" "SQLite" "TestSQL"
+	"ITables" PRIVATE "MySQL" "TestSQL"
 	"${PROJECT_SOURCE_DIR}/dCommon"
 	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
 )
-
 target_link_libraries(dDatabaseGame
-	INTERFACE dCommon
-	PRIVATE sqlite3 MariaDB::ConnCpp)
+	PUBLIC MariaDB::ConnCpp
+	INTERFACE dCommon)
 
 # Glob together all headers that need to be precompiled
 file(

dDatabase/GameDatabase/Database.cpp

@@ -2,12 +2,8 @@
 #include "Game.h"
 #include "dConfig.h"
 #include "Logger.h"
-#include "DluAssert.h"
-
-#include "SQLiteDatabase.h"
 #include "MySQLDatabase.h"
-
-#include <ranges>
+#include "DluAssert.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
@@ -15,33 +11,13 @@ 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;
 	}
 
-	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 = new MySQLDatabase();
 	database->Connect();
 }
 

dDatabase/GameDatabase/Database.h

@@ -12,6 +12,4 @@ 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,8 +26,13 @@
 #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 (std::exception& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
+#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (sql::SQLException& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
 #else
 #  define DLU_SQL_TRY_CATCH_RETHROW(x) x
 #endif // _DEBUG
@@ -45,6 +50,7 @@ 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,8 +36,6 @@ 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{};
-		float tertiaryScore{};
+		uint32_t tertiaryScore{};
 		uint32_t numWins{};
 		uint32_t numTimesPlayed{};
 		uint32_t ranking{};

dDatabase/GameDatabase/ITables/IServers.h

@@ -9,11 +9,10 @@ public:
 	struct MasterInfo {
 		std::string ip;
 		uint32_t port{};
-		std::string password{};
 	};
 
 	// Set the master server ip and port.
-	virtual void SetMasterInfo(const MasterInfo& info) = 0;
+	virtual void SetMasterIp(const std::string_view ip, const uint32_t port) = 0;
 
 	// Get the master server info.
 	virtual std::optional<MasterInfo> GetMasterInfo() = 0;

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -14,7 +14,6 @@ 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
@@ -68,7 +67,7 @@ void MySQLDatabase::ExecuteCustomQuery(const std::string_view query) {
 
 sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& query) {
 	if (!con) {
-		Database::Get()->Connect();
+		Connect();
 		LOG("Trying to reconnect to MySQL");
 	}
 
@@ -77,7 +76,7 @@ sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& quer
 
 		con = nullptr;
 
-		Database::Get()->Connect();
+		Connect();
 		LOG("Trying to reconnect to MySQL from invalid or closed connection");
 	}
 

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -30,6 +30,7 @@ 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;
@@ -96,7 +97,7 @@ public:
 	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 SetMasterInfo(const IServers::MasterInfo& info) 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;
@@ -124,8 +125,6 @@ public:
 	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,8 +39,3 @@ 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/Property.cpp

@@ -56,7 +56,6 @@ std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(co
 			params.playerId
 		);
 		if (count->next()) {
-			if (!result) result = IProperty::PropertyEntranceResult();
 			result->totalEntriesMatchingQuery = count->getUInt("count");
 		}
 	} else {
@@ -110,13 +109,11 @@ 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/MySQL/Tables/Servers.cpp

@@ -1,14 +1,14 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::SetMasterInfo(const MasterInfo& info) {
+void MySQLDatabase::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("TRUNCATE TABLE servers;");
-	ExecuteInsert("INSERT INTO `servers` (`name`, `ip`, `port`, `state`, `version`, `master_password`) VALUES ('master', ?, ?, 0, 171022, ?)", info.ip, info.port, info.password);
+	ExecuteInsert("INSERT INTO `servers` (`name`, `ip`, `port`, `state`, `version`) VALUES ('master', ?, ?, 0, 171022)", ip, port);
 }
 
 std::optional<IServers::MasterInfo> MySQLDatabase::GetMasterInfo() {
-	auto result = ExecuteSelect("SELECT ip, port, master_password FROM servers WHERE name='master' LIMIT 1;");
+	auto result = ExecuteSelect("SELECT ip, port FROM servers WHERE name='master' LIMIT 1;");
 
 	if (!result->next()) {
 		return std::nullopt;
@@ -18,7 +18,6 @@ std::optional<IServers::MasterInfo> MySQLDatabase::GetMasterInfo() {
 
 	toReturn.ip = result->getString("ip").c_str();
 	toReturn.port = result->getInt("port");
-	toReturn.password = result->getString("master_password").c_str();
 
 	return toReturn;
 }

dDatabase/GameDatabase/SQLite/CMakeLists.txt

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

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

@@ -1,270 +0,0 @@
-#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 SetMasterInfo(const IServers::MasterInfo& info) 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-#include "SQLiteDatabase.h"
-
-void SQLiteDatabase::SetMasterInfo(const MasterInfo& info) {
-	// 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`, `master_password`) VALUES ('master', ?, ?, 0, 171022, ?)", info.ip, info.port, info.password);
-}
-
-std::optional<IServers::MasterInfo> SQLiteDatabase::GetMasterInfo() {
-	auto [_, result] = ExecuteSelect("SELECT ip, port, master_password 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");
-	toReturn.password = result.getStringField("master_password");
-
-	return toReturn;
-}

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

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

@@ -1,9 +0,0 @@
-#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,6 +8,10 @@ void TestSQLDatabase::Destroy(std::string source) {
 
 }
 
+sql::PreparedStatement* TestSQLDatabase::CreatePreppedStmt(const std::string& query) {
+	return nullptr;
+}
+
 void TestSQLDatabase::Commit() {
 
 }
@@ -236,7 +240,7 @@ void TestSQLDatabase::InsertNewAccount(const std::string_view username, const st
 
 }
 
-void TestSQLDatabase::SetMasterInfo(const IServers::MasterInfo& info) {
+void TestSQLDatabase::SetMasterIp(const std::string_view ip, const uint32_t port) {
 
 }
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -7,6 +7,7 @@ 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;
@@ -73,7 +74,7 @@ class TestSQLDatabase : public GameDatabase {
 	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 SetMasterInfo(const IServers::MasterInfo& info) 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;
@@ -101,7 +102,6 @@ class TestSQLDatabase : public GameDatabase {
 	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 folder, std::string path) {
+Migration LoadMigration(std::string path) {
 	Migration migration{};
-	std::ifstream file(BinaryPathFinder::GetBinaryDir() / "migrations/" / folder / path);
+	std::ifstream file(BinaryPathFinder::GetBinaryDir() / "migrations/" / path);
 
 	if (file.is_open()) {
 		std::string line;
@@ -34,19 +34,10 @@ Migration LoadMigration(std::string folder, 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/" / migrationFolder).string())) {
-		auto migration = LoadMigration("dlu/" + migrationFolder + "/", entry);
+	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/").string())) {
+		auto migration = LoadMigration("dlu/" + entry);
 
 		if (migration.data.empty()) {
 			continue;
@@ -55,7 +46,7 @@ void MigrationRunner::RunMigrations() {
 		if (Database::Get()->IsMigrationRun(migration.name)) continue;
 
 		LOG("Running migration: %s", migration.name.c_str());
-		if (migration.name == "5_brick_model_sd0.sql") {
+		if (migration.name == "dlu/5_brick_model_sd0.sql") {
 			runSd0Migrations = true;
 		} else {
 			finalSQL.append(migration.data.c_str());
@@ -95,14 +86,10 @@ void MigrationRunner::RunSQLiteMigrations() {
 	cdstmt.execQuery().finalize();
 	cdstmt.finalize();
 
-	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\");");
-	}
+	Database::Get()->CreateMigrationHistoryTable();
 
 	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;
 

dECS/CMakeLists.txt

@@ -0,0 +1,15 @@
+set(gcc_like_cxx "$<COMPILE_LANG_AND_ID:CXX,ARMClang,AppleClang,Clang,GNU,LCC>")
+set(msvc_cxx "$<COMPILE_LANG_AND_ID:CXX,MSVC>")
+
+add_library(dECS STATIC
+    "Core.h"
+    "Iter.h"
+    "Core.cpp"
+    "System.cpp"
+)
+target_include_directories(dECS PUBLIC .)
+target_link_libraries(dECS PRIVATE dCommon magic_enum::magic_enum)
+target_compile_options(dECS PRIVATE
+  "$<${gcc_like_cxx}:$<BUILD_INTERFACE:-Wall;-Wextra>>"
+  "$<${msvc_cxx}:$<BUILD_INTERFACE:/W3>>"
+)

dECS/Core.cpp

@@ -0,0 +1,70 @@
+#include <atomic>
+#include <magic_enum/magic_enum_containers.hpp>
+#include <eReplicaComponentType.h>
+#include "Core.h"
+
+namespace dECS {
+    struct WorldData {
+        using CompSignature = magic_enum::containers::bitset<eReplicaComponentType>;
+        using CompMap = std::unordered_map<LWOOBJID, CompSignature>;
+        using CompStorage = std::unordered_map<eReplicaComponentType, std::unique_ptr<IStorage>>;
+
+        std::atomic<LWOOBJID> nextId = 1;
+        CompMap map;
+        CompStorage data;
+    };
+
+    World::World() : m_World{ std::make_shared<WorldData>() } {};
+
+    Entity World::MakeEntity() {
+        return Entity{ m_World->nextId.fetch_add(1, std::memory_order::relaxed),
+                       m_World };
+    }
+
+    void* Entity::AddComponent(const eReplicaComponentType kind, const StorageConstructor storageConstructor) {
+        if (auto w = m_World.lock()) {
+            // Add to kind signature
+            w->map[m_Id].set(kind, true);
+
+            // Get or add storage
+            auto storageIt = w->data.find(kind);
+            if (storageIt == w->data.cend()) {
+                bool inserted = false;
+                std::tie(storageIt, inserted) = w->data.try_emplace(kind, storageConstructor());
+                if (!inserted) throw "storage emplacement failure";
+            }
+            auto& storage = *storageIt->second;
+
+            // Return reference if already mapped, otherwise add component
+            auto compIt = storage.rowMap.find(m_Id);
+            if (compIt == storage.rowMap.cend()) {
+                const auto curSize = storage.rowMap.size();
+                storage.rowMap.emplace(m_Id, curSize);
+                return storage.emplace_back();
+            }
+            const auto row = compIt->second;
+            return storage.at(row);
+        }
+        return nullptr;
+    }
+
+    const void* Entity::GetComponent(const eReplicaComponentType kind) const {
+        if (auto const w = m_World.lock()) {
+            // Check that the entity has this component
+            if (!w->map[m_Id].test(kind)) return nullptr;
+
+            // Get the location where it's stored
+            const auto& storage = *w->data.at(kind);
+            const auto it = storage.rowMap.find(m_Id);
+            if (it == storage.rowMap.cend()) return nullptr;
+            const auto row = it->second;
+            return storage.at(row);
+        }
+        return nullptr;
+    }
+
+    void* Entity::GetComponent(const eReplicaComponentType kind) {
+        // Casting away const for this overload is safe, if not at all pretty
+        return const_cast<void*>(std::as_const(*this).GetComponent(kind));
+    }
+}

dECS/Core.h

@@ -0,0 +1,180 @@
+#pragma once
+#include <cstdint>
+#include <memory>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+class Component;
+enum class eReplicaComponentType : uint32_t;
+using LWOOBJID = int64_t;
+
+namespace dECS {
+    // template <typename C>
+    // concept IsComponent = std::derived_from<C, Component>;
+
+    // Data structures
+    struct WorldData;
+    class World;
+
+    template <typename... Cs>
+    class System;
+
+    class Entity;
+    struct IStorage;
+
+    template <typename C>
+    class Storage;
+
+    using WorldPtr = std::shared_ptr<WorldData>;
+    using WeakWorldPtr = std::weak_ptr<WorldData>;
+
+    class World {
+    public:
+        World();
+
+        [[nodiscard]]
+        Entity MakeEntity();
+
+        template <typename... Cs>
+        [[nodiscard]]
+        System<Cs...> MakeSystem() {
+            return System<Cs...>{};
+        }
+
+        template <typename... Cs, typename S>
+        [[nodiscard]]
+        System<Cs...> MakeSystem(S&& name) {
+            return System<Cs...>{ std::forward<S>(name) };
+        }
+
+    private:
+        WorldPtr m_World;
+    };
+
+    template <typename... Cs>
+    class System {
+    public:
+        friend System World::MakeSystem<Cs...>();
+
+        template <typename... Ts, typename S>
+        friend System<Ts...> World::MakeSystem(S&&);
+
+        /*template <typename Fn>
+            requires std::is_invocable_r_v<void, Fn(Cs...), ObjId, Cs...>
+        void ForEach(Fn&& f) {
+            for (ObjId i = 0; i < mT.size(); ++i) {
+                auto& c = mT[i];
+                f(i, std::get<Cs>(c)...);
+            }
+        }*/
+
+        template <typename Fn>
+            requires std::is_invocable_r_v<void, Fn(Cs...), Cs...>
+        void ForEach(Fn&& fn) {
+            std::tuple<Cs...> comps; // some sort of iterator that returns a tuple each 'step?'
+            for (size_t i = 0; i < 5; ++i) {
+                fn(std::get<Cs>(comps)...);
+            }
+        }
+
+    private:
+        System() = default;
+
+        template <typename S>
+        explicit System(S&& name)
+            : m_name{ std::forward<S>(name) }
+        {}
+
+        std::string m_name;
+    };
+
+    class Entity {
+    public:
+        friend Entity World::MakeEntity();
+
+        using StorageConstructor = std::function<std::unique_ptr<IStorage>()>;
+
+        [[nodiscard]]
+        constexpr LWOOBJID GetObjectID() const noexcept {
+            return m_Id;
+        }
+
+        [[maybe_unused]]
+        void* AddComponent(eReplicaComponentType, StorageConstructor);
+
+        template <typename C>
+        [[maybe_unused]]
+        C* AddComponent() {
+            return static_cast<C*>(AddComponent(C::ComponentType, std::make_unique<Storage<C>>));
+        }
+
+        [[nodiscard]]
+        const void* GetComponent(eReplicaComponentType) const;
+
+        [[nodiscard]]
+        void* GetComponent(eReplicaComponentType);
+
+        template <typename C>
+        [[nodiscard]]
+        const C* GetComponent() const {
+            return static_cast<const C*>(GetComponent(C::ComponentType));
+        }
+
+        template <typename C>
+        [[nodiscard]]
+        C* GetComponent() {
+            return static_cast<C*>(GetComponent(C::ComponentType));
+        }
+
+    private:
+        Entity(const LWOOBJID id, const WeakWorldPtr world)
+            : m_Id{ id }
+            , m_World { world }
+            {}
+
+        LWOOBJID m_Id;
+
+        WeakWorldPtr m_World;
+    };
+
+    struct IStorage {
+        using RowMap = std::unordered_map<LWOOBJID, size_t>;
+
+        virtual ~IStorage() = default;
+
+        [[nodiscard]]
+        virtual void* at(size_t) = 0;
+
+        [[nodiscard]]
+        virtual const void* at(size_t) const = 0;
+
+        [[nodiscard]]
+        virtual void* emplace_back() = 0;
+
+        RowMap rowMap;
+    };
+
+    template <typename C>
+    class Storage : public IStorage {
+    public:
+        [[nodiscard]]
+        void* at(const size_t index) override {
+            return static_cast<void*>(&m_Vec.at(index));
+        }
+
+        [[nodiscard]]
+        const void* at(const size_t index) const override {
+            return static_cast<const void*>(&m_Vec.at(index));
+        }
+
+        [[nodiscard]]
+        void* emplace_back() override {
+            return static_cast<void*>(&m_Vec.emplace_back());
+        }
+
+    private:
+        std::vector<C> m_Vec;
+    };
+}

dECS/Iter.h

@@ -0,0 +1,12 @@
+#include "Core.h"
+
+namespace dECS {
+    class Iter {
+    public:
+        [[nodiscard]]
+        bool Next();
+
+    private:
+        WeakWorldPtr m_World;
+    };
+}

dECS/System.cpp

@@ -0,0 +1,52 @@
+#include "PetComponent.h"
+#include "MovementAIComponent.h"
+#include "MissionComponent.h"
+#include "eMissionState.h"
+
+using Pet = PetComponent;
+using Mission = MissionComponent;
+using MovementAI = MovementAIComponent;
+
+struct Position : NiPoint3 {};
+struct Treasure {};
+
+namespace decs {
+    template <typename... Cs>
+    class System {
+    public:
+        template <typename Fn>
+        void each(Fn&& fn) {
+            fn();
+        }
+    };
+
+    class Scene {
+    public:
+        template <typename... Cs>
+        System<Cs...> system() {
+            return System<Cs...>{};
+        }
+    };
+}
+
+void run() {
+    auto scene = decs::Scene{};
+
+    scene.system<Pet>()
+        .each([](Pet& pet) {
+
+        });
+
+    scene.system<Pet, MovementAI>()
+        .each([](Pet& pet, MovementAI& move) {
+
+        });
+
+    scene.system<Pet, const Mission, const Position>()
+        .each([](Pet& pet, Mission const& mission, Position const& pos) {
+            auto const digUnlocked = mission.GetMissionState(842) == eMissionState::COMPLETE;
+            auto const treasurePos = PetDigServer::GetClosestTreasure(pos);
+
+
+        });
+}

dGame/CMakeLists.txt

@@ -26,6 +26,7 @@ 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

@@ -21,8 +21,6 @@
 #include "eObjectBits.h"
 #include "eGameMasterLevel.h"
 #include "ePlayerFlag.h"
-#include "CDPlayerFlagsTable.h"
-#include "FlagComponent.h"
 
 Character::Character(uint32_t id, User* parentUser) {
 	//First load the name, etc:
@@ -38,7 +36,7 @@ Character::~Character() {
 	m_ParentUser = nullptr;
 }
 
-void Character::UpdateInfoFromDatabase(bool clearSessionFlags) {
+void Character::UpdateInfoFromDatabase() {
 	auto charInfo = Database::Get()->GetCharacterInfo(m_ID);
 
 	if (charInfo) {
@@ -66,17 +64,10 @@ void Character::UpdateInfoFromDatabase(bool clearSessionFlags) {
 
 	m_OurEntity = nullptr;
 	m_BuildMode = false;
-
-	// This is not done through a game message because our current implementation does this at a point
-	// in time where an Entity does not exist, so there is no FlagComponent to handle the msg.
-	if (clearSessionFlags) {
-		FlagComponent::ClearSessionFlags(m_Doc);
-		WriteToDatabase();
-	}
 }
 
-void Character::UpdateFromDatabase(bool clearSessionFlags) {
-	UpdateInfoFromDatabase(clearSessionFlags);
+void Character::UpdateFromDatabase() {
+	UpdateInfoFromDatabase();
 }
 
 void Character::DoQuickXMLDataParse() {
@@ -205,6 +196,25 @@ void Character::DoQuickXMLDataParse() {
 		character->QueryAttribute("lzrz", &m_OriginalRotation.z);
 		character->QueryAttribute("lzrw", &m_OriginalRotation.w);
 	}
+
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
+	if (flags) {
+		auto* currentChild = flags->FirstChildElement();
+		while (currentChild) {
+			const auto* temp = currentChild->Attribute("v");
+			const auto* id = currentChild->Attribute("id");
+			if (temp && id) {
+				uint32_t index = 0;
+				uint64_t value = 0;
+
+				index = std::stoul(id);
+				value = std::stoull(temp);
+
+				m_PlayerFlags.insert(std::make_pair(index, value));
+			}
+			currentChild = currentChild->NextSiblingElement();
+		}
+	}
 }
 
 void Character::UnlockEmote(int emoteID) {
@@ -221,12 +231,6 @@ void Character::SetBuildMode(bool buildMode) {
 }
 
 void Character::SaveXMLToDatabase() {
-	// Check that we can actually _save_ before saving
-	if (!m_OurEntity) {
-		LOG("%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
-		return;
-	}
-
 	//For metrics, we'll record the time it took to save:
 	auto start = std::chrono::system_clock::now();
 
@@ -265,8 +269,41 @@ void Character::SaveXMLToDatabase() {
 		character->LinkEndChild(emotes);
 	}
 
+	//Export our flags:
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
+	if (!flags) {
+		flags = m_Doc.NewElement("flag"); //Create a flags tag if we don't have one
+		m_Doc.FirstChildElement("obj")->LinkEndChild(flags); //Link it to the obj tag so we can find next time
+	}
+
+	flags->DeleteChildren(); //Clear it if we have anything, so that we can fill it up again without dupes
+	for (std::pair<uint32_t, uint64_t> flag : m_PlayerFlags) {
+		auto* f = m_Doc.NewElement("f");
+		f->SetAttribute("id", flag.first);
+
+		//Because of the joy that is tinyxml2, it doesn't offer a function to set a uint64 as an attribute.
+		//Only signed 64-bits ints would work.
+		std::string v = std::to_string(flag.second);
+		f->SetAttribute("v", v.c_str());
+
+		flags->LinkEndChild(f);
+	}
+
+	// Prevents the news feed from showing up on world transfers
+	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
+		auto* s = m_Doc.NewElement("s");
+		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
+		flags->LinkEndChild(s);
+	}
+
 	SaveXmlRespawnCheckpoints();
 
+	//Call upon the entity to update our xmlDoc:
+	if (!m_OurEntity) {
+		LOG("%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		return;
+	}
+
 	m_OurEntity->UpdateXMLDoc(m_Doc);
 
 	WriteToDatabase();
@@ -277,6 +314,23 @@ void Character::SaveXMLToDatabase() {
 	LOG("%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
 }
 
+void Character::SetIsNewLogin() {
+	// If we dont have a flag element, then we cannot have a s element as a child of flag.
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
+	if (!flags) return;
+
+	auto* currentChild = flags->FirstChildElement();
+	while (currentChild) {
+		auto* nextChild = currentChild->NextSiblingElement();
+		if (currentChild->Attribute("si")) {
+			flags->DeleteChild(currentChild);
+			LOG("Removed isLoggedIn flag from character %i:%s, saving character to database", GetID(), GetName().c_str());
+			WriteToDatabase();
+		}
+		currentChild = nextChild;
+	}
+}
+
 void Character::WriteToDatabase() {
 	//Dump our xml into m_XMLData:
 	tinyxml2::XMLPrinter printer(0, true, 0);
@@ -286,6 +340,75 @@ void Character::WriteToDatabase() {
 	Database::Get()->UpdateCharacterXml(m_ID, printer.CStr());
 }
 
+void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
+	// If the flag is already set, we don't have to recalculate it
+	if (GetPlayerFlag(flagId) == value) return;
+
+	if (value) {
+		// Update the mission component:
+		auto* player = Game::entityManager->GetEntity(m_ObjectID);
+
+		if (player != nullptr) {
+			auto* missionComponent = player->GetComponent<MissionComponent>();
+
+			if (missionComponent != nullptr) {
+				missionComponent->Progress(eMissionTaskType::PLAYER_FLAG, flagId);
+			}
+		}
+	}
+
+	// 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;
+		}
+	} 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));
+
+	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
+		return (it->second & shiftedValue) != 0;
+	}
+
+	return false; //by def, return false.
+}
+
+void Character::SetRetroactiveFlags() {
+	// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
+	if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
+		SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
+	}
+}
+
 void Character::SaveXmlRespawnCheckpoints() {
 	//Export our respawn points:
 	auto* points = m_Doc.FirstChildElement("obj")->FirstChildElement("res");
@@ -342,11 +465,7 @@ void Character::OnZoneLoad() {
 	if (missionComponent != nullptr) {
 		// Fix the monument race flag
 		if (missionComponent->GetMissionState(319) >= eMissionState::READY_TO_COMPLETE) {
-			GameMessages::SetFlag setFlag{};
-			setFlag.target = m_ObjectID;
-			setFlag.iFlagId = ePlayerFlag::AG_FINISH_LINE_BUILT;
-			setFlag.bFlag = true;
-			SEND_ENTITY_MSG(setFlag);
+			SetPlayerFlag(ePlayerFlag::AG_FINISH_LINE_BUILT, true);
 		}
 	}
 

dGame/Character.h

@@ -31,7 +31,7 @@ public:
 	 */
 	void WriteToDatabase();
 	void SaveXMLToDatabase();
-	void UpdateFromDatabase(bool clearSessionFlags = false);
+	void UpdateFromDatabase();
 
 	void SaveXmlRespawnCheckpoints();
 	void LoadXmlRespawnCheckpoints();
@@ -40,6 +40,15 @@ public:
 	const tinyxml2::XMLDocument& GetXMLDoc() const { return m_Doc; }
 	void _setXmlDoc(tinyxml2::XMLDocument& doc) { doc.DeepCopy(&m_Doc); }
 
+	/**
+	 * Out of abundance of safety and clarity of what this saves, this is its own function.
+	 *
+	 * Clears the s element from the flag element and saves the xml to the database.  Used to prevent the news
+	 * feed from showing up on world transfers.
+	 *
+	 */
+	void SetIsNewLogin();
+
 	/**
 	 * Gets the database ID of the character
 	 * @return the database ID of the character
@@ -401,11 +410,32 @@ public:
 	 */
 	void UnlockEmote(int emoteID);
 
+	/**
+	 * Sets a flag for the character, indicating certain parts of the game that have been interacted with. Not to be
+	 * confused with the permissions
+	 * @param flagId the ID of the flag to set
+	 * @param value the value to set for the flag
+	 */
+	void SetPlayerFlag(uint32_t flagId, bool value);
+
+	/**
+	 * Gets the value for a certain character flag
+	 * @param flagId the ID of the flag to get a value for
+	 * @return the value of the flag given the ID (the default is false, obviously)
+	 */
+	bool GetPlayerFlag(uint32_t flagId) const;
+
 	/**
 	 * Notifies the character that they're now muted
 	 */
 	void SendMuteNotice() const;
 
+	/**
+	 * Sets any flags that are meant to have been set that may not have been set due to them being
+	 * missing in a previous patch.
+	 */
+	void SetRetroactiveFlags();
+
 	/**
 	 * Get the equipped items for this character, only used for character creation
 	 * @return the equipped items for this character on world load
@@ -435,7 +465,7 @@ public:
 	void _setXmlData(const std::string& xmlData) { m_XMLData = xmlData; }
 
 private:
-	void UpdateInfoFromDatabase(bool clearSessionFlags);
+	void UpdateInfoFromDatabase();
 	/**
 	 * The ID of this character. First 32 bits of the ObjectID.
 	 */
@@ -590,6 +620,11 @@ private:
 	 */
 	uint64_t m_LastLogin{};
 
+	/**
+	 * The gameplay flags this character has (not just true values)
+	 */
+	std::unordered_map<uint32_t, uint64_t> m_PlayerFlags;
+
 	/**
 	 * The character XML belonging to this character
 	 */

dGame/Entity.cpp

@@ -84,7 +84,6 @@
 #include "GhostComponent.h"
 #include "AchievementVendorComponent.h"
 #include "VanityUtilities.h"
-#include "FlagComponent.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -97,7 +96,6 @@
 #include "CDScriptComponentTable.h"
 #include "CDSkillBehaviorTable.h"
 #include "CDZoneTableTable.h"
-#include "StringifiedEnum.h"
 
 #include <ranges>
 
@@ -141,8 +139,6 @@ Entity::Entity(const LWOOBJID& objectID, EntityInfo info, User* parentUser, Enti
 
 		PlayerManager::AddPlayer(this);
 	}
-
-	RegisterMsg(MessageType::Game::REQUEST_SERVER_OBJECT_INFO, this, &Entity::OnRequestServerObjectInfo);
 }
 
 Entity::~Entity() {
@@ -390,9 +386,6 @@ void Entity::Initialize() {
 		if (m_Character) {
 			comp->LoadFromXml(m_Character->GetXMLDoc());
 		} else {
-			// extraInfo overrides. Client ORs the database smashable and the luz smashable.
-			comp->SetIsSmashable(comp->GetIsSmashable() | isSmashable);
-
 			if (componentID > 0) {
 				std::vector<CDDestructibleComponent> destCompData = destCompTable->Query([=](CDDestructibleComponent entry) { return (entry.id == componentID); });
 
@@ -427,6 +420,9 @@ void Entity::Initialize() {
 						comp->SetMinCoins(currencyValues[0].minvalue);
 						comp->SetMaxCoins(currencyValues[0].maxvalue);
 					}
+
+					// extraInfo overrides. Client ORs the database smashable and the luz smashable.
+					comp->SetIsSmashable(comp->GetIsSmashable() | isSmashable);
 				}
 			} else {
 				comp->SetHealth(1);
@@ -486,8 +482,6 @@ void Entity::Initialize() {
 		AddComponent<CharacterComponent>(m_Character, systemAddress)->LoadFromXml(m_Character->GetXMLDoc());
 
 		AddComponent<GhostComponent>();
-
-		AddComponent<FlagComponent>()->LoadFromXml(m_Character->GetXMLDoc());
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY) > 0 || m_Character) {
@@ -781,12 +775,6 @@ 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()) {
@@ -866,9 +854,6 @@ 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;
 	}
 }
 
@@ -877,9 +862,6 @@ 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);
 	}
 }
 
@@ -1511,27 +1493,6 @@ 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);
 }
@@ -1571,7 +1532,7 @@ void Entity::Kill(Entity* murderer, const eKillType killType) {
 
 	m_DieCallbacks.clear();
 
-	//お前はもう死んでいる
+	//OMAI WA MOU, SHINDERIU
 
 	GetScript()->OnDie(this, murderer);
 
@@ -2214,7 +2175,7 @@ void Entity::SetRespawnRot(const NiQuaternion& rotation) {
 
 int32_t Entity::GetCollisionGroup() const {
 	for (const auto* component : m_Components | std::views::values) {
-		auto* compToCheck = dynamic_cast<const PhysicsComponent*>(component);
+		auto* compToCheck = dynamic_cast<const PhysicsComponent*>(component);	
 		if (compToCheck) {
 			return compToCheck->GetCollisionGroup();
 		}
@@ -2222,125 +2183,3 @@ int32_t Entity::GetCollisionGroup() const {
 
 	return 0;
 }
-
-bool Entity::HandleMsg(GameMessages::GameMsg& msg) const {
-	bool handled = false;
-	const auto [beg, end] = m_MsgHandlers.equal_range(msg.msgId);
-	for (auto it = beg; it != end; ++it) {
-		if (it->second) handled |= it->second(msg);
-	}
-
-	return handled;
-}
-
-void Entity::RegisterMsg(const MessageType::Game msgId, std::function<bool(GameMessages::GameMsg&)> handler) {
-	m_MsgHandlers.emplace(msgId, handler);
-}
-
-bool Entity::OnRequestServerObjectInfo(GameMessages::GameMsg& msg) {
-	auto& request = static_cast<GameMessages::RequestServerObjectInfo&>(msg);
-
-	AMFArrayValue response;
-
-	response.Insert("visible", true);
-	response.Insert("objectID", std::to_string(request.targetForReport));
-	response.Insert("serverInfo", true);
-
-	auto& data = *response.InsertArray("data");
-
-	auto& objectDetails = data.PushDebug("Object Details");
-
-	objectDetails.PushDebug<AMFStringValue>("Name") = "";
-	objectDetails.PushDebug<AMFIntValue>("Template ID(LOT)") = GetLOT();
-	objectDetails.PushDebug<AMFStringValue>("Object ID") = std::to_string(GetObjectID());
-	objectDetails.PushDebug<AMFStringValue>("Type") = "";
-
-	if (!m_ParentEntity) {
-		objectDetails.PushDebug<AMFBoolValue>("Has a parent object") = false;
-	} else {
-		objectDetails.PushDebug<AMFStringValue>("Parent's Object ID") = std::to_string(m_ParentEntity->GetObjectID());
-	}
-
-	if (!m_ChildEntities.empty()) {
-		if (!request.bVerbose) {
-			objectDetails.PushDebug("Child Objects (shown only in high-detail reports)");
-		} else {
-			auto& childDetails = objectDetails.PushDebug("Child Objects");
-			for (const auto* childObj : m_ChildEntities) {
-				std::stringstream stream;
-				stream << "Child ID: " << childObj->GetObjectID();
-				childDetails.PushDebug<AMFStringValue>(stream.str().c_str()) = std::to_string(childObj->GetObjectID());
-			}
-		}
-	}
-
-	if (!request.bVerbose) {
-		objectDetails.PushDebug("Component Information (shown only in high-detail reports)");
-		objectDetails.PushDebug("Memory Usage Info (shown only in high-detail reports)");
-		objectDetails.PushDebug("Registered Messages (shown only in high-detail reports)");
-	} else {
-		auto& componentInfo = objectDetails.PushDebug("Component Information");
-		for (const auto& [componentType, component] : m_Components) {
-			std::stringstream stream;
-			const auto componentName = StringifiedEnum::ToString(componentType);
-			stream << componentName.data() << ", Active";
-
-			auto& currentCompInfo = componentInfo.PushDebug(stream.str().c_str());
-			currentCompInfo.PushDebug<AMFIntValue>("Type ID") = GeneralUtils::ToUnderlying(componentType);
-
-			auto& memUsageInfo = objectDetails.PushDebug("Memory Usage Info");
-			memUsageInfo.PushDebug<AMFIntValue>("Static size of this GameObject") = sizeof(Entity);
-			int staticSizeObject{};
-
-			objectDetails.PushDebug<AMFBoolValue>("Is a human player") = IsPlayer();
-
-			if (!m_Groups.empty() && request.bVerbose) {
-				auto& groupInfo = objectDetails.PushDebug("Group Info");
-				for (const auto& group : m_Groups) {
-					groupInfo.PushDebug<AMFStringValue>(group) = "";
-				}
-			}
-			LWOOBJID upper32Bits = GetObjectID();
-			upper32Bits >>= 32;
-			if (((upper32Bits & 0xfc000000) == 0x4000000) && ((upper32Bits & 0xffffc000) != 0x4000000)) {
-				objectDetails.PushDebug<AMFStringValue>("Object ID Type") = "Spawned";
-			} else if (!(upper32Bits & 0xf8000000U)) {
-				if ((upper32Bits & 0xffffc000U) == 0x4000000) {
-					objectDetails.PushDebug<AMFStringValue>("Object ID Type") = "Local";
-				} else if (!(upper32Bits & 0xfc000000U)) {
-					objectDetails.PushDebug<AMFStringValue>("Object ID Type") = "Static";
-				}
-			} else {
-				objectDetails.PushDebug<AMFStringValue>("Object ID Type") = "Global";
-			}
-			LWOOBJID spawnerId{ LWOOBJID_EMPTY };
-			if (m_Spawner) {
-				objectDetails.PushDebug<AMFStringValue>("Spawner's Object ID") = std::to_string(m_Spawner->m_Info.spawnerID);
-			}
-
-			objectDetails.PushDebug<AMFStringValue>("Precondition(s)");
-
-			objectDetails.PushDebug<AMFIntValue>("Components Waiting") = 0;
-
-			if (!request.bVerbose) {
-				objectDetails.PushDebug("Config Data (shown only in high-detail reports)");
-			} else {
-				auto& configInfo = objectDetails.PushDebug("Config Data");
-				for (const auto& setting : GetSettings()) {
-					configInfo.PushDebug<AMFStringValue>(GeneralUtils::UTF16ToWTF8(setting->GetKey())) = setting->GetValueAsString();
-				}
-			}
-		}
-	}
-
-	GameMessages::GetObjectReportInfo report;
-	report.target = request.targetForReport;
-	report.bVerbose = request.bVerbose;
-	report.info = &data;
-	SEND_ENTITY_MSG(report);
-
-	auto* player = Game::entityManager->GetEntity(request.clientId);
-	if (player) GameMessages::SendUIMessageServerToSingleClient("ToggleObjectDebugger", response, player->GetSystemAddress());
-
-	return true;
-}

dGame/Entity.h

@@ -13,18 +13,6 @@
 #include "eKillType.h"
 #include "Observable.h"
 
-namespace GameMessages {
-	struct GameMsg;
-	struct ActivityNotify;
-	struct ShootingGalleryFire;
-	struct ChildLoaded;
-	struct PlayerResurrectionFinished;
-};
-
-namespace MessageType {
-	enum class Game : uint16_t;
-}
-
 namespace Loot {
 	class Info;
 };
@@ -222,10 +210,6 @@ 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);
@@ -321,16 +305,6 @@ public:
 	// Scale will only be communicated to the client when the construction packet is sent
 	void SetScale(const float scale) { m_Scale = scale; };
 
-	void RegisterMsg(const MessageType::Game msgId, std::function<bool(GameMessages::GameMsg&)> handler);
-
-	bool HandleMsg(GameMessages::GameMsg& msg) const;
-
-	bool OnRequestServerObjectInfo(GameMessages::GameMsg& msg);
-
-	void RegisterMsg(const MessageType::Game msgId, auto* self, const auto handler) {
-		RegisterMsg(msgId, std::bind(handler, self, std::placeholders::_1));
-	}
-
 	/**
 	 * @brief The observable for player entity position updates.
 	 */
@@ -389,11 +363,6 @@ 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;
-
-	std::multimap<MessageType::Game, std::function<bool(GameMessages::GameMsg&)>> m_MsgHandlers;
 };
 
 /**

dGame/EntityManager.cpp

@@ -419,7 +419,7 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 
 void EntityManager::SerializeEntity(Entity* entity) {
 	if (!entity) return;
-
+	
 	EntityManager::SerializeEntity(*entity);
 }
 
@@ -604,23 +604,3 @@ void EntityManager::FireEventServerSide(Entity* origin, std::string args) {
 bool EntityManager::IsExcludedFromGhosting(LOT lot) {
 	return std::find(m_GhostingExcludedLOTs.begin(), m_GhostingExcludedLOTs.end(), lot) != m_GhostingExcludedLOTs.end();
 }
-
-#ifndef _DEBUG
-bool EntityManager::SendMsg(GameMessages::GameMsg& msg, std::source_location location) {
-	if (msg.target == LWOOBJID_EMPTY) {
-		LOG("Attempted to send message to empty target from funcion %s:%d", location.function_name(), location.line());
-	}
-	bool bRet = false;
-	auto* entity = GetEntity(msg.target);
-	if (entity) bRet = entity->HandleMsg(msg);
-	return bRet;
-}
-#else
-bool EntityManager::SendMsg(GameMessages::GameMsg& msg) {
-	bool bRet = false;
-	auto* entity = GetEntity(msg.target);
-	if (entity) bRet = entity->HandleMsg(msg);
-	return bRet;
-}
-#endif
-

dGame/EntityManager.h

@@ -2,20 +2,12 @@
 #define ENTITYMANAGER_H
 
 #include <map>
-#include <source_location>
 #include <stack>
 #include <vector>
 #include <unordered_map>
 
 #include "dCommonVars.h"
 
-// Convenience macro to send a message to the entity manager
-#define SEND_ENTITY_MSG(msg) Game::entityManager->SendMsg(msg)
-
-namespace GameMessages {
-	struct GameMsg;	
-};
-
 class Entity;
 class EntityInfo;
 class Player;
@@ -80,14 +72,6 @@ public:
 	const bool GetHardcoreDropinventoryOnDeath() { return m_HardcoreDropinventoryOnDeath; };
 	const uint32_t GetHardcoreUscoreEnemiesMultiplier() { return m_HardcoreUscoreEnemiesMultiplier; };
 
-	// Sends a message to be handled by the receiving entity
-
-#ifndef _DEBUG
-	bool SendMsg(GameMessages::GameMsg& msg, std::source_location location = std::source_location::current());
-#else
-	bool SendMsg(GameMessages::GameMsg& msg);
-#endif
-
 private:
 	void SerializeEntities();
 	void KillEntities();

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));
+			entry.push_back(new LDFData<float>(u"HitPercentage", (leaderboardEntry.tertiaryScore / 100.0f)));
 			// 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;
+			return entry.charId == data.friendID || entry.charId == relatedPlayer;
 			});
-		if (res != friendOfPlayer.cend() || entry.charId == relatedPlayer) {
+		if (res != friendOfPlayer.cend()) {
 			friendsLeaderboard.push_back(entry);
 		}
 	}

dGame/UserManager.cpp

@@ -197,10 +197,6 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
 			skillComponent->Reset();
 		}
 
-		GameMessages::ClearSessionFlags msg{};
-		msg.target = chars[i]->GetObjectID();
-		SEND_ENTITY_MSG(msg);
-
 		Game::entityManager->DestroyEntity(chars[i]->GetEntity());
 
 		chars[i]->SaveXMLToDatabase();
@@ -214,7 +210,8 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
 
 	for (const auto& characterId : Database::Get()->GetAccountCharacterIds(u->GetAccountID())) {
 		Character* character = new Character(characterId, u);
-		character->UpdateFromDatabase(true);
+		character->UpdateFromDatabase();
+		character->SetIsNewLogin();
 		chars.push_back(character);
 	}
 

dGame/dBehaviors/CMakeLists.txt

@@ -55,7 +55,7 @@ set(DGAME_DBEHAVIORS_SOURCES "AirMovementBehavior.cpp"
 	"VerifyBehavior.cpp")
 
 add_library(dBehaviors OBJECT ${DGAME_DBEHAVIORS_SOURCES})
-target_link_libraries(dBehaviors PUBLIC dDatabaseCDClient dPhysics)
+target_link_libraries(dBehaviors PUBLIC dDatabaseCDClient dPhysics magic_enum::magic_enum)
 target_include_directories(dBehaviors PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dGame/dGameMessages" # via BehaviorContext.h
 	PRIVATE

dGame/dComponents/CMakeLists.txt

@@ -7,10 +7,10 @@ set(DGAME_DCOMPONENTS_SOURCES
 	"BuildBorderComponent.cpp"
 	"CharacterComponent.cpp"
 	"CollectibleComponent.cpp"
+	"Component.cpp"
 	"ControllablePhysicsComponent.cpp"
 	"DestroyableComponent.cpp"
 	"DonationVendorComponent.cpp"
-	"FlagComponent.cpp"
 	"GhostComponent.cpp"
 	"InventoryComponent.cpp"
 	"ItemComponent.cpp"
@@ -65,6 +65,7 @@ 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"
@@ -78,4 +79,4 @@ target_include_directories(dComponents PUBLIC "."
 )
 target_precompile_headers(dComponents REUSE_FROM dGameBase)
 
-target_link_libraries(dComponents INTERFACE dBehaviors)
+target_link_libraries(dComponents PUBLIC magic_enum::magic_enum INTERFACE dBehaviors)

dGame/dComponents/CharacterComponent.cpp

@@ -22,7 +22,6 @@
 #include "Mail.h"
 #include "ZoneInstanceManager.h"
 #include "WorldPackets.h"
-#include "MessageType/Game.h"
 #include <ctime>
 
 CharacterComponent::CharacterComponent(Entity* parent, Character* character, const SystemAddress& systemAddress) : Component(parent) {
@@ -48,36 +47,6 @@ CharacterComponent::CharacterComponent(Entity* parent, Character* character, con
 	m_CountryCode = 0;
 	m_LastUpdateTimestamp = std::time(nullptr);
 	m_SystemAddress = systemAddress;
-
-	RegisterMsg(MessageType::Game::GET_OBJECT_REPORT_INFO, this, &CharacterComponent::OnGetObjectReportInfo);
-}
-
-bool CharacterComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
-	auto& request = static_cast<GameMessages::GetObjectReportInfo&>(msg);
-
-	auto& cmptType = request.info->PushDebug("Character");
-
-	cmptType.PushDebug<AMFIntValue>("Component ID") = GeneralUtils::ToUnderlying(ComponentType);
-	cmptType.PushDebug<AMFIntValue>("Character's account ID") = m_Character->GetParentUser()->GetAccountID();
-	cmptType.PushDebug<AMFBoolValue>("Last log out time") = m_Character->GetLastLogin();
-	cmptType.PushDebug<AMFDoubleValue>("Seconds played this session") = 0;
-	cmptType.PushDebug<AMFBoolValue>("Editor enabled") = false;
-	cmptType.PushDebug<AMFDoubleValue>("Total number of seconds played") = m_TotalTimePlayed;
-	cmptType.PushDebug<AMFStringValue>("Total currency") = std::to_string(m_Character->GetCoins());
-	cmptType.PushDebug<AMFStringValue>("Currency able to be picked up") = std::to_string(m_DroppedCoins);
-	cmptType.PushDebug<AMFStringValue>("Tooltip flags value") = "0";
-	// visited locations
-	cmptType.PushDebug<AMFBoolValue>("is a GM") = m_GMLevel > eGameMasterLevel::CIVILIAN;
-	cmptType.PushDebug<AMFBoolValue>("Has PVP flag turned on") = m_PvpEnabled;
-	cmptType.PushDebug<AMFIntValue>("GM Level") = GeneralUtils::ToUnderlying(m_GMLevel);
-	cmptType.PushDebug<AMFIntValue>("Editor level") = GeneralUtils::ToUnderlying(m_EditorLevel);
-	cmptType.PushDebug<AMFStringValue>("Guild ID") = "0";
-	cmptType.PushDebug<AMFStringValue>("Guild Name") = "";
-	cmptType.PushDebug<AMFDoubleValue>("Reputation") = m_Reputation;
-	cmptType.PushDebug<AMFIntValue>("Current Activity Type") = GeneralUtils::ToUnderlying(m_CurrentActivity);
-	cmptType.PushDebug<AMFDoubleValue>("Property Clone ID") = m_Character->GetPropertyCloneID();
-
-	return true;
 }
 
 bool CharacterComponent::LandingAnimDisabled(int zoneID) {
@@ -112,8 +81,6 @@ CharacterComponent::~CharacterComponent() {
 void CharacterComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 
 	if (bIsInitialUpdate) {
-		if (!m_Character || !m_Character->GetParentUser()) return;
-
 		outBitStream.Write(m_ClaimCodes[0] != 0);
 		if (m_ClaimCodes[0] != 0) outBitStream.Write(m_ClaimCodes[0]);
 		outBitStream.Write(m_ClaimCodes[1] != 0);
@@ -133,7 +100,7 @@ void CharacterComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInit
 		outBitStream.Write(m_Character->GetEyebrows());
 		outBitStream.Write(m_Character->GetEyes());
 		outBitStream.Write(m_Character->GetMouth());
-		outBitStream.Write<uint64_t>(m_Character->GetParentUser()->GetAccountID());
+		outBitStream.Write<uint64_t>(0); //AccountID, trying out if 0 works.
 		outBitStream.Write(m_Character->GetLastLogin()); //Last login
 		outBitStream.Write<uint64_t>(0); //"prop mod last display time"
 		outBitStream.Write<uint64_t>(m_Uscore); //u-score

dGame/dComponents/CharacterComponent.h

@@ -323,8 +323,6 @@ public:
 	Character* m_Character;
 private:
 
-	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
-
 	/**
 	 * The map of active venture vision effects
 	 */

dGame/dComponents/Component.cpp

@@ -0,0 +1,21 @@
+#include "Component.h"
+
+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,16 +1,10 @@
 #pragma once
 
-namespace tinyxml2 {
-	class XMLDocument;
-}
+#include "tinyxml2.h"
 
 namespace RakNet {
 	class BitStream;
-}
-
-namespace GameMessages {
-	struct GameMsg;
-}
+};
 
 class Entity;
 
@@ -19,6 +13,7 @@ class Entity;
  */
 class Component {
 public:
+	Component() = default;
 	Component(Entity* parent) : m_Parent{ parent } {}
 	virtual ~Component() = default;
 
@@ -32,34 +27,30 @@ public:
 	 * 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:
 
-	void RegisterMsg(const MessageType::Game msgId, auto* self, const auto handler) {
-		m_Parent->RegisterMsg(msgId, std::bind(handler, self, std::placeholders::_1));
-	}
-
 	/**
 	 * The entity that owns this component
 	 */

dGame/dComponents/FlagComponent.cpp

@@ -1,222 +0,0 @@
-#include "FlagComponent.h"
-
-#include "CDPlayerFlagsTable.h"
-
-#include "eMissionTaskType.h"
-#include "ePlayerFlag.h"
-
-#include "MissionComponent.h"
-#include "Amf3.h"
-
-FlagComponent::FlagComponent(Entity* parent) : Component(parent) {
-	RegisterMsg(MessageType::Game::SET_FLAG, this, &FlagComponent::OnSetFlag);
-	RegisterMsg(MessageType::Game::GET_FLAG, this, &FlagComponent::OnGetFlag);
-	RegisterMsg(MessageType::Game::CLEAR_SESSION_FLAGS, this, &FlagComponent::OnClearSessionFlags);
-	RegisterMsg(MessageType::Game::SET_RETROACTIVE_FLAGS, this, &FlagComponent::OnSetRetroactiveFlags);
-	RegisterMsg(MessageType::Game::GET_OBJECT_REPORT_INFO, this, &FlagComponent::OnGetObjectReportInfo);
-}
-
-bool FlagComponent::OnSetFlag(GameMessages::GameMsg& msg) {
-	auto& setFlag = static_cast<GameMessages::SetFlag&>(msg);
-	SetPlayerFlag(setFlag.iFlagId, setFlag.bFlag);
-
-	// This is always set the first time a player loads into a world from character select
-	// and is used to know when to refresh the players inventory items so they show up.
-	if (setFlag.iFlagId == ePlayerFlag::IS_NEWS_SCREEN_VISIBLE && setFlag.bFlag) {
-		m_Parent->SetVar<bool>(u"dlu_first_time_load", true);
-	}
-
-	return true;
-}
-
-bool FlagComponent::OnGetFlag(GameMessages::GameMsg& msg) {
-	auto& getFlag = static_cast<GameMessages::GetFlag&>(msg);
-	getFlag.bFlag = GetPlayerFlag(getFlag.iFlagId);
-	return true;
-}
-
-void FlagComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
-	if (!doc.FirstChildElement("obj")) return;
-	auto& obj = *doc.FirstChildElement("obj");
-
-	if (!obj.FirstChildElement("flag")) {
-		obj.InsertNewChildElement("flag");
-	}
-
-	auto& flags = *obj.FirstChildElement("flag");
-
-	flags.DeleteChildren(); //Clear it if we have anything, so that we can fill it up again without dupes
-
-	// Save our flags
-	for (const auto& [index, flagBucket] : m_PlayerFlags) {
-		auto& f = *flags.InsertNewChildElement("f");
-		f.SetAttribute("id", index);
-		f.SetAttribute("v", flagBucket);
-	}
-
-	// Save our session flags
-	for (const auto& sessionFlag : m_SessionFlags) {
-		auto& s = *flags.InsertNewChildElement("s");
-		LOG("Saving session flag %i", sessionFlag);
-		s.SetAttribute("si", sessionFlag);
-	}
-}
-
-void FlagComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
-	if (!doc.FirstChildElement("obj")) return;
-	auto& obj = *doc.FirstChildElement("obj");
-
-	if (!obj.FirstChildElement("flag")) return;
-	auto& flags = *obj.FirstChildElement("flag");
-
-	const auto* currentChild = flags.FirstChildElement("f");
-	while (currentChild) {
-		const auto* temp = currentChild->Attribute("v");
-		const auto* id = currentChild->Attribute("id");
-		if (temp && id) {
-			uint32_t index = 0;
-			uint64_t value = 0;
-
-			index = std::stoul(id);
-			value = std::stoull(temp);
-
-			m_PlayerFlags.insert(std::make_pair(index, value));
-		}
-		currentChild = currentChild->NextSiblingElement("f");
-	}
-
-	// Now load our session flags
-	currentChild = flags.FirstChildElement("s");
-	while (currentChild) {
-		const auto* temp = currentChild->Attribute("si");
-		if (temp) {
-			uint32_t sessionIndex = 0;
-			sessionIndex = std::stoul(temp);
-			m_SessionFlags.insert(sessionIndex);
-		}
-		currentChild = currentChild->NextSiblingElement("s");
-	}
-}
-
-void FlagComponent::SetPlayerFlag(const uint32_t flagId, const bool value) {
-	// If the flag is already set, we don't have to recalculate it
-	if (GetPlayerFlag(flagId) == value) return;
-
-	if (value) {
-		// Update the mission component:
-		auto* missionComponent = m_Parent->GetComponent<MissionComponent>();
-
-		if (missionComponent != nullptr) {
-			missionComponent->Progress(eMissionTaskType::PLAYER_FLAG, flagId);
-		}
-	}
-
-	const auto flagEntry = CDPlayerFlagsTable::GetEntry(flagId);
-
-	if (flagEntry && flagEntry->sessionOnly) {
-		if (value) m_SessionFlags.insert(flagId);
-		else m_SessionFlags.erase(flagId);
-	} else {
-		// 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;
-			}
-		} 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_Parent->GetObjectID(), flagId, value, m_Parent->GetSystemAddress());
-}
-
-bool FlagComponent::GetPlayerFlag(const uint32_t flagId) const {
-	bool toReturn = false; //by def, return false.
-
-	const auto flagEntry = CDPlayerFlagsTable::GetEntry(flagId);
-	if (flagEntry && flagEntry->sessionOnly) {
-		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 toReturn;
-}
-
-bool FlagComponent::OnSetRetroactiveFlags(GameMessages::GameMsg& msg) {
-	// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
-	if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) ||
-		GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) ||
-		GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) ||
-		GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
-		SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
-	}
-	return true;
-}
-
-bool FlagComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
-	auto& request = static_cast<GameMessages::GetObjectReportInfo&>(msg);
-
-	auto& cmptType = request.info->PushDebug("Player Flag");
-	cmptType.PushDebug<AMFIntValue>("Component ID") = GeneralUtils::ToUnderlying(ComponentType);
-
-	auto& allFlags = cmptType.PushDebug("All flags");
-	for (const auto& [id, flagChunk] : m_PlayerFlags) {
-		const auto base = id * 64;
-		auto flagChunkCopy = flagChunk;
-		for (int i = 0; i < 64; i++) {
-			if (static_cast<bool>(flagChunkCopy & 1)) {
-				const int32_t flagId = base + i;
-				std::stringstream stream;
-				stream << "Flag: " << flagId;
-				allFlags.PushDebug(stream.str().c_str());
-			}
-			flagChunkCopy >>= 1;
-		}
-	}
-
-	return true;
-}
-
-void FlagComponent::ClearSessionFlags(tinyxml2::XMLDocument& doc) {
-	if (!doc.FirstChildElement("obj")) return;
-	auto& obj = *doc.FirstChildElement("obj");
-
-	if (!obj.FirstChildElement("flag")) return;
-	auto& flags = *obj.FirstChildElement("flag");
-
-	auto* currentChild = flags.FirstChildElement();
-	while (currentChild) {
-		auto* nextChild = currentChild->NextSiblingElement();
-		if (currentChild->Attribute("si")) {
-			flags.DeleteChild(currentChild);
-		}
-		currentChild = nextChild;
-	}
-}

dGame/dComponents/FlagComponent.h

@@ -1,62 +0,0 @@
-#ifndef FLAGCOMPONENT_H
-#define FLAGCOMPONENT_H
-
-#include <cstdint>
-#include <set>
-#include <unordered_map>
-
-#include "Component.h"
-#include "eReplicaComponentType.h"
-
-class FlagComponent final : public Component {
-public:
-	static const inline eReplicaComponentType ComponentType = eReplicaComponentType::FLAG;
-	FlagComponent(Entity* parent);
-
-	void UpdateXml(tinyxml2::XMLDocument& doc) override;
-	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
-
-	// Used to clear the save data from a static context where you only have a doc (switching characters)
-	static void ClearSessionFlags(tinyxml2::XMLDocument& doc);
-private:
-
-	/**
-	 * Sets a flag for the character, indicating certain parts of the game that have been interacted with. Not to be
-	 * confused with the permissions
-	 * @param flagId the ID of the flag to set
-	 * @param value the value to set for the flag
-	 */
-	bool OnSetFlag(GameMessages::GameMsg& msg);
-	void SetPlayerFlag(const uint32_t flagId, const bool value);
-
-	/**
-	 * Gets the value for a certain character flag
-	 * @param flagId the ID of the flag to get a value for
-	 * @return the value of the flag given the ID (the default is false, obviously)
-	 */
-	bool OnGetFlag(GameMessages::GameMsg& msg);
-	bool GetPlayerFlag(const uint32_t flagId) const;
-
-	bool OnClearSessionFlags(GameMessages::GameMsg& msg) { m_SessionFlags.clear(); return true; }
-
-	/**
-	 * Sets any flags that are meant to have been set that may not have been set due to them being
-	 * missing in a previous patch.
-	 */
-	bool OnSetRetroactiveFlags(GameMessages::GameMsg& msg);
-
-	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
-
-	/**
-	 * 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)
-	 */
-	std::unordered_map<uint32_t, uint64_t> m_PlayerFlags;
-};
-
-#endif  //!FLAGCOMPONENT_H

dGame/dComponents/InventoryComponent.cpp

@@ -31,7 +31,6 @@
 #include "eStateChangeType.h"
 #include "eUseItemResponse.h"
 #include "Mail.h"
-#include "ProximityMonitorComponent.h"
 
 #include "CDComponentsRegistryTable.h"
 #include "CDInventoryComponentTable.h"
@@ -69,10 +68,9 @@ InventoryComponent::InventoryComponent(Entity* parent) : Component(parent) {
 	auto slot = 0u;
 
 	for (const auto& item : items) {
-		if (!Inventory::IsValidItem(item.itemid)) continue;
-		AddItem(item.itemid, item.count);
-
-		if (!item.equip) continue;
+		if (!item.equip || !Inventory::IsValidItem(item.itemid)) {
+			continue;
+		}
 
 		const LWOOBJID id = ObjectIDManager::GenerateObjectID();
 
@@ -831,30 +829,6 @@ 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;
 		}
 

dGame/dComponents/MovementAIComponent.cpp

@@ -265,7 +265,6 @@ 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);
 		});