Some fixes to LUA so that it complies

Ensure the correct size is written to the bitstream.  It is always supposed to write 64 bits.

.clang-format

@@ -1,37 +0,0 @@
----
-BraceWrapping: 
-  AfterCaseLabel: false
-  AfterClass: false
-  AfterControlStatement: false
-  AfterEnum: false
-  AfterFunction: false
-  AfterNamespace: false
-  AfterObjCDeclaration: false
-  AfterStruct: false
-  AfterUnion: false
-  AfterExternBlock: false
-  BeforeCatch: false
-  BeforeElse: false
-  IndentBraces: false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-  SplitEmptyNamespace: false
-  BeforeLambdaBody: false
-  BeforeWhile: false
-BreakBeforeBraces: Attach
-ColumnLimit: 0
-IndentWidth: 4
-IndentCaseLabels: true
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex: '<[[:alnum:].]+\.h>'
-    Priority: 1
-  - Regex: '<[[:alnum:].]+>'
-    Priority: 2
-  - Regex: '.*/.*'
-    Priority: 3
-  - Regex: '.*'
-    Priority: 4
-DerivePointerAlignment: false
-PointerAlignment: Left
-...

.clang-tidy

@@ -1,17 +0,0 @@
-Checks: '-*,readability-*,performance-*,modernize-*,-modernize-use-trailing-return-type,bugprone-*'
-WarningsAsErrors: true
-HeaderFilterRegex: ''
-FormatStyle: none
-CheckOptions:
-  - key: readability-identifier-naming.ClassCase
-    value: CamelCase
-  - key: readability-identifier-naming.ClassMethodCase
-    value: CamelCase
-  - key: readability-identifier-naming.ClassMemberPrefix
-    value: m_
-  - key: readability-identifier-naming.ClassMemberCase
-    value: CamelCase
-  - key: readability-identifier-naming.ClassConstantCase
-    value: UPPER_CASE
-  - key: readability-identifier-naming.FunctionCase
-    value: CamelCase

.git-blame-ignore-revs

@@ -6,3 +6,6 @@
 
 # convert to unix line endings
 72477e01e2711e0f61cdb192ee266e5e21b8846f
+
+# enum cleanup
+faf42d2f8cf432df2993b031f079b0b8c6d7dbe7

.gitmodules

@@ -14,12 +14,6 @@
 	path = thirdparty/mariadb-connector-cpp
 	url = https://github.com/mariadb-corporation/mariadb-connector-cpp.git
 	ignore = dirty
-[submodule "thirdparty/docker-utils"]
-	path = thirdparty/docker-utils
-	url = https://github.com/lcdr/utils.git
-[submodule "thirdparty/LUnpack"]
-	path = thirdparty/LUnpack
-	url = https://github.com/Xiphoseer/LUnpack.git
 [submodule "thirdparty/AccountManager"]
 	path = thirdparty/AccountManager
 	url = https://github.com/DarkflameUniverse/AccountManager

CMakeLists.txt

@@ -89,8 +89,8 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
-# Create a /res directory
-make_directory(${CMAKE_BINARY_DIR}/res)
+# Create a /resServer directory
+make_directory(${CMAKE_BINARY_DIR}/resServer)
 
 # Create a /logs directory
 make_directory(${CMAKE_BINARY_DIR}/logs)
@@ -163,6 +163,7 @@ set(INCLUDED_DIRECTORIES
 	"dGame/dMission"
 	"dGame/dEntity"
 	"dGame/dPropertyBehaviors"
+	"dGame/dPropertyBehaviors/ControlBehaviorMessages"
 	"dGame/dUtilities"
 	"dPhysics"
 	"dNavigation"
@@ -176,6 +177,7 @@ set(INCLUDED_DIRECTORIES
 	"dScripts/ai"
 	"dScripts/client"
 	"dScripts/EquipmentScripts"
+	"dScripts/EquipmentTriggers"
 	"dScripts/zone"
 	"dScripts/02_server/DLU"
 	"dScripts/02_server/Enemy"
@@ -253,6 +255,11 @@ set(INCLUDED_DIRECTORIES
 	"tests/dGameTests/dComponentsTests"
 	)
 
+if(__include_lua__)
+	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua")
+	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua/sol")
+endif()
+
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
 	include_directories("/usr/local/include/")
@@ -315,6 +322,7 @@ add_subdirectory(dDatabase)
 add_subdirectory(dChatFilter)
 add_subdirectory(dNet)
 add_subdirectory(dScripts) # Add for dGame to use
+add_subdirectory(dLua)
 add_subdirectory(dGame)
 add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)

CMakePresets.json

@@ -23,10 +23,7 @@
         "name": "ci-macos-11",
         "displayName": "CI configure step for MacOS",
         "description": "Same as default, Used in GitHub actions workflow",
-        "inherits": "default",
-        "cacheVariables": {
-          "OPENSSL_ROOT_DIR": "/usr/local/opt/openssl@3/"
-        }
+        "inherits": "default"
       },
       {
         "name": "ci-windows-2022",

CMakeVariables.txt

@@ -8,15 +8,17 @@ LICENSE=AGPL-3.0
 # 171022 - Unmodded client
 NET_VERSION=171022
 # Debugging
-__dynamic=1
 # Set __dynamic to 1 to enable the -rdynamic flag for the linker, yielding some symbols in crashlogs.
-# __ggdb=1
+__dynamic=1
 # Set __ggdb to 1 to enable the -ggdb flag for the linker, including more debug info.
-# __include_backtrace__=1
+# __ggdb=1
 # Set __include_backtrace__ to 1 to includes the backtrace library for better crashlogs.
-# __compile_backtrace__=1
+# __include_backtrace__=1
 # Set __compile_backtrace__ to 1 to compile the backtrace library instead of using system libraries.
-__maria_db_connector_compile_jobs__=1
+# __compile_backtrace__=1
 # Set to the number of jobs (make -j equivalent) to compile the mariadbconn files with.
-__enable_testing__=1
+__maria_db_connector_compile_jobs__=1
 # When set to 1 and uncommented, compiling and linking testing folders and libraries will be done.
+__enable_testing__=1
+# The path to OpenSSL.  Change this if your OpenSSL install path is different than the default.
+OPENSSL_ROOT_DIR=/usr/local/opt/openssl@3/

Docker.md

@@ -4,7 +4,7 @@
 
 - [Docker](https://docs.docker.com/get-docker/) (Docker Desktop or on Linux normal Docker)
 - [Docker Compose](https://docs.docker.com/compose/install/) (Included in Docker Desktop)
-- LEGO® Universe packed Client. Check the main [README](./README.md) for details on this.
+- LEGO® Universe Client. Check the main [README](./README.md) for details on this.
 
 ## Run server inside Docker
 

Docker_Windows.md

@@ -25,7 +25,7 @@
 11. Once the command has completed (you can see you path again and can enter commands), close the window.
 12. Inside the downloaded folder, copy `.env.example` and name the copy `.env`
 13. Open `.env` with Notepad by right-clicking it and selecting _Open With_ -> _More apps_ -> _Notepad_.
-14. Change the text after `CLIENT_PATH=` to the location of your client. The folder you are pointing to must contain a folder called `client` which should contain the client files.
+14. Change the text after `CLIENT_PATH=` to the location of your client. This folder must contain either a folder `client` or `legouniverse.exe`.
     > If you need the extra performance, place the client files in `\\wsl$\<your linux OS>\...` to avoid working across file systems, see [Docker Best Practices](https://docs.docker.com/desktop/windows/wsl/#best-practices) and [WSL documentation](https://docs.microsoft.com/en-us/windows/wsl/filesystems#file-storage-and-performance-across-file-systems).
 
 15. Optionally, you can change the number after `BUILD_THREADS=` to the number of cores / threads your processor has. If your computer crashes while building, you can try to reduce this value.

README.md

@@ -18,210 +18,192 @@ Darkflame Universe is licensed under AGPLv3, please read [LICENSE](LICENSE). Som
 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. DLU 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.
+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 in the resources tab below when checking if a client will work.
+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.
 
-## Build
-Development of the latest iteration of Darkflame Universe has been done primarily in a Unix-like environment and is where it has been tested and designed for deployment. It is therefore highly recommended that Darkflame Universe be built and deployed using a Unix-like environment for the most streamlined experience.
+## Steps to setup server
+* [Clone this repository](#clone-the-repository)
+* [Install dependencies](#install-dependencies)
+* [Database setup](#database-setup)
+* [Build the server](#build-the-server)
+* [Configuring your server](#configuring-your-server)
+	* [Required Configuration](#required-configuration)
+	* [Optional Configuration](#optional-configuration)
+* [Verify your setup](#verify-your-setup)
+* [Running the server](#running-the-server)
+* [User Guide](#user-guide)
 
-### Prerequisites
-#### Clone the repository
+## Clone the repository
+If you are on Windows, you will need to download and install git from [here](https://git-scm.com/download/win)
+
+Then run the following command
 ```bash
 git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 ```
-#### Python
 
-Some tools utilized to streamline the setup process require Python 3, make sure you have it installed.
+## Install dependencies
 
+### Windows packages
+Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
+You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.18**</font> or later!).
 
-### Choosing the right version for your client
-DLU clients identify themselves using a higher version number than the regular live clients out there.
-This was done make sure that older and incomplete clients wouldn't produce false positive bug reports for us, and because we made bug fixes and new content for the client.
+### MacOS packages
+Ensure you have [brew](https://brew.sh) installed.
+You will need to install the following packages
+```bash
+brew install cmake gcc mariadb openssl zlib
+```
 
-If you're using a DLU client you'll have to go into the "CMakeVariables.txt" file and change the NET_VERSION variable to 171023 to match the modified client's version number.
+### Linux packages
+Make sure packages like `gcc`, and `zlib` are installed. Depending on the distribution, these packages might already be installed. Note that on systems like Ubuntu, you will need the `zlib1g-dev` package so that the header files are available. `libssl-dev` will also be required as well as `openssl`. You will also need a MySQL database solution to use. We recommend using `mariadb-server`.
 
-### Enabling testing
-While it is highly recommended to enable testing, if you would like to save compilation time, you'll want to comment out the enable_testing variable in CMakeVariables.txt.
-It is recommended that after building and if testing is enabled, to run `ctest` and make sure all the tests pass.
+For Ubuntu, you would run the following commands. On other systems, the package install command will differ.
 
-### Using Docker
-Refer to [Docker.md](/Docker.md).
+```bash
+sudo apt update && sudo apt upgrade
 
-For Windows, refer to [Docker_Windows.md](/Docker_Windows.md).
+# Install packages
+sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-server cmake
+```
 
-### Linux builds
-Make sure packages like `gcc`, `cmake`, and `zlib` are installed. Depending on the distribution, these packages might already be installed. Note that on systems like Ubuntu, you will need the `zlib1g-dev` package so that the header files are available. `libssl-dev` will also be required as well as `openssl`.
+#### Required CMake version
+This project uses <font size="4">**CMake version 3.18**</font> or higher and as such you will need to ensure you have this version installed.
+You can check your CMake version by using the following command in a terminal.
+```bash
+cmake --version
+```
 
-CMake must be version 3.14 or higher!
+If you are going to be using an Ubuntu environment to run the server, you may need to get a more recent version of `cmake` than the packages available may provide.
 
-#### Build the repository
+The general approach to do so would be to obtain a copy of the signing key and then add the CMake repository to your apt.
+You can do so with the following commands.
 
+[Source of the below commands](https://askubuntu.com/questions/355565/how-do-i-install-the-latest-version-of-cmake-from-the-command-line)
+
+```bash
+# Remove the old version of CMake
+sudo apt purge --auto-remove cmake
+
+# Prepare for installation
+sudo apt update && sudo apt install -y software-properties-common lsb-release && sudo apt clean all
+
+# Obtain a copy of the signing key
+wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /etc/apt/trusted.gpg.d/kitware.gpg >/dev/null
+
+# Add the repository to your sources list.
+sudo apt-add-repository "deb https://apt.kitware.com/ubuntu/ $(lsb_release -cs) main"
+
+# Next you'll want to ensure that Kitware's keyring stays up to date
+sudo apt update
+sudo apt install kitware-archive-keyring
+sudo rm /etc/apt/trusted.gpg.d/kitware.gpg
+
+# If sudo apt update above returned an error, copy the public key at the end of the error message and run the following command
+# if the error message was "The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 6AF7F09730B3F0A4"
+# then the below command would be "sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6AF7F09730B3F0A4"
+sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys <TheCopiedPublicKey>
+
+# Finally update and install
+sudo apt update
+sudo apt install cmake
+```
+
+## Database setup
+First you'll need to start MariaDB.
+
+For Windows the service is always running by default.
+
+For MacOS, run the following command
+```bash
+brew services start mariadb
+```
+
+For Linux, run the following command
+```bash
+sudo systemctl start mysql
+# If systemctl is not a known command on your distribution, try the following instead
+sudo service mysql start
+```
+
+<font size="4">**You will need to run this command every time you restart your environment**</font>
+
+If you are using Linux and `systemctl` and want the MariaDB instance to start on startup, run the following command
+```bash
+sudo systemctl enable --now mysql
+```
+
+Once MariaDB is started, you'll need to create a user and an empty database for Darkflame Universe to use.
+
+First, login to the MariaDB instance.
+
+To do this on Ubuntu/Linux, MacOS, or another Unix like operating system, run the following command in a terminal
+```bash
+# Logs you into the MariaDB instance as root
+sudo mysql
+```
+
+For Windows, run the following command in the `Command Prompt (MariaDB xx.xx)` terminal
+```bash
+# Logs you into the mysql instance
+mysql -u root -p
+# You will then be prompted for the password you set for root during installation of MariaDB
+```
+
+Now that you are logged in, run the following commands.
+
+```bash
+# Creates a user for this computer which uses a password and grant said user all privileges.
+# Change mydarkflameuser to a custom username and password to a custom password. 
+GRANT ALL ON *.* TO 'mydarkflameuser'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+
+# Then create a database for Darkflame Universe to use.
+CREATE DATABASE darkflame;
+```
+
+## Build the server
 You can either run `build.sh` when in the root folder of the repository:
 
 ```bash
 ./build.sh
 ```
 
-Or manually run the commands used in `build.sh`:
+Or manually run the commands used in [build.sh](build.sh).
 
+If you would like to build the server faster, append `-j<number>` where number is the number of simultaneous compile jobs to run at once.  It is recommended that you have this number always be 1 less than your core count to prevent slowdowns.  The command would look like this if you would build with 4 jobs at once:
 ```bash
-# Create the build directory, preserving it if it already exists
-mkdir -p build
-cd build
-
-# Run CMake to generate make files
-cmake ..
-
-# To build utilizing multiple cores, append `-j` and the amount of cores to utilize, for example `cmake --build . --config Release -j8'
-cmake --build . --config Release
+./build.sh -j4
 ```
+### 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.
+* If you are using a Darkflame Universe client, ensure NET_VERSION is changed to 171023.
 
-### MacOS builds
-Ensure `cmake`, `zlib` and `open ssl` are installed as well as a compiler (e.g `clang` or `gcc`).
+## Configuring your server
+This server has a few steps that need to be taken to configure the server for your use case.
 
-In the repository root folder run the following. Ensure -DOPENSSL_ROOT_DIR=/path/to/openssl points to your openssl install location
-```bash
-# Create the build directory, preserving it if it already exists
-mkdir -p build
-cd build
+### Required Configuration
+Darkflame Universe can run with either a packed or an unpacked client.
+Navigate to `build/sharedconfig.ini` and fill in the following fields:
+* `mysql_host` (This is the IP address or hostname of your MariaDB server.  This is highly likely `localhost`)
+  * If you setup your MariaDB instance on a port other than 3306, which can be done on a Windows install, you will need to make this value `tcp://localhost:portNum` where portNum is replaced with the port you chose to run MariaDB on.
+* `mysql_database` (This is the database you created for the server)
+* `mysql_username` (This is the user you created for the server)
+* `mysql_password` (This is the password for the user you created for the server)
+* `client_location` (This is the location of the client files.  This should be the folder path of a packed or unpacked client)
+	* Ideally the path to the client should not contain any spaces.
 
-# Run CMake to generate build files
-cmake .. -DOPENSSL_ROOT_DIR=/path/to/openssl
-
-# Get cmake to build the project. If make files are being used then using make and appending `-j` and the amount of cores to utilize may be preferable, for example `make -j8`
-cmake --build . --config Release
-```
-
-### Windows builds (native)
-Ensure that you have either the [MSVC](https://visualstudio.microsoft.com/vs/) or the [Clang](https://github.com/llvm/llvm-project/releases/) (recommended) compiler installed. You will also need to install [CMake](https://cmake.org/download/). Currently on native Windows the server will only work in Release mode.
-
-#### Build the repository
-```batch
-:: Create the build directory
-mkdir build
-cd build
-
-:: Run CMake to generate make files
-cmake ..
-
-:: Run CMake with build flag to build
-cmake --build . --config Release
-```
-#### Windows for ARM has not been tested but should build by doing the following
-```batch
-:: Create the build directory
-mkdir build
-cd build
-
-:: Run CMake to generate make files
-cmake .. -DMARIADB_BUILD_SOURCE=ON
-
-:: Run CMake with build flag to build
-cmake --build . --config Release
-```
-
-### Windows builds (WSL)
-This section will go through how to install [WSL](https://docs.microsoft.com/en-us/windows/wsl/install) and building in a Linux environment under Windows. WSL requires Windows 10 version 2004 and higher (Build 19041 and higher) or Windows 11.
-
-#### Open the Command Prompt application with Administrator permissions and run the following:
-```bash
-# Installing Windows Subsystem for Linux
-wsl --install
-```
-
-#### Open the Ubuntu application and run the following:
-```bash
-# Make sure the install is up to date
-apt update && apt upgrade
-
-# Make sure the gcc, cmake, and build-essentials are installed
-sudo apt install gcc
-sudo apt install cmake
-sudo apt install build-essential
-```
-
-[**Follow the Linux instructions**](#linux-builds)
-
-### ARM builds
-AArch64 builds should work on linux and MacOS using their respective build steps. Windows ARM should build but it has not been tested
-
-### Updating your build
-To update your server to the latest version navigate to your cloned directory
-```bash
-cd /path/to/DarkflameServer
-```
-run the following commands to update to the latest changes
-```bash
-git pull
-git submodule update --init --recursive
-```
-now follow the build section for your system
-
-## Setting up the environment
-
-### Resources
-
-#### LEGO® Universe 1.10.64
-
-This repository does not distribute any LEGO® Universe files. A full install of LEGO® Universe version 1.10.64 (latest) is required to finish setting up Darkflame Universe.
-
-Known good SHA256 checksums of the client:
-- `8f6c7e84eca3bab93232132a88c4ae6f8367227d7eafeaa0ef9c40e86c14edf5` (packed client, rar compressed)
-- `c1531bf9401426042e8bab2de04ba1b723042dc01d9907c2635033d417de9e05` (packed client, includes extra locales, rar compressed)
-- `0d862f71eedcadc4494c4358261669721b40b2131101cbd6ef476c5a6ec6775b` (unpacked client, includes extra locales, rar compressed)
-
-Known good *SHA1* checksum of the DLU client:
-- `91498e09b83ce69f46baf9e521d48f23fe502985` (packed client, zip compressed)
-
-How to generate a SHA256 checksum:
-```bash
-# Replace <file> with the file path to the client
-
-# If on Linux or MacOS
-shasum -a 256 <file>
-
-# If on Windows
-certutil -hashfile <file> SHA256
-```
-
-#### Unpacking the client
-* Clone lcdr's utilities repository [here](https://github.com/lcdr/utils)
-* Use `pkextractor.pyw` to unpack the client files if they are not already unpacked
-
-#### Setup resource directory
-* In the `build` directory create a `res` directory if it does not already exist.
-* Copy over or create symlinks from `macros`, `BrickModels`, `chatplus_en_us.txt`, `names`, and `maps` in your client `res` directory to the server `build/res` directory
-* Unzip the navmeshes [here](./resources/navmeshes.zip) and place them in `build/res/maps/navmeshes`
-
-#### Setup locale
-* In the `build` directory create a `locale` directory if it does not already exist
-* Copy over or create symlinks from `locale.xml` in your client `locale` directory to the `build/locale` directory
-
-#### Client database
-* Move the file `res/cdclient.fdb` from the unpacked client to the `build/res` folder on the server.
-* The server will automatically copy and convert the file from fdb to sqlite should `CDServer.sqlite` not already exist.
-* You can also convert the database manually using `fdb_to_sqlite.py` using lcdr's utilities.  Just make sure to rename the file to `CDServer.sqlite` instead of `cdclient.sqlite`.
-* Migrations to the database are automatically run on server start.  When migrations are needed to be ran, the server may take a bit longer to start.
-
-### Database
-Darkflame Universe utilizes a MySQL/MariaDB database for account and character information.
-
-Initial setup can vary drastically based on which operating system or distribution you are running; there are instructions out there for most setups, follow those and come back here when you have a database up and running.
-
-* All that you need to do is create a database to connect to.  As long as the server can connect to the database, the schema will always be kept up to date when you start the server.
-
-#### Configuration
-
-After the server has been built there should be four `ini` files in the build director: `sharedconfig.ini`, `authconfig.ini`, `chatconfig.ini`, `masterconfig.ini`, and `worldconfig.ini`. Go through them and fill in the database credentials and configure other settings if necessary.
-
-#### Migrations
-
-The database is automatically setup and migrated to what it should look like for the latest commit whenever you start the server.
-
-#### Verify
+### Optional Configuration
+* After the server has been built there should be five `ini` files in the build directory: `sharedconfig.ini`, `authconfig.ini`, `chatconfig.ini`, `masterconfig.ini`, and `worldconfig.ini`.
+* `authconfig.ini` contains an option to enable or disable play keys on your server. Do not change the default port for auth.
+* `chatconfig.ini` contains a port option.
+* `masterconfig.ini` contains options related to permissions you want to run your servers with.
+* `sharedconfig.ini` contains several options that are shared across all servers
+* `worldconfig.ini` contains several options to turn on QOL improvements should you want them. If you would like the most vanilla experience possible, you will need to turn some of these settings off.
 
+## Verify your setup
 Your build directory should now look like this:
 * AuthServer
 * ChatServer
@@ -230,202 +212,105 @@ Your build directory should now look like this:
 * authconfig.ini
 * chatconfig.ini
 * masterconfig.ini
+* sharedconfig.ini
 * worldconfig.ini
-* **locale/**
-  * locale.xml
-* **res/**
-  * cdclient.fdb
-  * chatplus_en_us.txt
-  * **macros/**
-    * ...
-  * **BrickModels/**
-    * ...
-  * **maps/**
-    * **navmeshes/**
-      * ...
-    * ...
 * ...
 
 ## Running the server
-If everything has been configured correctly you should now be able to run the `MasterServer` binary. Darkflame Universe utilizes port numbers under 1024, so under Linux you either have to give the binary network permissions or run it under sudo.
+If everything has been configured correctly you should now be able to run the `MasterServer` binary which is located in the `build` directory. Darkflame Universe utilizes port numbers under 1024, so under Linux you 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.
 
 ### 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 Manager
+### Account management tool (Nexus Dashboard)
+**If you are just using this server for yourself, you can skip setting up Nexus Dashboard**
 
-Follow the instructions [here](https://github.com/DarkflameUniverse/AccountManager) to setup the DLU account management Python web application. This is the intended way for users to create accounts.
+Follow the instructions [here](https://github.com/DarkflameUniverse/NexusDashboard) to setup the DLU Nexus Dashboard web application. This is the intended way for users to create accounts and the intended way for moderators to approve names/pets/properties and do other moderation actions.
 
 ### Admin levels
+The admin level, or Game Master level (hereafter referred to as gmlevel), is specified in the `accounts.gm_level` column in the MySQL database. Normal players should have this set to `0`, which comes with no special privileges. The system administrator will have this set to `9`, which comes will all privileges. gmlevel `8` should be used to give a player a majority of privileges without the safety critical once.
 
-The admin level, or game master level, is specified in the `accounts.gm_level` column in the MySQL database. Normal players should have this set to `0`, which comes with no special privileges. The system administrator will have this set to `9`, which comes will all privileges. Admin level `8` should be used to give a player a majority of privileges without the safety critical once.
+While a character has a gmlevel of anything but `0`, some gameplay behavior will change. When testing gameplay, you should always use a character with a gmlevel of `0`.
 
-While a character has a gmlevel of anything but 0, some gameplay behavior will change. When testing gameplay, you should always use a character with a gmlevel of 0.
+# User guide
+Some changes to the client `boot.cfg` file are needed to play on your server.
 
-## User guide
-A few modifications have to be made to the client.
-
-### Client configuration
+## Allowing a user to connect to your server
 To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
 * Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
 * 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`
 * 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.
 
-### Brick-By-Brick building
+## Updating your server
+To update your server to the latest version navigate to your cloned directory
+```bash
+cd path/to/DarkflameServer
+```
+Run the following commands to update to the latest changes
+```bash
+git pull
+git submodule update --init --recursive
+```
+Now follow the [build](#build-the-server) section for your system and your server is up to date.
 
-Brick-By-Brick building requires `PATCHSERVERIP=0:` in the `boot.cfg` to point to a HTTP server which always returns `HTTP 404 - Not Found` for all requests. This can be achieved by pointing it to `localhost` while having `sudo python -m http.server 80` running in the background.
+## In-game commands
+* A list of all in-game commands can be found [here](./docs/Commands.md).
 
-### In-game commands
-Here is a summary of the commands available in-game. All commands are prefixed by `/` and typed in the in-game chat window. Some commands requires admin privileges. Operands within `<>` are required, operands within `()` are not. For the full list of in-game commands, please checkout [the source file](./dGame/dUtilities/SlashCommandHandler.cpp).
+## Verifying your client files
 
-<table>
-<thead>
-  <th>
-    Command
-  </th>
-  <th>
-    Usage
-  </th>
-  <th>
-    Description
-  </th>
-  <th>
-    Admin Level Requirement
-  </th>
-</thead>
-<tbody>
-  <tr>
-    <td>
-      info
-    </td>
-    <td>
-      /info
-    </td>
-    <td>
-      Displays server info to the user, including where to find the server's source code.
-    </td>
-    <td>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      credits
-    </td>
-    <td>
-      /credits
-    </td>
-    <td>
-      Displays the names of the people behind Darkflame Universe.
-    </td>
-    <td>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      instanceinfo
-    </td>
-    <td>
-      /instanceinfo
-    </td>
-    <td>
-      Displays in the chat the current zone, clone, and instance id.
-    </td>
-    <td>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      gmlevel
-    </td>
-    <td>
-      /gmlevel &#60;level&#62;
-    </td>
-    <td>
-      Within the authorized range of levels for the current account, changes the character's game master level to the specified value. This is required to use certain commands.
-    </td>
-    <td>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      testmap
-    </td>
-    <td>
-      /testmap &#60;zone&#62; (clone-id)
-    </td>
-    <td>
-      Transfers you to the given zone by id and clone id.
-    </td>
-    <td>
-      1
-    </td>
-  </tr>
-  <tr>
-    <td>
-      ban
-    </td>
-    <td>
-      /ban &#60;username&#62;
-    </td>
-    <td>
-      Bans a user from the server.
-    </td>
-    <td>
-      4
-    </td>
-  </tr>
-  <tr>
-    <td>
-      gmadditem
-    </td>
-    <td>
-      /gmadditem &#60;id&#62; (count)
-    </td>
-    <td>
-      Adds the given item to your inventory by id.
-    </td>
-    <td>
-      8
-    </td>
-  </tr>
-  <tr>
-    <td>
-      spawn
-    </td>
-    <td>
-      /spawn &#60;id&#62;
-    </td>
-    <td>
-      Spawns an object at your location by id.
-    </td>
-    <td>
-      8
-    </td>
-  </tr>
-  <tr>
-    <td>
-      metrics
-    </td>
-    <td>
-      /metrics
-    </td>
-    <td>
-      Prints some information about the server's performance.
-    </td>
-    <td>
-      8
-    </td>
-  </tr>
-</tbody>
-</table>
+### LEGO® Universe 1.10.64
+To verify that you are indeed using a LEGO® Universe 1.10.64 client, make sure you have the full client compressed **in a rar file** and run the following command.
+```bash
+# Replace <file> with the file path to the zipped client
+
+# If on Linux or MacOS
+shasum -a 256 <file>
+
+# If on Windows using the Command Prompt
+certutil -hashfile <file> SHA256
+```
+
+Below are known good SHA256 checksums of the client:
+* `8f6c7e84eca3bab93232132a88c4ae6f8367227d7eafeaa0ef9c40e86c14edf5` (packed client, rar compressed)
+* `c1531bf9401426042e8bab2de04ba1b723042dc01d9907c2635033d417de9e05` (packed client, includes extra locales, rar compressed)
+* `0d862f71eedcadc4494c4358261669721b40b2131101cbd6ef476c5a6ec6775b` (unpacked client, includes extra locales, rar compressed)
+
+If the returned hash matches one of the lines above then you can continue with setting up the server. If you are using a fully downloaded and complete client from live, then it will work, but the hash above may not match. Otherwise you must obtain a full install of LEGO® Universe 1.10.64.
+
+### Darkflame Universe Client
+Darkflame Universe clients identify themselves using a higher version number than the regular live clients out there.
+This was done make sure that older and incomplete clients wouldn't produce false positive bug reports for us, and because we made bug fixes and new content for the client.
+
+To verify that you are indeed using a Darkflame Universe client, make sure you have the full client compressed **in a zip file** and run the following command.
+
+```bash
+# Replace <file> with the file path to the zipped client
+
+# If on Linux or MacOS
+shasum -a 1 <file>
+
+# If on Windows using the Command Prompt
+certutil -hashfile <file> SHA1
+```
+
+Known good *SHA1* checksum of the Darkflame Universe client:
+- `91498e09b83ce69f46baf9e521d48f23fe502985` (packed client, zip compressed)
+
+# Development Documentation
+This is a Work in Progress, but below are some quick links to documentaion for systems and structs in the server
+[Networked message structs](https://lcdruniverse.org/lu_packets/lu_packets/index.html)
+[General system documentation](https://docs.lu-dev.net/en/latest/index.html)
 
 # Credits
-## Active Contributors
-* [EmosewaMC](https://github.com/EmosewaMC)
-* [Jettford](https://github.com/Jettford)
-* [Aaron K.](https://github.com/aronwk-aaron)
 
 ## DLU Team
 * [DarwinAnim8or](https://github.com/DarwinAnim8or)
@@ -434,25 +319,30 @@ Here is a summary of the commands available in-game. All commands are prefixed b
 * [averysumner](https://github.com/codeshaunted)
 * [Jon002](https://github.com/jaller200)
 * [Jonny](https://github.com/cuzitsjonny)
+* [Aaron K.](https://github.com/aronwk-aaron)
 
-### Research and tools
+### Research and Tools
 * [lcdr](https://github.com/lcdr)
 * [Xiphoseer](https://github.com/Xiphoseer)
 
-### Community management
+### Community Management
 * [Neal](https://github.com/NealSpellman)
 
-### Former contributors
+### Logo
+* Cole Peterson (BlasterBuilder)
+
+## Active Contributors
+* [EmosewaMC](https://github.com/EmosewaMC)
+* [Jettford](https://github.com/Jettford)
+
+## Former Contributors
 * TheMachine
 * Matthew
 * [Raine](https://github.com/Rainebannister)
 * Bricknave
 
-### Logo
-* Cole Peterson (BlasterBuilder)
-
-## Special thanks
+## Special Thanks
 * humanoid24
 * pwjones1969
 * [Simon](https://github.com/SimonNitzsche)
-* ALL OF THE NETDEVIL AND LEGO TEAMS!
+* [ALL OF THE NETDEVIL AND LEGO TEAMS!](https://www.mobygames.com/game/macintosh/lego-universe/credits)

build.sh

@@ -9,5 +9,5 @@ cd build
 cmake ..
 
 # To build utilizing multiple cores, append `-j` and the amount of cores to utilize, for example `cmake --build . --config Release -j8'
-cmake --build . --config Release
+cmake --build . --config Release $1
 

dAuthServer/AuthServer.cpp

@@ -15,22 +15,28 @@
 
 //RakNet includes:
 #include "RakNetDefines.h"
+#include <MessageIdentifiers.h>
 
 //Auth includes:
 #include "AuthPackets.h"
-#include "dMessageIdentifiers.h"
+#include "eConnectionType.h"
+#include "eServerMessageType.h"
+#include "eAuthMessageType.h"
 
 #include "Game.h"
 namespace Game {
 	dLogger* logger = nullptr;
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
+	bool shouldShutdown = false;
 }
 
 dLogger* SetupLogger();
 void HandlePacket(Packet* packet);
 
 int main(int argc, char** argv) {
+	constexpr uint32_t authFramerate = mediumFramerate;
+	constexpr uint32_t authFrameDelta = mediumFrameDelta;
 	Diagnostics::SetProcessName("Auth");
 	Diagnostics::SetProcessFileName(argv[0]);
 	Diagnostics::Initialize();
@@ -66,7 +72,7 @@ int main(int argc, char** argv) {
 
 	//Find out the master's IP:
 	std::string masterIP;
-	int masterPort = 1500;
+	uint32_t masterPort = 1500;
 	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
 	auto res = stmt->executeQuery();
 	while (res->next()) {
@@ -78,26 +84,28 @@ int main(int argc, char** argv) {
 	delete stmt;
 
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
-	int maxClients = 50;
-	int ourPort = 1001; //LU client is hardcoded to use this for auth port, so I'm making it the default.
+	uint32_t maxClients = 50;
+	uint32_t ourPort = 1001; //LU client is hardcoded to use this for auth port, so I'm making it the default.
 	if (Game::config->GetValue("max_clients") != "") maxClients = std::stoi(Game::config->GetValue("max_clients"));
 	if (Game::config->GetValue("port") != "") ourPort = std::atoi(Game::config->GetValue("port").c_str());
 
-	Game::server = new dServer(Game::config->GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth, Game::config);
+	Game::server = new dServer(Game::config->GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth, Game::config, &Game::shouldShutdown);
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
 	Packet* packet = nullptr;
-	int framesSinceLastFlush = 0;
-	int framesSinceMasterDisconnect = 0;
-	int framesSinceLastSQLPing = 0;
+	constexpr uint32_t logFlushTime = 30 * authFramerate; // 30 seconds in frames
+	constexpr uint32_t sqlPingTime = 10 * 60 * authFramerate; // 10 minutes in frames
+	uint32_t framesSinceLastFlush = 0;
+	uint32_t framesSinceMasterDisconnect = 0;
+	uint32_t framesSinceLastSQLPing = 0;
 
-	while (true) {
+	while (!Game::shouldShutdown) {
 		//Check if we're still connected to master:
 		if (!Game::server->GetIsConnectedToMaster()) {
 			framesSinceMasterDisconnect++;
 
-			if (framesSinceMasterDisconnect >= 30)
+			if (framesSinceMasterDisconnect >= authFramerate)
 				break; //Exit our loop, shut down.
 		} else framesSinceMasterDisconnect = 0;
 
@@ -113,16 +121,16 @@ int main(int argc, char** argv) {
 		}
 
 		//Push our log every 30s:
-		if (framesSinceLastFlush >= 900) {
+		if (framesSinceLastFlush >= logFlushTime) {
 			Game::logger->Flush();
 			framesSinceLastFlush = 0;
 		} else framesSinceLastFlush++;
 
 		//Every 10 min we ping our sql server to keep it alive hopefully:
-		if (framesSinceLastSQLPing >= 40000) {
+		if (framesSinceLastSQLPing >= sqlPingTime) {
 			//Find out the master's IP for absolutely no reason:
 			std::string masterIP;
-			int masterPort;
+			uint32_t masterPort;
 			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
 			auto res = stmt->executeQuery();
 			while (res->next()) {
@@ -137,7 +145,7 @@ int main(int argc, char** argv) {
 		} else framesSinceLastSQLPing++;
 
 		//Sleep our thread since auth can afford to.
-		t += std::chrono::milliseconds(mediumFramerate); //Auth can run at a lower "fps"
+		t += std::chrono::milliseconds(authFrameDelta); //Auth can run at a lower "fps"
 		std::this_thread::sleep_until(t);
 	}
 
@@ -163,13 +171,15 @@ dLogger* SetupLogger() {
 }
 
 void HandlePacket(Packet* packet) {
+	if (packet->length < 4) return;
+
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (packet->data[1] == SERVER) {
-			if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) {
+		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
+			if (static_cast<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
-		} else if (packet->data[1] == AUTH) {
-			if (packet->data[3] == MSG_AUTH_LOGIN_REQUEST) {
+		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
+			if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}
 		}

dChatFilter/dChatFilter.cpp

@@ -12,6 +12,7 @@
 #include "dConfig.h"
 #include "Database.h"
 #include "Game.h"
+#include "eGameMasterLevel.h"
 
 using namespace dChatFilterDCF;
 
@@ -108,8 +109,8 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteLis
 	}
 }
 
-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, int gmLevel, bool whiteList) {
-	if (gmLevel > GAME_MASTER_LEVEL_FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList) {
+	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
 	if (!whiteList && m_DeniedWords.empty()) return { { 0, message.length() } };
 

dChatFilter/dChatFilter.h

@@ -4,6 +4,7 @@
 
 #include "dCommonVars.h"
 
+enum class eGameMasterLevel : uint8_t;
 namespace dChatFilterDCF {
 	static const uint32_t header = ('D' + ('C' << 8) + ('F' << 16) + ('B' << 24));
 	static const uint32_t formatVersion = 2;
@@ -23,7 +24,7 @@ public:
 	void ReadWordlistPlaintext(const std::string& filepath, bool whiteList);
 	bool ReadWordlistDCF(const std::string& filepath, bool whiteList);
 	void ExportWordlistToDCF(const std::string& filepath, bool whiteList);
-	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, int gmLevel, bool whiteList = true);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/ChatPacketHandler.cpp

@@ -3,15 +3,20 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
 #include "dLogger.h"
-#include "AddFriendResponseCode.h"
-#include "AddFriendResponseType.h"
+#include "eAddFriendResponseCode.h"
+#include "eAddFriendResponseType.h"
 #include "RakString.h"
 #include "dConfig.h"
+#include "eObjectBits.h"
+#include "eConnectionType.h"
+#include "eChatMessageType.h"
+#include "eChatInternalMessageType.h"
+#include "eClientMessageType.h"
+#include "eGameMessageType.h"
 
 extern PlayerContainer playerContainer;
 
@@ -45,8 +50,8 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = res->getUInt(1);
-		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
+		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
 
 		fd.isBestFriend = res->getInt(2) == 3; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		if (fd.isBestFriend) player->countOfBestFriends += 1;
@@ -71,11 +76,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
 	bitStream.Write((uint16_t)friends.size());
@@ -115,7 +120,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 	auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
 	if (requestor->playerName == playerName) {
-		SendFriendResponse(requestor, requestor, AddFriendResponseType::MYTHRAN);
+		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
 		return;
 	};
 	std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName));
@@ -153,7 +158,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		requestee.reset(new PlayerData());
 		requestee->playerName = playerName;
 
-		SendFriendResponse(requestor, requestee.get(), result->next() ? AddFriendResponseType::NOTONLINE : AddFriendResponseType::INVALIDCHARACTER);
+		SendFriendResponse(requestor, requestee.get(), result->next() ? eAddFriendResponseType::NOTONLINE : eAddFriendResponseType::INVALIDCHARACTER);
 		return;
 	}
 
@@ -178,10 +183,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			bestFriendStatus = oldBestFriendStatus;
 
 			// Set the bits
-			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
-			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
-			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
+			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
 
 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@@ -197,10 +202,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		if (oldBestFriendStatus != bestFriendStatus) {
 			if (requestee->countOfBestFriends >= maxNumberOfBestFriends || requestor->countOfBestFriends >= maxNumberOfBestFriends) {
 				if (requestee->countOfBestFriends >= maxNumberOfBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::THEIRFRIENDLISTFULL, false);
+					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
 				}
 				if (requestor->countOfBestFriends >= maxNumberOfBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::YOURFRIENDSLISTFULL, false);
+					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
 				}
 			} else {
 				// Then update the database with this new info.
@@ -215,8 +220,8 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				if (bestFriendStatus == 3U) {
 					requestee->countOfBestFriends += 1;
 					requestor->countOfBestFriends += 1;
-					if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee.get(), requestor, AddFriendResponseType::ACCEPTED, false, true);
-					if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::ACCEPTED, false, true);
+					if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee.get(), requestor, eAddFriendResponseType::ACCEPTED, false, true);
+					if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::ACCEPTED, false, true);
 					for (auto& friendData : requestor->friends) {
 						if (friendData.friendID == requestee->playerID) {
 							friendData.isBestFriend = true;
@@ -230,7 +235,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				}
 			}
 		} else {
-			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::WAITINGAPPROVAL, true, true);
+			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
 		// Do not send this if we are requesting to be a best friend.
@@ -247,7 +252,7 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	inStream.Read(playerID);
 	inStream.Read(playerID);
 
-	AddFriendResponseCode clientResponseCode = static_cast<AddFriendResponseCode>(packet->data[0x14]);
+	eAddFriendResponseCode clientResponseCode = static_cast<eAddFriendResponseCode>(packet->data[0x14]);
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
 
 	//Now to try and find both of these:
@@ -255,29 +260,29 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	auto requestee = playerContainer.GetPlayerData(friendName);
 	if (!requestor || !requestee) return;
 
-	AddFriendResponseType serverResponseCode{};
+	eAddFriendResponseType serverResponseCode{};
 	uint8_t isAlreadyBestFriends = 0U;
 	// We need to convert this response code to one we can actually send back to the client.
 	switch (clientResponseCode) {
-	case AddFriendResponseCode::ACCEPTED:
-		serverResponseCode = AddFriendResponseType::ACCEPTED;
+	case eAddFriendResponseCode::ACCEPTED:
+		serverResponseCode = eAddFriendResponseType::ACCEPTED;
 		break;
-	case AddFriendResponseCode::BUSY:
-		serverResponseCode = AddFriendResponseType::BUSY;
+	case eAddFriendResponseCode::BUSY:
+		serverResponseCode = eAddFriendResponseType::BUSY;
 		break;
-	case AddFriendResponseCode::CANCELLED:
-		serverResponseCode = AddFriendResponseType::CANCELLED;
+	case eAddFriendResponseCode::CANCELLED:
+		serverResponseCode = eAddFriendResponseType::CANCELLED;
 		break;
-	case AddFriendResponseCode::REJECTED:
-		serverResponseCode = AddFriendResponseType::DECLINED;
+	case eAddFriendResponseCode::REJECTED:
+		serverResponseCode = eAddFriendResponseType::DECLINED;
 		break;
 	}
 
 	// Now that we have handled the base cases, we need to check the other cases.
-	if (serverResponseCode == AddFriendResponseType::ACCEPTED) {
+	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
 		for (auto friendData : requestor->friends) {
 			if (friendData.friendID == requestee->playerID) {
-				serverResponseCode = AddFriendResponseType::ALREADYFRIEND;
+				serverResponseCode = eAddFriendResponseType::ALREADYFRIEND;
 				if (friendData.isBestFriend) {
 					isAlreadyBestFriends = 1U;
 				}
@@ -286,7 +291,7 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	}
 
 	// This message is NOT sent for best friends and is handled differently for those requests.
-	if (serverResponseCode == AddFriendResponseType::ACCEPTED) {
+	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
 		// Add the each player to the others friend list.
 		FriendData requestorData;
 		requestorData.zoneID = requestor->zoneID;
@@ -313,8 +318,8 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 		statement->execute();
 	}
 
-	if (serverResponseCode != AddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
-	if (serverResponseCode != AddFriendResponseType::ALREADYFRIEND) SendFriendResponse(requestee, requestor, serverResponseCode, isAlreadyBestFriends);
+	if (serverResponseCode != eAddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
+	if (serverResponseCode != eAddFriendResponseType::ALREADYFRIEND) SendFriendResponse(requestee, requestor, serverResponseCode, isAlreadyBestFriends);
 }
 
 void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
@@ -336,8 +341,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}
 
 	// Convert friendID to LWOOBJID
-	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
-	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
+	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
 
 	std::unique_ptr<sql::PreparedStatement> deletestmt(Database::CreatePreppedStmt("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
 	deletestmt->setUInt(1, static_cast<uint32_t>(playerID));
@@ -412,10 +417,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 		const auto otherName = std::string(otherMember->playerName.c_str());
 
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(otherMember->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(otherMember->playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
@@ -451,10 +456,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the sender:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonA->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -474,10 +479,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the receiver:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonB->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -716,11 +721,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
 
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write(sender->playerID);
@@ -731,14 +736,14 @@ void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender)
 
 void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_INVITE_CONFIRM);
+	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -758,14 +763,14 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader
 
 void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -783,14 +788,14 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 
 void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_LEADER);
+	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
@@ -800,14 +805,14 @@ void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64Play
 
 void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_ADD_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -829,14 +834,14 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria
 
 void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_REMOVE_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -855,14 +860,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
 	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -889,11 +894,11 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(friendData->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData->playerName.c_str();
@@ -922,17 +927,17 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	//Make sure people aren't requesting people that they're already friends with:
 	for (auto fr : receiver->friends) {
 		if (fr.friendID == sender->playerID) {
-			SendFriendResponse(sender, receiver, AddFriendResponseType::ALREADYFRIEND, fr.isBestFriend);
+			SendFriendResponse(sender, receiver, eAddFriendResponseType::ALREADYFRIEND, fr.isBestFriend);
 			return; //we have this player as a friend, yeet this function so it doesn't send another request.
 		}
 	}
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
@@ -940,22 +945,22 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, AddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
+void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	if (!receiver || !sender) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	// Portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
-	bitStream.Write<uint8_t>(responseCode != AddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
+	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
 	// Then write the player name
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	// Then if this is an acceptance code, write the following extra info.
-	if (responseCode == AddFriendResponseType::ACCEPTED) {
+	if (responseCode == eAddFriendResponseType::ACCEPTED) {
 		bitStream.Write(sender->playerID);
 		bitStream.Write(sender->zoneID);
 		bitStream.Write(isBestFriendRequest); //isBFF
@@ -969,11 +974,11 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
 	if (!receiver) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
 

dChatServer/ChatPacketHandler.h

@@ -4,7 +4,7 @@
 #include "BitStream.h"
 
 struct PlayerData;
-enum class AddFriendResponseType : uint8_t;
+enum class eAddFriendResponseType : uint8_t;
 
 namespace ChatPacketHandler {
 	void HandleFriendlistRequest(Packet* packet);
@@ -35,6 +35,6 @@ namespace ChatPacketHandler {
 	void SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType, uint8_t isBestFriend);
 
 	void SendFriendRequest(PlayerData* receiver, PlayerData* sender);
-	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, AddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
+	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
 	void SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful);
 };

dChatServer/ChatServer.cpp

@@ -9,26 +9,32 @@
 #include "dLogger.h"
 #include "Database.h"
 #include "dConfig.h"
-#include "dMessageIdentifiers.h"
 #include "dChatFilter.h"
 #include "Diagnostics.h"
 #include "AssetManager.h"
 #include "BinaryPathFinder.h"
-
+#include "eConnectionType.h"
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
+#include "eChatMessageType.h"
+#include "eChatInternalMessageType.h"
+#include "eWorldMessageType.h"
 
 #include "Game.h"
+
+//RakNet includes:
+#include "RakNetDefines.h"
+#include <MessageIdentifiers.h>
+
 namespace Game {
 	dLogger* logger = nullptr;
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
 	dChatFilter* chatFilter = nullptr;
 	AssetManager* assetManager = nullptr;
+	bool shouldShutdown = false;
 }
 
-//RakNet includes:
-#include "RakNetDefines.h"
 
 dLogger* SetupLogger();
 void HandlePacket(Packet* packet);
@@ -36,6 +42,8 @@ void HandlePacket(Packet* packet);
 PlayerContainer playerContainer;
 
 int main(int argc, char** argv) {
+	constexpr uint32_t chatFramerate = mediumFramerate;
+	constexpr uint32_t chatFrameDelta = mediumFrameDelta;
 	Diagnostics::SetProcessName("Chat");
 	Diagnostics::SetProcessFileName(argv[0]);
 	Diagnostics::Initialize();
@@ -86,7 +94,7 @@ int main(int argc, char** argv) {
 
 	//Find out the master's IP:
 	std::string masterIP;
-	int masterPort = 1000;
+	uint32_t masterPort = 1000;
 	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
 	auto res = stmt->executeQuery();
 	while (res->next()) {
@@ -98,28 +106,30 @@ int main(int argc, char** argv) {
 	delete stmt;
 
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
-	int maxClients = 50;
-	int ourPort = 1501;
+	uint32_t maxClients = 50;
+	uint32_t ourPort = 1501;
 	if (Game::config->GetValue("max_clients") != "") maxClients = std::stoi(Game::config->GetValue("max_clients"));
 	if (Game::config->GetValue("port") != "") ourPort = std::atoi(Game::config->GetValue("port").c_str());
 
-	Game::server = new dServer(Game::config->GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config);
+	Game::server = new dServer(Game::config->GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::shouldShutdown);
 
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", bool(std::stoi(Game::config->GetValue("dont_generate_dcf"))));
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
 	Packet* packet = nullptr;
-	int framesSinceLastFlush = 0;
-	int framesSinceMasterDisconnect = 0;
-	int framesSinceLastSQLPing = 0;
+	constexpr uint32_t logFlushTime = 30 * chatFramerate; // 30 seconds in frames
+	constexpr uint32_t sqlPingTime = 10 * 60 * chatFramerate; // 10 minutes in frames
+	uint32_t framesSinceLastFlush = 0;
+	uint32_t framesSinceMasterDisconnect = 0;
+	uint32_t framesSinceLastSQLPing = 0;
 
-	while (true) {
+	while (!Game::shouldShutdown) {
 		//Check if we're still connected to master:
 		if (!Game::server->GetIsConnectedToMaster()) {
 			framesSinceMasterDisconnect++;
 
-			if (framesSinceMasterDisconnect >= 30)
+			if (framesSinceMasterDisconnect >= chatFramerate)
 				break; //Exit our loop, shut down.
 		} else framesSinceMasterDisconnect = 0;
 
@@ -135,16 +145,16 @@ int main(int argc, char** argv) {
 		}
 
 		//Push our log every 30s:
-		if (framesSinceLastFlush >= 900) {
+		if (framesSinceLastFlush >= logFlushTime) {
 			Game::logger->Flush();
 			framesSinceLastFlush = 0;
 		} else framesSinceLastFlush++;
 
 		//Every 10 min we ping our sql server to keep it alive hopefully:
-		if (framesSinceLastSQLPing >= 40000) {
+		if (framesSinceLastSQLPing >= sqlPingTime) {
 			//Find out the master's IP for absolutely no reason:
 			std::string masterIP;
-			int masterPort;
+			uint32_t masterPort;
 			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
 			auto res = stmt->executeQuery();
 			while (res->next()) {
@@ -159,7 +169,7 @@ int main(int argc, char** argv) {
 		} else framesSinceLastSQLPing++;
 
 		//Sleep our thread since auth can afford to.
-		t += std::chrono::milliseconds(mediumFramerate); //Chat can run at a lower "fps"
+		t += std::chrono::milliseconds(chatFrameDelta); //Chat can run at a lower "fps"
 		std::this_thread::sleep_until(t);
 	}
 
@@ -193,25 +203,27 @@ void HandlePacket(Packet* packet) {
 		Game::logger->Log("ChatServer", "A server is connecting, awaiting user list.");
 	}
 
-	if (packet->data[1] == CHAT_INTERNAL) {
-		switch (packet->data[3]) {
-		case MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION:
+	if (packet->length < 4) return; // Nothing left to process.  Need 4 bytes to continue.
+
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
+		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
+		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
 			playerContainer.InsertPlayer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION:
+		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
 			playerContainer.RemovePlayer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_MUTE_UPDATE:
+		case eChatInternalMessageType::MUTE_UPDATE:
 			playerContainer.MuteUpdate(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_CREATE_TEAM:
+		case eChatInternalMessageType::CREATE_TEAM:
 			playerContainer.CreateTeamServer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_ANNOUNCEMENT: {
+		case eChatInternalMessageType::ANNOUNCEMENT: {
 			//we just forward this packet to every connected server
 			CINSTREAM;
 			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
@@ -223,67 +235,67 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (packet->data[1] == CHAT) {
-		switch (packet->data[3]) {
-		case MSG_CHAT_GET_FRIENDS_LIST:
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
+		switch (static_cast<eChatMessageType>(packet->data[3])) {
+		case eChatMessageType::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
 
-		case MSG_CHAT_GET_IGNORE_LIST:
+		case eChatMessageType::GET_IGNORE_LIST:
 			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.");
 			break;
 
-		case MSG_CHAT_TEAM_GET_STATUS:
+		case eChatMessageType::TEAM_GET_STATUS:
 			ChatPacketHandler::HandleTeamStatusRequest(packet);
 			break;
 
-		case MSG_CHAT_ADD_FRIEND_REQUEST:
+		case eChatMessageType::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 MSG_CHAT_ADD_FRIEND_RESPONSE:
+		case eChatMessageType::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 MSG_CHAT_REMOVE_FRIEND:
+		case eChatMessageType::REMOVE_FRIEND:
 			ChatPacketHandler::HandleRemoveFriend(packet);
 			break;
 
-		case MSG_CHAT_GENERAL_CHAT_MESSAGE:
+		case eChatMessageType::GENERAL_CHAT_MESSAGE:
 			ChatPacketHandler::HandleChatMessage(packet);
 			break;
 
-		case MSG_CHAT_PRIVATE_CHAT_MESSAGE:
+		case eChatMessageType::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 MSG_CHAT_TEAM_INVITE:
+		case eChatMessageType::TEAM_INVITE:
 			ChatPacketHandler::HandleTeamInvite(packet);
 			break;
 
-		case MSG_CHAT_TEAM_INVITE_RESPONSE:
+		case eChatMessageType::TEAM_INVITE_RESPONSE:
 			ChatPacketHandler::HandleTeamInviteResponse(packet);
 			break;
 
-		case MSG_CHAT_TEAM_LEAVE:
+		case eChatMessageType::TEAM_LEAVE:
 			ChatPacketHandler::HandleTeamLeave(packet);
 			break;
 
-		case MSG_CHAT_TEAM_SET_LEADER:
+		case eChatMessageType::TEAM_SET_LEADER:
 			ChatPacketHandler::HandleTeamPromote(packet);
 			break;
 
-		case MSG_CHAT_TEAM_KICK:
+		case eChatMessageType::TEAM_KICK:
 			ChatPacketHandler::HandleTeamKick(packet);
 			break;
 
-		case MSG_CHAT_TEAM_SET_LOOT:
+		case eChatMessageType::TEAM_SET_LOOT:
 			ChatPacketHandler::HandleTeamLootOption(packet);
 			break;
 
@@ -292,9 +304,9 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (packet->data[1] == WORLD) {
-		switch (packet->data[3]) {
-		case MSG_WORLD_CLIENT_ROUTE_PACKET: {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
+		switch (static_cast<eWorldMessageType>(packet->data[3])) {
+		case eWorldMessageType::ROUTE_PACKET: {
 			Game::logger->Log("ChatServer", "Routing packet from world");
 			break;
 		}

dChatServer/PlayerContainer.cpp

@@ -6,9 +6,10 @@
 #include "dLogger.h"
 #include "ChatPacketHandler.h"
 #include "GeneralUtils.h"
-#include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
 #include "Database.h"
+#include "eConnectionType.h"
+#include "eChatInternalMessageType.h"
 
 PlayerContainer::PlayerContainer() {
 }
@@ -149,7 +150,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -348,7 +349,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);

dCommon/AMFFormat.h

@@ -257,7 +257,7 @@ private:
 	/*!
 	 \return The AMF value type
 	 */
-	AMFValueType GetValueType() { return ValueType; }
+	AMFValueType GetValueType() override { return ValueType; }
 
 public:
 	static const AMFValueType ValueType = AMFArray;
@@ -362,7 +362,7 @@ private:
 	/*!
 	 \return The AMF value type
 	 */
-	AMFValueType GetValueType() { return ValueType; }
+	AMFValueType GetValueType() override { return ValueType; }
 	~AMFObjectValue() override;
 
 public:

dCommon/AMFFormat_BitStream.cpp

@@ -65,6 +65,15 @@ void RakNet::BitStream::Write<AMFValue*>(AMFValue* value) {
 			this->Write((AMFArrayValue*)value);
 			break;
 		}
+		case AMFObject:
+		case AMFXML:
+		case AMFByteArray:
+		case AMFVectorInt:
+		case AMFVectorUInt:
+		case AMFVectorDouble:
+		case AMFVectorObject:
+		case AMFDictionary:
+			break;
 		}
 	}
 }

dCommon/Brick.h

@@ -0,0 +1,11 @@
+#ifndef __BRICK__H__
+#define __BRICK__H__
+
+#include <cstdint>
+
+struct Brick {
+	uint32_t designerID;
+	uint32_t materialID;
+};
+
+#endif  //!__BRICK__H__

dCommon/Diagnostics.cpp

@@ -111,7 +111,7 @@ static void ErrorCallback(void* data, const char* msg, int errnum) {
 
 void GenerateDump() {
 	std::string cmd = "sudo gcore " + std::to_string(getpid());
-	system(cmd.c_str());
+	int ret = system(cmd.c_str()); // Saving a return just to prevent warning
 }
 
 void CatchUnhandled(int sig) {

dCommon/FdbToSqlite.cpp

@@ -10,10 +10,11 @@
 #include "GeneralUtils.h"
 #include "Game.h"
 #include "dLogger.h"
+#include "AssetManager.h"
 
 #include "eSqliteDataType.h"
 
-std::map<eSqliteDataType, std::string> FdbToSqlite::Convert::sqliteType = {
+std::map<eSqliteDataType, std::string> FdbToSqlite::Convert::m_SqliteType = {
 			{ eSqliteDataType::NONE, "none"},
 			{ eSqliteDataType::INT32, "int32"},
 			{ eSqliteDataType::REAL, "real"},
@@ -23,20 +24,23 @@ std::map<eSqliteDataType, std::string> FdbToSqlite::Convert::sqliteType = {
 			{ eSqliteDataType::TEXT_8, "text_8"}
 };
 
-FdbToSqlite::Convert::Convert(std::string basePath) {
-	this->basePath = basePath;
+FdbToSqlite::Convert::Convert(std::string binaryOutPath) {
+	this->m_BinaryOutPath = binaryOutPath;
 }
 
-bool FdbToSqlite::Convert::ConvertDatabase() {
-	fdb.open(basePath + "/cdclient.fdb", std::ios::binary);
+bool FdbToSqlite::Convert::ConvertDatabase(AssetMemoryBuffer& buffer) {
+	if (m_ConversionStarted) return false;
 
+	std::istream cdClientBuffer(&buffer);
+
+	this->m_ConversionStarted = true;
 	try {
-		CDClientDatabase::Connect(basePath + "/CDServer.sqlite");
+		CDClientDatabase::Connect(m_BinaryOutPath + "/CDServer.sqlite");
 
 		CDClientDatabase::ExecuteQuery("BEGIN TRANSACTION;");
 
-		int32_t numberOfTables = ReadInt32();
-		ReadTables(numberOfTables);
+		int32_t numberOfTables = ReadInt32(cdClientBuffer);
+		ReadTables(numberOfTables, cdClientBuffer);
 
 		CDClientDatabase::ExecuteQuery("COMMIT;");
 	} catch (CppSQLite3Exception& e) {
@@ -44,138 +48,133 @@ bool FdbToSqlite::Convert::ConvertDatabase() {
 		return false;
 	}
 
-	fdb.close();
 	return true;
 }
 
-int32_t FdbToSqlite::Convert::ReadInt32() {
+int32_t FdbToSqlite::Convert::ReadInt32(std::istream& cdClientBuffer) {
 	int32_t nextInt{};
-	BinaryIO::BinaryRead(fdb, nextInt);
+	BinaryIO::BinaryRead(cdClientBuffer, nextInt);
 	return nextInt;
 }
 
-int64_t FdbToSqlite::Convert::ReadInt64() {
-	int32_t prevPosition = SeekPointer();
+int64_t FdbToSqlite::Convert::ReadInt64(std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
 	int64_t value{};
-	BinaryIO::BinaryRead(fdb, value);
+	BinaryIO::BinaryRead(cdClientBuffer, value);
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 	return value;
 }
 
-std::string FdbToSqlite::Convert::ReadString() {
-	int32_t prevPosition = SeekPointer();
+std::string FdbToSqlite::Convert::ReadString(std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
-	auto readString = BinaryIO::ReadString(fdb);
+	auto readString = BinaryIO::ReadString(cdClientBuffer);
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 	return readString;
 }
 
-int32_t FdbToSqlite::Convert::SeekPointer() {
+int32_t FdbToSqlite::Convert::SeekPointer(std::istream& cdClientBuffer) {
 	int32_t position{};
-	BinaryIO::BinaryRead(fdb, position);
-	int32_t prevPosition = fdb.tellg();
-	fdb.seekg(position);
+	BinaryIO::BinaryRead(cdClientBuffer, position);
+	int32_t prevPosition = cdClientBuffer.tellg();
+	cdClientBuffer.seekg(position);
 	return prevPosition;
 }
 
-std::string FdbToSqlite::Convert::ReadColumnHeader() {
-	int32_t prevPosition = SeekPointer();
+std::string FdbToSqlite::Convert::ReadColumnHeader(std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
-	int32_t numberOfColumns = ReadInt32();
-	std::string tableName = ReadString();
+	int32_t numberOfColumns = ReadInt32(cdClientBuffer);
+	std::string tableName = ReadString(cdClientBuffer);
 
-	auto columns = ReadColumns(numberOfColumns);
+	auto columns = ReadColumns(numberOfColumns, cdClientBuffer);
 	std::string newTable = "CREATE TABLE IF NOT EXISTS '" + tableName + "' (" + columns + ");";
 	CDClientDatabase::ExecuteDML(newTable);
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 
 	return tableName;
 }
 
-void FdbToSqlite::Convert::ReadTables(int32_t& numberOfTables) {
-	int32_t prevPosition = SeekPointer();
+void FdbToSqlite::Convert::ReadTables(int32_t& numberOfTables, std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
 	for (int32_t i = 0; i < numberOfTables; i++) {
-		auto columnHeader = ReadColumnHeader();
-		ReadRowHeader(columnHeader);
+		auto columnHeader = ReadColumnHeader(cdClientBuffer);
+		ReadRowHeader(columnHeader, cdClientBuffer);
 	}
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }
 
-std::string FdbToSqlite::Convert::ReadColumns(int32_t& numberOfColumns) {
+std::string FdbToSqlite::Convert::ReadColumns(int32_t& numberOfColumns, std::istream& cdClientBuffer) {
 	std::stringstream columnsToCreate;
-	int32_t prevPosition = SeekPointer();
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
 	std::string name{};
 	eSqliteDataType dataType{};
 	for (int32_t i = 0; i < numberOfColumns; i++) {
 		if (i != 0) columnsToCreate << ", ";
-		dataType = static_cast<eSqliteDataType>(ReadInt32());
-		name = ReadString();
-		columnsToCreate << "'" << name << "' " << FdbToSqlite::Convert::sqliteType[dataType];
+		dataType = static_cast<eSqliteDataType>(ReadInt32(cdClientBuffer));
+		name = ReadString(cdClientBuffer);
+		columnsToCreate << "'" << name << "' " << FdbToSqlite::Convert::m_SqliteType[dataType];
 	}
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 	return columnsToCreate.str();
 }
 
-void FdbToSqlite::Convert::ReadRowHeader(std::string& tableName) {
-	int32_t prevPosition = SeekPointer();
+void FdbToSqlite::Convert::ReadRowHeader(std::string& tableName, std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
-	int32_t numberOfAllocatedRows = ReadInt32();
+	int32_t numberOfAllocatedRows = ReadInt32(cdClientBuffer);
 	if (numberOfAllocatedRows != 0) assert((numberOfAllocatedRows & (numberOfAllocatedRows - 1)) == 0);  // assert power of 2 allocation size
-	ReadRows(numberOfAllocatedRows, tableName);
+	ReadRows(numberOfAllocatedRows, tableName, cdClientBuffer);
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }
 
-void FdbToSqlite::Convert::ReadRows(int32_t& numberOfAllocatedRows, std::string& tableName) {
-	int32_t prevPosition = SeekPointer();
+void FdbToSqlite::Convert::ReadRows(int32_t& numberOfAllocatedRows, std::string& tableName, std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
 	int32_t rowid = 0;
 	for (int32_t row = 0; row < numberOfAllocatedRows; row++) {
-		int32_t rowPointer = ReadInt32();
+		int32_t rowPointer = ReadInt32(cdClientBuffer);
 		if (rowPointer == -1) rowid++;
-		else ReadRow(rowid, rowPointer, tableName);
+		else ReadRow(rowPointer, tableName, cdClientBuffer);
 	}
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }
 
-void FdbToSqlite::Convert::ReadRow(int32_t& rowid, int32_t& position, std::string& tableName) {
-	int32_t prevPosition = fdb.tellg();
-	fdb.seekg(position);
+void FdbToSqlite::Convert::ReadRow(int32_t& position, std::string& tableName, std::istream& cdClientBuffer) {
+	int32_t prevPosition = cdClientBuffer.tellg();
+	cdClientBuffer.seekg(position);
 
 	while (true) {
-		ReadRowInfo(tableName);
-		int32_t linked = ReadInt32();
-
-		rowid += 1;
-
+		ReadRowInfo(tableName, cdClientBuffer);
+		int32_t linked = ReadInt32(cdClientBuffer);
 		if (linked == -1) break;
-
-		fdb.seekg(linked);
+		cdClientBuffer.seekg(linked);
 	}
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }
 
-void FdbToSqlite::Convert::ReadRowInfo(std::string& tableName) {
-	int32_t prevPosition = SeekPointer();
+void FdbToSqlite::Convert::ReadRowInfo(std::string& tableName, std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
-	int32_t numberOfColumns = ReadInt32();
-	ReadRowValues(numberOfColumns, tableName);
+	int32_t numberOfColumns = ReadInt32(cdClientBuffer);
+	ReadRowValues(numberOfColumns, tableName, cdClientBuffer);
 
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }
 
-void FdbToSqlite::Convert::ReadRowValues(int32_t& numberOfColumns, std::string& tableName) {
-	int32_t prevPosition = SeekPointer();
+void FdbToSqlite::Convert::ReadRowValues(int32_t& numberOfColumns, std::string& tableName, std::istream& cdClientBuffer) {
+	int32_t prevPosition = SeekPointer(cdClientBuffer);
 
 	int32_t emptyValue{};
 	int32_t intValue{};
@@ -189,26 +188,26 @@ void FdbToSqlite::Convert::ReadRowValues(int32_t& numberOfColumns, std::string&
 
 	for (int32_t i = 0; i < numberOfColumns; i++) {
 		if (i != 0) insertedRow << ", "; // Only append comma and space after first entry in row.
-		switch (static_cast<eSqliteDataType>(ReadInt32())) {
+		switch (static_cast<eSqliteDataType>(ReadInt32(cdClientBuffer))) {
 		case eSqliteDataType::NONE:
-			BinaryIO::BinaryRead(fdb, emptyValue);
+			BinaryIO::BinaryRead(cdClientBuffer, emptyValue);
 			assert(emptyValue == 0);
 			insertedRow << "NULL";
 			break;
 
 		case eSqliteDataType::INT32:
-			intValue = ReadInt32();
+			intValue = ReadInt32(cdClientBuffer);
 			insertedRow << intValue;
 			break;
 
 		case eSqliteDataType::REAL:
-			BinaryIO::BinaryRead(fdb, floatValue);
+			BinaryIO::BinaryRead(cdClientBuffer, floatValue);
 			insertedRow << std::fixed << std::setprecision(34) << floatValue; // maximum precision of floating point number
 			break;
 
 		case eSqliteDataType::TEXT_4:
 		case eSqliteDataType::TEXT_8: {
-			stringValue = ReadString();
+			stringValue = ReadString(cdClientBuffer);
 			size_t position = 0;
 
 			// Need to escape quote with a double of ".
@@ -224,12 +223,12 @@ void FdbToSqlite::Convert::ReadRowValues(int32_t& numberOfColumns, std::string&
 		}
 
 		case eSqliteDataType::INT_BOOL:
-			BinaryIO::BinaryRead(fdb, boolValue);
+			BinaryIO::BinaryRead(cdClientBuffer, boolValue);
 			insertedRow << static_cast<bool>(boolValue);
 			break;
 
 		case eSqliteDataType::INT64:
-			int64Value = ReadInt64();
+			int64Value = ReadInt64(cdClientBuffer);
 			insertedRow << std::to_string(int64Value);
 			break;
 
@@ -244,5 +243,5 @@ void FdbToSqlite::Convert::ReadRowValues(int32_t& numberOfColumns, std::string&
 
 	auto copiedString = insertedRow.str();
 	CDClientDatabase::ExecuteDML(copiedString);
-	fdb.seekg(prevPosition);
+	cdClientBuffer.seekg(prevPosition);
 }

dCommon/FdbToSqlite.h

@@ -7,43 +7,139 @@
 #include <iosfwd>
 #include <map>
 
+class AssetMemoryBuffer;
+
 enum class eSqliteDataType : int32_t;
 
 namespace FdbToSqlite {
 	class Convert {
 	public:
-		Convert(std::string inputFile);
+		/**
+		 * Create a new convert object with an input .fdb file and an output binary path.
+		 * 
+		 * @param inputFile The file which ends in .fdb to be converted
+		 * @param binaryPath The base path where the file will be saved
+		 */
+		Convert(std::string binaryOutPath);
 
-		bool ConvertDatabase();
+		/**
+		 * Converts the input file to sqlite.  Calling multiple times is safe.
+		 * 
+		 * @return true if the database was converted properly, false otherwise. 
+		 */
+		bool ConvertDatabase(AssetMemoryBuffer& buffer);
 
-		int32_t ReadInt32();
+		/**
+		 * @brief Reads a 32 bit int from the fdb file.
+		 * 
+		 * @return The read value
+		 */
+		int32_t ReadInt32(std::istream& cdClientBuffer);
 
-		int64_t ReadInt64();
+		/**
+		 * @brief Reads a 64 bit integer from the fdb file.
+		 * 
+		 * @return The read value
+		 */
+		int64_t ReadInt64(std::istream& cdClientBuffer);
 
-		std::string ReadString();
+		/**
+		 * @brief Reads a string from the fdb file.
+		 * 
+		 * @return The read string
+		 * 
+		 * TODO This needs to be translated to latin-1!
+		 */
+		std::string ReadString(std::istream& cdClientBuffer);
 
-		int32_t SeekPointer();
+		/**
+		 * @brief Seeks to a pointer position.
+		 * 
+		 * @return The previous position before the seek
+		 */
+		int32_t SeekPointer(std::istream& cdClientBuffer);
 
-		std::string ReadColumnHeader();
+		/**
+		 * @brief Reads a column header from the fdb file and creates the table in the database
+		 * 
+		 * @return The table name
+		 */
+		std::string ReadColumnHeader(std::istream& cdClientBuffer);
 
-		void ReadTables(int32_t& numberOfTables);
+		/**
+		 * @brief Read the tables from the fdb file.
+		 * 
+		 * @param numberOfTables The number of tables to read
+		 */
+		void ReadTables(int32_t& numberOfTables, std::istream& cdClientBuffer);
 
-		std::string ReadColumns(int32_t& numberOfColumns);
+		/**
+		 * @brief Reads the columns from the fdb file.
+		 * 
+		 * @param numberOfColumns The number of columns to read
+		 * @return All columns of the table formatted for a sql query
+		 */
+		std::string ReadColumns(int32_t& numberOfColumns, std::istream& cdClientBuffer);
 
-		void ReadRowHeader(std::string& tableName);
+		/**
+		 * @brief Reads the row header from the fdb file.
+		 * 
+		 * @param tableName The tables name
+		 */
+		void ReadRowHeader(std::string& tableName, std::istream& cdClientBuffer);
 
-		void ReadRows(int32_t& numberOfAllocatedRows, std::string& tableName);
+		/**
+		 * @brief Read the rows from the fdb file.,
+		 * 
+		 * @param numberOfAllocatedRows The number of rows that were allocated.  Always a power of 2! 
+		 * @param tableName The tables name.
+		 */
+		void ReadRows(int32_t& numberOfAllocatedRows, std::string& tableName, std::istream& cdClientBuffer);
 
-		void ReadRow(int32_t& rowid, int32_t& position, std::string& tableName);
+		/**
+		 * @brief Reads a row from the fdb file.
+		 * 
+		 * @param position The position to seek in the fdb to
+		 * @param tableName The tables name
+		 */
+		void ReadRow(int32_t& position, std::string& tableName, std::istream& cdClientBuffer);
 
-		void ReadRowInfo(std::string& tableName);
+		/**
+		 * @brief Reads the row info from the fdb file.
+		 * 
+		 * @param tableName The tables name
+		 */
+		void ReadRowInfo(std::string& tableName, std::istream& cdClientBuffer);
 
-		void ReadRowValues(int32_t& numberOfColumns, std::string& tableName);
+		/**
+		 * @brief Reads each row and its values from the fdb file and inserts them into the database
+		 * 
+		 * @param numberOfColumns The number of columns to read in
+		 * @param tableName The tables name
+		 */
+		void ReadRowValues(int32_t& numberOfColumns, std::string& tableName, std::istream& cdClientBuffer);
 	private:
-		static std::map<eSqliteDataType, std::string> sqliteType;
-		std::string basePath{};
-		std::ifstream fdb{};
-	}; // class FdbToSqlite
+
+		/**
+		 * Maps each sqlite data type to its string equivalent.
+		 */
+		static std::map<eSqliteDataType, std::string> m_SqliteType;
+
+		/**
+		 * Base path of the folder containing the fdb file
+		 */
+		std::string m_BasePath{};
+		
+		/**
+		 * Whether or not a conversion was started.  If one was started, do not attempt to convert the file again.
+		 */
+		bool m_ConversionStarted{};
+
+		/**
+		 * The path where the CDServer will be stored
+		 */
+		std::string m_BinaryOutPath{};
+	}; //! class FdbToSqlite
 }; //! namespace FdbToSqlite
 
 #endif  //!__FDBTOSQLITE__H__

dCommon/Game.h

@@ -21,4 +21,5 @@ namespace Game {
 	extern RakPeerInterface* chatServer;
 	extern AssetManager* assetManager;
 	extern SystemAddress chatSysAddr;
+	extern bool shouldShutdown;
 }

dCommon/GeneralUtils.cpp

@@ -241,7 +241,7 @@ std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t d
 	return vector;
 }
 
-std::vector<std::u16string> GeneralUtils::SplitString(std::u16string& str, char16_t delimiter) {
+std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str, char16_t delimiter) {
 	std::vector<std::u16string> vector = std::vector<std::u16string>();
 	std::u16string current;
 
@@ -319,3 +319,7 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 
 	return sortedFiles;
 }
+
+bool GeneralUtils::TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst) {
+	return TryParse<float>(x.c_str(), dst.x) && TryParse<float>(y.c_str(), dst.y) && TryParse<float>(z.c_str(), dst.z);
+}

dCommon/GeneralUtils.h

@@ -10,10 +10,15 @@
 #include <type_traits>
 #include <stdexcept>
 #include <BitStream.h>
+#include "NiPoint3.h"
 
 #include "Game.h"
 #include "dLogger.h"
 
+enum eInventoryType : uint32_t;
+enum class eObjectBits : size_t;
+enum class eReplicaComponentType : uint32_t;
+
 /*!
   \file GeneralUtils.hpp
   \brief A namespace containing general utility functions
@@ -62,9 +67,9 @@ namespace GeneralUtils {
 
 	//! Sets a bit on a numerical value
 	template <typename T>
-	void SetBit(T& value, size_t index) {
+	inline void SetBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -74,9 +79,9 @@ namespace GeneralUtils {
 
 	//! Clears a bit on a numerical value
 	template <typename T>
-	void ClearBit(T& value, size_t index) {
+	inline void ClearBit(T& value, eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
+		auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -135,7 +140,7 @@ namespace GeneralUtils {
 
 	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);
 
-	std::vector<std::u16string> SplitString(std::u16string& str, char16_t delimiter);
+	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);
 
 	std::vector<std::string> SplitString(const std::string& str, char delimiter);
 
@@ -174,6 +179,16 @@ namespace GeneralUtils {
 		return std::stoull(value);
 	}
 
+	template <>
+	inline eInventoryType Parse(const char* value) {
+		return static_cast<eInventoryType>(std::stoul(value));
+	}
+
+	template <>
+	inline eReplicaComponentType Parse(const char* value) {
+		return static_cast<eReplicaComponentType>(std::stoul(value));
+	}
+
 	template <typename T>
 	bool TryParse(const char* value, T& dst) {
 		try {
@@ -195,6 +210,8 @@ namespace GeneralUtils {
 		return TryParse<T>(value.c_str(), dst);
 	}
 
+	bool TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst);
+
 	template<typename T>
 	std::u16string to_u16string(T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));

dCommon/LDFFormat.cpp

@@ -3,122 +3,174 @@
 // Custom Classes
 #include "GeneralUtils.h"
 
+#include "Game.h"
+#include "dLogger.h"
+
 // C++
-#include <sstream>
+#include <string_view>
 #include <vector>
 
+using LDFKey = std::string_view;
+using LDFTypeAndValue = std::string_view;
+
+using LDFType = std::string_view;
+using LDFValue = std::string_view;
+
 //! Returns a pointer to a LDFData value based on string format
-LDFBaseData* LDFBaseData::DataFromString(const std::string& format) {
+LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
+	// A valid LDF must be at least 3 characters long (=0:) is the shortest valid LDF (empty UTF-16 key with no initial value)
+	if (format.empty() || format.length() <= 2) return nullptr;
+	auto equalsPosition = format.find('=');
+	// You can have an empty key, just make sure the type and value might exist
+	if (equalsPosition == std::string::npos || equalsPosition == (format.size() - 1)) return nullptr;
 
-	// First, check the format
-	std::istringstream ssFormat(format);
-	std::string token;
+	std::pair<LDFKey, LDFTypeAndValue> keyValue;
+	keyValue.first = format.substr(0, equalsPosition);
+	keyValue.second = format.substr(equalsPosition + 1, format.size());
 
-	std::vector<std::string> keyValueArray;
-	while (std::getline(ssFormat, token, '=')) {
-		keyValueArray.push_back(token);
+	std::u16string key = GeneralUtils::ASCIIToUTF16(keyValue.first);
+
+	auto colonPosition = keyValue.second.find(':');
+
+	// If : is the first thing after an =, then this is an invalid LDF since
+	// we dont have a type to use.
+	if (colonPosition == std::string::npos || colonPosition == 0) return nullptr;
+
+	std::pair<LDFType, LDFValue> ldfTypeAndValue;
+	ldfTypeAndValue.first = keyValue.second.substr(0, colonPosition);
+	ldfTypeAndValue.second = keyValue.second.substr(colonPosition + 1, keyValue.second.size());
+
+	// Only allow empty values for string values.
+	if (ldfTypeAndValue.second.size() == 0 && !(ldfTypeAndValue.first == "0" || ldfTypeAndValue.first == "13")) return nullptr;
+
+	eLDFType type;
+	char* storage;
+	try {
+		type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
+	} catch (std::exception) {
+		Game::logger->Log("LDFFormat", "Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
+		return nullptr;
 	}
 
-	if (keyValueArray.size() == 2) {
-		std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
+	LDFBaseData* returnValue = nullptr;
+	switch (type) {
+	case LDF_TYPE_UTF_16: {
+		std::u16string data = GeneralUtils::UTF8ToUTF16(ldfTypeAndValue.second);
+		returnValue = new LDFData<std::u16string>(key, data);
+		break;
+	}
 
-		std::vector<std::string> dataArray;
-		std::istringstream ssData(keyValueArray[1]);
-		while (std::getline(ssData, token, ':')) {
-			dataArray.push_back(token);
+	case LDF_TYPE_S32: {
+		try {
+			int32_t data = static_cast<int32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<int32_t>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
 		}
+		break;
+	}
 
-		if (dataArray.size() > 2) { // hacky fix for strings with colons in them
-			std::vector<std::string> newDataArray;
-			newDataArray.push_back(dataArray[0]);
-			std::string value = "";
-			for (size_t i = 1; i < dataArray.size(); ++i) {
-				value += dataArray[i] + ':';
-			}
-			value.pop_back(); // remove last colon
-			newDataArray.push_back(value);
-			dataArray = newDataArray;
+	case LDF_TYPE_FLOAT: {
+		try {
+			float data = strtof(ldfTypeAndValue.second.data(), &storage);
+			returnValue = new LDFData<float>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
 		}
+		break;
+	}
 
-		if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
-			dataArray.push_back("");
+	case LDF_TYPE_DOUBLE: {
+		try {
+			double data = strtod(ldfTypeAndValue.second.data(), &storage);
+			returnValue = new LDFData<double>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
 		}
+		break;
+	}
 
-		if (dataArray.size() == 2) {
-			eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
+	case LDF_TYPE_U32:
+	{
+		uint32_t data;
 
-			switch (type) {
-			case LDF_TYPE_UTF_16: {
-				std::u16string data = GeneralUtils::UTF8ToUTF16(dataArray[1]);
-				return new LDFData<std::u16string>(key, data);
-			}
-
-			case LDF_TYPE_S32: {
-				int32_t data = static_cast<int32_t>(stoull(dataArray[1]));
-				return new LDFData<int32_t>(key, data);
-			}
-
-			case LDF_TYPE_FLOAT: {
-				float data = static_cast<float>(stof(dataArray[1]));
-				return new LDFData<float>(key, data);
-			}
-
-			case LDF_TYPE_DOUBLE: {
-				double data = static_cast<float>(stod(dataArray[1]));
-				return new LDFData<double>(key, data);
-			}
-
-			case LDF_TYPE_U32:
-			{
-				uint32_t data;
-
-				if (dataArray[1] == "true") {
-					data = 1;
-				} else if (dataArray[1] == "false") {
-					data = 0;
-				} else {
-					data = static_cast<uint32_t>(stoul(dataArray[1]));
-				}
-
-				return new LDFData<uint32_t>(key, data);
-			}
-
-			case LDF_TYPE_BOOLEAN: {
-				bool data;
-
-				if (dataArray[1] == "true") {
-					data = true;
-				} else if (dataArray[1] == "false") {
-					data = false;
-				} else {
-					data = static_cast<bool>(stoi(dataArray[1]));
-				}
-
-				return new LDFData<bool>(key, data);
-			}
-
-			case LDF_TYPE_U64: {
-				uint64_t data = static_cast<uint64_t>(stoull(dataArray[1]));
-				return new LDFData<uint64_t>(key, data);
-			}
-
-			case LDF_TYPE_OBJID: {
-				LWOOBJID data = static_cast<LWOOBJID>(stoll(dataArray[1]));
-				return new LDFData<LWOOBJID>(key, data);
-			}
-
-			case LDF_TYPE_UTF_8: {
-				std::string data = dataArray[1];
-				return new LDFData<std::string>(key, data);
-			}
-
-			case LDF_TYPE_UNKNOWN: {
+		if (ldfTypeAndValue.second == "true") {
+			data = 1;
+		} else if (ldfTypeAndValue.second == "false") {
+			data = 0;
+		} else {
+			try {
+				data = static_cast<uint32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
+			} catch (std::exception) {
+				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 				return nullptr;
 			}
-			}
 		}
+
+		returnValue = new LDFData<uint32_t>(key, data);
+		break;
 	}
 
-	return nullptr;
+	case LDF_TYPE_BOOLEAN: {
+		bool data;
 
+		if (ldfTypeAndValue.second == "true") {
+			data = true;
+		} else if (ldfTypeAndValue.second == "false") {
+			data = false;
+		} else {
+			try {
+				data = static_cast<bool>(strtol(ldfTypeAndValue.second.data(), &storage, 10));
+			} catch (std::exception) {
+				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+				return nullptr;
+			}
+		}
+
+		returnValue = new LDFData<bool>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_U64: {
+		try {
+			uint64_t data = static_cast<uint64_t>(strtoull(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<uint64_t>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
+	}
+
+	case LDF_TYPE_OBJID: {
+		try {
+			LWOOBJID data = static_cast<LWOOBJID>(strtoll(ldfTypeAndValue.second.data(), &storage, 10));
+			returnValue = new LDFData<LWOOBJID>(key, data);
+		} catch (std::exception) {
+			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			return nullptr;
+		}
+		break;
+	}
+
+	case LDF_TYPE_UTF_8: {
+		std::string data = ldfTypeAndValue.second.data();
+		returnValue = new LDFData<std::string>(key, data);
+		break;
+	}
+
+	case LDF_TYPE_UNKNOWN: {
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		break;
+	}
+
+	default: {
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
+		break;
+	}
+	}
+	return returnValue;
 }

dCommon/LDFFormat.h

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef __LDFFORMAT__H__
+#define __LDFFORMAT__H__
 
 // Custom Classes
 #include "dCommonVars.h"
@@ -6,18 +7,12 @@
 
 // C++
 #include <string>
+#include <string_view>
 #include <sstream>
 
 // RakNet
+#include "BitStream.h"
 
-#include "../thirdparty/raknet/Source/BitStream.h"
-
-/*!
-  \file LDFFormat.hpp
-  \brief A collection of LDF format classes
- */
-
- //! An enum for LDF Data Types
 enum eLDFType {
 	LDF_TYPE_UNKNOWN = -1,          //!< Unknown data type
 	LDF_TYPE_UTF_16 = 0,            //!< UTF-16 wstring data type
@@ -31,36 +26,21 @@ enum eLDFType {
 	LDF_TYPE_UTF_8 = 13,            //!< UTF-8 string data type
 };
 
-//! A base class for the LDF data
 class LDFBaseData {
 public:
 
-	//! Destructor
-	virtual ~LDFBaseData(void) {}
+	virtual ~LDFBaseData() {}
 
-	//! Writes the data to a packet
-	/*!
-	  \param packet The packet
-	 */
 	virtual void WriteToPacket(RakNet::BitStream* packet) = 0;
 
-	//! Gets the key
-	/*!
-	  \return The key
-	 */
-	virtual const std::u16string& GetKey(void) = 0;
+	virtual const std::u16string& GetKey() = 0;
 
-	//! Gets the value type
-	/*!
-	  \return The value type
-	 */
-	virtual eLDFType GetValueType(void) = 0;
+	virtual eLDFType GetValueType() = 0;
 
-	//! Gets a string from the key/value pair
-	/*!
-	  \param includeKey Whether or not to include the key in the data
-	  \param includeTypeId Whether or not to include the type id in the data
-	  \return The string representation of the data
+	/** Gets a string from the key/value pair
+	 * @param includeKey Whether or not to include the key in the data
+	 * @param includeTypeId Whether or not to include the type id in the data
+	 * @return The string representation of the data
 	 */
 	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;
 
@@ -68,19 +48,15 @@ public:
 
 	virtual LDFBaseData* Copy() = 0;
 
-	// MARK: Functions
-
-	//! Returns a pointer to a LDFData value based on string format
-	/*!
-	  \param format The format
+	/**
+	 * Given an input string, return the data as a LDF key.
 	 */
-	static LDFBaseData* DataFromString(const std::string& format);
+	static LDFBaseData* DataFromString(const std::string_view& format);
 
 };
 
-//! A structure for an LDF key-value pair
 template<typename T>
-class LDFData : public LDFBaseData {
+class LDFData: public LDFBaseData {
 private:
 	std::u16string key;
 	T value;
@@ -164,15 +140,11 @@ public:
 
 		if (includeKey) {
 			const std::string& sKey = GeneralUtils::UTF16ToWTF8(this->key, this->key.size());
-
-			stream << sKey << "=";
+			stream << sKey << '=';
 		}
 
 		if (includeTypeId) {
-			const std::string& sType = std::to_string(this->GetValueType());
-
-
-			stream << sType << ":";
+			stream << this->GetValueType() << ':';
 		}
 
 		const std::string& sData = this->GetValueString();
@@ -234,20 +206,18 @@ inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
 	}
 }
 
-// MARK: String Data
-template<> inline std::string LDFData<std::u16string>::GetValueString(void) {
-	//std::string toReturn(this->value.begin(), this->value.end());
-	//return toReturn;
-
+template<> inline std::string LDFData<std::u16string>::GetValueString() {
 	return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
 }
 
-template<> inline std::string LDFData<int32_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<float>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<double>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint32_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<bool>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint64_t>::GetValueString(void) { return std::to_string(this->value); }
-template<> inline std::string LDFData<LWOOBJID>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }
 
-template<> inline std::string LDFData<std::string>::GetValueString(void) { return this->value; }
+template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }
+
+#endif  //!__LDFFORMAT__H__

dCommon/NiPoint3.cpp

@@ -128,6 +128,12 @@ NiPoint3 NiPoint3::operator+(const NiPoint3& point) const {
 	return NiPoint3(this->x + point.x, this->y + point.y, this->z + point.z);
 }
 
+//! Operator for addition of vectors
+NiPoint3 NiPoint3::operator+=(const NiPoint3& point) const {
+	return NiPoint3(this->x + point.x, this->y + point.y, this->z + point.z);
+}
+
+
 //! Operator for subtraction of vectors
 NiPoint3 NiPoint3::operator-(const NiPoint3& point) const {
 	return NiPoint3(this->x - point.x, this->y - point.y, this->z - point.z);

dCommon/NiPoint3.h

@@ -135,6 +135,9 @@ public:
 	//! Operator for addition of vectors
 	NiPoint3 operator+(const NiPoint3& point) const;
 
+	//! Operator for addition of vectors
+	NiPoint3 operator+=(const NiPoint3& point) const;
+
 	//! Operator for subtraction of vectors
 	NiPoint3 operator-(const NiPoint3& point) const;
 

dCommon/PermissionMap.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-/**
- * Bitmap of permissions and restrictions for characters.
- */
-enum class PermissionMap : uint64_t
-{
-	/**
-	 * Reserved for future use, bit 0-3.
-	 */
-
-	 /**
-	  * The character has restricted trade acccess, bit 4.
-	  */
-	RestrictedTradeAccess = 0x1 << 4,
-
-	/**
-	 * The character has restricted mail access, bit 5.
-	 */
-	 RestrictedMailAccess = 0x1 << 5,
-
-	 /**
-	  * The character has restricted chat access, bit 6.
-	  */
-	  RestrictedChatAccess = 0x1 << 6,
-
-	  //
-	  // Combined permissions
-	  //
-
-	  /**
-	   * The character is marked as 'old', restricted from trade and mail.
-	   */
-	   Old = RestrictedTradeAccess | RestrictedMailAccess,
-
-	   /**
-		* The character is soft banned, restricted from trade, mail, and chat.
-		*/
-		SoftBanned = RestrictedTradeAccess | RestrictedMailAccess | RestrictedChatAccess,
-};

dCommon/dClient/AssetManager.cpp

@@ -45,9 +45,10 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 	switch (m_AssetBundleType) {
 		case eAssetBundleType::Packed: {
 			this->LoadPackIndex();
-
-			this->UnpackRequiredAssets();
-
+			break;
+		}
+		case eAssetBundleType::None:
+		case eAssetBundleType::Unpacked: {
 			break;
 		}
 	}
@@ -114,7 +115,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		*len = ftell(file);
 		*data = (char*)malloc(*len);
 		fseek(file, 0, SEEK_SET);
-		fread(*data, sizeof(uint8_t), *len, file);
+		int32_t readInData = fread(*data, sizeof(uint8_t), *len, file);
 		fclose(file);
 
 		return true;
@@ -160,31 +161,6 @@ AssetMemoryBuffer AssetManager::GetFileAsBuffer(const char* name) {
 	return AssetMemoryBuffer(buf, len, success);
 }
 
-void AssetManager::UnpackRequiredAssets() {
-	if (std::filesystem::exists(m_ResPath / "cdclient.fdb")) return;
-
-	char* data;
-	uint32_t size;
-
-	bool success = this->GetFile("cdclient.fdb", &data, &size);
-
-	if (!success) {
-		Game::logger->Log("AssetManager", "Failed to extract required files from the packs.");
-
-		delete data;
-
-		return;
-	}
-
-	std::ofstream cdclientOutput(m_ResPath / "cdclient.fdb", std::ios::out | std::ios::binary);
-	cdclientOutput.write(data, size);
-	cdclientOutput.close();
-
-	delete data;
-
-	return;
-}
-
 uint32_t AssetManager::crc32b(uint32_t base, uint8_t* message, size_t l) {
 	size_t i, j;
 	uint32_t crc, msb;

dCommon/dClient/AssetManager.h

@@ -60,7 +60,6 @@ public:
 
 private:
 	void LoadPackIndex();
-	void UnpackRequiredAssets();
 
 	// Modified crc algorithm (mpeg2)
 	// Reference: https://stackoverflow.com/questions/54339800/how-to-modify-crc-32-to-crc-32-mpeg-2

dCommon/dClient/Pack.cpp

@@ -77,7 +77,7 @@ bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
 
 	if (!isCompressed) {
 		char* tempData = (char*)malloc(pkRecord.m_UncompressedSize);
-		fread(tempData, sizeof(uint8_t), pkRecord.m_UncompressedSize, file);
+		int32_t readInData = fread(tempData, sizeof(uint8_t), pkRecord.m_UncompressedSize, file);
 
 		*data = tempData;
 		*len = pkRecord.m_UncompressedSize;
@@ -97,11 +97,11 @@ bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
 		if (currentReadPos >= pkRecord.m_UncompressedSize) break;
 
 		uint32_t size;
-		fread(&size, sizeof(uint32_t), 1, file);
+		int32_t readInData = fread(&size, sizeof(uint32_t), 1, file);
 		pos += 4; // Move pointer position 4 to the right
 
 		char* chunk = (char*)malloc(size);
-		fread(chunk, sizeof(int8_t), size, file);
+		int32_t readInData2 = fread(chunk, sizeof(int8_t), size, file);
 		pos += size; // Move pointer position the amount of bytes read to the right
 
 		int32_t err;

dCommon/dConfig.h

@@ -24,7 +24,6 @@ public:
 	 * Reloads the config file to reset values
 	 */
 	void ReloadConfig();
-
 private:
 	void ProcessLine(const std::string& line);
 

dCommon/dEnums/ItemSetPassiveAbilityID.h

@@ -1,105 +0,0 @@
-#pragma once
-
-/**
-2	Engineer (Rank 1) Item Set
-3	Engineer (Rank 2) Item Set
-4	Engineer (Rank 3) Item Set
-7	Knight (Rank 1) Item Set
-8	Knight (Rank 2) Item Set
-9	Knight (Rank 3) Item Set
-10	Space Ranger (Rank 1) Item Set
-11	Space Ranger (Rank 2) Item Set
-12	Space Ranger (Rank 3) Item Set
-13	Samurai (Rank 1) Item Set
-14	Samurai (Rank 2) Item Set
-15	Samurai (Rank 3) Item Set
-16	Sorcerer (Rank 1) Item Set
-17	Sorcerer (Rank 2) Item Set
-18	Sorcerer (Rank 3) Item Set
-19	Space Marauder (Rank 1) Item Set
-20	Space Marauder (Rank 2) Item Set
-21	Space Marauder (Rank 3) Item Set
-22	Shinobi (Rank 1) Item Set
-23	Shinobi (Rank 2) Item Set
-24	Shinobi (Rank 3) Item Set
-25	Inventor (Rank 1) Item Set
-26	Inventor (Rank 2) Item Set
-27	Inventor (Rank 3) Item Set
-28	Summoner (Rank 1) Item Set
-29	Summoner (Rank 2) Item Set
-30	Summoner (Rank 3) Item Set
-31	Adventurer (Rank 1) Item Set
-32	Adventurer (Rank 2) Item Set
-33	Adventurer (Rank 3) Item Set
-34	Daredevil (Rank 1) Item Set
-35	Daredevil (Rank 2) Item Set
-36	Daredevil (Rank 3) Item Set
-37	Buccaneer (Rank 1) Item Set
-38	Buccaneer (Rank 2) Item Set
-39	Buccaneer (Rank 3) Item Set
-40	Bone Suit Item Set
-41	Imagination Spinjitzu Item Set
-42	Bat Lord Item Set
-43	Mosaic Jester Item Set
-44	Explorien Bot Item Set
-45	[Unnamed] Item Set
-46	[Unnamed] Item Set
-47	[Unnamed] Item Set
-48	Earth Spinjitzu Item Set
-49	[Unnamed] Item Set
-50	Fire Spinjitzu Item Set
-51	Ice Spinjitzu Item Set
-52	Lightning Spinjitzu Item Set
- */
-enum class ItemSetPassiveAbilityID
-{
-	EngineerRank1 = 2,
-	EngineerRank2 = 3,
-	EngineerRank3 = 4,
-	KnightRank1 = 7,
-	KnightRank2 = 8,
-	KnightRank3 = 9,
-	SpaceRangerRank1 = 10,
-	SpaceRangerRank2 = 11,
-	SpaceRangerRank3 = 12,
-	SamuraiRank1 = 13,
-	SamuraiRank2 = 14,
-	SamuraiRank3 = 15,
-	SorcererRank1 = 16,
-	SorcererRank2 = 17,
-	SorcererRank3 = 18,
-	SpaceMarauderRank1 = 19,
-	SpaceMarauderRank2 = 20,
-	SpaceMarauderRank3 = 21,
-	ShinobiRank1 = 22,
-	ShinobiRank2 = 23,
-	ShinobiRank3 = 24,
-	InventorRank1 = 25,
-	InventorRank2 = 26,
-	InventorRank3 = 27,
-	SummonerRank1 = 28,
-	SummonerRank2 = 29,
-	SummonerRank3 = 30,
-	AdventurerRank1 = 31,
-	AdventurerRank2 = 32,
-	AdventurerRank3 = 33,
-	DaredevilRank1 = 34,
-	DaredevilRank2 = 35,
-	DaredevilRank3 = 36,
-	BuccaneerRank1 = 37,
-	BuccaneerRank2 = 38,
-	BuccaneerRank3 = 39,
-	BoneSuit = 40,
-	ImaginationSpinjitzu = 41,
-	BatLord = 42,
-	MosaicJester = 43,
-	ExplorienBot = 44,
-	Unnamed1 = 45,
-	Unnamed2 = 46,
-	Unnamed3 = 47,
-	EarthSpinjitzu = 48,
-	Unnamed4 = 49,
-	FireSpinjitzu = 50,
-	IceSpinjitzu = 51,
-	LightningSpinjitzu = 52
-};

dCommon/dEnums/MissionLockState.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#ifndef MISSIONLOCKSTATE_H
-#define MISSIONLOCKSTATE_H
-
-enum class MissionLockState : int
-{
-	MISSION_LOCK_LOCKED,
-	MISSION_LOCK_NEW,
-	MISSION_LOCK_UNLOCKED,
-};
-
-#endif

dCommon/dEnums/MissionState.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#ifndef __MISSIONSTATE__H__
-#define __MISSIONSTATE__H__
-
-/**
- * Represents the possible states a mission can be in
- */
-enum class MissionState : int {
-	/**
-	 * The mission state is unknown
-	 */
-	MISSION_STATE_UNKNOWN = -1,
-
-	/**
-	 * The mission is yielding rewards
-	 */
-	 MISSION_STATE_REWARDING = 0,
-
-	 /**
-	  * The mission can be accepted
-	  */
-	  MISSION_STATE_AVAILABLE = 1,
-
-	  /**
-	   * The mission has been accepted but not yet completed
-	   */
-	   MISSION_STATE_ACTIVE = 2,
-
-	   /**
-		* All the tasks for the mission have been completed and the entity can turn the mission in to complete it
-		*/
-		MISSION_STATE_READY_TO_COMPLETE = 4,            //!< The mission is ready to complete
-
-		/**
-		 * The mission has been completed
-		 */
-		 MISSION_STATE_COMPLETE = 8,
-
-		 /**
-		  * The mission is available again and has been completed before. Used for daily missions.
-		  */
-		  MISSION_STATE_COMPLETE_AVAILABLE = 9,
-
-		  /**
-		   * The mission is active and has been completed before. Used for daily missions.
-		   */
-		   MISSION_STATE_COMPLETE_ACTIVE = 10,
-
-		   /**
-			* The mission has been completed before and has now been completed again. Used for daily missions.
-			*/
-			MISSION_STATE_COMPLETE_READY_TO_COMPLETE = 12
-};
-
-#endif  //!__MISSIONSTATE__H__

dCommon/dEnums/MissionTaskType.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#ifndef MISSIONTASKTYPE_H
-#define MISSIONTASKTYPE_H
-
-//! An enum for mission task types
-enum class MissionTaskType : int {
-	MISSION_TASK_TYPE_UNKNOWN = -1,                     //!< The task type is unknown
-	MISSION_TASK_TYPE_SMASH = 0,                        //!< A task for smashing something
-	MISSION_TASK_TYPE_SCRIPT = 1,                       //!< A task handled by a server LUA script
-	MISSION_TASK_TYPE_ACTIVITY = 2,                     //!< A task for completing a quickbuild
-	MISSION_TASK_TYPE_ENVIRONMENT = 3,                  //!< A task for something in the environment
-	MISSION_TASK_TYPE_MISSION_INTERACTION = 4,          //!< A task for interacting with a mission
-	MISSION_TASK_TYPE_EMOTE = 5,                        //!< A task for playing an emote
-	MISSION_TASK_TYPE_FOOD = 9,                         //!< A task for eating food
-	MISSION_TASK_TYPE_SKILL = 10,                       //!< A task for performing a skill
-	MISSION_TASK_TYPE_ITEM_COLLECTION = 11,             //!< A task for collecting an item
-	MISSION_TASK_TYPE_LOCATION = 12,                    //!< A task for finding a location
-	MISSION_TASK_TYPE_MINIGAME = 14,                    //!< A task for doing something in a minigame
-	MISSION_TASK_TYPE_NON_MISSION_INTERACTION = 15,     //!< A task for interacting with a non-mission
-	MISSION_TASK_TYPE_MISSION_COMPLETE = 16,            //!< A task for completing a mission
-	MISSION_TASK_TYPE_EARN_REPUTATION = 17,             //!< A task for earning reputation
-	MISSION_TASK_TYPE_POWERUP = 21,                     //!< A task for collecting a powerup
-	MISSION_TASK_TYPE_PET_TAMING = 22,                  //!< A task for taming a pet
-	MISSION_TASK_TYPE_RACING = 23,                      //!< A task for racing
-	MISSION_TASK_TYPE_PLAYER_FLAG = 24,                 //!< A task for setting a player flag
-	MISSION_TASK_TYPE_PLACE_MODEL = 25,                //!< A task for picking up a model
-	MISSION_TASK_TYPE_VISIT_PROPERTY = 30               //!< A task for visiting a property
-};
-
-#endif

dCommon/dEnums/RacingTaskParam.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-enum class RacingTaskParam : int32_t {
-	RACING_TASK_PARAM_FINISH_WITH_PLACEMENT = 1,            //<! A task param for finishing with a specific placement.
-	RACING_TASK_PARAM_LAP_TIME = 2,                         //<! A task param for finishing with a specific lap time.
-	RACING_TASK_PARAM_TOTAL_TRACK_TIME = 3,                 //<! A task param for finishing with a specific track time.
-	RACING_TASK_PARAM_COMPLETE_ANY_RACING_TASK = 4,         //<! A task param for completing a racing task.
-	RACING_TASK_PARAM_COMPLETE_TRACK_TASKS = 5,             //<! A task param for completing a task for a specific track.
-	RACING_TASK_PARAM_MODULAR_BUILDING = 6,                 //<! A task param for modular building with racing builds.
-	RACING_TASK_PARAM_SAFE_DRIVER = 10,                     //<! A task param for completing a race without smashing.
-	RACING_TASK_PARAM_SMASHABLES = 11,                      //<! A task param for smashing entities during a race.
-	RACING_TASK_PARAM_COLLECT_IMAGINATION = 12,             //<! A task param for collecting imagination during a race.
-	RACING_TASK_PARAM_COMPETED_IN_RACE = 13,                //<! A task param for competing in a race.
-	RACING_TASK_PARAM_WIN_RACE_IN_WORLD = 14,               //<! A task param for winning a race in a specific world.
-	RACING_TASK_PARAM_FIRST_PLACE_MULTIPLE_TRACKS = 15,     //<! A task param for finishing in first place on multiple tracks.
-	RACING_TASK_PARAM_LAST_PLACE_FINISH = 16,               //<! A task param for finishing in last place.
-	RACING_TASK_PARAM_SMASH_SPECIFIC_SMASHABLE = 17         //<! A task param for smashing dragon eggs during a race.
-};

dCommon/dEnums/dCommonVars.h

@@ -6,21 +6,31 @@
 #include <cstdint>
 #include <string>
 #include <set>
-#include "../thirdparty/raknet/Source/BitStream.h"
+#include "BitStream.h"
+#include "eConnectionType.h"
+#include "eClientMessageType.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
-typedef int RESTICKET;
+// These are the same define, but they mean two different things in different contexts
+// so a different define to distinguish what calculation is happening will help clarity.
+#define FRAMES_TO_MS(x) 1000 / x
+#define MS_TO_FRAMES(x) 1000 / x
 
-const int highFrameRate = 16;	//60fps
-const int mediumFramerate = 33;	//30fps
-const int lowFramerate = 66;	//15fps
+//=========== FRAME TIMINGS ===========
+constexpr uint32_t highFramerate = 60;
+constexpr uint32_t mediumFramerate = 30;
+constexpr uint32_t lowFramerate = 15;
+
+constexpr uint32_t highFrameDelta = FRAMES_TO_MS(highFramerate);
+constexpr uint32_t mediumFrameDelta = FRAMES_TO_MS(mediumFramerate);
+constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 
 //========== MACROS ===========
 
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
-#define CMSGHEADER PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GAME_MSG);
+#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
 #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 
@@ -33,33 +43,20 @@ typedef uint32_t LWOCLONEID;                 //!< Used for Clone IDs
 typedef uint16_t LWOMAPID;                   //!< Used for Map IDs
 typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
 typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
-typedef uint32_t STRIPID;
-typedef uint32_t BEHAVIORSTATE;
-
-typedef int32_t PetTamingPiece;             //!< Pet Taming Pieces
+typedef uint32_t StripId;
 
 const LWOOBJID LWOOBJID_EMPTY = 0;          //!< An empty object ID
 const LOT LOT_NULL = -1;                    //!< A null LOT
 const int32_t LOOTTYPE_NONE = 0;            //!< No loot type available
 const float SECONDARY_PRIORITY = 1.0f;      //!< Secondary Priority
-const uint32_t INVENTORY_INVALID = -1;      //!< Invalid Inventory
-const uint32_t INVENTORY_DEFAULT = -1;      //!< Default Inventory
-const uint32_t StatusChangeInfo = 0;        //!< Status Change Info (???)
 const uint32_t INVENTORY_MAX = 9999999;     //!< The Maximum Inventory Size
 const uint32_t LWOCLONEID_INVALID = -1;     //!< Invalid LWOCLONEID
 const uint16_t LWOINSTANCEID_INVALID = -1;  //!< Invalid LWOINSTANCEID
 const uint16_t LWOMAPID_INVALID = -1;       //!< Invalid LWOMAPID
 const uint64_t LWOZONEID_INVALID = 0;       //!< Invalid LWOZONEID
 
-typedef std::set<LWOOBJID> TSetObjID;
-
 const float PI = 3.14159f;
 
-#if defined(__unix) || defined(__APPLE__)
-//For Linux:
-typedef __int64_t __int64;
-#endif
-
 //============ STRUCTS ==============
 
 struct LWOSCENEID {
@@ -160,500 +157,4 @@ public:
 	}
 };
 
-struct Brick {
-	uint32_t designerID;
-	uint32_t materialID;
-};
-
-//This union is used by the behavior system
-union suchar {
-	unsigned char usigned;
-	char svalue;
-};
-
-//=========== DLU ENUMS ============
-
-enum eGameMasterLevel : int32_t {
-	GAME_MASTER_LEVEL_CIVILIAN = 0,             // Normal player.
-	GAME_MASTER_LEVEL_FORUM_MODERATOR = 1,      // No permissions on live servers.
-	GAME_MASTER_LEVEL_JUNIOR_MODERATOR = 2,     // Can kick/mute and pull chat logs.
-	GAME_MASTER_LEVEL_MODERATOR = 3,            // Can return lost items.
-	GAME_MASTER_LEVEL_SENIOR_MODERATOR = 4,     // Can ban.
-	GAME_MASTER_LEVEL_LEAD_MODERATOR = 5,       // Can approve properties.
-	GAME_MASTER_LEVEL_JUNIOR_DEVELOPER = 6,     // Junior developer & future content team. Civilan on live.
-	GAME_MASTER_LEVEL_INACTIVE_DEVELOPER = 7,   // Inactive developer, limited permissions.
-	GAME_MASTER_LEVEL_DEVELOPER = 8,            // Active developer, full permissions on live.
-	GAME_MASTER_LEVEL_OPERATOR = 9              // Can shutdown server for restarts & updates.
-};
-
-//=========== LU ENUMS ============
-
-//! An enum for object ID bits
-enum eObjectBits : int32_t {
-	OBJECT_BIT_PERSISTENT = 32,     //!< The 32 bit index
-	OBJECT_BIT_CLIENT = 46,         //!< The 46 bit index
-	OBJECT_BIT_SPAWNED = 58,        //!< The 58 bit index
-	OBJECT_BIT_CHARACTER = 60       //!< The 60 bit index
-};
-
-//! An enum for MatchUpdate types
-enum eMatchUpdate : int {
-	MATCH_UPDATE_PLAYER_JOINED = 0,
-	MATCH_UPDATE_PLAYER_LEFT = 1,
-	MATCH_UPDATE_TIME = 3,
-	MATCH_UPDATE_TIME_START_DELAY = 4,
-	MATCH_UPDATE_PLAYER_READY = 5,
-	MATCH_UPDATE_PLAYER_UNREADY = 6
-};
-
-//! An enum for camera cycling modes
-enum eCyclingMode : uint32_t {
-	ALLOW_CYCLE_TEAMMATES,
-	DISALLOW_CYCLING
-};
-
-enum eCinematicEvent : uint32_t {
-	STARTED,
-	WAYPOINT,
-	ENDED,
-};
-
-//! An enum for character creation responses
-enum eCreationResponse : uint8_t {
-	CREATION_RESPONSE_SUCCESS = 0,                  //!< The creation was successful
-	CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE,        //!< The Object ID can't be used
-	CREATION_RESPONSE_NAME_NOT_ALLOWED,             //!< The name is not allowed
-	CREATION_RESPONSE_PREDEFINED_NAME_IN_USE,       //!< The predefined name is already in use
-	CREATION_RESPONSE_CUSTOM_NAME_IN_USE            //!< The custom name is already in use
-};
-
-//! An enum for login responses
-enum eLoginResponse : uint8_t {
-	LOGIN_RESPONSE_GENERAL_FAILED = 0,
-	LOGIN_RESPONSE_SUCCESS = 1,
-	LOGIN_RESPONSE_BANNED = 2,
-	LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH = 5,
-	LOGIN_RESPONSE_WRONG_PASS_OR_USER = 6,
-	LOGIN_RESPONSE_ACCOUNT_LOCKED = 7
-};
-
-//! An enum for character rename responses
-enum eRenameResponse : uint8_t {
-	RENAME_RESPONSE_SUCCESS = 0,                    //!< The renaming was successful
-	RENAME_RESPONSE_UNKNOWN_ERROR,                  //!< There was an unknown error
-	RENAME_RESPONSE_NAME_UNAVAILABLE,               //!< The name is unavailable
-	RENAME_RESPONSE_NAME_IN_USE                     //!< The name is already in use
-};
-
-//! A replica packet type
-enum eReplicaPacketType {
-	PACKET_TYPE_CONSTRUCTION,                       //!< A construction packet
-	PACKET_TYPE_SERIALIZATION,                      //!< A serialization packet
-	PACKET_TYPE_DESTRUCTION                         //!< A destruction packet
-};
-
-enum ServerDisconnectIdentifiers {
-	SERVER_DISCON_UNKNOWN_SERVER_ERROR = 0,               //!< Unknown server error
-	SERVER_DISCON_DUPLICATE_LOGIN = 4,                    //!< Used when another user with the same username is logged in (duplicate login)
-	SERVER_DISCON_SERVER_SHUTDOWN = 5,                    //!< Used when the server is shutdown
-	SERVER_DISCON_SERVER_MAP_LOAD_FAILURE = 6,            //!< Used when the server cannot load a map
-	SERVER_DISCON_INVALID_SESSION_KEY = 7,                //!< Used if the session is invalid
-	SERVER_DISCON_ACCOUNT_NOT_IN_PENDING_LIST = 8,        //!< ???
-	SERVER_DISCON_CHARACTER_NOT_FOUND = 9,                //!< Used if a character that the server has is not found (i.e, corruption with user-player data)
-	SERVER_DISCON_CHARACTER_CORRUPTED = 10,               //!< Similar to abovce
-	SERVER_DISCON_KICK = 11,                              //!< Used if the user is kicked from the server
-	SERVER_DISCON_FREE_TRIAL_EXPIRED = 12,                //!< Used if the user's free trial expired
-	SERVER_DISCON_PLAY_SCHEDULE_TIME_DONE = 13            //!< Used if the user's play time is used up
-};
-
-//! The Behavior Types for use with the AI system
-enum eCombatBehaviorTypes : uint32_t {
-	PASSIVE = 0,                    //!< The object is passive
-	AGGRESSIVE = 1,                 //!< The object is aggressive
-	PASSIVE_TURRET = 2,             //!< The object is a passive turret
-	AGGRESSIVE_TURRET = 3           //!< The object is an aggressive turret
-};
-
-//! The Combat Role Type for use with the AI system
-enum eCombatRoleType : uint32_t {
-	MELEE = 0,                      //!< Used for melee attacks
-	RANGED = 1,                     //!< Used for range attacks
-	SUPPORT = 2                     //!< Used for support
-};
-
-//! The kill types for the Die packet
-enum eKillType : uint32_t {
-	VIOLENT,
-	SILENT
-};
-
-//! The various world states used throughout the server
-enum eObjectWorldState {
-	WORLDSTATE_INWORLD,             //!< Probably used when the object is in the world
-	WORLDSTATE_ATTACHED,            //!< Probably used when the object is attached to another object
-	WORLDSTATE_INVENTORY            //!< Probably used when the object is in an inventory
-};
-
-//! The trigger stats (???)
-enum eTriggerStat {
-	INVALID_STAT,                   //!< ???
-	HEALTH,                         //!< Probably used for health
-	ARMOR,                          //!< Probably used for armor
-	IMAGINATION                     //!< Probably used for imagination
-};
-
-//! The trigger operations (???)
-enum eTriggerOperator {
-	INVALID_OPER,                   //!< ???
-	EQUAL,                          //!< ???
-	NOT_EQUAL,                      //!< ???
-	GREATER,                        //!< ???
-	GREATER_EQUAL,                  //!< ???
-	LESS,                           //!< ???
-	LESS_EQUAL                      //!< ???
-};
-
-//! The various build types
-enum eBuildType {
-	BUILD_NOWHERE,                  //!< Used if something can't be built anywhere
-	BUILD_IN_WORLD,                 //!< Used if something can be built in the world
-	BUILD_ON_PROPERTY               //!< Used if something can be build on a property
-};
-
-//! Quickbuild fail reasons
-enum eFailReason : uint32_t {
-	REASON_NOT_GIVEN,
-	REASON_OUT_OF_IMAGINATION,
-	REASON_CANCELED_EARLY,
-	REASON_BUILD_ENDED
-};
-
-//! Terminate interaction type
-enum eTerminateType : uint32_t {
-	RANGE,
-	USER,
-	FROM_INTERACTION
-};
-
-//! The combat state
-enum eCombatState {
-	IDLE,                           //!< The AI is in an idle state
-	AGGRO,                          //!< The AI is in an aggressive state
-	TETHER,                         //!< The AI is being redrawn back to tether point
-	SPAWN,                          //!< The AI is spawning
-	DEAD                            //!< The AI is dead
-};
-
-enum eControlSceme {
-	SCHEME_A,
-	SCHEME_D,
-	SCHEME_GAMEPAD,
-	SCHEME_E,
-	SCHEME_FPS,
-	SCHEME_DRIVING,
-	SCHEME_TAMING,
-	SCHEME_MODULAR_BUILD,
-	SCHEME_WEAR_A_ROBOT //== freecam?
-};
-
-enum eStunState {
-	PUSH,
-	POP
-};
-
-enum eNotifyType {
-	NOTIFY_TYPE_SUCCESS,
-	NOTIFY_TYPE_QUIT,
-	NOTIFY_TYPE_FAILED,
-	NOTIFY_TYPE_BEGIN,
-	NOTIFY_TYPE_READY,
-	NOTIFY_TYPE_NAMINGPET
-};
-
-enum eReplicaComponentType : int32_t {
-	COMPONENT_TYPE_CONTROLLABLE_PHYSICS = 1,			//!< The ControllablePhysics Component
-	COMPONENT_TYPE_RENDER = 2,			//!< The Render Component
-	COMPONENT_TYPE_SIMPLE_PHYSICS = 3,			//!< The SimplePhysics Component
-	COMPONENT_TYPE_CHARACTER = 4,			//!< The Character Component
-	COMPONENT_TYPE_SCRIPT = 5,			//!< The Script Component
-	COMPONENT_TYPE_BOUNCER = 6,			//!< The Bouncer Component
-	COMPONENT_TYPE_BUFF = 7,			//!< The Buff Component
-	COMPONENT_TYPE_SKILL = 9,			//!< The Skill Component
-	COMPONENT_TYPE_ITEM = 11,			//!< The Item Component
-	COMPONENT_TYPE_VENDOR = 16,			//!< The Vendor Component
-	COMPONENT_TYPE_INVENTORY = 17,			//!< The Inventory Component
-	COMPONENT_TYPE_SHOOTING_GALLERY = 19,			//!< The Shooting Gallery Component
-	COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS = 20,			//!< The RigidBodyPhantomPhysics Component
-	COMPONENT_TYPE_COLLECTIBLE = 23,			//!< The Collectible Component
-	COMPONENT_TYPE_MOVING_PLATFORM = 25,			//!< The MovingPlatform Component
-	COMPONENT_TYPE_PET = 26,			//!< The Pet Component
-	COMPONENT_TYPE_VEHICLE_PHYSICS = 30,			//!< The VehiclePhysics Component
-	COMPONENT_TYPE_MOVEMENT_AI = 31,			//!< The MovementAI Component
-	COMPONENT_TYPE_PROPERTY = 36,			//!< The Property Component
-	COMPONENT_TYPE_SCRIPTED_ACTIVITY = 39,			//!< The ScriptedActivity Component
-	COMPONENT_TYPE_PHANTOM_PHYSICS = 40,			//!< The PhantomPhysics Component
-	COMPONENT_TYPE_MODEL = 42,			//!< The Model Component
-	COMPONENT_TYPE_PROPERTY_ENTRANCE = 43,			//!< The PhantomPhysics Component
-	COMPONENT_TYPE_PROPERTY_MANAGEMENT = 45,			//!< The PropertyManagement Component
-	COMPONENT_TYPE_REBUILD = 48,			//!< The Rebuild Component
-	COMPONENT_TYPE_SWITCH = 49,			//!< The Switch Component
-	COMPONENT_TYPE_ZONE_CONTROL = 50,			//!< The ZoneControl Component
-	COMPONENT_TYPE_PACKAGE = 53,			//!< The Package Component
-	COMPONENT_TYPE_PLAYER_FLAG = 58,			//!< The PlayerFlag Component
-	COMPONENT_TYPE_BASE_COMBAT_AI = 60,			//!< The BaseCombatAI Component
-	COMPONENT_TYPE_MODULE_ASSEMBLY = 61,			//!< The ModuleAssembly Component
-	COMPONENT_TYPE_PROPERTY_VENDOR = 65,			//!< The PropertyVendor Component
-	COMPONENT_TYPE_ROCKET_LAUNCH = 67,			//!< The RocketLaunch Component
-	COMPONENT_TYPE_RACING_CONTROL = 71,			//!< The RacingControl Component
-	COMPONENT_TYPE_MISSION_OFFER = 73,			//!< The MissionOffer Component
-	COMPONENT_TYPE_EXHIBIT = 75,			//!< The Exhibit Component
-	COMPONENT_TYPE_RACING_STATS = 74,			//!< The Racing Stats Component
-	COMPONENT_TYPE_SOUND_TRIGGER = 77,			//!< The Sound Trigger Component
-	COMPONENT_TYPE_PROXIMITY_MONITOR = 78,			//!< The Proximity Monitor Component
-	COMPONENT_TYPE_MISSION = 84,			//!< The Mission Component
-	COMPONENT_TYPE_ROCKET_LAUNCH_LUP = 97,			//!< The LUP Launchpad Componen
-	COMPONENT_TYPE_RAIL_ACTIVATOR = 104,			//!< The Rail Activator Component
-	COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT = 106,			//!< The Player Forced Movement Component
-	COMPONENT_TYPE_POSSESSABLE = 108,			//!< The Possessable Component
-	COMPONENT_TYPE_LEVEL_PROGRESSION = 109,			//!< The Level Progression Component
-	COMPONENT_TYPE_POSSESSOR = 110,			//!< The Possessor Component
-	COMPONENT_TYPE_BUILD_BORDER = 114,			//!< The Build Border Component
-	COMPONENT_TYPE_DESTROYABLE = 1000,			//!< The Destroyable Component
-};
-
-enum class UseItemResponse : uint32_t {
-	NoImaginationForPet = 1,
-	FailedPrecondition,
-	MountsNotAllowed
-};
-
-/**
- * Represents the different types of inventories an entity may have
- */
-enum eInventoryType : uint32_t {
-	ITEMS = 0,
-	VAULT_ITEMS,
-	BRICKS,
-	MODELS_IN_BBB,
-	TEMP_ITEMS = 4,
-	MODELS,
-	TEMP_MODELS,
-	BEHAVIORS,
-	PROPERTY_DEEDS,
-	VENDOR_BUYBACK = 11,
-	HIDDEN = 12, //Used for missional items
-	VAULT_MODELS = 14,
-	ITEM_SETS, //internal
-	INVALID // made up, for internal use!!!
-};
-
-enum eRebuildState : uint32_t {
-	REBUILD_OPEN,
-	REBUILD_COMPLETED = 2,
-	REBUILD_RESETTING = 4,
-	REBUILD_BUILDING,
-	REBUILD_INCOMPLETE
-};
-
-/**
- * The loot source's type.
- */
-enum eLootSourceType : int32_t {
-	LOOT_SOURCE_NONE = 0,
-	LOOT_SOURCE_CHEST,
-	LOOT_SOURCE_MISSION,
-	LOOT_SOURCE_MAIL,
-	LOOT_SOURCE_CURRENCY,
-	LOOT_SOURCE_ACHIEVEMENT,
-	LOOT_SOURCE_TRADE,
-	LOOT_SOURCE_QUICKBUILD,
-	LOOT_SOURCE_DELETION,
-	LOOT_SOURCE_VENDOR,
-	LOOT_SOURCE_ACTIVITY,
-	LOOT_SOURCE_PICKUP,
-	LOOT_SOURCE_BRICK,
-	LOOT_SOURCE_PROPERTY,
-	LOOT_SOURCE_MODERATION,
-	LOOT_SOURCE_EXHIBIT,
-	LOOT_SOURCE_INVENTORY,
-	LOOT_SOURCE_CLAIMCODE,
-	LOOT_SOURCE_CONSUMPTION,
-	LOOT_SOURCE_CRAFTING,
-	LOOT_SOURCE_LEVEL_REWARD,
-	LOOT_SOURCE_RELOCATE
-};
-
-enum eGameActivities : uint32_t {
-	ACTIVITY_NONE,
-	ACTIVITY_QUICKBUILDING,
-	ACTIVITY_SHOOTING_GALLERY,
-	ACTIVITY_RACING,
-	ACTIVITY_PINBALL,
-	ACTIVITY_PET_TAMING
-};
-
-enum ePlayerFlags {
-	BTARR_TESTING = 0,
-	PLAYER_HAS_ENTERED_PET_RANCH = 1,
-	MINIMAP_UNLOCKED = 2,
-	ACTIVITY_REBUILDING_FAIL_TIME = 3,
-	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
-	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
-	HELP_WALKING_CONTROLS = 6,
-	FIRST_SMASHABLE = 7,
-	FIRST_IMAGINATION_PICKUP = 8,
-	FIRST_DAMAGE = 9,
-	FIRST_ITEM = 10,
-	FIRST_BRICK = 11,
-	FIRST_CONSUMABLE = 12,
-	FIRST_EQUIPPABLE = 13,
-	CHAT_HELP = 14,
-	FIRST_PET_TAMING_MINIGAME = 15,
-	FIRST_PET_ON_SWITCH = 16,
-	FIRST_PET_JUMPED_ON_SWITCH = 17,
-	FIRST_PET_FOUND_TREASURE = 18,
-	FIRST_PET_DUG_TREASURE = 19,
-	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
-	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
-	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
-	FIRST_EMOTE_UNLOCKED = 23,
-	GF_PIRATE_REP = 24,
-	AG_BOB_CINEMATIC_EVENT = 25,
-	HELP_JUMPING_CONTROLS = 26,
-	HELP_DOUBLE_JUMP_CONTROLS = 27,
-	HELP_CAMERA_CONTROLS = 28,
-	HELP_ROTATE_CONTROLS = 29,
-	HELP_SMASH = 30,
-	MONUMENT_INTRO_MUSIC_PLAYED = 31,
-	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
-	AG_FINISH_LINE_BUILT = 33,
-	AG_BOSS_AREA_FOUND = 34,
-	AG_LANDED_IN_BATTLEFIELD = 35,
-	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
-	MODULAR_BUILD_STARTED = 37,
-	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
-	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
-	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
-	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
-	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
-	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
-	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
-	JOINED_A_FACTION = 45,
-	VENTURE_FACTION = 46,
-	ASSEMBLY_FACTION = 47,
-	PARADOX_FACTION = 48,
-	SENTINEL_FACTION = 49,
-	LUP_WORLD_ACCESS = 50,
-	AG_FIRST_FLAG_COLLECTED = 51,
-	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
-	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
-	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
-	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
-	GF_PET_DIG_FLAG_1 = 56,
-	GF_PET_DIG_FLAG_2 = 57,
-	GF_PET_DIG_FLAG_3 = 58,
-	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
-	GF_PLAYER_FALL_DEATH = 60,
-	GF_PLAYER_CAN_GET_FLAG_1 = 61,
-	GF_PLAYER_CAN_GET_FLAG_2 = 62,
-	GF_PLAYER_CAN_GET_FLAG_3 = 63,
-	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
-	AG_FIRST_COMBAT_COMPLETE = 65,
-	AG_COMPLETE_BOB_MISSION = 66,
-	IS_NEWS_SCREEN_VISIBLE = 114,
-	NJ_GARMADON_CINEMATIC_SEEN = 125,
-	ELEPHANT_PET_3050 = 801,
-	CAT_PET_3054 = 802,
-	TRICERATOPS_PET_3195 = 803,
-	TERRIER_PET_3254 = 804,
-	SKUNK_PET_3261 = 805,
-	LION_PET_3520 = 806,
-	BUNNY_PET_3672 = 807,
-	CROCODILE_PET_3994 = 808,
-	DOBERMAN_PET_5635 = 809,
-	BUFFALO_PET_5636 = 810,
-	ROBOT_DOG_PET_5637 = 811,
-	EUROPEAN_DRAGON_PET_5639 = 812,
-	TORTOISE_PET_5640 = 813,
-	ASIAN_DRAGON_PET_5641 = 814,
-	MANTIS_PET_5642 = 815,
-	PANDA_PET_5643 = 816,
-	WARTHOG_PET_6720 = 817,
-	GOAT_PET_7638 = 818,
-	CRAB_PET_7694 = 819,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
-	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
-	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
-	AG_BATTLE_BINOC_AT_PARADOX = 1102,
-	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
-	AG_BATTLE_BINOC_AT_BECK = 1104,
-	AG_MONUMENT_BINOC_INTRO = 1105,
-	AG_MONUMENT_BINOC_OUTRO = 1106,
-	AG_LAUNCH_BINOC_INTRO = 1107,
-	AG_LAUNCH_BINOC_BISON = 1108,
-	AG_LAUNCH_BINOC_SHARK = 1109,
-	NS_BINOC_CONCERT_TRANSITION = 1201,
-	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
-	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
-	NS_BINOC_GF_LAUNCH = 1204,
-	NS_BINOC_FV_LAUNCH = 1205,
-	NS_BINOC_BRICK_ANNEX_WATER = 1206,
-	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
-	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
-	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
-	NS_BINOC_TBA = 1210,
-	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
-	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
-	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
-	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
-	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
-	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
-	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
-	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
-	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
-	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
-	PR_BINOC_AT_LAUNCH_PAD = 1251,
-	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
-	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
-	PR_BINOC_ON_BY_CROWS_NEST = 1254,
-	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
-	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
-	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
-	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
-	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
-	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
-	GF_BINOC_ON_LANDING_PAD = 1301,
-	GF_BINOC_AT_RAVINE_START = 1302,
-	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
-	GF_BINOC_AT_TURTLE_AREA = 1304,
-	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
-	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
-	GF_BINOC_IN_RACING_AREA = 1307,
-	GF_BINOC_IN_CROC_AREA = 1308,
-	GF_BINOC_IN_JAIL_AREA = 1309,
-	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
-	NT_PLINTH_REBUILD = 1919,
-	NT_FACTION_SPY_DUKE = 1974,
-	NT_FACTION_SPY_OVERBUILD = 1976,
-	NT_FACTION_SPY_HAEL = 1977,
-	NJ_EARTH_SPINJITZU = 2030,
-	NJ_LIGHTNING_SPINJITZU = 2031,
-	NJ_ICE_SPINJITZU = 2032,
-	NJ_FIRE_SPINJITZU = 2033,
-	NJ_WU_SHOW_DAILY_CHEST = 2099
-};
-
-//======== FUNC ===========
-
-template<typename T>
-inline T const& clamp(const T& val, const T& low, const T& high) {
-	if (val < low) return low;
-	else if (val > high) return high;
-
-	return val;
-}
-
 #endif  //!__DCOMMONVARS__H__

dCommon/dEnums/dMessageIdentifiers.h

@@ -1,552 +0,0 @@
-#pragma once
-#include "MessageIdentifiers.h"
-
-enum CONNECTION_TYPE {
-	SERVER = 0,         //!< Means it is used throughout all servers
-	AUTH,               //!< Means it is sent from the client authentication
-	CHAT,               //!< Means it is sent from and to the chat server
-	CHAT_INTERNAL,      //!< Unused - We can potentially use this in the future for various things
-	WORLD,              //!< Means it is sent from the client world
-	CLIENT,             //!< Means it is sent to the client from the world server
-	MASTER              //!< Means it is sent to and from the master server
-};
-
-//! The Internal Server Packet Identifiers
-enum SERVER {
-	MSG_SERVER_VERSION_CONFIRM = 0,     /*!< Sent during a handshake to confirm the server/client version */
-	MSG_SERVER_DISCONNECT_NOTIFY,       /*!< Sent when a user disconnected */
-	MSG_SERVER_GENERAL_NOTIFY           /*!< A general notification */
-};
-
-//! The Internal Authentication Packet Identifiers
-enum AUTH {
-	MSG_AUTH_LOGIN_REQUEST = 0,             /*!< Sent from the client when a user logs in */
-	MSG_AUTH_LOGOUT_REQUEST,                /*!< Sent from the client when a user logs out */
-	MSG_AUTH_CREATE_NEW_ACCOUNT_REQUEST,    /*!< Sent from the client when a user creates a new account */
-	MSG_AUTH_LEGOINTERFACE_AUTH_RESPONSE,   /*!< Unknown */
-	MSG_AUTH_SESSIONKEY_RECEIVED_CONFIRM,   /*!< Sent when the server recieved the session key (?) */
-	MSG_AUTH_RUNTIME_CONFIG                 /*!< Unknown */
-};
-
-//! The Internal Chat Packet Identifiers
-enum CHAT {
-	MSG_CHAT_LOGIN_SESSION_NOTIFY = 0,      /*!< When a user logs in */
-	MSG_CHAT_GENERAL_CHAT_MESSAGE,          /*!< Used for global chat messages */
-	MSG_CHAT_PRIVATE_CHAT_MESSAGE,          /*!< Used for private chat messages */
-	MSG_CHAT_USER_CHANNEL_CHAT_MESSAGE,     /*!< Unknown */
-	MSG_CHAT_WORLD_DISCONNECT_REQUEST,      /*!< Unknown */
-	MSG_CHAT_WORLD_PROXIMITY_RESPONSE,      /*!< Unknown */
-	MSG_CHAT_WORLD_PARCEL_RESPONSE,         /*!< Unknown */
-	MSG_CHAT_ADD_FRIEND_REQUEST,            /*!< When the client requests to add a friend */
-	MSG_CHAT_ADD_FRIEND_RESPONSE,           /*!< Sent from the server when the client adds a friend */
-	MSG_CHAT_REMOVE_FRIEND,                 /*!< When the client removes a friend */
-	MSG_CHAT_GET_FRIENDS_LIST,              /*!< Sent when the client requests a user's friends list */
-	MSG_CHAT_ADD_IGNORE,                    /*!< Sent when the client adds a friend to the "ignore" list */
-	MSG_CHAT_REMOVE_IGNORE,                 /*!< Sent when the client removes a friend from the "ignore" list */
-	MSG_CHAT_GET_IGNORE_LIST,               /*!< Sent when the client requests a user's ignored list */
-	MSG_CHAT_TEAM_MISSED_INVITE_CHECK,      /*!< Unknown (Something with an unresponded-to friend request probably) */
-	MSG_CHAT_TEAM_INVITE,                   /*!< When the client invites a user to a team */
-	MSG_CHAT_TEAM_INVITE_RESPONSE,          /*!< Sent from the server when the client invites someone to the team */
-	MSG_CHAT_TEAM_KICK,                     /*!< Sent when the client kicks a member from a team */
-	MSG_CHAT_TEAM_LEAVE,                    /*!< Sent when the client leaves a team */
-	MSG_CHAT_TEAM_SET_LOOT,                 /*!< Unknown (Something to do with team loot) */
-	MSG_CHAT_TEAM_SET_LEADER,               /*!< Unknown (Probably sets the team leader or something) */
-	MSG_CHAT_TEAM_GET_STATUS,               /*!< Check to see if we are in a team or not, sent on world join */
-	MSG_CHAT_GUILD_CREATE,                  /*!< Guild Creation */
-	MSG_CHAT_GUILD_INVITE,                  /*!< Guild Invitation */
-	MSG_CHAT_GUILD_INVITE_RESPONSE,         /*!< Guild Invite Response */
-	MSG_CHAT_GUILD_LEAVE,                   /*!< Guild Leave */
-	MSG_CHAT_GUILD_KICK,                    /*!< Guild Kick */
-	MSG_CHAT_GUILD_GET_STATUS,              /*!< Guild Get Status */
-	MSG_CHAT_GUILD_GET_ALL,                 /*!< Guild Get All */
-	MSG_CHAT_SHOW_ALL,
-	MSG_CHAT_BLUEPRINT_MODERATED,
-	MSG_CHAT_BLUEPRINT_MODEL_READY,
-	MSG_CHAT_PROPERTY_READY_FOR_APPROVAL,
-	MSG_CHAT_PROPERTY_MODERATION_CHANGED,
-	MSG_CHAT_PROPERTY_BUILDMODE_CHANGED,
-	MSG_CHAT_PROPERTY_BUILDMODE_CHANGED_REPORT,
-	MSG_CHAT_MAIL,
-	MSG_CHAT_WORLD_INSTANCE_LOCATION_REQUEST,
-	MSG_CHAT_REPUTATION_UPDATE,
-	MSG_CHAT_SEND_CANNED_TEXT,
-	MSG_CHAT_GMLEVEL_UPDATE,
-	MSG_CHAT_CHARACTER_NAME_CHANGE_REQUEST,
-	MSG_CHAT_CSR_REQUEST,
-	MSG_CHAT_CSR_REPLY,
-	MSG_CHAT_GM_KICK,
-	MSG_CHAT_GM_ANNOUNCE,
-	MSG_CHAT_GM_MUTE,
-	MSG_CHAT_ACTIVITY_UPDATE,
-	MSG_CHAT_WORLD_ROUTE_PACKET,
-	MSG_CHAT_GET_ZONE_POPULATIONS,
-	MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE,
-	MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
-	MSG_CHAT_MATCH_REQUEST,
-	MSG_CHAT_UGCMANIFEST_REPORT_MISSING_FILE,
-	MSG_CHAT_UGCMANIFEST_REPORT_DONE_FILE,
-	MSG_CHAT_UGCMANIFEST_REPORT_DONE_BLUEPRINT,
-	MSG_CHAT_UGCC_REQUEST,
-	MSG_CHAT_WHO,
-	MSG_CHAT_WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
-	MSG_CHAT_ACHIEVEMENT_NOTIFY,
-	MSG_CHAT_GM_CLOSE_PRIVATE_CHAT_WINDOW,
-	MSG_CHAT_UNEXPECTED_DISCONNECT,
-	MSG_CHAT_PLAYER_READY,
-	MSG_CHAT_GET_DONATION_TOTAL,
-	MSG_CHAT_UPDATE_DONATION,
-	MSG_CHAT_PRG_CSR_COMMAND,
-	MSG_CHAT_HEARTBEAT_REQUEST_FROM_WORLD,
-	MSG_CHAT_UPDATE_FREE_TRIAL_STATUS
-};
-
-//! Used for packets related to chatting
-enum CHAT_INTERNAL {
-	MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION = 0,
-	MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION,
-	MSG_CHAT_INTERNAL_ADD_FRIEND,
-	MSG_CHAT_INTERNAL_ADD_BEST_FRIEND,
-	MSG_CHAT_INTERNAL_ADD_TO_TEAM,
-	MSG_CHAT_INTERNAL_ADD_BLOCK,
-	MSG_CHAT_INTERNAL_REMOVE_FRIEND,
-	MSG_CHAT_INTERNAL_REMOVE_BLOCK,
-	MSG_CHAT_INTERNAL_REMOVE_FROM_TEAM,
-	MSG_CHAT_INTERNAL_DELETE_TEAM,
-	MSG_CHAT_INTERNAL_REPORT,
-	MSG_CHAT_INTERNAL_PRIVATE_CHAT,
-	MSG_CHAT_INTERNAL_PRIVATE_CHAT_RESPONSE,
-	MSG_CHAT_INTERNAL_ANNOUNCEMENT,
-	MSG_CHAT_INTERNAL_MAIL_COUNT_UPDATE,
-	MSG_CHAT_INTERNAL_MAIL_SEND_NOTIFY,
-	MSG_CHAT_INTERNAL_REQUEST_USER_LIST,
-	MSG_CHAT_INTERNAL_FRIEND_LIST,
-	MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER,
-	MSG_CHAT_INTERNAL_TEAM_UPDATE,
-	MSG_CHAT_INTERNAL_MUTE_UPDATE,
-	MSG_CHAT_INTERNAL_CREATE_TEAM,
-};
-
-//! Used for packets send to the world
-enum WORLD {
-	MSG_WORLD_CLIENT_VALIDATION = 1,  // 				Session info
-	MSG_WORLD_CLIENT_CHARACTER_LIST_REQUEST,
-	MSG_WORLD_CLIENT_CHARACTER_CREATE_REQUEST,
-	MSG_WORLD_CLIENT_LOGIN_REQUEST,  // 			Character selected
-	MSG_WORLD_CLIENT_GAME_MSG,
-	MSG_WORLD_CLIENT_CHARACTER_DELETE_REQUEST,
-	MSG_WORLD_CLIENT_CHARACTER_RENAME_REQUEST,
-	MSG_WORLD_CLIENT_HAPPY_FLOWER_MODE_NOTIFY,
-	MSG_WORLD_CLIENT_SLASH_RELOAD_MAP,  // 			Reload map cmp
-	MSG_WORLD_CLIENT_SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
-	MSG_WORLD_CLIENT_SLASH_PUSH_MAP,  // 			Push map cmd
-	MSG_WORLD_CLIENT_SLASH_PULL_MAP,  // 			Pull map cmd
-	MSG_WORLD_CLIENT_LOCK_MAP_REQUEST,
-	MSG_WORLD_CLIENT_GENERAL_CHAT_MESSAGE,  // 		General chat message
-	MSG_WORLD_CLIENT_HTTP_MONITOR_INFO_REQUEST,
-	MSG_WORLD_CLIENT_SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
-	MSG_WORLD_CLIENT_MODELS_CLEAR,
-	MSG_WORLD_CLIENT_EXHIBIT_INSERT_MODEL,
-	MSG_WORLD_CLIENT_LEVEL_LOAD_COMPLETE,  // 		Character data request
-	MSG_WORLD_CLIENT_TMP_GUILD_CREATE,
-	MSG_WORLD_CLIENT_ROUTE_PACKET,  // 				Social?
-	MSG_WORLD_CLIENT_POSITION_UPDATE,
-	MSG_WORLD_CLIENT_MAIL,
-	MSG_WORLD_CLIENT_WORD_CHECK, // 				Whitelist word check
-	MSG_WORLD_CLIENT_STRING_CHECK,  // 				Whitelist string check
-	MSG_WORLD_CLIENT_GET_PLAYERS_IN_ZONE,
-	MSG_WORLD_CLIENT_REQUEST_UGC_MANIFEST_INFO,
-	MSG_WORLD_CLIENT_BLUEPRINT_GET_ALL_DATA_REQUEST,
-	MSG_WORLD_CLIENT_CANCEL_MAP_QUEUE,
-	MSG_WORLD_CLIENT_HANDLE_FUNNESS,
-	MSG_WORLD_CLIENT_FAKE_PRG_CSR_MESSAGE,
-	MSG_WORLD_CLIENT_REQUEST_FREE_TRIAL_REFRESH,
-	MSG_WORLD_CLIENT_GM_SET_FREE_TRIAL_STATUS
-};
-
-//! An enum for packets sent to the client
-enum CLIENT {
-	MSG_CLIENT_LOGIN_RESPONSE = 0,
-	MSG_CLIENT_LOGOUT_RESPONSE,
-	MSG_CLIENT_LOAD_STATIC_ZONE,
-	MSG_CLIENT_CREATE_OBJECT,
-	MSG_CLIENT_CREATE_CHARACTER,
-	MSG_CLIENT_CREATE_CHARACTER_EXTENDED,
-	MSG_CLIENT_CHARACTER_LIST_RESPONSE,
-	MSG_CLIENT_CHARACTER_CREATE_RESPONSE,
-	MSG_CLIENT_CHARACTER_RENAME_RESPONSE,
-	MSG_CLIENT_CHAT_CONNECT_RESPONSE,
-	MSG_CLIENT_AUTH_ACCOUNT_CREATE_RESPONSE,
-	MSG_CLIENT_DELETE_CHARACTER_RESPONSE,
-	MSG_CLIENT_GAME_MSG,
-	MSG_CLIENT_CONNECT_CHAT,
-	MSG_CLIENT_TRANSFER_TO_WORLD,
-	MSG_CLIENT_IMPENDING_RELOAD_NOTIFY,
-	MSG_CLIENT_MAKE_GM_RESPONSE,
-	MSG_CLIENT_HTTP_MONITOR_INFO_RESPONSE,
-	MSG_CLIENT_SLASH_PUSH_MAP_RESPONSE,
-	MSG_CLIENT_SLASH_PULL_MAP_RESPONSE,
-	MSG_CLIENT_SLASH_LOCK_MAP_RESPONSE,
-	MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE,
-	MSG_CLIENT_BLUEPRINT_LUP_SAVE_RESPONSE,
-	MSG_CLIENT_BLUEPRINT_LOAD_RESPONSE_ITEMID,
-	MSG_CLIENT_BLUEPRINT_GET_ALL_DATA_RESPONSE,
-	MSG_CLIENT_MODEL_INSTANTIATE_RESPONSE,
-	MSG_CLIENT_DEBUG_OUTPUT,
-	MSG_CLIENT_ADD_FRIEND_REQUEST,
-	MSG_CLIENT_ADD_FRIEND_RESPONSE,
-	MSG_CLIENT_REMOVE_FRIEND_RESPONSE,
-	MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE,
-	MSG_CLIENT_UPDATE_FRIEND_NOTIFY,
-	MSG_CLIENT_ADD_IGNORE_RESPONSE,
-	MSG_CLIENT_REMOVE_IGNORE_RESPONSE,
-	MSG_CLIENT_GET_IGNORE_LIST_RESPONSE,
-	MSG_CLIENT_TEAM_INVITE,
-	MSG_CLIENT_TEAM_INVITE_INITIAL_RESPONSE,
-	MSG_CLIENT_GUILD_CREATE_RESPONSE,
-	MSG_CLIENT_GUILD_GET_STATUS_RESPONSE,
-	MSG_CLIENT_GUILD_INVITE,
-	MSG_CLIENT_GUILD_INVITE_INITIAL_RESPONSE,
-	MSG_CLIENT_GUILD_INVITE_FINAL_RESPONSE,
-	MSG_CLIENT_GUILD_INVITE_CONFIRM,
-	MSG_CLIENT_GUILD_ADD_PLAYER,
-	MSG_CLIENT_GUILD_REMOVE_PLAYER,
-	MSG_CLIENT_GUILD_LOGIN_LOGOUT,
-	MSG_CLIENT_GUILD_RANK_CHANGE,
-	MSG_CLIENT_GUILD_DATA,
-	MSG_CLIENT_GUILD_STATUS,
-	MSG_CLIENT_MAIL,
-	MSG_CLIENT_DB_PROXY_RESULT,
-	MSG_CLIENT_SHOW_ALL_RESPONSE,
-	MSG_CLIENT_WHO_RESPONSE,
-	MSG_CLIENT_SEND_CANNED_TEXT,
-	MSG_CLIENT_UPDATE_CHARACTER_NAME,
-	MSG_CLIENT_SET_NETWORK_SIMULATOR,
-	MSG_CLIENT_INVALID_CHAT_MESSAGE,
-	MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE,
-	MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
-	MSG_CLIENT_CHAT_MODERATION_STRING,
-	MSG_CLIENT_UGC_MANIFEST_RESPONSE,
-	MSG_CLIENT_IN_LOGIN_QUEUE,
-	MSG_CLIENT_SERVER_STATES,
-	MSG_CLIENT_GM_CLOSE_TARGET_CHAT_WINDOW,
-	MSG_CLIENT_GENERAL_TEXT_FOR_LOCALIZATION,
-	MSG_CLIENT_UPDATE_FREE_TRIAL_STATUS,
-	MSG_CLIENT_UGC_DOWNLOAD_FAILED = 120
-};
-
-//! Used for packets sent to the master server
-enum MASTER {
-	MSG_MASTER_REQUEST_PERSISTENT_ID = 1,
-	MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE,
-	MSG_MASTER_REQUEST_ZONE_TRANSFER,
-	MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE,
-	MSG_MASTER_SERVER_INFO,
-	MSG_MASTER_REQUEST_SESSION_KEY,
-	MSG_MASTER_SET_SESSION_KEY,
-	MSG_MASTER_SESSION_KEY_RESPONSE,
-	MSG_MASTER_PLAYER_ADDED,
-	MSG_MASTER_PLAYER_REMOVED,
-
-	MSG_MASTER_CREATE_PRIVATE_ZONE,
-	MSG_MASTER_REQUEST_PRIVATE_ZONE,
-
-	MSG_MASTER_WORLD_READY,
-	MSG_MASTER_PREP_ZONE,
-
-	MSG_MASTER_SHUTDOWN,
-	MSG_MASTER_SHUTDOWN_RESPONSE,
-	MSG_MASTER_SHUTDOWN_IMMEDIATE,
-
-	MSG_MASTER_SHUTDOWN_UNIVERSE,
-
-	MSG_MASTER_AFFIRM_TRANSFER_REQUEST,
-	MSG_MASTER_AFFIRM_TRANSFER_RESPONSE,
-
-	MSG_MASTER_NEW_SESSION_ALERT
-};
-
-//! The Game messages
-enum GAME_MSG : unsigned short {
-	GAME_MSG_TELEPORT = 19,
-	GAME_MSG_SET_PLAYER_CONTROL_SCHEME = 26,
-	GAME_MSG_DROP_CLIENT_LOOT = 30,
-	GAME_MSG_DIE = 37,
-	GAME_MSG_REQUEST_DIE = 38,
-	GAME_MSG_PLAY_EMOTE = 41,
-	GAME_MSG_PLAY_ANIMATION = 43,
-	GAME_MSG_CONTROL_BEHAVIOR = 48,
-	GAME_MSG_SET_NAME = 72,
-	GAME_MSG_ECHO_START_SKILL = 118,
-	GAME_MSG_START_SKILL = 119,
-	GAME_MSG_VERIFY_ACK = 121,
-	GAME_MSG_ADD_SKILL = 127,
-	GAME_MSG_REMOVE_SKILL = 128,
-	GAME_MSG_SET_CURRENCY = 133,
-	GAME_MSG_PICKUP_CURRENCY = 137,
-	GAME_MSG_PICKUP_ITEM = 139,
-	GAME_MSG_TEAM_PICKUP_ITEM = 140,
-	GAME_MSG_PLAY_FX_EFFECT = 154,
-	GAME_MSG_STOP_FX_EFFECT = 155,
-	GAME_MSG_REQUEST_RESURRECT = 159,
-	GAME_MSG_RESURRECT = 160,
-	GAME_MSG_PUSH_EQUIPPED_ITEMS_STATE = 191,
-	GAME_MSG_POP_EQUIPPED_ITEMS_STATE = 192,
-	GAME_MSG_SET_GM_LEVEL = 193,
-	GAME_MSG_SET_STUNNED = 198,
-	GAME_MSG_KNOCKBACK = 202,
-	GAME_MSG_REBUILD_CANCEL = 209,
-	GAME_MSG_ENABLE_REBUILD = 213,
-	GAME_MSG_MOVE_ITEM_IN_INVENTORY = 224,
-	GAME_MSG_ADD_ITEM_TO_INVENTORY_CLIENT_SYNC = 227,
-	GAME_MSG_REMOVE_ITEM_FROM_INVENTORY = 230,
-	GAME_MSG_EQUIP_ITEM = 231,
-	GAME_MSG_UN_EQUIP_ITEM = 233,
-	GAME_MSG_OFFER_MISSION = 248,
-	GAME_MSG_RESPOND_TO_MISSION = 249,
-	GAME_MSG_NOTIFY_MISSION = 254,
-	GAME_MSG_NOTIFY_MISSION_TASK = 255,
-	GAME_MSG_REBUILD_NOTIFY_STATE = 336,
-	GAME_MSG_TERMINATE_INTERACTION = 357,
-	GAME_MSG_SERVER_TERMINATE_INTERACTION = 358,
-	GAME_MSG_REQUEST_USE = 364,
-	GAME_MSG_VENDOR_OPEN_WINDOW = 369,
-	GAME_MSG_BUY_FROM_VENDOR = 373,
-	GAME_MSG_SELL_TO_VENDOR = 374,
-	GAME_MSG_TEAM_SET_OFF_WORLD_FLAG = 383,
-	GAME_MSG_SET_INVENTORY_SIZE = 389,
-	GAME_MSG_ACKNOWLEDGE_POSSESSION = 391,
-	GAME_MSG_SET_SHOOTING_GALLERY_PARAMS = 400,
-	GAME_MSG_REQUEST_ACTIVITY_START_STOP = 402,
-	GAME_MSG_REQUEST_ACTIVITY_ENTER = 403,
-	GAME_MSG_REQUEST_ACTIVITY_EXIT = 404,
-	GAME_MSG_ACTIVITY_ENTER = 405,
-	GAME_MSG_ACTIVITY_EXIT = 406,
-	GAME_MSG_ACTIVITY_START = 407,
-	GAME_MSG_ACTIVITY_STOP = 408,
-	GAME_MSG_SHOOTING_GALLERY_CLIENT_AIM_UPDATE = 409,
-	GAME_MSG_SHOOTING_GALLERY_FIRE = 411,
-	GAME_MSG_REQUEST_VENDOR_STATUS_UPDATE = 416,
-	GAME_MSG_VENDOR_STATUS_UPDATE = 417,
-	GAME_MSG_NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE = 425,
-	GAME_MSG_CONSUME_CLIENT_ITEM = 427,
-	GAME_MSG_CLIENT_ITEM_CONSUMED = 428,
-	GAME_MSG_UPDATE_SHOOTING_GALLERY_ROTATION = 448,
-	GAME_MSG_SET_FLAG = 471,
-	GAME_MSG_NOTIFY_CLIENT_FLAG_CHANGE = 472,
-	GAME_MSG_VENDOR_TRANSACTION_RESULT = 476,
-	GAME_MSG_HAS_BEEN_COLLECTED = 486,
-	GAME_MSG_DISPLAY_CHAT_BUBBLE = 495,
-	GAME_MSG_SPAWN_PET = 498,
-	GAME_MSG_DESPAWN_PET = 499,
-	GAME_MSG_PLAYER_LOADED = 505,
-	GAME_MSG_PLAYER_READY = 509,
-	GAME_MSG_REQUEST_LINKED_MISSION = 515,
-	GAME_MSG_INVALID_ZONE_TRANSFER_LIST = 519,
-	GAME_MSG_MISSION_DIALOGUE_OK = 520,
-	GAME_MSG_DISPLAY_MESSAGE_BOX = 529,
-	GAME_MSG_MESSAGE_BOX_RESPOND = 530,
-	GAME_MSG_CHOICE_BOX_RESPOND = 531,
-	GAME_MSG_SMASH = 537,
-	GAME_MSG_UNSMASH = 538,
-	GAME_MSG_SET_SHOOTING_GALLERY_RETICULE_EFFECT = 548,
-	GAME_MSG_PLACE_MODEL_RESPONSE = 0x223,
-	GAME_MSG_SET_JET_PACK_MODE = 561,
-	GAME_MSG_REGISTER_PET_ID = 565,
-	GAME_MSG_REGISTER_PET_DBID = 566,
-	GAME_MSG_SHOW_ACTIVITY_COUNTDOWN = 568,
-	GAME_MSG_START_ACTIVITY_TIME = 576,
-	GAME_MSG_ACTIVITY_PAUSE = 602,
-	GAME_MSG_USE_NON_EQUIPMENT_ITEM = 603,
-	GAME_MSG_USE_ITEM_RESULT = 607,
-	GAME_MSG_COMMAND_PET = 640,
-	GAME_MSG_PET_RESPONSE = 641,
-	GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 648,
-	GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 649,
-	GAME_MSG_NOTIFY_OBJECT = 656,
-	GAME_MSG_CLIENT_NOTIFY_PET = 659,
-	GAME_MSG_NOTIFY_PET = 660,
-	GAME_MSG_NOTIFY_PET_TAMING_MINIGAME = 661,
-	GAME_MSG_START_SERVER_PET_MINIGAME_TIMER = 662,
-	GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME = 663,
-	GAME_MSG_PET_NAME_CHANGED = 686,
-	GAME_MSG_PET_TAMING_MINIGAME_RESULT = 667,
-	GAME_MSG_PET_TAMING_TRY_BUILD_RESULT = 668,
-	GAME_MSG_NOTIFY_TAMING_BUILD_SUCCESS = 673,
-	GAME_MSG_NOTIFY_TAMING_MODEL_LOADED_ON_SERVER = 674,
-	GAME_MSG_ADD_PET_TO_PLAYER = 681,
-	GAME_MSG_REQUEST_SET_PET_NAME = 683,
-	GAME_MSG_SET_PET_NAME = 684,
-	GAME_MSG_NOTIFY_PET_TAMING_PUZZLE_SELECTED = 675,
-	GAME_MSG_SHOW_PET_ACTION_BUTTON = 692,
-	GAME_MSG_SET_EMOTE_LOCK_STATE = 693,
-	GAME_MSG_USE_ITEM_REQUIREMENTS_RESPONSE = 703,
-	GAME_MSG_PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT = 713,
-	GAME_MSG_DOWNLOAD_PROPERTY_DATA = 716,
-	GAME_MSG_QUERY_PROPERTY_DATA = 717,
-	GAME_MSG_PROPERTY_EDITOR_BEGIN = 724,
-	GAME_MSG_PROPERTY_EDITOR_END = 725,
-	GAME_MSG_START_PATHING = 735,
-	GAME_MSG_NOTIFY_CLIENT_ZONE_OBJECT = 737,
-	GAME_MSG_UPDATE_REPUTATION = 746,
-	GAME_MSG_PROPERTY_RENTAL_RESPONSE = 750,
-	GAME_MSG_REQUEST_PLATFORM_RESYNC = 760,
-	GAME_MSG_PLATFORM_RESYNC = 761,
-	GAME_MSG_PLAY_CINEMATIC = 762,
-	GAME_MSG_END_CINEMATIC = 763,
-	GAME_MSG_CINEMATIC_UPDATE = 764,
-	GAME_MSG_TOGGLE_GHOST_REFERENCE_OVERRIDE = 767,
-	GAME_MSG_SET_GHOST_REFERENCE_POSITION = 768,
-	GAME_MSG_FIRE_EVENT_SERVER_SIDE = 770,
-	GAME_MSG_SET_NETWORK_SCRIPT_VAR = 781,
-	GAME_MSG_UPDATE_MODEL_FROM_CLIENT = 793,
-	GAME_MSG_DELETE_MODEL_FROM_CLIENT = 794,
-	GAME_MSG_PLAY_ND_AUDIO_EMITTER = 821,
-	GAME_MSG_PLAY2_DAMBIENT_SOUND = 831,
-	GAME_MSG_ENTER_PROPERTY1 = 840,
-	GAME_MSG_ENTER_PROPERTY2 = 841,
-	GAME_MSG_PROPERTY_ENTRANCE_SYNC = 842,
-	GAME_MSG_PROPERTY_SELECT_QUERY = 845,
-	GAME_MSG_PARSE_CHAT_MESSAGE = 850,
-	GAME_MSG_BROADCAST_TEXT_TO_CHATBOX = 858,
-	GAME_MSG_OPEN_PROPERTY_MANAGEMENT = 860,
-	GAME_MSG_OPEN_PROPERTY_VENDOR = 861,
-	GAME_MSG_UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK = 863,
-	GAME_MSG_CLIENT_TRADE_REQUEST = 868,
-	GAME_MSG_SERVER_TRADE_REQUEST = 869,
-	GAME_MSG_SERVER_TRADE_INVITE = 870,
-	GAME_MSG_CLIENT_TRADE_REPLY = 871,
-	GAME_MSG_SERVER_TRADE_REPLY = 872,
-	GAME_MSG_SERVER_TRADE_INITIAL_REPLY = 873,
-	GAME_MSG_SERVER_TRADE_FINAL_REPLY = 874,
-	GAME_MSG_CLIENT_TRADE_UPDATE = 875,
-	GAME_MSG_SERVER_SIDE_TRADE_UPDATE = 876,
-	GAME_MSG_SERVER_TRADE_UPDATE = 877,
-	GAME_MSG_CLIENT_TRADE_CANCEL = 878,
-	GAME_MSG_CLIENT_SIDE_TRADE_CANCEL = 879,
-	GAME_MSG_CLIENT_TRADE_ACCEPT = 880,
-	GAME_MSG_SERVER_SIDE_TRADE_ACCEPT = 881,
-	GAME_MSG_SERVER_SIDE_TRADE_CANCEL = 882,
-	GAME_MSG_SERVER_TRADE_CANCEL = 883,
-	GAME_MSG_SERVER_TRADE_ACCEPT = 884,
-	GAME_MSG_READY_FOR_UPDATES = 888,
-	GAME_MSG_ORIENT_TO_OBJECT = 905,
-	GAME_MSG_ORIENT_TO_POSITION = 906,
-	GAME_MSG_ORIENT_TO_ANGLE = 907,
-	GAME_MSG_BOUNCER_ACTIVE_STATUS = 942,
-	GAME_MSG_UN_USE_BBB_MODEL = 999,
-	GAME_MSG_BBB_LOAD_ITEM_REQUEST = 1000,
-	GAME_MSG_BBB_SAVE_REQUEST = 1001,
-	GAME_MSG_BBB_SAVE_RESPONSE = 1006,
-	GAME_MSG_NOTIFY_CLIENT_OBJECT = 1042,
-	GAME_MSG_DISPLAY_ZONE_SUMMARY = 1043,
-	GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST = 1053,
-	GAME_MSG_MODIFY_PLAYER_ZONE_STATISTIC = 1046,
-	GAME_MSG_START_BUILDING_WITH_ITEM = 1057,
-	GAME_MSG_START_ARRANGING_WITH_ITEM = 1061,
-	GAME_MSG_FINISH_ARRANGING_WITH_ITEM = 1062,
-	GAME_MSG_DONE_ARRANGING_WITH_ITEM = 1063,
-	GAME_MSG_SET_BUILD_MODE = 1068,
-	GAME_MSG_BUILD_MODE_SET = 1069,
-	GAME_MSG_SET_BUILD_MODE_CONFIRMED = 1073,
-	GAME_MSG_NOTIFY_CLIENT_FAILED_PRECONDITION = 1081,
-	GAME_MSG_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1093,
-	GAME_MSG_MODULAR_BUILD_BEGIN = 1094,
-	GAME_MSG_MODULAR_BUILD_END = 1095,
-	GAME_MSG_MODULAR_BUILD_MOVE_AND_EQUIP = 1096,
-	GAME_MSG_MODULAR_BUILD_FINISH = 1097,
-	GAME_MSG_REPORT_BUG = 1198,
-	GAME_MSG_MISSION_DIALOGUE_CANCELLED = 1129,
-	GAME_MSG_ECHO_SYNC_SKILL = 1144,
-	GAME_MSG_SYNC_SKILL = 1145,
-	GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT = 1148,
-	GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT = 1151,
-	GAME_MSG_MODULAR_BUILD_CONVERT_MODEL = 1155,
-	GAME_MSG_SET_PLAYER_ALLOWED_RESPAWN = 1165,
-	GAME_MSG_UI_MESSAGE_SERVER_TO_SINGLE_CLIENT = 1184,
-	GAME_MSG_UI_MESSAGE_SERVER_TO_ALL_CLIENTS = 1185,
-	GAME_MSG_PET_TAMING_TRY_BUILD = 1197,
-	GAME_MSG_REQUEST_SMASH_PLAYER = 1202,
-	GAME_MSG_FIRE_EVENT_CLIENT_SIDE = 1213,
-	GAME_MSG_TOGGLE_GM_INVIS = 1218,
-	GAME_MSG_CHANGE_OBJECT_WORLD_STATE = 1223,
-	GAME_MSG_VEHICLE_LOCK_INPUT = 1230,
-	GAME_MSG_VEHICLE_UNLOCK_INPUT = 1231,
-	GAME_MSG_RACING_RESET_PLAYER_TO_LAST_RESET = 1252,
-	GAME_MSG_RACING_SERVER_SET_PLAYER_LAP_AND_PLANE = 1253,
-	GAME_MSG_RACING_SET_PLAYER_RESET_INFO = 1254,
-	GAME_MSG_RACING_PLAYER_INFO_RESET_FINISHED = 1255,
-	GAME_MSG_LOCK_NODE_ROTATION = 1260,
-	GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE = 1273,
-	GAME_MSG_NOTIFY_VEHICLE_OF_RACING_OBJECT = 1276,
-	GAME_MSG_PLAYER_REACHED_RESPAWN_CHECKPOINT = 1296,
-	GAME_MSG_HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE = 1300,
-	GAME_MSG_HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE = 1301,
-	GAME_MSG_PROPERTY_CONTENTS_FROM_CLIENT = 1305,
-	GAME_MSG_GET_MODELS_ON_PROPERTY = 1306,
-	GAME_MSG_MATCH_REQUEST = 1308,
-	GAME_MSG_MATCH_RESPONSE = 1309,
-	GAME_MSG_MATCH_UPDATE = 1310,
-	GAME_MSG_MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT = 1131,
-	GAME_MSG_MODULE_ASSEMBLY_QUERY_DATA = 1132,
-	GAME_MSG_CHANGE_IDLE_FLAGS = 1338,
-	GAME_MSG_VEHICLE_ADD_PASSIVE_BOOST_ACTION = 1340,
-	GAME_MSG_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION = 1341,
-	GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION = 1342,
-	GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION = 1343,
-	GAME_MSG_VEHICLE_ADD_SLOWDOWN_ACTION = 1344,
-	GAME_MSG_VEHICLE_REMOVE_SLOWDOWN_ACTION = 1345,
-	GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_SLOWDOWN_ACTION = 1346,
-	GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_SLOWDOWN_ACTION = 1347,
-	GAME_MSG_BUYBACK_FROM_VENDOR = 1350,
-	GAME_MSG_SET_PROPERTY_ACCESS = 1366,
-	GAME_MSG_ZONE_PROPERTY_MODEL_PLACED = 1369,
-	GAME_MSG_ZONE_PROPERTY_MODEL_ROTATED = 1370,
-	GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED = 1371,
-	GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED = 1372,
-	GAME_MSG_ZONE_PROPERTY_MODEL_PICKED_UP = 1373,
-	GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED = 1374,
-	GAME_MSG_NOTIFY_RACING_CLIENT = 1390,
-	GAME_MSG_RACING_PLAYER_HACK_CAR = 1391,
-	GAME_MSG_RACING_PLAYER_LOADED = 1392,
-	GAME_MSG_RACING_CLIENT_READY = 1393,
-	GAME_MSG_UPDATE_CHAT_MODE = 1395,
-	GAME_MSG_VEHICLE_NOTIFY_FINISHED_RACE = 1396,
-	GAME_MSG_SET_CONSUMABLE_ITEM = 1409,
-	GAME_MSG_SET_PET_NAME_MODERATED = 1448,
-	GAME_MSG_MODIFY_LEGO_SCORE = 1459,
-	GAME_MSG_RESTORE_TO_POST_LOAD_STATS = 1468,
-	GAME_MSG_SET_RAIL_MOVEMENT = 1471,
-	GAME_MSG_START_RAIL_MOVEMENT = 1472,
-	GAME_MSG_CANCEL_RAIL_MOVEMENT = 1474,
-	GAME_MSG_CLIENT_RAIL_MOVEMENT_READY = 1476,
-	GAME_MSG_PLAYER_RAIL_ARRIVED_NOTIFICATION = 1477,
-	GAME_MSG_UPDATE_PLAYER_STATISTIC = 1481,
-	GAME_MSG_MODULAR_ASSEMBLY_NIF_COMPLETED = 1498,
-	GAME_MSG_NOTIFY_NOT_ENOUGH_INV_SPACE = 1516,
-	GAME_MSG_TEAM_SET_LEADER = 0x0615,
-	GAME_MSG_TEAM_INVITE_CONFIRM = 0x0616,
-	GAME_MSG_TEAM_GET_STATUS_RESPONSE = 0x0617,
-	GAME_MSG_TEAM_ADD_PLAYER = 0x061a,
-	GAME_MSG_TEAM_REMOVE_PLAYER = 0x061b,
-	GAME_MSG_START_CELEBRATION_EFFECT = 1618,
-	GAME_MSG_ADD_BUFF = 1647,
-	GAME_MSG_SERVER_DONE_LOADING_ALL_OBJECTS = 1642,
-	GAME_MSG_PLACE_PROPERTY_MODEL = 1170,
-	GAME_MSG_VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER = 1606,
-	GAME_MSG_ADD_RUN_SPEED_MODIFIER = 1505,
-	GAME_MSG_HANDLE_HOT_PROPERTY_DATA = 1511,
-	GAME_MSG_SEND_HOT_PROPERTY_DATA = 1510,
-	GAME_MSG_REMOVE_RUN_SPEED_MODIFIER = 1506,
-	GAME_MSG_UPDATE_PROPERTY_PERFORMANCE_COST = 1547,
-	GAME_MSG_PROPERTY_ENTRANCE_BEGIN = 1553,
-	GAME_MSG_REMOVE_BUFF = 1648,
-	GAME_MSG_REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1666,
-	GAME_MSG_RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1667,
-	GAME_MSG_PLAYER_SET_CAMERA_CYCLING_MODE = 1676,
-	GAME_MSG_SET_MOUNT_INVENTORY_ID = 1726,
-	GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE = 1734,
-	GAME_MSG_NOTIFY_LEVEL_REWARDS = 1735,
-	GAME_MSG_DISMOUNT_COMPLETE = 1756,
-	GAME_MSG_MARK_INVENTORY_ITEM_AS_ACTIVE = 1767,
-	END
-};

dCommon/dEnums/eAddFriendResponseCode.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#ifndef __ADDFRIENDRESPONSECODE__H__
-#define __ADDFRIENDRESPONSECODE__H__
+#ifndef __EADDFRIENDRESPONSECODE__H__
+#define __EADDFRIENDRESPONSECODE__H__
 
 #include <cstdint>
 
-enum class AddFriendResponseCode : uint8_t {
+enum class eAddFriendResponseCode : uint8_t {
 	ACCEPTED = 0,
 	REJECTED,
 	BUSY,

dCommon/dEnums/eAddFriendResponseType.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#ifndef __ADDFRIENDRESPONSETYPE__H__
-#define __ADDFRIENDRESPONSETYPE__H__
+#ifndef __EADDFRIENDRESPONSETYPE__H__
+#define __EADDFRIENDRESPONSETYPE__H__
 
 #include <cstdint>
 
-enum class AddFriendResponseType : uint8_t {
+enum class eAddFriendResponseType : uint8_t {
 	ACCEPTED = 0,
 	ALREADYFRIEND,
 	INVALIDCHARACTER,
@@ -21,4 +21,4 @@ enum class AddFriendResponseType : uint8_t {
 	FRIENDISFREETRIAL
 };
 
-#endif  //!__ADDFRIENDRESPONSETYPE__H__
+#endif  //!__EADDFRIENDRESPONSETYPE__H__

dCommon/dEnums/eAuthMessageType.h

@@ -0,0 +1,15 @@
+#ifndef __EAUTHMESSAGETYPE__H__
+#define __EAUTHMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eAuthMessageType : uint32_t {
+	LOGIN_REQUEST = 0,
+	LOGOUT_REQUEST,
+	CREATE_NEW_ACCOUNT_REQUEST,
+	LEGOINTERFACE_AUTH_RESPONSE,
+	SESSIONKEY_RECEIVED_CONFIRM,
+	RUNTIME_CONFIG
+};
+
+#endif  //!__EAUTHMESSAGETYPE__H__

dCommon/dEnums/eBasicAttackSuccessTypes.h

@@ -0,0 +1,12 @@
+#ifndef __EBASICATTACKSUCCESSTYPES__H__
+#define __EBASICATTACKSUCCESSTYPES__H__
+
+#include <cstdint>
+
+enum class eBasicAttackSuccessTypes : uint8_t {
+	SUCCESS = 1,
+	FAILARMOR,
+	FAILIMMUNE
+};
+
+#endif  //!__EBASICATTACKSUCCESSTYPES__H__

dCommon/dEnums/eBubbleType.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#ifndef __EBUBBLETYPE__H__
+#define __EBUBBLETYPE__H__
+
+#include <cstdint>
+
+enum class eBubbleType : uint32_t {
+	DEFAULT = 0,
+	ENERGY,
+	SKUNK
+};
+
+#endif  //!__EBUBBLETYPE__H__

dCommon/dEnums/eBuildType.h

@@ -0,0 +1,12 @@
+#ifndef __EBUILDTYPE__H__
+#define __EBUILDTYPE__H__
+
+#include <cstdint>
+
+enum class eBuildType :uint32_t {
+	NOWHERE,
+	IN_WORLD,
+	ON_PROPERTY
+};
+
+#endif  //!__EBUILDTYPE__H__

dCommon/dEnums/eCharacterCreationResponse.h

@@ -0,0 +1,14 @@
+#ifndef __ECHARACTERCREATIONRESPONSE__H__
+#define __ECHARACTERCREATIONRESPONSE__H__
+
+#include <cstdint>
+
+enum class eCharacterCreationResponse : uint8_t {
+	SUCCESS = 0,
+	OBJECT_ID_UNAVAILABLE,
+	NAME_NOT_ALLOWED,
+	PREDEFINED_NAME_IN_USE,
+	CUSTOM_NAME_IN_USE
+};
+
+#endif  //!__ECHARACTERCREATIONRESPONSE__H__

dCommon/dEnums/eCharacterVersion.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef __ECHARACTERVERSION__H__
+#define __ECHARACTERVERSION__H__
+
+#include <cstdint>
+
+enum class eCharacterVersion : uint32_t {
+// Versions from the live game
+	RELEASE = 0, // Initial release of the game
+	LIVE, // Fixes for the 1.9 release bug fixes for missions leading up to joining a faction
+// New versions for DLU fixes
+	// Fixes the "Joined a faction" player flag not being set properly
+	PLAYER_FACTION_FLAGS,
+	// Fixes vault size value
+	VAULT_SIZE,
+	// Fixes speed base value in level component
+	UP_TO_DATE, // will become SPEED_BASE
+};
+
+#endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eChatInternalMessageType.h

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

dCommon/dEnums/eChatMessageType.h

@@ -0,0 +1,78 @@
+#ifndef __ECHATMESSAGETYPE__H__
+#define __ECHATMESSAGETYPE__H__
+
+#include <cstdint>
+
+//! The Internal Chat Packet Identifiers
+enum class eChatMessageType :uint32_t {
+	LOGIN_SESSION_NOTIFY = 0,
+	GENERAL_CHAT_MESSAGE,
+	PRIVATE_CHAT_MESSAGE,
+	USER_CHANNEL_CHAT_MESSAGE,
+	WORLD_DISCONNECT_REQUEST,
+	WORLD_PROXIMITY_RESPONSE,
+	WORLD_PARCEL_RESPONSE,
+	ADD_FRIEND_REQUEST,
+	ADD_FRIEND_RESPONSE,
+	REMOVE_FRIEND,
+	GET_FRIENDS_LIST,
+	ADD_IGNORE,
+	REMOVE_IGNORE,
+	GET_IGNORE_LIST,
+	TEAM_MISSED_INVITE_CHECK,
+	TEAM_INVITE,
+	TEAM_INVITE_RESPONSE,
+	TEAM_KICK,
+	TEAM_LEAVE,
+	TEAM_SET_LOOT,
+	TEAM_SET_LEADER,
+	TEAM_GET_STATUS,
+	GUILD_CREATE,
+	GUILD_INVITE,
+	GUILD_INVITE_RESPONSE,
+	GUILD_LEAVE,
+	GUILD_KICK,
+	GUILD_GET_STATUS,
+	GUILD_GET_ALL,
+	SHOW_ALL,
+	BLUEPRINT_MODERATED,
+	BLUEPRINT_MODEL_READY,
+	PROPERTY_READY_FOR_APPROVAL,
+	PROPERTY_MODERATION_CHANGED,
+	PROPERTY_BUILDMODE_CHANGED,
+	PROPERTY_BUILDMODE_CHANGED_REPORT,
+	MAIL,
+	WORLD_INSTANCE_LOCATION_REQUEST,
+	REPUTATION_UPDATE,
+	SEND_CANNED_TEXT,
+	GMLEVEL_UPDATE,
+	CHARACTER_NAME_CHANGE_REQUEST,
+	CSR_REQUEST,
+	CSR_REPLY,
+	GM_KICK,
+	GM_ANNOUNCE,
+	GM_MUTE,
+	ACTIVITY_UPDATE,
+	WORLD_ROUTE_PACKET,
+	GET_ZONE_POPULATIONS,
+	REQUEST_MINIMUM_CHAT_MODE,
+	REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
+	MATCH_REQUEST,
+	UGCMANIFEST_REPORT_MISSING_FILE,
+	UGCMANIFEST_REPORT_DONE_FILE,
+	UGCMANIFEST_REPORT_DONE_BLUEPRINT,
+	UGCC_REQUEST,
+	WHO,
+	WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
+	ACHIEVEMENT_NOTIFY,
+	GM_CLOSE_PRIVATE_CHAT_WINDOW,
+	UNEXPECTED_DISCONNECT,
+	PLAYER_READY,
+	GET_DONATION_TOTAL,
+	UPDATE_DONATION,
+	PRG_CSR_COMMAND,
+	HEARTBEAT_REQUEST_FROM_WORLD,
+	UPDATE_FREE_TRIAL_STATUS
+};
+
+#endif  //!__ECHATMESSAGETYPE__H__

dCommon/dEnums/eCinematicEvent.h

@@ -0,0 +1,12 @@
+#ifndef __ECINEMATICEVENT__H__
+#define __ECINEMATICEVENT__H__
+
+#include <cstdint>
+
+enum class eCinematicEvent : uint32_t {
+	STARTED,
+	WAYPOINT,
+	ENDED,
+};
+
+#endif  //!__ECINEMATICEVENT__H__

dCommon/dEnums/eClientMessageType.h

@@ -0,0 +1,76 @@
+#ifndef __ECLIENTMESSAGETYPE__H__
+#define __ECLIENTMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eClientMessageType : uint32_t {
+	LOGIN_RESPONSE = 0,
+	LOGOUT_RESPONSE,
+	LOAD_STATIC_ZONE,
+	CREATE_OBJECT,
+	CREATE_CHARACTER,
+	CREATE_CHARACTER_EXTENDED,
+	CHARACTER_LIST_RESPONSE,
+	CHARACTER_CREATE_RESPONSE,
+	CHARACTER_RENAME_RESPONSE,
+	CHAT_CONNECT_RESPONSE,
+	AUTH_ACCOUNT_CREATE_RESPONSE,
+	DELETE_CHARACTER_RESPONSE,
+	GAME_MSG,
+	CONNECT_CHAT,
+	TRANSFER_TO_WORLD,
+	IMPENDING_RELOAD_NOTIFY,
+	MAKE_GM_RESPONSE,
+	HTTP_MONITOR_INFO_RESPONSE,
+	SLASH_PUSH_MAP_RESPONSE,
+	SLASH_PULL_MAP_RESPONSE,
+	SLASH_LOCK_MAP_RESPONSE,
+	BLUEPRINT_SAVE_RESPONSE,
+	BLUEPRINT_LUP_SAVE_RESPONSE,
+	BLUEPRINT_LOAD_RESPONSE_ITEMID,
+	BLUEPRINT_GET_ALL_DATA_RESPONSE,
+	MODEL_INSTANTIATE_RESPONSE,
+	DEBUG_OUTPUT,
+	ADD_FRIEND_REQUEST,
+	ADD_FRIEND_RESPONSE,
+	REMOVE_FRIEND_RESPONSE,
+	GET_FRIENDS_LIST_RESPONSE,
+	UPDATE_FRIEND_NOTIFY,
+	ADD_IGNORE_RESPONSE,
+	REMOVE_IGNORE_RESPONSE,
+	GET_IGNORE_LIST_RESPONSE,
+	TEAM_INVITE,
+	TEAM_INVITE_INITIAL_RESPONSE,
+	GUILD_CREATE_RESPONSE,
+	GUILD_GET_STATUS_RESPONSE,
+	GUILD_INVITE,
+	GUILD_INVITE_INITIAL_RESPONSE,
+	GUILD_INVITE_FINAL_RESPONSE,
+	GUILD_INVITE_CONFIRM,
+	GUILD_ADD_PLAYER,
+	GUILD_REMOVE_PLAYER,
+	GUILD_LOGIN_LOGOUT,
+	GUILD_RANK_CHANGE,
+	GUILD_DATA,
+	GUILD_STATUS,
+	MAIL,
+	DB_PROXY_RESULT,
+	SHOW_ALL_RESPONSE,
+	WHO_RESPONSE,
+	SEND_CANNED_TEXT,
+	UPDATE_CHARACTER_NAME,
+	SET_NETWORK_SIMULATOR,
+	INVALID_CHAT_MESSAGE,
+	MINIMUM_CHAT_MODE_RESPONSE,
+	MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
+	CHAT_MODERATION_STRING,
+	UGC_MANIFEST_RESPONSE,
+	IN_LOGIN_QUEUE,
+	SERVER_STATES,
+	GM_CLOSE_TARGET_CHAT_WINDOW,
+	GENERAL_TEXT_FOR_LOCALIZATION,
+	UPDATE_FREE_TRIAL_STATUS,
+	UGC_DOWNLOAD_FAILED = 120
+};
+
+#endif  //!__ECLIENTMESSAGETYPE__H__

dCommon/dEnums/eConnectionType.h

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

dCommon/dEnums/eControlScheme.h

@@ -0,0 +1,18 @@
+#ifndef __ECONTROLSCHEME__H__
+#define __ECONTROLSCHEME__H__
+
+#include <cstdint>
+
+enum class eControlScheme : uint32_t {
+	SCHEME_A,
+	SCHEME_D,
+	SCHEME_GAMEPAD,
+	SCHEME_E,
+	SCHEME_FPS,
+	SCHEME_DRIVING,
+	SCHEME_TAMING,
+	SCHEME_MODULAR_BUILD,
+	SCHEME_WEAR_A_ROBOT //== freecam?
+};
+
+#endif  //!__ECONTROLSCHEME__H__

dCommon/dEnums/eCyclingMode.h

@@ -0,0 +1,11 @@
+#ifndef __ECYCLINGMODE__H__
+#define __ECYCLINGMODE__H__
+
+#include <cstdint>
+
+enum class eCyclingMode : uint32_t {
+	ALLOW_CYCLE_TEAMMATES,
+	DISALLOW_CYCLING
+};
+
+#endif  //!__ECYCLINGMODE__H__

dCommon/dEnums/eEndBehavior.h

@@ -0,0 +1,11 @@
+#ifndef __EENDBEHAVIOR__H__
+#define __EENDBEHAVIOR__H__
+
+#include <cstdint>
+
+enum class eEndBehavior : uint32_t {
+	RETURN,
+	WAIT
+};
+
+#endif  //!__EENDBEHAVIOR__H__

dCommon/dEnums/eGameActivity.h

@@ -0,0 +1,15 @@
+#ifndef __EGAMEACTIVITY__H__
+#define __EGAMEACTIVITY__H__
+
+#include <cstdint>
+
+enum class eGameActivity : uint32_t {
+	NONE,
+	QUICKBUILDING,
+	SHOOTING_GALLERY,
+	RACING,
+	PINBALL,
+	PET_TAMING
+};
+
+#endif  //!__EGAMEACTIVITY__H__

dCommon/dEnums/eGameMasterLevel.h

@@ -0,0 +1,20 @@
+#ifndef __EGAMEMASTERLEVEL__H__
+#define __EGAMEMASTERLEVEL__H__
+
+#include <cstdint>
+
+enum class eGameMasterLevel : uint8_t {
+	CIVILIAN = 0,             // Normal player.
+	FORUM_MODERATOR = 1,      // No permissions on live servers.
+	JUNIOR_MODERATOR = 2,     // Can kick/mute and pull chat logs.
+	MODERATOR = 3,            // Can return lost items.
+	SENIOR_MODERATOR = 4,     // Can ban.
+	LEAD_MODERATOR = 5,       // Can approve properties.
+	JUNIOR_DEVELOPER = 6,     // Junior developer & future content team. Civilan on live.
+	INACTIVE_DEVELOPER = 7,   // Inactive developer, limited permissions.
+	DEVELOPER = 8,            // Active developer, full permissions on live.
+	OPERATOR = 9              // Can shutdown server for restarts & updates.
+};
+
+
+#endif  //!__EGAMEMASTERLEVEL__H__

dCommon/dEnums/eGameMessageType.h

@@ -0,0 +1,303 @@
+#ifndef __EGAMEMESSAGETYPE__H__
+#define __EGAMEMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eGameMessageType : uint16_t {
+	TELEPORT = 19,
+	SET_PLAYER_CONTROL_SCHEME = 26,
+	DROP_CLIENT_LOOT = 30,
+	DIE = 37,
+	REQUEST_DIE = 38,
+	PLAY_EMOTE = 41,
+	PLAY_ANIMATION = 43,
+	CONTROL_BEHAVIOR = 48,
+	SET_NAME = 72,
+	ECHO_START_SKILL = 118,
+	START_SKILL = 119,
+	VERIFY_ACK = 121,
+	ADD_SKILL = 127,
+	REMOVE_SKILL = 128,
+	SET_CURRENCY = 133,
+	PICKUP_CURRENCY = 137,
+	PICKUP_ITEM = 139,
+	TEAM_PICKUP_ITEM = 140,
+	PLAY_FX_EFFECT = 154,
+	STOP_FX_EFFECT = 155,
+	REQUEST_RESURRECT = 159,
+	RESURRECT = 160,
+	PUSH_EQUIPPED_ITEMS_STATE = 191,
+	POP_EQUIPPED_ITEMS_STATE = 192,
+	SET_GM_LEVEL = 193,
+	SET_STUNNED = 198,
+	SET_STUN_IMMUNITY = 200,
+	KNOCKBACK = 202,
+	REBUILD_CANCEL = 209,
+	ENABLE_REBUILD = 213,
+	MOVE_ITEM_IN_INVENTORY = 224,
+	ADD_ITEM_TO_INVENTORY_CLIENT_SYNC = 227,
+	REMOVE_ITEM_FROM_INVENTORY = 230,
+	EQUIP_ITEM = 231,
+	UN_EQUIP_ITEM = 233,
+	OFFER_MISSION = 248,
+	RESPOND_TO_MISSION = 249,
+	NOTIFY_MISSION = 254,
+	NOTIFY_MISSION_TASK = 255,
+	REBUILD_NOTIFY_STATE = 336,
+	TERMINATE_INTERACTION = 357,
+	SERVER_TERMINATE_INTERACTION = 358,
+	REQUEST_USE = 364,
+	VENDOR_OPEN_WINDOW = 369,
+	BUY_FROM_VENDOR = 373,
+	SELL_TO_VENDOR = 374,
+	TEAM_SET_OFF_WORLD_FLAG = 383,
+	SET_INVENTORY_SIZE = 389,
+	ACKNOWLEDGE_POSSESSION = 391,
+	SET_SHOOTING_GALLERY_PARAMS = 400,
+	REQUEST_ACTIVITY_START_STOP = 402,
+	REQUEST_ACTIVITY_ENTER = 403,
+	REQUEST_ACTIVITY_EXIT = 404,
+	ACTIVITY_ENTER = 405,
+	ACTIVITY_EXIT = 406,
+	ACTIVITY_START = 407,
+	ACTIVITY_STOP = 408,
+	SHOOTING_GALLERY_CLIENT_AIM_UPDATE = 409,
+	SHOOTING_GALLERY_FIRE = 411,
+	REQUEST_VENDOR_STATUS_UPDATE = 416,
+	VENDOR_STATUS_UPDATE = 417,
+	NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE = 425,
+	CONSUME_CLIENT_ITEM = 427,
+	CLIENT_ITEM_CONSUMED = 428,
+	UPDATE_SHOOTING_GALLERY_ROTATION = 448,
+	SET_FLAG = 471,
+	NOTIFY_CLIENT_FLAG_CHANGE = 472,
+	VENDOR_TRANSACTION_RESULT = 476,
+	HAS_BEEN_COLLECTED = 486,
+	DISPLAY_CHAT_BUBBLE = 495,
+	SPAWN_PET = 498,
+	DESPAWN_PET = 499,
+	PLAYER_LOADED = 505,
+	PLAYER_READY = 509,
+	REQUEST_LINKED_MISSION = 515,
+	INVALID_ZONE_TRANSFER_LIST = 519,
+	MISSION_DIALOGUE_OK = 520,
+	DISPLAY_MESSAGE_BOX = 529,
+	MESSAGE_BOX_RESPOND = 530,
+	CHOICE_BOX_RESPOND = 531,
+	SMASH = 537,
+	UNSMASH = 538,
+	PLACE_MODEL_RESPONSE = 547,
+	SET_SHOOTING_GALLERY_RETICULE_EFFECT = 548,
+	SET_JET_PACK_MODE = 561,
+	REGISTER_PET_ID = 565,
+	REGISTER_PET_DBID = 566,
+	SHOW_ACTIVITY_COUNTDOWN = 568,
+	START_ACTIVITY_TIME = 576,
+	ACTIVITY_PAUSE = 602,
+	USE_NON_EQUIPMENT_ITEM = 603,
+	USE_ITEM_RESULT = 607,
+	COMMAND_PET = 640,
+	PET_RESPONSE = 641,
+	REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 648,
+	SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 649,
+	NOTIFY_OBJECT = 656,
+	CLIENT_NOTIFY_PET = 659,
+	NOTIFY_PET = 660,
+	NOTIFY_PET_TAMING_MINIGAME = 661,
+	START_SERVER_PET_MINIGAME_TIMER = 662,
+	CLIENT_EXIT_TAMING_MINIGAME = 663,
+	PET_NAME_CHANGED = 686,
+	PET_TAMING_MINIGAME_RESULT = 667,
+	PET_TAMING_TRY_BUILD_RESULT = 668,
+	NOTIFY_TAMING_BUILD_SUCCESS = 673,
+	NOTIFY_TAMING_MODEL_LOADED_ON_SERVER = 674,
+	ACTIVATE_BUBBLE_BUFF = 678,
+	DEACTIVATE_BUBBLE_BUFF = 679,
+	ADD_PET_TO_PLAYER = 681,
+	REQUEST_SET_PET_NAME = 683,
+	SET_PET_NAME = 684,
+	NOTIFY_PET_TAMING_PUZZLE_SELECTED = 675,
+	SHOW_PET_ACTION_BUTTON = 692,
+	SET_EMOTE_LOCK_STATE = 693,
+	USE_ITEM_REQUIREMENTS_RESPONSE = 703,
+	PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT = 713,
+	DOWNLOAD_PROPERTY_DATA = 716,
+	QUERY_PROPERTY_DATA = 717,
+	PROPERTY_EDITOR_BEGIN = 724,
+	PROPERTY_EDITOR_END = 725,
+	IS_MINIFIG_IN_A_BUBBLE = 729,
+	START_PATHING = 733,
+	ACTIVATE_BUBBLE_BUFF_FROM_SERVER = 734,
+	DEACTIVATE_BUBBLE_BUFF_FROM_SERVER = 735,
+	NOTIFY_CLIENT_ZONE_OBJECT = 737,
+	UPDATE_REPUTATION = 746,
+	PROPERTY_RENTAL_RESPONSE = 750,
+	REQUEST_PLATFORM_RESYNC = 760,
+	PLATFORM_RESYNC = 761,
+	PLAY_CINEMATIC = 762,
+	END_CINEMATIC = 763,
+	CINEMATIC_UPDATE = 764,
+	TOGGLE_GHOST_REFERENCE_OVERRIDE = 767,
+	SET_GHOST_REFERENCE_POSITION = 768,
+	FIRE_EVENT_SERVER_SIDE = 770,
+	SET_NETWORK_SCRIPT_VAR = 781,
+	UPDATE_MODEL_FROM_CLIENT = 793,
+	DELETE_MODEL_FROM_CLIENT = 794,
+	PLAY_ND_AUDIO_EMITTER = 821,
+	PLAY2_DAMBIENT_SOUND = 831,
+	ENTER_PROPERTY1 = 840,
+	ENTER_PROPERTY2 = 841,
+	PROPERTY_ENTRANCE_SYNC = 842,
+	PROPERTY_SELECT_QUERY = 845,
+	PARSE_CHAT_MESSAGE = 850,
+	BROADCAST_TEXT_TO_CHATBOX = 858,
+	OPEN_PROPERTY_MANAGEMENT = 860,
+	OPEN_PROPERTY_VENDOR = 861,
+	UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK = 863,
+	CLIENT_TRADE_REQUEST = 868,
+	SERVER_TRADE_REQUEST = 869,
+	SERVER_TRADE_INVITE = 870,
+	CLIENT_TRADE_REPLY = 871,
+	SERVER_TRADE_REPLY = 872,
+	SERVER_TRADE_INITIAL_REPLY = 873,
+	SERVER_TRADE_FINAL_REPLY = 874,
+	CLIENT_TRADE_UPDATE = 875,
+	SERVER_SIDE_TRADE_UPDATE = 876,
+	SERVER_TRADE_UPDATE = 877,
+	CLIENT_TRADE_CANCEL = 878,
+	CLIENT_SIDE_TRADE_CANCEL = 879,
+	CLIENT_TRADE_ACCEPT = 880,
+	SERVER_SIDE_TRADE_ACCEPT = 881,
+	SERVER_SIDE_TRADE_CANCEL = 882,
+	SERVER_TRADE_CANCEL = 883,
+	SERVER_TRADE_ACCEPT = 884,
+	READY_FOR_UPDATES = 888,
+	ORIENT_TO_OBJECT = 905,
+	ORIENT_TO_POSITION = 906,
+	ORIENT_TO_ANGLE = 907,
+	BOUNCER_ACTIVE_STATUS = 942,
+	UN_USE_BBB_MODEL = 999,
+	BBB_LOAD_ITEM_REQUEST = 1000,
+	BBB_SAVE_REQUEST = 1001,
+	BBB_SAVE_RESPONSE = 1006,
+	NOTIFY_CLIENT_OBJECT = 1042,
+	DISPLAY_ZONE_SUMMARY = 1043,
+	ZONE_SUMMARY_DISMISSED = 1044,
+	ACTIVITY_STATE_CHANGE_REQUEST = 1053,
+	MODIFY_PLAYER_ZONE_STATISTIC = 1046,
+	START_BUILDING_WITH_ITEM = 1057,
+	START_ARRANGING_WITH_ITEM = 1061,
+	FINISH_ARRANGING_WITH_ITEM = 1062,
+	DONE_ARRANGING_WITH_ITEM = 1063,
+	SET_BUILD_MODE = 1068,
+	BUILD_MODE_SET = 1069,
+	SET_BUILD_MODE_CONFIRMED = 1073,
+	NOTIFY_CLIENT_FAILED_PRECONDITION = 1081,
+	MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1093,
+	MODULAR_BUILD_BEGIN = 1094,
+	MODULAR_BUILD_END = 1095,
+	MODULAR_BUILD_MOVE_AND_EQUIP = 1096,
+	MODULAR_BUILD_FINISH = 1097,
+	REPORT_BUG = 1198,
+	MISSION_DIALOGUE_CANCELLED = 1129,
+	ECHO_SYNC_SKILL = 1144,
+	SYNC_SKILL = 1145,
+	REQUEST_SERVER_PROJECTILE_IMPACT = 1148,
+	DO_CLIENT_PROJECTILE_IMPACT = 1151,
+	MODULAR_BUILD_CONVERT_MODEL = 1155,
+	SET_PLAYER_ALLOWED_RESPAWN = 1165,
+	UI_MESSAGE_SERVER_TO_SINGLE_CLIENT = 1184,
+	UI_MESSAGE_SERVER_TO_ALL_CLIENTS = 1185,
+	PET_TAMING_TRY_BUILD = 1197,
+	REQUEST_SMASH_PLAYER = 1202,
+	FIRE_EVENT_CLIENT_SIDE = 1213,
+	TOGGLE_GM_INVIS = 1218,
+	CHANGE_OBJECT_WORLD_STATE = 1223,
+	VEHICLE_LOCK_INPUT = 1230,
+	VEHICLE_UNLOCK_INPUT = 1231,
+	RACING_RESET_PLAYER_TO_LAST_RESET = 1252,
+	RACING_SERVER_SET_PLAYER_LAP_AND_PLANE = 1253,
+	RACING_SET_PLAYER_RESET_INFO = 1254,
+	RACING_PLAYER_INFO_RESET_FINISHED = 1255,
+	LOCK_NODE_ROTATION = 1260,
+	VEHICLE_SET_WHEEL_LOCK_STATE = 1273,
+	NOTIFY_VEHICLE_OF_RACING_OBJECT = 1276,
+	SET_NAME_BILLBOARD_STATE = 1284,
+	PLAYER_REACHED_RESPAWN_CHECKPOINT = 1296,
+	HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE = 1300,
+	HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE = 1301,
+	PROPERTY_CONTENTS_FROM_CLIENT = 1305,
+	GET_MODELS_ON_PROPERTY = 1306,
+	MATCH_REQUEST = 1308,
+	MATCH_RESPONSE = 1309,
+	MATCH_UPDATE = 1310,
+	MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT = 1131,
+	MODULE_ASSEMBLY_QUERY_DATA = 1132,
+	SHOW_BILLBOARD_INTERACT_ICON = 1337,
+	CHANGE_IDLE_FLAGS = 1338,
+	VEHICLE_ADD_PASSIVE_BOOST_ACTION = 1340,
+	VEHICLE_REMOVE_PASSIVE_BOOST_ACTION = 1341,
+	VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION = 1342,
+	VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION = 1343,
+	VEHICLE_ADD_SLOWDOWN_ACTION = 1344,
+	VEHICLE_REMOVE_SLOWDOWN_ACTION = 1345,
+	VEHICLE_NOTIFY_SERVER_ADD_SLOWDOWN_ACTION = 1346,
+	VEHICLE_NOTIFY_SERVER_REMOVE_SLOWDOWN_ACTION = 1347,
+	BUYBACK_FROM_VENDOR = 1350,
+	SET_PROPERTY_ACCESS = 1366,
+	ZONE_PROPERTY_MODEL_PLACED = 1369,
+	ZONE_PROPERTY_MODEL_ROTATED = 1370,
+	ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED = 1371,
+	ZONE_PROPERTY_MODEL_EQUIPPED = 1372,
+	ZONE_PROPERTY_MODEL_PICKED_UP = 1373,
+	ZONE_PROPERTY_MODEL_REMOVED = 1374,
+	NOTIFY_RACING_CLIENT = 1390,
+	RACING_PLAYER_HACK_CAR = 1391,
+	RACING_PLAYER_LOADED = 1392,
+	RACING_CLIENT_READY = 1393,
+	UPDATE_CHAT_MODE = 1395,
+	VEHICLE_NOTIFY_FINISHED_RACE = 1396,
+	SET_CONSUMABLE_ITEM = 1409,
+	SET_STATUS_IMMUNITY = 1435,
+	SET_PET_NAME_MODERATED = 1448,
+	MODIFY_LEGO_SCORE = 1459,
+	RESTORE_TO_POST_LOAD_STATS = 1468,
+	SET_RAIL_MOVEMENT = 1471,
+	START_RAIL_MOVEMENT = 1472,
+	CANCEL_RAIL_MOVEMENT = 1474,
+	CLIENT_RAIL_MOVEMENT_READY = 1476,
+	PLAYER_RAIL_ARRIVED_NOTIFICATION = 1477,
+	UPDATE_PLAYER_STATISTIC = 1481,
+	MODULAR_ASSEMBLY_NIF_COMPLETED = 1498,
+	NOTIFY_NOT_ENOUGH_INV_SPACE = 1516,
+	TEAM_SET_LEADER = 1557,
+	TEAM_INVITE_CONFIRM = 1558,
+	TEAM_GET_STATUS_RESPONSE = 1559,
+	TEAM_ADD_PLAYER = 1526,
+	TEAM_REMOVE_PLAYER = 1563,
+	START_CELEBRATION_EFFECT = 1618,
+	ADD_BUFF = 1647,
+	SERVER_DONE_LOADING_ALL_OBJECTS = 1642,
+	PLACE_PROPERTY_MODEL = 1170,
+	VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER = 1606,
+	ADD_RUN_SPEED_MODIFIER = 1505,
+	HANDLE_HOT_PROPERTY_DATA = 1511,
+	SEND_HOT_PROPERTY_DATA = 1510,
+	REMOVE_RUN_SPEED_MODIFIER = 1506,
+	UPDATE_PROPERTY_PERFORMANCE_COST = 1547,
+	PROPERTY_ENTRANCE_BEGIN = 1553,
+	SET_RESURRECT_RESTORE_VALUES = 1591,
+	VEHICLE_STOP_BOOST = 1617,
+	REMOVE_BUFF = 1648,
+	REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1666,
+	RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1667,
+	PLAYER_SET_CAMERA_CYCLING_MODE = 1676,
+	SET_MOUNT_INVENTORY_ID = 1726,
+	NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE = 1734,
+	NOTIFY_LEVEL_REWARDS = 1735,
+	DISMOUNT_COMPLETE = 1756,
+	MARK_INVENTORY_ITEM_AS_ACTIVE = 1767,
+	END
+};
+
+#endif  //!__EGAMEMESSAGETYPE__H__

dCommon/dEnums/eHelpType.h

@@ -0,0 +1,41 @@
+
+#ifndef __EHELPTYPE__H__
+#define __EHELPTYPE__H__
+
+#include <cstdint>
+
+enum class eHelpType : int32_t {
+	NONE = 0,
+	UNLOCK_MINIMAP = 2,
+	TOGGLETOOLTIP_OUTOFTIME_REBUILD = 3,
+	TOGGLETOOLTIP_LEAVELOSE_REBUILD = 4,
+	TOGGLECONTROLSTUTORIAL_WALKING = 6,
+	DISPLAYTUTORIAL_PASSPORT_1ST_SMASH = 7,
+	TOOLTIP_1ST_IMAGINATION_PICKUP = 8,
+	UNKNOWN9 = 9,
+	PETTAMINGMINIGAME_TUTORIAL_01 = 15,
+	PR_BOUNCER_TUTORIAL_03 = 16,
+	PR_TOOLTIP_1ST_PET_JUMPED_ON_SWITCH = 17,
+	PR_DIG_TUTORIAL_01 = 18,
+	PR_DIG_TUTORIAL_03 = 19,
+	PR_BOUNCER_TUTORIAL_01 = 20,
+	PR_NO_IMAGINATION_HIBERNATE = 21,
+	UNKNOWN22 = 22,
+	TOGGLECONTROLSTUTORIAL_JUMPING = 26,
+	TOGGLECONTROLSTUTORIAL_DOUBLEJUMPING = 27,
+	TOGGLECONTROLSTUTORIAL_CAMERA = 28,
+	TOGGLECONTROLSTUTORIAL_SMASH = 30,
+	UNKNOWN38 = 38,
+	UI_MOD_BUILD_PUT_ON_HAT = 40,
+	UI_MOD_BUILD_EQUIP_FIRST_MODULE = 41,
+	UNKNOWN42 = 42,
+	UNKNOWN43 = 43,
+	UI_MOD_BUILD_GO_LAUNCH_ROCKET = 44,
+	UI_MOD_BUILD_TALK_TO_SKYLANE = 45,
+	UNKNOWN53 = 53,
+	PET_DESPAWN_BY_OWNER_HIBERNATE = 69,
+	PET_DESPAWN_TAMING_NEW_PET = 70,
+	UI_INVENTORY_FULL_CANNOT_PICKUP_ITEM = 86
+};
+
+#endif  //!__EHELPTYPE__H__

dCommon/dEnums/eInventoryType.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#ifndef __EINVENTORYTYPE__H__
+#define __EINVENTORYTYPE__H__
+
+#include <cstdint>
+static const uint8_t NUMBER_OF_INVENTORIES = 17;
+/**
+ * Represents the different types of inventories an entity may have
+ */
+enum eInventoryType : uint32_t {
+	ITEMS = 0,
+	VAULT_ITEMS,
+	BRICKS,
+	MODELS_IN_BBB,
+	TEMP_ITEMS,
+	MODELS,
+	TEMP_MODELS,
+	BEHAVIORS,
+	PROPERTY_DEEDS,
+	BRICKS_IN_BBB,
+	VENDOR,
+	VENDOR_BUYBACK,
+	QUEST, //Used for mission items
+	DONATION,
+	VAULT_MODELS,
+	ITEM_SETS, //internal, technically this is BankBehaviors.
+	INVALID // made up, for internal use!!!, Technically this called the ALL inventory.
+};
+
+class InventoryType {
+public:
+	static const char* InventoryTypeToString(eInventoryType inventory) {
+		const char* eInventoryTypeTable[NUMBER_OF_INVENTORIES] = {
+				"ITEMS",
+				"VAULT_ITEMS",
+				"BRICKS",
+				"MODELS_IN_BBB",
+				"TEMP_ITEMS",
+				"MODELS",
+				"TEMP_MODELS",
+				"BEHAVIORS",
+				"PROPERTY_DEEDS",
+				"BRICKS_IN_BBB",
+				"VENDOR",
+				"VENDOR_BUYBACK",
+				"QUEST", //Used for mission items
+				"DONATION",
+				"VAULT_MODELS",
+				"ITEM_SETS", //internal, technically this is BankBehaviors.
+				"INVALID" // made up, for internal use!!!, Technically this called the ALL inventory.
+		};
+
+		if (inventory > NUMBER_OF_INVENTORIES - 1) return nullptr;
+		return eInventoryTypeTable[inventory];
+	};
+};
+
+#endif  //!__EINVENTORYTYPE__H__

dCommon/dEnums/eItemSetPassiveAbilityID.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#ifndef __EITEMSETPASSIVEABILITYID__H__
+#define __EITEMSETPASSIVEABILITYID__H__
+
+enum class eItemSetPassiveAbilityID {
+	EngineerRank1 = 2,
+	EngineerRank2 = 3,
+	EngineerRank3 = 4,
+	KnightRank1 = 7,
+	KnightRank2 = 8,
+	KnightRank3 = 9,
+	SpaceRangerRank1 = 10,
+	SpaceRangerRank2 = 11,
+	SpaceRangerRank3 = 12,
+	SamuraiRank1 = 13,
+	SamuraiRank2 = 14,
+	SamuraiRank3 = 15,
+	SorcererRank1 = 16,
+	SorcererRank2 = 17,
+	SorcererRank3 = 18,
+	SpaceMarauderRank1 = 19,
+	SpaceMarauderRank2 = 20,
+	SpaceMarauderRank3 = 21,
+	ShinobiRank1 = 22,
+	ShinobiRank2 = 23,
+	ShinobiRank3 = 24,
+	InventorRank1 = 25,
+	InventorRank2 = 26,
+	InventorRank3 = 27,
+	SummonerRank1 = 28,
+	SummonerRank2 = 29,
+	SummonerRank3 = 30,
+	AdventurerRank1 = 31,
+	AdventurerRank2 = 32,
+	AdventurerRank3 = 33,
+	DaredevilRank1 = 34,
+	DaredevilRank2 = 35,
+	DaredevilRank3 = 36,
+	BuccaneerRank1 = 37,
+	BuccaneerRank2 = 38,
+	BuccaneerRank3 = 39,
+	BoneSuit = 40,
+	ImaginationSpinjitzu = 41,
+	BatLord = 42,
+	MosaicJester = 43,
+	ExplorienBot = 44,
+	Unnamed1 = 45,
+	Unnamed2 = 46,
+	Unnamed3 = 47,
+	EarthSpinjitzu = 48,
+	Unnamed4 = 49,
+	FireSpinjitzu = 50,
+	IceSpinjitzu = 51,
+	LightningSpinjitzu = 52
+};
+
+#endif  //!__EITEMSETPASSIVEABILITYID__H__

dCommon/dEnums/eItemType.h

@@ -6,31 +6,31 @@
 #include <cstdint>
 
 enum class eItemType : int32_t {
-	ITEM_TYPE_UNKNOWN = -1, 			//!< An unknown item type
-	ITEM_TYPE_BRICK = 1, 				//!< A brick
-	ITEM_TYPE_HAT = 2, 					//!< A hat / head item
-	ITEM_TYPE_HAIR = 3, 				//!< A hair item
-	ITEM_TYPE_NECK = 4, 				//!< A neck item
-	ITEM_TYPE_LEFT_HAND = 5, 			//!< A left handed item
-	ITEM_TYPE_RIGHT_HAND = 6, 			//!< A right handed item
-	ITEM_TYPE_LEGS = 7, 				//!< A pants item
-	ITEM_TYPE_LEFT_TRINKET = 8, 		//!< A left handled trinket item
-	ITEM_TYPE_RIGHT_TRINKET = 9, 		//!< A right handed trinket item
-	ITEM_TYPE_BEHAVIOR = 10,			//!< A behavior
-	ITEM_TYPE_PROPERTY = 11,			//!< A property
-	ITEM_TYPE_MODEL = 12,				//!< A model
-	ITEM_TYPE_COLLECTIBLE = 13,			//!< A collectible item
-	ITEM_TYPE_CONSUMABLE = 14,			//!< A consumable item
-	ITEM_TYPE_CHEST = 15,				//!< A chest item
-	ITEM_TYPE_EGG = 16,					//!< An egg
-	ITEM_TYPE_PET_FOOD = 17,			//!< A pet food item
-	ITEM_TYPE_QUEST_OBJECT = 18,		//!< A quest item
-	ITEM_TYPE_PET_INVENTORY_ITEM = 19,	//!< A pet inventory item
-	ITEM_TYPE_PACKAGE = 20,				//!< A package
-	ITEM_TYPE_LOOT_MODEL = 21,			//!< A loot model
-	ITEM_TYPE_VEHICLE = 22,				//!< A vehicle
-	ITEM_TYPE_CURRENCY = 23,			//!< Currency
-	ITEM_TYPE_MOUNT = 24				//!< A Mount
+	UNKNOWN = -1,
+	BRICK = 1,
+	HAT,
+	HAIR,
+	NECK,
+	LEFT_HAND,
+	RIGHT_HAND,
+	LEGS,
+	LEFT_TRINKET,
+	RIGHT_TRINKET,
+	BEHAVIOR,
+	PROPERTY,
+	MODEL,
+	COLLECTIBLE,
+	CONSUMABLE,
+	CHEST,
+	EGG,
+	PET_FOOD,
+	QUEST_OBJECT,
+	PET_INVENTORY_ITEM,
+	PACKAGE,
+	LOOT_MODEL,
+	VEHICLE,
+	LUP_MODEL,
+	MOUNT
 };
 
 #endif  //!__EITEMTYPE__H__

dCommon/dEnums/eKillType.h

@@ -0,0 +1,11 @@
+#ifndef __EKILLTYPE__H__
+#define __EKILLTYPE__H__
+
+#include <cstdint>
+
+enum class eKillType : uint32_t {
+	VIOLENT,
+	SILENT
+};
+
+#endif  //!__EKILLTYPE__H__

dCommon/dEnums/eLoginResponse.h

@@ -0,0 +1,24 @@
+#ifndef __ELOGINRESPONSE__H__
+#define __ELOGINRESPONSE__H__
+
+#include <cstdint>
+
+enum class eLoginResponse : uint8_t {
+	GENERAL_FAILED = 0,
+	SUCCESS,
+	BANNED,
+	// Unused 3
+	// Unused 4
+	PERMISSIONS_NOT_HIGH_ENOUGH = 5,
+	INVALID_USER,
+	ACCOUNT_LOCKED,
+	WRONG_PASS,
+	ACCOUNT_ACTIVATION_PENDING,
+	ACCOUNT_DISABLED,
+	GAME_TIME_EXPIRED,
+	FREE_TRIAL_ENDED,
+	PLAY_SCHEDULE_TIME_UP,
+	ACCOUNT_NOT_ACTIVATED
+};
+
+#endif  //!__ELOGINRESPONSE__H__

dCommon/dEnums/eLootSourceType.h

@@ -0,0 +1,31 @@
+#ifndef __ELOOTSOURCETYPE__H__
+#define __ELOOTSOURCETYPE__H__
+
+#include <cstdint>
+
+enum class eLootSourceType : uint32_t {
+	NONE = 0,
+	CHEST,
+	MISSION,
+	MAIL,
+	CURRENCY,
+	ACHIEVEMENT,
+	TRADE,
+	QUICKBUILD,
+	DELETION,
+	VENDOR,
+	ACTIVITY,
+	PICKUP,
+	BRICK,
+	PROPERTY,
+	MODERATION,
+	EXHIBIT,
+	INVENTORY,
+	CLAIMCODE,
+	CONSUMPTION,
+	CRAFTING,
+	LEVEL_REWARD,
+	RELOCATE
+};
+
+#endif  //!__ELOOTSOURCETYPE__H__

dCommon/dEnums/eMasterMessageType.h

@@ -0,0 +1,36 @@
+#ifndef __EMASTERMESSAGETYPE__H__
+#define __EMASTERMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eMasterMessageType : uint32_t {
+	REQUEST_PERSISTENT_ID = 1,
+	REQUEST_PERSISTENT_ID_RESPONSE,
+	REQUEST_ZONE_TRANSFER,
+	REQUEST_ZONE_TRANSFER_RESPONSE,
+	SERVER_INFO,
+	REQUEST_SESSION_KEY,
+	SET_SESSION_KEY,
+	SESSION_KEY_RESPONSE,
+	PLAYER_ADDED,
+	PLAYER_REMOVED,
+
+	CREATE_PRIVATE_ZONE,
+	REQUEST_PRIVATE_ZONE,
+
+	WORLD_READY,
+	PREP_ZONE,
+
+	SHUTDOWN,
+	SHUTDOWN_RESPONSE,
+	SHUTDOWN_IMMEDIATE,
+
+	SHUTDOWN_UNIVERSE,
+
+	AFFIRM_TRANSFER_REQUEST,
+	AFFIRM_TRANSFER_RESPONSE,
+
+	NEW_SESSION_ALERT
+};
+
+#endif  //!__EMASTERMESSAGETYPE__H__

dCommon/dEnums/eMatchUpdate.h

@@ -0,0 +1,17 @@
+#ifndef __EMATCHUPDATE__H__
+#define __EMATCHUPDATE__H__
+
+#include <cstdint>
+
+enum class eMatchUpdate : int32_t {
+	PLAYER_ADDED = 0,
+	PLAYER_REMOVED,
+	PHASE_CREATED,
+	PHASE_WAIT_READY,
+	PHASE_WAIT_START,
+	PLAYER_READY,
+	PLAYER_NOT_READY,
+	PLAYER_UPDATE
+};
+
+#endif  //!__EMATCHUPDATE__H__

dCommon/dEnums/eMissionLockState.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#ifndef __EMISSIONLOCKSTATE__H__
+#define __EMISSIONLOCKSTATE__H__
+
+enum class eMissionLockState : int {
+	LOCKED,
+	NEW,
+	UNLOCKED,
+};
+
+#endif  //!__EMISSIONLOCKSTATE__H__

dCommon/dEnums/eMissionState.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#ifndef __MISSIONSTATE__H__
+#define __MISSIONSTATE__H__
+
+/**
+ * Represents the possible states a mission can be in
+ */
+enum class eMissionState : int {
+	/**
+	 * The mission state is unknown
+	 */
+	UNKNOWN = -1,
+
+	/**
+	 * The mission is yielding rewards
+	 */
+	REWARDING = 0,
+
+	/**
+	 * The mission can be accepted
+	 */
+	AVAILABLE = 1,
+
+	/**
+	 * The mission has been accepted but not yet completed
+	 */
+	ACTIVE = 2,
+
+	/**
+	* All the tasks for the mission have been completed and the entity can turn the mission in to complete it
+	*/
+	READY_TO_COMPLETE = 4,            //!< The mission is ready to complete
+
+	/**
+	 * The mission has been completed
+	*/
+	COMPLETE = 8,
+
+	/**
+	 * The mission is available again and has been completed before. Used for daily missions.
+	 */
+	COMPLETE_AVAILABLE = 9,
+
+	/**
+	 * The mission is active and has been completed before. Used for daily missions.
+	 */
+	COMPLETE_ACTIVE = 10,
+
+	/**
+	* The mission has been completed before and has now been completed again. Used for daily missions.
+	*/
+	COMPLETE_READY_TO_COMPLETE = 12
+};
+
+#endif  //!__MISSIONSTATE__H__

dCommon/dEnums/eMissionTaskType.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#ifndef __EMISSIONTASKTYPE__H__
+#define __EMISSIONTASKTYPE__H__
+
+enum class eMissionTaskType : int {
+	UNKNOWN = -1,
+	SMASH,
+	SCRIPT,
+	ACTIVITY,
+	COLLECTION,
+	TALK_TO_NPC,
+	EMOTE,
+	SHASH_CHAIN,
+	BUY,
+	SELL,
+	USE_ITEM,
+	USE_SKILL,
+	GATHER,
+	EXPLORE,
+	DELIVERY,
+	PERFORM_ACTIVITY,
+	INTERACT,
+	META,
+	EARN_REPUTATION,
+	VOTING,
+	SHOWCASE_DELIVERY,
+	REVIECE_CAST,
+	POWERUP,
+	PET_TAMING,
+	RACING,
+	PLAYER_FLAG,
+	PLACE_MODEL,
+	REMOVE_MODEL,
+	ADD_BEHAVIOR,
+	REMOVE_BEHAVIOR,
+	CLAIM_PROPERTY,
+	VISIT_PROPERTY,
+	TIME_PLAYED,
+	DONATION
+};
+
+#endif  //!__EMISSIONTASKTYPE__H__

dCommon/dEnums/eMovementPlatformState.h

@@ -0,0 +1,16 @@
+#ifndef __EMOVEMENTPLATFORMSTATE__H__
+#define __EMOVEMENTPLATFORMSTATE__H__
+
+#include <cstdint>
+
+/**
+ * The different types of platform movement state, supposedly a bitmap
+ */
+enum class eMovementPlatformState : uint32_t
+{
+	Moving = 0b00010,
+	Stationary = 0b11001,
+	Stopped = 0b01100
+};
+
+#endif  //!__EMOVEMENTPLATFORMSTATE__H__

dCommon/dEnums/eObjectBits.h

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

dCommon/dEnums/eObjectWorldState.h

@@ -0,0 +1,12 @@
+#ifndef __EOBJECTWORLDSTATE__H__
+#define __EOBJECTWORLDSTATE__H__
+
+#include <cstdint>
+
+enum class eObjectWorldState : uint32_t {
+	INWORLD,
+	ATTACHED,
+	INVENTORY
+};
+
+#endif  //!__EOBJECTWORLDSTATE__H__

dCommon/dEnums/ePackageType.h

@@ -0,0 +1,13 @@
+#ifndef __EPACKAGETYPE__H__
+#define __EPACKAGETYPE__H__
+
+enum class ePackageType {
+	INVALID = -1,
+	ITEM,
+	BRICKS,
+	MODELS,
+	CAR_MODELS
+};
+
+
+#endif  //!__EPACKAGETYPE__H__

dCommon/dEnums/ePermissionMap.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <cstdint>
+
+#ifndef __EPERMISSIONMAP__H__
+#define __EPERMISSIONMAP__H__
+
+/**
+ * Bitmap of permissions and restrictions for characters.
+ */
+enum class ePermissionMap : uint64_t {
+	/**
+	 * Reserved for future use, bit 0-3.
+	 */
+
+	/**
+	 * The character has restricted trade acccess, bit 4.
+	 */
+	RestrictedTradeAccess = 0x1 << 4,
+
+	/**
+	 * The character has restricted mail access, bit 5.
+	 */
+	RestrictedMailAccess = 0x1 << 5,
+
+	/**
+	 * The character has restricted chat access, bit 6.
+	 */
+	RestrictedChatAccess = 0x1 << 6,
+
+	//
+	// Combined permissions
+	//
+
+	/**
+	 * The character is marked as 'old', restricted from trade and mail.
+	 */
+	Old = RestrictedTradeAccess | RestrictedMailAccess,
+
+	/**
+	* The character is soft banned, restricted from trade, mail, and chat.
+	*/
+	SoftBanned = RestrictedTradeAccess | RestrictedMailAccess | RestrictedChatAccess,
+};
+
+#endif  //!__EPERMISSIONMAP__H__

dCommon/dEnums/ePetTamingNotifyType.h

@@ -0,0 +1,15 @@
+#ifndef __EPETTAMINGNOTIFYTYPE__H__
+#define __EPETTAMINGNOTIFYTYPE__H__
+
+#include <cstdint>
+
+enum class ePetTamingNotifyType : uint32_t {
+	SUCCESS,
+	QUIT,
+	FAILED,
+	BEGIN,
+	READY,
+	NAMINGPET
+};
+
+#endif  //!__EPETTAMINGNOTIFYTYPE__H__

dCommon/dEnums/ePhysicsEffectType.h

@@ -0,0 +1,15 @@
+#ifndef __EPHYSICSEFFECTTYPE__H__
+#define __EPHYSICSEFFECTTYPE__H__
+
+
+#include <cstdint>
+
+enum class ePhysicsEffectType : uint32_t {
+	PUSH,
+	ATTRACT,
+	REPULSE,
+	GRAVITY_SCALE,
+	FRICTION
+};
+
+#endif  //!__EPHYSICSEFFECTTYPE__H__

dCommon/dEnums/ePlayerFlag.h

@@ -0,0 +1,172 @@
+#ifndef __EPLAYERFLAG__H__
+#define __EPLAYERFLAG__H__
+
+#include <cstdint>
+
+enum ePlayerFlag : int32_t {
+	BTARR_TESTING = 0,
+	PLAYER_HAS_ENTERED_PET_RANCH = 1,
+	MINIMAP_UNLOCKED = 2,
+	ACTIVITY_REBUILDING_FAIL_TIME = 3,
+	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
+	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
+	HELP_WALKING_CONTROLS = 6,
+	FIRST_SMASHABLE = 7,
+	FIRST_IMAGINATION_PICKUP = 8,
+	FIRST_DAMAGE = 9,
+	FIRST_ITEM = 10,
+	FIRST_BRICK = 11,
+	FIRST_CONSUMABLE = 12,
+	FIRST_EQUIPPABLE = 13,
+	CHAT_HELP = 14,
+	FIRST_PET_TAMING_MINIGAME = 15,
+	FIRST_PET_ON_SWITCH = 16,
+	FIRST_PET_JUMPED_ON_SWITCH = 17,
+	FIRST_PET_FOUND_TREASURE = 18,
+	FIRST_PET_DUG_TREASURE = 19,
+	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
+	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
+	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
+	FIRST_EMOTE_UNLOCKED = 23,
+	GF_PIRATE_REP = 24,
+	AG_BOB_CINEMATIC_EVENT = 25,
+	HELP_JUMPING_CONTROLS = 26,
+	HELP_DOUBLE_JUMP_CONTROLS = 27,
+	HELP_CAMERA_CONTROLS = 28,
+	HELP_ROTATE_CONTROLS = 29,
+	HELP_SMASH = 30,
+	MONUMENT_INTRO_MUSIC_PLAYED = 31,
+	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
+	AG_FINISH_LINE_BUILT = 33,
+	AG_BOSS_AREA_FOUND = 34,
+	AG_LANDED_IN_BATTLEFIELD = 35,
+	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
+	MODULAR_BUILD_STARTED = 37,
+	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
+	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
+	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
+	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
+	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
+	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
+	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
+	JOINED_A_FACTION = 45,
+	VENTURE_FACTION = 46,
+	ASSEMBLY_FACTION = 47,
+	PARADOX_FACTION = 48,
+	SENTINEL_FACTION = 49,
+	LUP_WORLD_ACCESS = 50,
+	AG_FIRST_FLAG_COLLECTED = 51,
+	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
+	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
+	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
+	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
+	GF_PET_DIG_FLAG_1 = 56,
+	GF_PET_DIG_FLAG_2 = 57,
+	GF_PET_DIG_FLAG_3 = 58,
+	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
+	GF_PLAYER_FALL_DEATH = 60,
+	GF_PLAYER_CAN_GET_FLAG_1 = 61,
+	GF_PLAYER_CAN_GET_FLAG_2 = 62,
+	GF_PLAYER_CAN_GET_FLAG_3 = 63,
+	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
+	AG_FIRST_COMBAT_COMPLETE = 65,
+	AG_COMPLETE_BOB_MISSION = 66,
+	FIRST_MANUAL_PET_HIBERNATE = 69,
+	CAGED_SPIDER = 74,
+	IS_NEWS_SCREEN_VISIBLE = 114,
+	NJ_GARMADON_CINEMATIC_SEEN = 125,
+	EQUPPED_TRIAL_FACTION_GEAR = 126,
+	ELEPHANT_PET_3050 = 801,
+	CAT_PET_3054 = 803,
+	TRICERATOPS_PET_3195 = 806,
+	TERRIER_PET_3254 = 807,
+	SKUNK_PET_3261 = 811,
+	BUNNY_PET_3672 = 813,
+	CROCODILE_PET_3994 = 814,
+	DOBERMAN_PET_5635 = 815,
+	BUFFALO_PET_5636 = 816,
+	ROBOT_DOG_PET_5637 = 818,
+	RED_DRAGON_PET_5639 = 819,
+	TORTOISE_PET_5640 = 820,
+	GREEN_DRAGON_PET_5641 = 821,
+	PANDA_PET_5643 = 822,
+	MANTIS_PET_5642 = 823,
+	WARTHOG_PET_6720 = 824,
+	LION_PET_3520 = 825,
+	GOAT_PET_7638 = 818,
+	CRAB_PET_7694 = 827,
+	REINDEER_PET_12294 = 829,
+	STEGOSAURUS_PET_12431 = 830,
+	SABER_CAT_PET_12432 = 831,
+	GRYPHON_PET_12433 = 832,
+	ALINE_PET_12334 = 833,
+	UNKNOWN_PET = 834,
+	EARTH_DRAGON_PET_16210 = 836,
+	SKELETON_DRAGON_PET_13067 = 838,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
+	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
+	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
+	AG_BATTLE_BINOC_AT_PARADOX = 1102,
+	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
+	AG_BATTLE_BINOC_AT_BECK = 1104,
+	AG_MONUMENT_BINOC_INTRO = 1105,
+	AG_MONUMENT_BINOC_OUTRO = 1106,
+	AG_LAUNCH_BINOC_INTRO = 1107,
+	AG_LAUNCH_BINOC_BISON = 1108,
+	AG_LAUNCH_BINOC_SHARK = 1109,
+	NS_BINOC_CONCERT_TRANSITION = 1201,
+	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
+	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
+	NS_BINOC_GF_LAUNCH = 1204,
+	NS_BINOC_FV_LAUNCH = 1205,
+	NS_BINOC_BRICK_ANNEX_WATER = 1206,
+	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
+	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
+	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
+	NS_BINOC_TBA = 1210,
+	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
+	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
+	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
+	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
+	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
+	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
+	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
+	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
+	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
+	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
+	PR_BINOC_AT_LAUNCH_PAD = 1251,
+	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
+	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
+	PR_BINOC_ON_BY_CROWS_NEST = 1254,
+	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
+	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
+	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
+	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
+	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
+	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
+	GF_BINOC_ON_LANDING_PAD = 1301,
+	GF_BINOC_AT_RAVINE_START = 1302,
+	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
+	GF_BINOC_AT_TURTLE_AREA = 1304,
+	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
+	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
+	GF_BINOC_IN_RACING_AREA = 1307,
+	GF_BINOC_IN_CROC_AREA = 1308,
+	GF_BINOC_IN_JAIL_AREA = 1309,
+	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
+	NT_HEART_OF_DARKNESS = 1911,
+	NT_PLINTH_REBUILD = 1919,
+	NT_FACTION_SPY_DUKE = 1974,
+	NT_FACTION_SPY_OVERBUILD = 1976,
+	NT_FACTION_SPY_HAEL = 1977,
+	NJ_EARTH_SPINJITZU = 2030,
+	NJ_LIGHTNING_SPINJITZU = 2031,
+	NJ_ICE_SPINJITZU = 2032,
+	NJ_FIRE_SPINJITZU = 2033,
+	NJ_WU_SHOW_DAILY_CHEST = 2099
+};
+
+#endif  //!__EPLAYERFLAG__H__

dCommon/dEnums/eQuickBuildFailReason.h

@@ -0,0 +1,13 @@
+#ifndef __EQUICKBUILDFAILREASON__H__
+#define __EQUICKBUILDFAILREASON__H__
+
+#include <cstdint>
+
+enum class eQuickBuildFailReason : uint32_t {
+	NOT_GIVEN,
+	OUT_OF_IMAGINATION,
+	CANCELED_EARLY,
+	BUILD_ENDED
+};
+
+#endif  //!__EQUICKBUILDFAILREASON__H__

dCommon/dEnums/eRacingTaskParam.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#ifndef __ERACINGTASKPARAM__H__
+#define __ERACINGTASKPARAM__H__
+
+#include <cstdint>
+
+enum class eRacingTaskParam : int32_t {
+	FINISH_WITH_PLACEMENT = 1,
+	LAP_TIME,
+	TOTAL_TRACK_TIME,
+	COMPLETE_ANY_RACING_TASK,
+	COMPLETE_TRACK_TASKS,
+	MODULAR_BUILDING,
+	SAFE_DRIVER = 10,
+	SMASHABLES,
+	COLLECT_IMAGINATION,
+	COMPETED_IN_RACE,
+	WIN_RACE_IN_WORLD,
+	FIRST_PLACE_MULTIPLE_TRACKS,
+	LAST_PLACE_FINISH,
+	SMASH_SPECIFIC_SMASHABLE
+};
+
+#endif  //!__ERACINGTASKPARAM__H__

dCommon/dEnums/eRebuildState.h

@@ -0,0 +1,15 @@
+#ifndef __EREBUILDSTATE__H__
+#define __EREBUILDSTATE__H__
+
+#include <cstdint>
+
+enum class eRebuildState : uint32_t {
+	OPEN,
+	COMPLETED = 2,
+	RESETTING = 4,
+	BUILDING,
+	INCOMPLETE
+};
+
+
+#endif  //!__EREBUILDSTATE__H__

dCommon/dEnums/eRenameResponse.h

@@ -0,0 +1,15 @@
+#ifndef __ERENAMERESPONSE__H__
+#define __ERENAMERESPONSE__H__
+
+#include <cstdint>
+
+//! An enum for character rename responses
+enum class eRenameResponse : uint8_t {
+	SUCCESS = 0,
+	UNKNOWN_ERROR,
+	NAME_UNAVAILABLE,
+	NAME_IN_USE
+};
+
+
+#endif  //!__ERENAMERESPONSE__H__

dCommon/dEnums/eReplicaComponentType.h

@@ -0,0 +1,127 @@
+#ifndef __EREPLICACOMPONENTTYPE__H__
+#define __EREPLICACOMPONENTTYPE__H__
+
+#include <cstdint>
+
+enum class eReplicaComponentType : uint32_t {
+	INVALID = 0,
+	CONTROLLABLE_PHYSICS,
+	RENDER,
+	SIMPLE_PHYSICS,
+	CHARACTER,
+	SCRIPT,
+	BOUNCER,
+	BUFF, // buff is really 98, this is DESTROYABLE
+	GHOST,
+	SKILL,
+	SPAWNER,
+	ITEM,
+	REBUILD,
+	REBUILD_START,
+	REBUILD_ACTIVATOR,
+	ICON_ONLY,
+	VENDOR,
+	INVENTORY,
+	PROJECTILE_PHYSICS,
+	SHOOTING_GALLERY,
+	RIGID_BODY_PHANTOM_PHYSICS,
+	DROP_EFFECT,
+	CHEST,
+	COLLECTIBLE,
+	BLUEPRINT,
+	MOVING_PLATFORM,
+	PET,
+	PLATFORM_BOUNDARY,
+	MODULE,
+	ARCADE,
+	VEHICLE_PHYSICS, // Havok demo based
+	MOVEMENT_AI,
+	EXHIBIT,
+	OVERHEAD_ICON,
+	PET_CONTROL,
+	MINIFIG,
+	PROPERTY,
+	PET_CREATOR,
+	MODEL_BUILDER,
+	SCRIPTED_ACTIVITY,
+	PHANTOM_PHYSICS,
+	SPRINGPAD,
+	MODEL,
+	PROPERTY_ENTRANCE,
+	FX,
+	PROPERTY_MANAGEMENT,
+	VEHICLE_PHYSICS_NEW, // internal physics based on havok
+	PHYSICS_SYSTEM,
+	QUICK_BUILD,
+	SWITCH,
+	ZONE_CONTROL, // Minigame
+	CHANGLING,
+	CHOICE_BUILD,
+	PACKAGE,
+	SOUND_REPEATER,
+	SOUND_AMBIENT_2D,
+	SOUND_AMBIENT_3D,
+	PRECONDITION,
+	PLAYER_FLAG,
+	CUSTOM_BUILD_ASSEMBLY,
+	BASE_COMBAT_AI,
+	MODULE_ASSEMBLY,
+	SHOWCASE_MODEL_HANDLER,
+	RACING_MODULE,
+	GENERIC_ACTIVATOR,
+	PROPERTY_VENDOR,
+	HF_LIGHT_DIRECTION_GADGET,
+	ROCKET_LAUNCH,
+	ROCKET_LANDING,
+	TRIGGER,
+	DROPPED_LOOT,
+	RACING_CONTROL,
+	FACTION_TRIGGER,
+	MISSION_OFFER,
+	RACING_STATS,
+	LUP_EXHIBIT,
+	BBB,
+	SOUND_TRIGGER,
+	PROXIMITY_MONITOR,
+	RACING_SOUND_TRIGGER,
+	CHAT,
+	FRIENDS_LIST,
+	GUILD,
+	LOCAL_SYSTEM,
+	MISSION,
+	MUTABLE_MODEL_BEHAVIORS,
+	PATHFINDING,
+	PET_TAMING_CONTROL,
+	PROPERTY_EDITOR,
+	SKINNED_RENDER,
+	SLASH_COMMAND,
+	STATUS_EFFECT,
+	TEAMS,
+	TEXT_EFFECT,
+	TRADE,
+	USER_CONTROL,
+	IGNORE_LIST,
+	ROCKET_LAUNCH_LUP,
+	BUFF_REAL, // the real buff component, should just be name BUFF
+	INTERACTION_MANAGER,
+	DONATION_VENDOR,
+	COMBAT_MEDIATOR,
+	COMMENDATION_VENDOR,
+	UNKNOWN_103,
+	RAIL_ACTIVATOR,
+	ROLLER,
+	PLAYER_FORCED_MOVEMENT,
+	CRAFTING,
+	POSSESSABLE,
+	LEVEL_PROGRESSION,
+	POSSESSOR,
+	MOUNT_CONTROL,
+	UNKNOWN_112,
+	PROPERTY_PLAQUE,
+	BUILD_BORDER,
+	UNKOWN_115,
+	CULLING_PLANE,
+	DESTROYABLE = 1000 // Actually 7
+};
+
+#endif  //!__EREPLICACOMPONENTTYPE__H__

dCommon/dEnums/eReplicaPacketType.h

@@ -0,0 +1,12 @@
+#ifndef __EREPLICAPACKETTYPE__H__
+#define __EREPLICAPACKETTYPE__H__
+
+#include <cstdint>
+
+enum class eReplicaPacketType : uint8_t {
+	CONSTRUCTION,
+	SERIALIZATION,
+	DESTRUCTION
+};
+
+#endif  //!__EREPLICAPACKETTYPE__H__

dCommon/dEnums/eServerDisconnectIdentifiers.h

@@ -0,0 +1,24 @@
+#ifndef __ESERVERDISCONNECTIDENTIFIERS__H__
+#define __ESERVERDISCONNECTIDENTIFIERS__H__
+
+#include <cstdint>
+
+enum class eServerDisconnectIdentifiers : uint32_t {
+	UNKNOWN_SERVER_ERROR = 0,
+	WRONG_GAME_VERSION,
+	WRONG_SERVER_VERSION,
+	CONNECTION_ON_INVALID_PORT,
+	DUPLICATE_LOGIN,
+	SERVER_SHUTDOWN,
+	SERVER_MAP_LOAD_FAILURE,
+	INVALID_SESSION_KEY,
+	ACCOUNT_NOT_IN_PENDING_LIST,
+	CHARACTER_NOT_FOUND,
+	CHARACTER_CORRUPTED,
+	KICK,
+	SAVE_FAILURE,
+	FREE_TRIAL_EXPIRED,
+	PLAY_SCHEDULE_TIME_DONE
+};
+
+#endif  //!__ESERVERDISCONNECTIDENTIFIERS__H__

dCommon/dEnums/eServerMessageType.h

@@ -0,0 +1,12 @@
+#ifndef __ESERVERMESSAGETYPE__H__
+#define __ESERVERMESSAGETYPE__H__
+
+#include <cstdint>
+//! The Internal Server Packet Identifiers
+enum class eServerMessageType : uint32_t {
+	VERSION_CONFIRM = 0,
+	DISCONNECT_NOTIFY,
+	GENERAL_NOTIFY
+};
+
+#endif  //!__ESERVERMESSAGETYPE__H__

dCommon/dEnums/eStateChangeType.h

@@ -0,0 +1,11 @@
+#ifndef __ESTATECHANGETYPE__H__
+#define __ESTATECHANGETYPE__H__
+
+#include <cstdint>
+
+enum class eStateChangeType : uint32_t {
+	PUSH,
+	POP
+};
+
+#endif  //!__ESTATECHANGETYPE__H__

dCommon/dEnums/eTerminateType.h

@@ -0,0 +1,12 @@
+#ifndef __ETERMINATETYPE__H__
+#define __ETERMINATETYPE__H__
+
+#include <cstdint>
+
+enum class eTerminateType : uint32_t {
+	RANGE,
+	USER,
+	FROM_INTERACTION
+};
+
+#endif  //!__ETERMINATETYPE__H__

dCommon/dEnums/eTriggerCommandType.h

@@ -0,0 +1,119 @@
+#ifndef __ETRIGGERCOMMANDTYPE__H__
+#define __ETRIGGERCOMMANDTYPE__H__
+
+// For info about Trigger Command see:
+// https://docs.lu-dev.net/en/latest/file-structures/lutriggers.html?highlight=trigger#possible-values-commands
+
+enum class eTriggerCommandType {
+	INVALID,
+	ZONE_PLAYER,
+	FIRE_EVENT,
+	DESTROY_OBJ,
+	TOGGLE_TRIGGER,
+	RESET_REBUILD,
+	SET_PATH,
+	SET_PICK_TYPE,
+	MOVE_OBJECT,
+	ROTATE_OBJECT,
+	PUSH_OBJECT,
+	REPEL_OBJECT,
+	SET_TIMER,
+	CANCEL_TIMER,
+	PLAY_CINEMATIC,
+	TOGGLE_BBB,
+	UPDATE_MISSION,
+	SET_BOUNCER_STATE,
+	BOUNCE_ALL_ON_BOUNCER,
+	TURN_AROUND_ON_PATH,
+	GO_FORWARD_ON_PATH,
+	GO_BACKWARD_ON_PATH,
+	STOP_PATHING,
+	START_PATHING,
+	LOCK_OR_UNLOCK_CONTROLS,
+	PLAY_EFFECT,
+	STOP_EFFECT,
+	ACTIVATE_MUSIC_CUE,
+	DEACTIVATE_MUSIC_CUE,
+	FLASH_MUSIC_CUE,
+	SET_MUSIC_PARAMETER,
+	PLAY_2D_AMBIENT_SOUND,
+	STOP_2D_AMBIENT_SOUND,
+	PLAY_3D_AMBIENT_SOUND,
+	STOP_3D_AMBIENT_SOUND,
+	ACTIVATE_MIXER_PROGRAM,
+	DEACTIVATE_MIXER_PROGRAM,
+	CAST_SKILL,
+	DISPLAY_ZONE_SUMMARY,
+	SET_PHYSICS_VOLUME_EFFECT,
+	SET_PHYSICS_VOLUME_STATUS,
+	SET_MODEL_TO_BUILD,
+	SPAWN_MODEL_BRICKS,
+	ACTIVATE_SPAWNER_NETWORK,
+	DEACTIVATE_SPAWNER_NETWORK,
+	RESET_SPAWNER_NETWORK,
+	DESTROY_SPAWNER_NETWORK_OBJECTS,
+	GO_TO_WAYPOINT,
+	ACTIVATE_PHYSICS
+};
+
+
+class TriggerCommandType {
+public:
+	static eTriggerCommandType StringToTriggerCommandType(std::string commandString) {
+		const std::map<std::string, eTriggerCommandType> TriggerCommandMap = {
+			{ "zonePlayer", eTriggerCommandType::ZONE_PLAYER},
+			{ "fireEvent", eTriggerCommandType::FIRE_EVENT},
+			{ "destroyObj", eTriggerCommandType::DESTROY_OBJ},
+			{ "toggleTrigger", eTriggerCommandType::TOGGLE_TRIGGER},
+			{ "resetRebuild", eTriggerCommandType::RESET_REBUILD},
+			{ "setPath", eTriggerCommandType::SET_PATH},
+			{ "setPickType", eTriggerCommandType::SET_PICK_TYPE},
+			{ "moveObject", eTriggerCommandType::MOVE_OBJECT},
+			{ "rotateObject", eTriggerCommandType::ROTATE_OBJECT},
+			{ "pushObject", eTriggerCommandType::PUSH_OBJECT},
+			{ "repelObject", eTriggerCommandType::REPEL_OBJECT},
+			{ "setTimer", eTriggerCommandType::SET_TIMER},
+			{ "cancelTimer", eTriggerCommandType::CANCEL_TIMER},
+			{ "playCinematic", eTriggerCommandType::PLAY_CINEMATIC},
+			{ "toggleBBB", eTriggerCommandType::TOGGLE_BBB},
+			{ "updateMission", eTriggerCommandType::UPDATE_MISSION},
+			{ "setBouncerState", eTriggerCommandType::SET_BOUNCER_STATE},
+			{ "bounceAllOnBouncer", eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER},
+			{ "turnAroundOnPath", eTriggerCommandType::TURN_AROUND_ON_PATH},
+			{ "goForwardOnPath", eTriggerCommandType::GO_FORWARD_ON_PATH},
+			{ "goBackwardOnPath", eTriggerCommandType::GO_BACKWARD_ON_PATH},
+			{ "stopPathing", eTriggerCommandType::STOP_PATHING},
+			{ "startPathing", eTriggerCommandType::START_PATHING},
+			{ "LockOrUnlockControls", eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS},
+			{ "PlayEffect", eTriggerCommandType::PLAY_EFFECT},
+			{ "StopEffect", eTriggerCommandType::STOP_EFFECT},
+			{ "activateMusicCue", eTriggerCommandType::ACTIVATE_MUSIC_CUE},
+			{ "deactivateMusicCue", eTriggerCommandType::DEACTIVATE_MUSIC_CUE},
+			{ "flashMusicCue", eTriggerCommandType::FLASH_MUSIC_CUE},
+			{ "setMusicParameter", eTriggerCommandType::SET_MUSIC_PARAMETER},
+			{ "play2DAmbientSound", eTriggerCommandType::PLAY_2D_AMBIENT_SOUND},
+			{ "stop2DAmbientSound", eTriggerCommandType::STOP_2D_AMBIENT_SOUND},
+			{ "play3DAmbientSound", eTriggerCommandType::PLAY_3D_AMBIENT_SOUND},
+			{ "stop3DAmbientSound", eTriggerCommandType::STOP_3D_AMBIENT_SOUND},
+			{ "activateMixerProgram", eTriggerCommandType::ACTIVATE_MIXER_PROGRAM},
+			{ "deactivateMixerProgram", eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM},
+			{ "CastSkill", eTriggerCommandType::CAST_SKILL},
+			{ "displayZoneSummary", eTriggerCommandType::DISPLAY_ZONE_SUMMARY},
+			{ "SetPhysicsVolumeEffect", eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT},
+			{ "SetPhysicsVolumeStatus", eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS},
+			{ "setModelToBuild", eTriggerCommandType::SET_MODEL_TO_BUILD},
+			{ "spawnModelBricks", eTriggerCommandType::SPAWN_MODEL_BRICKS},
+			{ "ActivateSpawnerNetwork", eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK},
+			{ "DeactivateSpawnerNetwork", eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK},
+			{ "ResetSpawnerNetwork", eTriggerCommandType::RESET_SPAWNER_NETWORK},
+			{ "DestroySpawnerNetworkObjects", eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS},
+			{ "Go_To_Waypoint", eTriggerCommandType::GO_TO_WAYPOINT},
+			{ "ActivatePhysics", eTriggerCommandType::ACTIVATE_PHYSICS}
+		};
+
+		auto intermed = TriggerCommandMap.find(commandString);
+		return (intermed != TriggerCommandMap.end()) ? intermed->second : eTriggerCommandType::INVALID;
+	};
+};
+
+#endif  //!__ETRIGGERCOMMANDTYPE__H__

dCommon/dEnums/eTriggerEventType.h

@@ -0,0 +1,53 @@
+#ifndef __ETRIGGEREVENTTYPE__H__
+#define __ETRIGGEREVENTTYPE__H__
+
+enum class eTriggerEventType {
+	INVALID,
+	DESTROY,
+	CUSTOM_EVENT,
+	ENTER,
+	EXIT,
+	CREATE,
+	HIT,
+	TIMER_DONE,
+	REBUILD_COMPLETE,
+	ACTIVATED,
+	DEACTIVATED,
+	ARRIVED,
+	ARRIVED_AT_END_OF_PATH,
+	ZONE_SUMMARY_DISMISSED,
+	ARRIVED_AT_DESIRED_WAYPOINT,
+	PET_ON_SWITCH,
+	PET_OFF_SWITCH,
+	INTERACT
+};
+
+class TriggerEventType {
+public:
+	static eTriggerEventType StringToTriggerEventType(std::string commandString) {
+		const std::map<std::string, eTriggerEventType> TriggerEventMap = {
+			{"OnDestroy", eTriggerEventType::DESTROY},
+			{"OnCustomEvent", eTriggerEventType::CUSTOM_EVENT},
+			{"OnEnter", eTriggerEventType::ENTER},
+			{"OnExit", eTriggerEventType::EXIT},
+			{"OnCreate", eTriggerEventType::CREATE},
+			{"OnHit", eTriggerEventType::HIT},
+			{"OnTimerDone", eTriggerEventType::TIMER_DONE},
+			{"OnRebuildComplete", eTriggerEventType::REBUILD_COMPLETE},
+			{"OnActivated", eTriggerEventType::ACTIVATED},
+			{"OnDectivated", eTriggerEventType::DEACTIVATED}, // Dectivated vs Deactivated
+			{"OnArrived", eTriggerEventType::ARRIVED},
+			{"OnArrivedAtEndOfPath", eTriggerEventType::ARRIVED_AT_END_OF_PATH},
+			{"OnZoneSummaryDismissed", eTriggerEventType::ZONE_SUMMARY_DISMISSED},
+			{"OnArrivedAtDesiredWaypoint", eTriggerEventType::ARRIVED_AT_DESIRED_WAYPOINT},
+			{"OnPetOnSwitch", eTriggerEventType::PET_ON_SWITCH},
+			{"OnPetOffSwitch", eTriggerEventType::PET_OFF_SWITCH},
+			{"OnInteract", eTriggerEventType::INTERACT},
+		};
+
+		auto intermed = TriggerEventMap.find(commandString);
+		return (intermed != TriggerEventMap.end()) ? intermed->second : eTriggerEventType::INVALID;
+	};
+};
+
+#endif  //!__ETRIGGEREVENTTYPE__H__

dCommon/dEnums/eUseItemResponse.h

@@ -0,0 +1,12 @@
+#ifndef __EUSEITEMRESPONSE__H__
+#define __EUSEITEMRESPONSE__H__
+
+#include <cstdint>
+
+enum class eUseItemResponse : uint32_t {
+	NoImaginationForPet = 1,
+	FailedPrecondition,
+	MountsNotAllowed
+};
+
+#endif  //!__EUSEITEMRESPONSE__H__

dCommon/dEnums/eWorldMessageType.h

@@ -0,0 +1,42 @@
+#ifndef __EWORLDMESSAGETYPE__H__
+#define __EWORLDMESSAGETYPE__H__
+
+#include <cstdint>
+
+enum class eWorldMessageType : uint32_t {
+	VALIDATION = 1,  // 				Session info
+	CHARACTER_LIST_REQUEST,
+	CHARACTER_CREATE_REQUEST,
+	LOGIN_REQUEST,  // 			Character selected
+	GAME_MSG,
+	CHARACTER_DELETE_REQUEST,
+	CHARACTER_RENAME_REQUEST,
+	HAPPY_FLOWER_MODE_NOTIFY,
+	SLASH_RELOAD_MAP,  // 			Reload map cmp
+	SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
+	SLASH_PUSH_MAP,  // 			Push map cmd
+	SLASH_PULL_MAP,  // 			Pull map cmd
+	LOCK_MAP_REQUEST,
+	GENERAL_CHAT_MESSAGE,  // 		General chat message
+	HTTP_MONITOR_INFO_REQUEST,
+	SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
+	MODELS_CLEAR,
+	EXHIBIT_INSERT_MODEL,
+	LEVEL_LOAD_COMPLETE,  // 		Character data request
+	TMP_GUILD_CREATE,
+	ROUTE_PACKET,  // 				Social?
+	POSITION_UPDATE,
+	MAIL,
+	WORD_CHECK, // 				Whitelist word check
+	STRING_CHECK,  // 				Whitelist string check
+	GET_PLAYERS_IN_ZONE,
+	REQUEST_UGC_MANIFEST_INFO,
+	BLUEPRINT_GET_ALL_DATA_REQUEST,
+	CANCEL_MAP_QUEUE,
+	HANDLE_FUNNESS,
+	FAKE_PRG_CSR_MESSAGE,
+	REQUEST_FREE_TRIAL_REFRESH,
+	GM_SET_FREE_TRIAL_STATUS
+};
+
+#endif  //!__EWORLDMESSAGETYPE__H__

dCommon/dLogger.cpp

@@ -89,7 +89,7 @@ void dLogger::Log(const std::string& className, const std::string& message) {
 void dLogger::LogDebug(const char* className, const char* format, ...) {
 	if (!m_logDebugStatements) return;
 	va_list args;
-	std::string log = "[" + std::string(className) + "] " + std::string(format);
+	std::string log = "[" + std::string(className) + "] " + std::string(format) + "\n";
 	va_start(args, format);
 	vLog(log.c_str(), args);
 	va_end(args);

dDatabase/CDClientManager.cpp

@@ -1,46 +1,80 @@
 #include "CDClientManager.h"
+#include "CDActivityRewardsTable.h"
+#include "CDAnimationsTable.h"
+#include "CDBehaviorParameterTable.h"
+#include "CDBehaviorTemplateTable.h"
+#include "CDComponentsRegistryTable.h"
+#include "CDCurrencyTableTable.h"
+#include "CDDestructibleComponentTable.h"
+#include "CDEmoteTable.h"
+#include "CDInventoryComponentTable.h"
+#include "CDItemComponentTable.h"
+#include "CDItemSetsTable.h"
+#include "CDItemSetSkillsTable.h"
+#include "CDLevelProgressionLookupTable.h"
+#include "CDLootMatrixTable.h"
+#include "CDLootTableTable.h"
+#include "CDMissionNPCComponentTable.h"
+#include "CDMissionTasksTable.h"
+#include "CDMissionsTable.h"
+#include "CDObjectSkillsTable.h"
+#include "CDObjectsTable.h"
+#include "CDPhysicsComponentTable.h"
+#include "CDRebuildComponentTable.h"
+#include "CDScriptComponentTable.h"
+#include "CDSkillBehaviorTable.h"
+#include "CDZoneTableTable.h"
+#include "CDVendorComponentTable.h"
+#include "CDActivitiesTable.h"
+#include "CDPackageComponentTable.h"
+#include "CDProximityMonitorComponentTable.h"
+#include "CDMovementAIComponentTable.h"
+#include "CDBrickIDTableTable.h"
+#include "CDRarityTableTable.h"
+#include "CDMissionEmailTable.h"
+#include "CDRewardsTable.h"
+#include "CDPropertyEntranceComponentTable.h"
+#include "CDPropertyTemplateTable.h"
+#include "CDFeatureGatingTable.h"
+#include "CDRailActivatorComponent.h"
 
-// Static Variables
-CDClientManager* CDClientManager::m_Address = nullptr;
-
-//! Initializes the manager
-void CDClientManager::Initialize(void) {
-	tables.insert(std::make_pair("ActivityRewards", new CDActivityRewardsTable()));
-	UNUSED(tables.insert(std::make_pair("Animations", new CDAnimationsTable())));
-	tables.insert(std::make_pair("BehaviorParameter", new CDBehaviorParameterTable()));
-	tables.insert(std::make_pair("BehaviorTemplate", new CDBehaviorTemplateTable()));
-	tables.insert(std::make_pair("ComponentsRegistry", new CDComponentsRegistryTable()));
-	tables.insert(std::make_pair("CurrencyTable", new CDCurrencyTableTable()));
-	tables.insert(std::make_pair("DestructibleComponent", new CDDestructibleComponentTable()));
-	tables.insert(std::make_pair("EmoteTable", new CDEmoteTableTable()));
-	tables.insert(std::make_pair("InventoryComponent", new CDInventoryComponentTable()));
-	tables.insert(std::make_pair("ItemComponent", new CDItemComponentTable()));
-	tables.insert(std::make_pair("ItemSets", new CDItemSetsTable()));
-	tables.insert(std::make_pair("ItemSetSkills", new CDItemSetSkillsTable()));
-	tables.insert(std::make_pair("LevelProgressionLookup", new CDLevelProgressionLookupTable()));
-	tables.insert(std::make_pair("LootMatrix", new CDLootMatrixTable()));
-	tables.insert(std::make_pair("LootTable", new CDLootTableTable()));
-	tables.insert(std::make_pair("MissionNPCComponent", new CDMissionNPCComponentTable()));
-	tables.insert(std::make_pair("MissionTasks", new CDMissionTasksTable()));
-	tables.insert(std::make_pair("Missions", new CDMissionsTable()));
-	tables.insert(std::make_pair("ObjectSkills", new CDObjectSkillsTable()));
-	tables.insert(std::make_pair("Objects", new CDObjectsTable()));
-	tables.insert(std::make_pair("PhysicsComponent", new CDPhysicsComponentTable()));
-	tables.insert(std::make_pair("RebuildComponent", new CDRebuildComponentTable()));
-	tables.insert(std::make_pair("ScriptComponent", new CDScriptComponentTable()));
-	tables.insert(std::make_pair("SkillBehavior", new CDSkillBehaviorTable()));
-	tables.insert(std::make_pair("ZoneTable", new CDZoneTableTable()));
-	tables.insert(std::make_pair("VendorComponent", new CDVendorComponentTable()));
-	tables.insert(std::make_pair("Activities", new CDActivitiesTable()));
-	tables.insert(std::make_pair("PackageComponent", new CDPackageComponentTable()));
-	tables.insert(std::make_pair("ProximityMonitorComponent", new CDProximityMonitorComponentTable()));
-	tables.insert(std::make_pair("MovementAIComponent", new CDMovementAIComponentTable()));
-	tables.insert(std::make_pair("BrickIDTable", new CDBrickIDTableTable()));
-	tables.insert(std::make_pair("RarityTable", new CDRarityTableTable()));
-	tables.insert(std::make_pair("MissionEmail", new CDMissionEmailTable()));
-	tables.insert(std::make_pair("Rewards", new CDRewardsTable()));
-	tables.insert(std::make_pair("PropertyEntranceComponent", new CDPropertyEntranceComponentTable()));
-	tables.insert(std::make_pair("PropertyTemplate", new CDPropertyTemplateTable()));
-	tables.insert(std::make_pair("FeatureGating", new CDFeatureGatingTable()));
-	tables.insert(std::make_pair("RailActivatorComponent", new CDRailActivatorComponentTable()));
+CDClientManager::CDClientManager() {
+	CDActivityRewardsTable::Instance();
+	UNUSED(CDAnimationsTable::Instance());
+	CDBehaviorParameterTable::Instance();
+	CDBehaviorTemplateTable::Instance();
+	CDComponentsRegistryTable::Instance();
+	CDCurrencyTableTable::Instance();
+	CDDestructibleComponentTable::Instance();
+	CDEmoteTableTable::Instance();
+	CDInventoryComponentTable::Instance();
+	CDItemComponentTable::Instance();
+	CDItemSetsTable::Instance();
+	CDItemSetSkillsTable::Instance();
+	CDLevelProgressionLookupTable::Instance();
+	CDLootMatrixTable::Instance();
+	CDLootTableTable::Instance();
+	CDMissionNPCComponentTable::Instance();
+	CDMissionTasksTable::Instance();
+	CDMissionsTable::Instance();
+	CDObjectSkillsTable::Instance();
+	CDObjectsTable::Instance();
+	CDPhysicsComponentTable::Instance();
+	CDRebuildComponentTable::Instance();
+	CDScriptComponentTable::Instance();
+	CDSkillBehaviorTable::Instance();
+	CDZoneTableTable::Instance();
+	CDVendorComponentTable::Instance();
+	CDActivitiesTable::Instance();
+	CDPackageComponentTable::Instance();
+	CDProximityMonitorComponentTable::Instance();
+	CDMovementAIComponentTable::Instance();
+	CDBrickIDTableTable::Instance();
+	CDRarityTableTable::Instance();
+	CDMissionEmailTable::Instance();
+	CDRewardsTable::Instance();
+	CDPropertyEntranceComponentTable::Instance();
+	CDPropertyTemplateTable::Instance();
+	CDFeatureGatingTable::Instance();
+	CDRailActivatorComponentTable::Instance();
 }