Public release of the DLU server code!

Have fun!

.clang-format

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

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

.github/workflows/main.yml

@@ -0,0 +1,43 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the action will run. 
+on:
+  # Triggers the workflow on push or pull request events but only for the master branch
+  push:
+    branches: [ master, closed-beta, crux-prime, dev ]
+  pull_request:
+    branches: [ master, closed-beta, dev ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  ubuntu-build:
+      runs-on: ubuntu-latest
+      steps:
+      - name: Checkout
+        uses: actions/checkout@v2.0.0
+      - name: Build project
+        uses: nicledomaS/cmake_build_action@v1.3
+        with:
+          submodule_update: ON
+          create_package: OFF
+      - uses: actions/upload-artifact@v2
+        with:
+          name: MasterServer
+          path: build/MasterServer
+      - uses: actions/upload-artifact@v2
+        with:
+          name: WorldServer
+          path: build/WorldServer
+      - uses: actions/upload-artifact@v2
+        with:
+          name: ChatServer
+          path: build/ChatServer
+      - uses: actions/upload-artifact@v2
+        with:
+          name: AuthServer
+          path: build/AuthServer

.gitignore

@@ -0,0 +1,116 @@
+temp/
+cmake-build-debug/
+RelWithDebInfo/
+
+# Third party libraries
+thirdparty/mysql/
+thirdparty/mysql_linux/
+CMakeVariables.txt
+
+# Build folders
+build/
+linux_build/
+
+# Codeblocks
+*.layout
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.idb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+*.lastbuildstate
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio Log Files
+*.tlog
+*.log
+
+# VS Code
+.vscode
+
+# Clion (IntelliJ)
+.idea
+.DS_Store
+
+# Exceptions:
+CMakeSettings.json
+*.vcxproj
+*.filters
+*.cmake
+CMakeCache.txt
+*.bin
+CMakeFiles/3.17.3/CompilerIdC/CMakeCCompilerId.c
+CMakeFiles/3.17.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
+CMakeFiles/3.17.3/VCTargetsPath.txt
+CMakeFiles/3e6b105f924142e3e299a1a30e09566e/generate.stamp.rule
+CMakeFiles/cmake.check_cache
+CMakeFiles/generate.stamp
+CMakeFiles/generate.stamp.depend
+CMakeFiles/generate.stamp.list
+CMakeFiles/TargetDirectories.txt
+*.sln
+*.recipe
+
+# clangd
+.cache
+thirdparty/zlib-1.2.11/

.gitmodules

@@ -0,0 +1,13 @@
+[submodule "thirdparty/cpp-httplib"]
+	path = thirdparty/cpp-httplib
+	url = https://github.com/yhirose/cpp-httplib
+[submodule "thirdparty/tinyxml2"]
+	path = thirdparty/tinyxml2
+	url = https://github.com/leethomason/tinyxml2
+[submodule "thirdparty/recastnavigation"]
+	path = thirdparty/recastnavigation
+	url = https://github.com/recastnavigation/recastnavigation
+[submodule "thirdparty/libbcrypt"]
+	path = thirdparty/libbcrypt
+	url = https://github.com/trusch/libbcrypt.git
+

CMakeLists.txt

@@ -0,0 +1,486 @@
+cmake_minimum_required(VERSION 3.12)
+project(Darkflame)
+
+# Read variables from file
+FILE(READ "${CMAKE_SOURCE_DIR}/CMakeVariables.txt" variables)
+
+string(REPLACE "\\\n" "" variables ${variables})
+string(REPLACE "\n" ";" variables ${variables})
+
+# Set the cmake variables, formatted as "VARIABLE #" in variables
+foreach(variable ${variables})
+    # If the string contains a #, skip it
+    if("${variable}" MATCHES "#")
+        continue()
+    endif()
+
+    # Split the variable into name and value
+    string(REPLACE "=" ";" variable ${variable})
+
+    # Check that the length of the variable is 2 (name and value)
+    list(LENGTH variable length)
+    if(NOT ${length} EQUAL 2)
+        continue()
+    endif()
+
+    list(GET variable 0 variable_name)
+    list(GET variable 1 variable_value)
+
+    # Set the variable
+    set(${variable_name} ${variable_value})
+
+    # Add compiler definition
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${variable_name}=${variable_value}")
+
+    message(STATUS "Variable: ${variable_name} = ${variable_value}")
+endforeach()
+
+# On windows it's better to build this from source, as there's no way FindZLIB is gonna find it
+if(NOT WIN32)
+find_package(ZLIB REQUIRED)
+endif()
+
+# Fetch External (Non-Submodule) Libraries
+if(WIN32)
+include(FetchContent)
+
+FetchContent_Declare(
+    mysql
+    URL https://dev.mysql.com/get/Downloads/Connector-C++/mysql-connector-c++-8.0.27-winx64.zip
+    URL_HASH MD5=e3c53f6e4d0a72fde2713f7597bf9468
+)
+
+FetchContent_Declare(
+    zlib
+    URL http://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
+    URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
+)
+
+FetchContent_MakeAvailable(zlib)
+FetchContent_MakeAvailable(mysql)
+
+set(ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
+set_target_properties(zlib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIRS}") # Why?
+add_library(ZLIB::ZLIB ALIAS zlib) # You're welcome
+
+endif(WIN32)
+if(UNIX)
+if(APPLE)
+else()
+include(FetchContent)
+
+FetchContent_Declare(
+    mysql
+    URL https://dev.mysql.com/get/Downloads/Connector-C++/mysql-connector-c++-8.0.27-linux-glibc2.12-x86-64bit.tar.gz
+    URL_HASH MD5=12f086b76c11022cc7139b41a36cdf9e
+)
+
+FetchContent_MakeAvailable(mysql)
+
+if (__include_backtrace__ AND __compile_backtrace__)
+    FetchContent_Declare(
+        backtrace
+        GIT_REPOSITORY https://github.com/ianlancetaylor/libbacktrace.git
+    )
+
+    FetchContent_MakeAvailable(backtrace)
+
+    if (NOT EXISTS ${backtrace_SOURCE_DIR}/.libs)
+    set(backtrace_make_cmd "${backtrace_SOURCE_DIR}/configure --prefix=\"/usr\" --enable-shared --with-system-libunwind")
+
+    execute_process(
+        COMMAND bash -c "cd ${backtrace_SOURCE_DIR} && ${backtrace_make_cmd} && make && cd ${CMAKE_SOURCE_DIR}"
+    )
+    endif()
+
+    link_directories(${backtrace_SOURCE_DIR}/.libs/)
+    include_directories(${backtrace_SOURCE_DIR})
+endif(__include_backtrace__)
+
+endif()
+endif(UNIX)
+
+# Set the version
+set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPROJECT_VERSION=${PROJECT_VERSION}")
+
+# Echo the version
+message(STATUS "Version: ${PROJECT_VERSION}")
+
+set(CMAKE_CXX_STANDARD 17)
+
+if(WIN32)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+endif(WIN32)
+
+# Our output dir
+set(CMAKE_BINARY_DIR ${PROJECT_BINARY_DIR})
+
+# Create a /res directory
+make_directory(${CMAKE_BINARY_DIR}/res)
+
+# Create a /locale directory
+make_directory(${CMAKE_BINARY_DIR}/locale)
+
+# Copy ini files on first build
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/authconfig.ini)
+    configure_file(
+        ${CMAKE_SOURCE_DIR}/resources/authconfig.ini ${PROJECT_BINARY_DIR}/authconfig.ini
+        COPYONLY
+    )
+endif()
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/chatconfig.ini)
+    configure_file(
+        ${CMAKE_SOURCE_DIR}/resources/chatconfig.ini ${PROJECT_BINARY_DIR}/chatconfig.ini
+        COPYONLY
+    )
+endif()
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/worldconfig.ini)
+    configure_file(
+        ${CMAKE_SOURCE_DIR}/resources/worldconfig.ini ${PROJECT_BINARY_DIR}/worldconfig.ini
+        COPYONLY
+    )
+endif()
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/masterconfig.ini)
+    configure_file(
+        ${CMAKE_SOURCE_DIR}/resources/masterconfig.ini ${PROJECT_BINARY_DIR}/masterconfig.ini
+        COPYONLY
+    )
+endif()
+
+# Copy files to output
+configure_file("${CMAKE_SOURCE_DIR}/vanity/CREDITS.md" "${CMAKE_BINARY_DIR}/vanity/CREDITS.md" COPYONLY)
+configure_file("${CMAKE_SOURCE_DIR}/vanity/INFO.md" "${CMAKE_BINARY_DIR}/vanity/INFO.md" COPYONLY)
+configure_file("${CMAKE_SOURCE_DIR}/vanity/TESTAMENT.md" "${CMAKE_BINARY_DIR}/vanity/TESTAMENT.md" COPYONLY)
+configure_file("${CMAKE_SOURCE_DIR}/vanity/NPC.xml" "${CMAKE_BINARY_DIR}/vanity/NPC.xml" COPYONLY)
+
+# 3rdparty includes
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/raknet/Source/)
+if(UNIX)
+    if(APPLE)
+        include_directories(/usr/local/include/)
+        include_directories(/usr/local/mysql-connector-c++/include/jdbc/)
+        include_directories(/usr/local/mysql-connector-c++/include/jdbc/cppconn/)
+    else()
+        include_directories(${mysql_SOURCE_DIR}/include/jdbc/)
+        include_directories(${mysql_SOURCE_DIR}/include/jdbc/cppconn/)
+    endif(APPLE)
+endif(UNIX)
+if(WIN32)
+include_directories(${mysql_SOURCE_DIR}/include/jdbc)
+include_directories(${mysql_SOURCE_DIR}/include/jdbc/cppconn)
+endif(WIN32)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/tinyxml2/)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Include)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Include)
+include_directories(${ZLIB_INCLUDE_DIRS})
+
+# Bcrypt
+if (NOT WIN32)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include/bcrypt)
+else ()
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/include)
+endif ()
+
+# Our includes
+include_directories(${PROJECT_BINARY_DIR})
+include_directories(${PROJECT_SOURCE_DIR}/dChatFilter/)
+include_directories(${PROJECT_SOURCE_DIR}/dCommon/)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dBehaviors)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dComponents)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dGameMessages)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dInventory)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dMission)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dEntity)
+include_directories(${PROJECT_SOURCE_DIR}/dGame/dUtilities)
+include_directories(${PROJECT_SOURCE_DIR}/dPhysics/)
+include_directories(${PROJECT_SOURCE_DIR}/dZoneManager/)
+include_directories(${PROJECT_SOURCE_DIR}/dDatabase/)
+include_directories(${PROJECT_SOURCE_DIR}/dDatabase/Tables/)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/SQLite/)
+include_directories(${PROJECT_SOURCE_DIR}/thirdparty/cpplinq/)
+include_directories(${PROJECT_SOURCE_DIR}/dNet/)
+include_directories(${PROJECT_SOURCE_DIR}/dScripts/)
+
+# Default to linking to libmysql
+set(MYSQL_LIB mysql)
+if(WIN32)
+set(MYSQL_LIB mysqlcppconn)
+endif(WIN32)
+
+# Lib folders:
+link_directories(${PROJECT_BINARY_DIR})
+if(UNIX)
+    if(APPLE)
+        link_directories(/usr/local/mysql-connector-c++/lib64/)
+    else()
+        link_directories(${mysql_SOURCE_DIR}/lib64/)
+
+        # Link to libmysqlcppconn on Linux
+        set(MYSQL_LIB mysqlcppconn)
+    endif(APPLE)
+endif(UNIX)
+if(WIN32)
+link_directories(${mysql_SOURCE_DIR}/lib64/vs14)
+endif(WIN32)
+
+# Source Code
+file(
+GLOB SOURCES
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dWorldServer/*.cpp
+)
+
+# Source Code for AuthServer
+file(
+GLOB SOURCES_AUTH
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dAuthServer/*.cpp
+)
+
+# Source Code for MasterServer
+file(
+GLOB SOURCES_MASTER
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dMasterServer/*.cpp
+)
+
+# Source Code for ChatServer
+file(
+GLOB SOURCES_CHAT
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dChatServer/*.cpp
+)
+
+# Source Code for raknet
+file(
+GLOB SOURCES_RAKNET
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/thirdparty/raknet/Source/*.cpp
+)
+
+# Source Code for recast
+file(
+GLOB SOURCES_RECAST
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Recast/Source/*.cpp
+)
+
+# Source Code for detour
+file(
+GLOB SOURCES_DETOUR
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/thirdparty/recastnavigation/Detour/Source/*.cpp
+)
+
+# Source Code for tinyxml2
+file(
+GLOB SOURCES_TINYXML2
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/thirdparty/tinyxml2/tinyxml2.cpp
+)
+
+# Source Code for libbcrypt
+file(
+GLOB SOURCES_LIBBCRYPT
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/*.c
+${PROJECT_SOURCE_DIR}/thirdparty/libbcrypt/src/*.c
+)
+
+# Source Code for dCommon
+file(
+GLOB SOURCES_DCOMMON
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dCommon/*.cpp
+)
+
+# Source Code for dChatFilter
+file(
+GLOB SOURCES_DCHATFILTER
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dChatFilter/*.cpp
+)
+
+# Source Code for dDatabase
+file(
+GLOB SOURCES_DDATABASE
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dDatabase/*.cpp
+${PROJECT_SOURCE_DIR}/dDatabase/Tables/*.cpp
+${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.cpp
+${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.c
+)
+
+# Source Code for dNet
+file(
+GLOB SOURCES_DNET
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dNet/*.cpp
+)
+
+# Source Code for dGame
+file(
+GLOB SOURCES_DGAME
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dGame/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dBehaviors/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dComponents/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dGameMessages/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dInventory/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dMission/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dEntity/*.cpp
+${PROJECT_SOURCE_DIR}/dGame/dUtilities/*.cpp
+${PROJECT_SOURCE_DIR}/dScripts/*.cpp
+)
+
+# Source Code for dZoneManager
+file(
+GLOB SOURCES_DZM
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dZoneManager/*.cpp
+)
+
+# Source Code for dPhysics
+file(
+GLOB SOURCES_DPHYSICS
+LIST_DIRECTORIES false
+RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+${PROJECT_SOURCE_DIR}/dPhysics/*.cpp
+)
+
+# 3rdparty static libraries:
+#add_library(zlib ${SOURCES_ZLIB})
+add_library(raknet ${SOURCES_RAKNET})
+add_library(tinyxml2 ${SOURCES_TINYXML2})
+add_library(detour ${SOURCES_DETOUR})
+add_library(recast ${SOURCES_RECAST})
+add_library(libbcrypt ${SOURCES_LIBBCRYPT})
+
+# Our static libraries:
+add_library(dCommon ${SOURCES_DCOMMON})
+add_library(dChatFilter ${SOURCES_DCHATFILTER})
+add_library(dDatabase ${SOURCES_DDATABASE})
+add_library(dNet ${SOURCES_DNET})
+add_library(dGame ${SOURCES_DGAME})
+add_library(dZoneManager ${SOURCES_DZM})
+add_library(dPhysics ${SOURCES_DPHYSICS})
+target_link_libraries(dNet dCommon) #Needed because otherwise linker errors occur.
+target_link_libraries(dCommon ZLIB::ZLIB)
+target_link_libraries(dCommon libbcrypt)
+
+# Our executables:
+add_executable(WorldServer ${SOURCES})
+add_executable(AuthServer ${SOURCES_AUTH})
+add_executable(MasterServer ${SOURCES_MASTER})
+add_executable(ChatServer ${SOURCES_CHAT})
+
+# Target libraries to link to:
+target_link_libraries(WorldServer dCommon)
+target_link_libraries(WorldServer dChatFilter)
+target_link_libraries(WorldServer dDatabase)
+target_link_libraries(WorldServer dNet)
+target_link_libraries(WorldServer dGame)
+target_link_libraries(WorldServer dZoneManager)
+target_link_libraries(WorldServer dPhysics)
+target_link_libraries(WorldServer detour)
+target_link_libraries(WorldServer recast)
+target_link_libraries(WorldServer raknet)
+target_link_libraries(WorldServer ${MYSQL_LIB})
+if(UNIX)
+target_link_libraries(WorldServer pthread)
+target_link_libraries(WorldServer dl)
+
+if(NOT APPLE AND __include_backtrace__)
+target_link_libraries(WorldServer backtrace)
+target_link_libraries(MasterServer backtrace)
+target_link_libraries(AuthServer backtrace)
+target_link_libraries(ChatServer backtrace)
+endif()
+
+endif(UNIX)
+if(WIN32)
+target_link_libraries(WorldServer ws2_32)
+endif(WIN32)
+target_link_libraries(WorldServer tinyxml2)
+
+# Target libraries for Auth:
+target_link_libraries(AuthServer dCommon)
+target_link_libraries(AuthServer dDatabase)
+target_link_libraries(AuthServer dNet)
+target_link_libraries(AuthServer raknet)
+target_link_libraries(AuthServer ${MYSQL_LIB})
+if(UNIX)
+target_link_libraries(AuthServer pthread)
+target_link_libraries(AuthServer dl)
+endif(UNIX)
+if(WIN32)
+target_link_libraries(AuthServer ws2_32)
+endif(WIN32)
+
+# Target libraries for Master:
+target_link_libraries(MasterServer dCommon)
+target_link_libraries(MasterServer dDatabase)
+target_link_libraries(MasterServer dNet)
+target_link_libraries(MasterServer raknet)
+target_link_libraries(MasterServer ${MYSQL_LIB})
+if(UNIX)
+target_link_libraries(MasterServer pthread)
+target_link_libraries(MasterServer dl)
+endif(UNIX)
+if(WIN32)
+target_link_libraries(MasterServer ws2_32)
+endif(WIN32)
+
+# Target libraries for Chat:
+target_link_libraries(ChatServer dCommon)
+target_link_libraries(ChatServer dChatFilter)
+target_link_libraries(ChatServer dDatabase)
+target_link_libraries(ChatServer dNet)
+target_link_libraries(ChatServer raknet)
+target_link_libraries(ChatServer ${MYSQL_LIB})
+if(UNIX)
+target_link_libraries(ChatServer pthread)
+target_link_libraries(ChatServer dl)
+endif(UNIX)
+if(WIN32)
+target_link_libraries(ChatServer ws2_32)
+endif(WIN32)
+
+# Compiler flags:
+# Disabled deprecated warnings as the MySQL includes have deprecated code in them. 
+# Disabled misleading indentation as DL_LinkedList from RakNet has a weird indent.
+# Disabled no-register
+# Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
+if(UNIX)
+    if(APPLE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++17 -O2 -Wuninitialized -Wno-unused-result -Wno-unknown-pragmas -fpermissive -D_GLIBCXX_USE_CXX11_ABI=0 -D_GLIBCXX_USE_CXX17_ABI=0 -fPIC")
+    else()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++17 -O2 -Wuninitialized -Wno-unused-result -Wno-unknown-pragmas -fpermissive -D_GLIBCXX_USE_CXX11_ABI=0 -D_GLIBCXX_USE_CXX17_ABI=0 -static-libgcc -fPIC")
+    endif()
+    if (__dynamic)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -rdynamic")
+    endif()
+    if (__ggdb)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb")
+    endif()
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -O2 -fPIC")
+endif(UNIX)

CONTRIBUTING.md

@@ -0,0 +1,366 @@
+# Contributing to Darkflame Universe
+
+This document outlines how to contribute to Darkflame Universe as well as guidelines and rules for contribution.
+
+## Filing Issues
+
+Issues should be used to report problems with the project, request a new feature, or to discuss potential changes before a PR is created.
+
+If you find an Issue that addresses the problem you're having, please add your own reproduction information to the existing issue rather than creating a new one.
+
+Issues should include (when applicable):
+- Expected Behavior
+- Current Behavior
+- Possible Solution
+- Steps to Reproduce
+- Your Enviorment
+
+## Pull Requests
+
+PRs to this project are always welcome and can be a quick way to get your fix or improvement slated for the next release. In general, PRs should:
+
+- Only fix/add the functionality in question **OR** address wide-spread whitespace/style issues, not both.
+- Address a single concern in the least number of changed lines as possible.
+- Include documentation in the repo.
+
+For changes that address core functionality or would require breaking changes (e.g. a major release), it's best to open an Issue to discuss your proposal first. This is not required but can save time creating and reviewing changes.
+
+In general, we follow the "fork-and-pull" Git workflow
+
+- Fork the repository to your own Github account
+- Clone the project to your machine
+- Create a branch locally with a succinct but descriptive name
+- Commit changes to the branch
+- Following any formatting and testing guidelines specific to this repo
+- Push changes to your fork
+- Open a PR in our repository.
+
+PRs should include (when applicable):
+- Description
+- Motivation and Context
+- Type of Changes
+- How Has This Been Tested?
+- Screenshots
+
+## Development Resources
+
+Check out a compiled list of development resources and tools [here](https://lu-dev.net/).
+
+## Coding Style
+
+This project has gone through multiple iterations of coding style. In the code you'll find a number of different coding styles in use. What follows is the preferred style for this project.
+
+### General
+
+Use 4 spaces instead of the tab character.
+
+Use typically trailing braces everywhere (if, else, functions, structures, typedefs, class definitions, etc.)
+
+```cpp
+if (x) {
+}
+```
+
+The else statement starts on the same line as the last closing brace.
+
+```cpp
+if (x) {
+} else {
+}
+```
+
+
+Do not pad parenthesized expressions with spaces
+
+```cpp
+if (x) {
+}
+```
+
+Instead of 
+
+```cpp
+if ( x ) {
+}
+```
+
+And
+
+```cpp
+x = (y * 0.5f);
+```
+
+Instead of
+
+```cpp
+x = ( y * 0.5f );
+```
+
+
+Use precision specification for floating point values unless there is an explicit need for a double.
+
+```cpp
+float f = 0.5f;
+```
+
+Instead of
+
+```cpp
+float f = 0.5;
+```
+
+And
+
+```cpp
+float f = 1.0f;
+```
+
+Instead of
+
+```cpp
+float f = 1.f;
+```
+
+
+Function names start with an upper case:
+
+```cpp
+void Function();
+```
+
+
+In multi-word function names each word starts with an upper case:
+
+```cpp
+void ThisFunctionDoesSomething();
+```
+
+
+The standard header for functions is:
+
+```cpp
+/**
+ * Function description
+ * @param param1 Description of param1
+ * @return Description of return value
+ */
+```
+
+
+Variable names start with a lower case character.
+
+```cpp
+float x;
+```
+
+
+In multi-word variable names the first word starts with a lower case character and each successive word starts with an upper case.
+
+```cpp
+float maxDistanceFromPlane;
+```
+
+
+Typedef names use the same naming convention as variables, however they always end with `_t`.
+
+```cpp
+typedef int fileHandle_t;
+```
+
+Do not use C style enums, instead use enum classes.
+
+```cpp
+enum class Contact {
+	None,
+	Edge,
+	ModelVertex
+};
+```
+
+Instead of
+
+```cpp
+enum Contact {
+	CONTACT_NONE,
+	CONTACT_EDGE,
+	CONTACT_MODELVERTEX,
+	CONTACT_TRMVERTEX
+};
+```
+
+Never use ambiguous integer types.
+
+```cpp
+uint16_t myInteger = 0;
+```
+
+Instead of
+
+```cpp
+unsigned short myInteger = 0;
+```
+
+Defined names use all upper case characters. Multiple words are separated with an underscore.
+
+```cpp
+#define SIDE_FRONT		0
+```
+
+
+Use `const` as much as possible.
+
+Use:
+
+```cpp
+const int* p;			// pointer to const int
+int* const p;			// const pointer to int
+const int* const p;		// const pointer to const int
+```
+
+Don’t use:
+
+```cpp
+int const* p;
+```
+
+
+### Classes
+
+The standard header for a class is:
+
+```cpp
+/**
+ * Class description
+ */
+```
+
+
+Class names should not start with a prefix and each successive word starts with an upper case.
+
+```cpp
+class Vec3;
+```
+
+
+Class variables start with `m` and each successive word starts with an upper case.
+
+```cpp
+class Vec3 {
+	float m_X;
+	float m_Y;
+	float m_Z;
+}
+```
+
+Class methods have the same naming convention as functions.
+
+```cpp
+class Vec3 {
+	float Length() const;
+}
+```
+
+Ordering of class variables and methods should be as follows:
+
+1.	constructor and destructor (followed by a line break)
+2.	list of friend classes
+3.	public variables
+4.	public methods
+5.	protected variables
+6.	protected methods
+7.	private variables
+8.	private methods
+
+This allows the public interface to be easily found at the beginning of the class.
+
+
+Always make class methods `const` when they do not modify any class variables.
+
+Avoid use of `const_cast`.  When object is needed to be modified, but only const versions are accessible, create a function that clearly gives an editable version of the object.  This keeps the control of the "const-ness" in the hands of the object and not the user.
+
+Return `const` objects unless the general usage of the object is to change its state.
+
+Function overloading should be used in most cases. For example, instead of:
+
+```cpp
+	const Anim*	GetAnimByIndex(int index) const;
+	const Anim*	GetAnimByName(const char* name) const;
+	const Anim*	GetRandomAnim(float randomDiversity) const;
+```
+
+Use:
+```cpp
+	const Anim*	GetAnim(int index) const;
+	const Anim*	GetAnim(const char* name) const;
+	const Anim*	GetAnim(float randomDiversity) const;
+```
+
+
+### Header Files
+
+At the beginning of all header files, there should be a `#pragma once` to prevent circular includes.
+
+
+Ordering of includes should be as follows, with each section getting a line break:
+
+1.	relevant header file (example: `Vec3.h` for `Vec3.cpp`)
+2.	c system headers (use angle brackets)
+3.	c++ standard library headers (use angle brackets)
+4.	third party library headers
+5.	internal headers
+
+For example, `Vec3.cpp`'s includes may look like:
+
+```cpp
+#include "Vec3.h"
+
+#include <math.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "BitStream.h"
+
+#include "dCommonVars.h"
+```
+
+
+Use forward declarations to your advantage, they decrease compile time.
+
+Use:
+
+```cpp
+class Vec3;
+
+class Player {
+	Vec3 m_Position;
+}
+```
+
+Don't use:
+
+```cpp
+#include "Vec3.h"
+
+class Player {
+	Vec3 m_Position;
+}
+```
+
+
+### File Names
+
+Each class should be in a separate source file unless it makes sense to group several smaller classes.
+All source files should use the `.cpp` extension and all header files should use the `.h` extension.
+The file name can be the same as the name of the class.
+
+```cpp
+class Winding;
+```
+
+files:
+
+```
+Winding.cpp
+Winding.h
+```

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    Darkflame Universe, a server emulator for LEGO Universe.
+    Copyright (C) 2021  The Darkflame Universe Team
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -36,6 +36,12 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 Some tools utilized to streamline the setup process require Python 3, make sure you have it installed.
 
+**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. 
+
+If you're using a DLU client, then you don't need to change anything. But if you're using any other client, you'll have to go into the "CMakeVariables.txt" file and change it to match your client's version. (likely 171022)
+
 ### Linux builds
 Make sure packages like `gcc`, `cmake`, and `zlib` are installed. Depending on the distribution, these packages might already be installed.
 
@@ -130,6 +136,9 @@ Known good SHA256 checksums of the client:
 - `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

build.sh

@@ -0,0 +1,9 @@
+# Create the build directory, preserving it if it already exists
+mkdir -p build
+cd build
+
+# Run cmake to generate make files
+cmake ..
+
+# Run make to build the project. To build utilizing multiple cores, append `-j` and the amount of cores to utilize, for example `make -j8`
+make

dAuthServer/AuthServer.cpp

@@ -0,0 +1,174 @@
+#include <iostream>
+#include <string>
+#include <ctime>
+#include <chrono>
+#include <thread>
+
+//DLU Includes:
+#include "dCommonVars.h"
+#include "dServer.h"
+#include "dLogger.h"
+#include "Database.h"
+#include "dConfig.h"
+#include "Diagnostics.h"
+
+//RakNet includes:
+#include "RakNetDefines.h"
+
+//Auth includes:
+#include "AuthPackets.h"
+#include "dMessageIdentifiers.h"
+
+#include "Game.h"
+namespace Game {
+	dLogger* logger;
+	dServer* server;
+	dConfig* config;
+}
+
+dLogger* SetupLogger();
+void HandlePacket(Packet* packet);
+
+int main(int argc, char** argv) {
+	Diagnostics::SetProcessName("Auth");
+	Diagnostics::SetProcessFileName(argv[0]);
+	Diagnostics::Initialize();
+
+	//Create all the objects we need to run our service:
+	Game::logger = SetupLogger();
+	if (!Game::logger) return 0;
+	Game::logger->Log("AuthServer", "Starting Auth server...\n");
+	Game::logger->Log("AuthServer", "Version: %i.%i\n", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
+	Game::logger->Log("AuthServer", "Compiled on: %s\n", __TIMESTAMP__);
+
+	//Read our config:
+	dConfig config("authconfig.ini");
+	Game::config = &config;
+	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+
+	//Connect to the MySQL Database
+	std::string mysql_host = config.GetValue("mysql_host");
+	std::string mysql_database = config.GetValue("mysql_database");
+	std::string mysql_username = config.GetValue("mysql_username");
+	std::string mysql_password = config.GetValue("mysql_password");
+
+    try {
+        Database::Connect(mysql_host, mysql_database, mysql_username, mysql_password);
+    } catch (sql::SQLException& ex) {
+		Game::logger->Log("AuthServer", "Got an error while connecting to the database: %s\n", ex.what());
+		Database::Destroy();
+		delete Game::server;
+		delete Game::logger;
+		return 0;
+    }
+
+	//Find out the master's IP:
+	std::string masterIP;
+	int masterPort = 1500;
+	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		masterIP = res->getString(1).c_str();
+		masterPort = res->getInt(2);
+	}
+
+	delete res;
+	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. 
+	if (config.GetValue("max_clients") != "") maxClients = std::stoi(config.GetValue("max_clients"));
+	if (config.GetValue("port") != "") ourPort = std::atoi(config.GetValue("port").c_str());
+	
+	Game::server = new dServer(config.GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Auth);
+
+	//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;
+
+	while (true) {
+		//Check if we're still connected to master:
+		if (!Game::server->GetIsConnectedToMaster()) {
+			framesSinceMasterDisconnect++;
+
+			if (framesSinceMasterDisconnect >= 30)
+				break; //Exit our loop, shut down.
+		}
+		else framesSinceMasterDisconnect = 0;
+
+		//In world we'd update our other systems here.
+
+		//Check for packets here:
+		Game::server->ReceiveFromMaster(); //ReceiveFromMaster also handles the master packets if needed.
+		packet = Game::server->Receive();
+		if (packet) {
+			HandlePacket(packet);
+			Game::server->DeallocatePacket(packet);
+			packet = nullptr;
+		}
+
+		//Push our log every 30s:
+		if (framesSinceLastFlush >= 900) {
+			Game::logger->Flush();
+			framesSinceLastFlush = 0;
+		} else framesSinceLastFlush++;
+
+		//Every 10 min we ping our sql server to keep it alive hopefully:
+		if (framesSinceLastSQLPing >= 40000) {
+			//Find out the master's IP for absolutely no reason:
+			std::string masterIP;
+			int masterPort;
+			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+			auto res = stmt->executeQuery();
+			while (res->next()) {
+				masterIP = res->getString(1).c_str();
+				masterPort = res->getInt(2);
+			}
+
+			delete res;
+			delete stmt;
+
+			framesSinceLastSQLPing = 0;
+		}
+		else framesSinceLastSQLPing++;
+
+		//Sleep our thread since auth can afford to.
+		t += std::chrono::milliseconds(mediumFramerate); //Auth can run at a lower "fps"
+		std::this_thread::sleep_until(t);
+	}
+
+	//Delete our objects here:
+	Database::Destroy();
+	delete Game::server;
+	delete Game::logger;
+
+	return 0;
+}
+
+dLogger * SetupLogger() {
+	std::string logPath = "./logs/AuthServer_" + std::to_string(time(nullptr)) + ".log";
+	bool logToConsole = false;
+#ifdef _DEBUG
+	logToConsole = true;
+#endif
+
+	return new dLogger(logPath, logToConsole);
+}
+
+void HandlePacket(Packet* packet) {
+	if (packet->data[0] == ID_USER_PACKET_ENUM) {
+		if (packet->data[1] == SERVER) {
+			if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) {
+				AuthPackets::HandleHandshake(Game::server, packet);
+			}
+		} else if (packet->data[1] == AUTH) {
+			if (packet->data[3] == MSG_AUTH_LOGIN_REQUEST) {
+				AuthPackets::HandleLoginRequest(Game::server, packet);
+			}
+		}
+	}
+}

dChatFilter/dChatFilter.cpp

@@ -0,0 +1,137 @@
+#include "dChatFilter.h"
+#include "BinaryIO.h"
+#include <fstream>
+#include <string>
+#include <functional>
+#include <algorithm>
+#include <sstream>
+#include <regex>
+
+#include "dCommonVars.h"
+#include "Database.h"
+#include "dLogger.h"
+#include "Game.h"
+
+using namespace dChatFilterDCF;
+
+dChatFilter::dChatFilter(const std::string& filepath, bool dontGenerateDCF) {
+	m_DontGenerateDCF = dontGenerateDCF;
+
+	if (!BinaryIO::DoesFileExist(filepath + ".dcf") || m_DontGenerateDCF) {
+		ReadWordlistPlaintext(filepath + ".txt");
+		if (!m_DontGenerateDCF) ExportWordlistToDCF(filepath + ".dcf");
+	}
+	else {
+		ReadWordlistDCF(filepath + ".dcf");
+	}
+
+	//Read player names that are ok as well:
+	auto stmt = Database::CreatePreppedStmt("select name from charinfo;");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		std::string line = res->getString(1).c_str();
+		std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
+		m_Words.push_back(CalculateHash(line));
+	}
+	delete res;
+	delete stmt;
+}
+
+dChatFilter::~dChatFilter() {
+	m_Words.clear();
+}
+
+void dChatFilter::ReadWordlistPlaintext(const std::string& filepath) {
+	std::ifstream file(filepath);
+	if (file) {
+		std::string line;
+		while (std::getline(file, line)) {
+			std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
+			m_Words.push_back(CalculateHash(line));
+		}
+	}
+}
+
+void dChatFilter::ReadWordlistDCF(const std::string& filepath) {
+	std::ifstream file(filepath, std::ios::binary);
+	if (file) {
+		fileHeader hdr;
+		BinaryIO::BinaryRead(file, hdr);
+		if (hdr.header != header) {
+			std::cout << "Wrong file header!" << std::endl;
+			file.close();
+			return;
+		}
+
+		if (hdr.formatVersion <= formatVersion) {
+			size_t wordsToRead = 0;
+			BinaryIO::BinaryRead(file, wordsToRead);
+			m_Words.reserve(wordsToRead);
+
+			size_t word = 0;
+			for (size_t i = 0; i < wordsToRead; ++i) {
+				BinaryIO::BinaryRead(file, word);
+				m_Words.push_back(word);
+			}
+		}
+		else {
+			std::cout << "Newer file or corrupt" << std::endl;
+			file.close();
+			return;
+		}
+	}
+}
+
+void dChatFilter::ExportWordlistToDCF(const std::string& filepath) {
+	std::ofstream file(filepath, std::ios::binary);
+	if (file) {
+		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::header));
+		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::formatVersion));
+		BinaryIO::BinaryWrite(file, size_t(m_Words.size()));
+
+		for (size_t word : m_Words) {
+			BinaryIO::BinaryWrite(file, word);
+		}
+
+		file.close();
+	}
+}
+
+bool dChatFilter::IsSentenceOkay(const std::string& message, int gmLevel) {
+	if (gmLevel > GAME_MASTER_LEVEL_FORUM_MODERATOR) return true; //If anything but a forum mod, return true.
+	if (message.empty()) return true;
+
+	std::stringstream sMessage(message);
+	std::string segment;
+	std::regex reg("(!*|\\?*|\\;*|\\.*|\\,*)");
+
+	while (std::getline(sMessage, segment, ' ')) {
+		std::transform(segment.begin(), segment.end(), segment.begin(), ::tolower); //Transform to lowercase
+		segment = std::regex_replace(segment, reg, "");
+
+		size_t hash = CalculateHash(segment);
+
+		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end()) {
+			return false;
+		}
+
+		if (!IsInWordlist(hash)) {
+			m_UserUnapprovedWordCache.push_back(hash);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+size_t dChatFilter::CalculateHash(const std::string& word) {
+	std::hash<std::string> hash{};
+
+	size_t value = hash(word);
+
+	return value;
+}
+
+bool dChatFilter::IsInWordlist(size_t word) {
+	return std::find(m_Words.begin(), m_Words.end(), word) != m_Words.end();
+}

dChatFilter/dChatFilter.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <vector>
+#include <string>
+
+#include "dCommonVars.h"
+
+namespace dChatFilterDCF {
+	static const uint32_t header = ('D' + ('C' << 8) + ('F' << 16) + ('B' << 24));
+	static const uint32_t formatVersion = 1;
+
+	struct fileHeader {
+		uint32_t header;
+		uint32_t formatVersion;
+	};
+};
+
+class dChatFilter
+{
+public:
+	dChatFilter(const std::string& filepath, bool dontGenerateDCF);
+	~dChatFilter();
+
+	void ReadWordlistPlaintext(const std::string & filepath);
+	void ReadWordlistDCF(const std::string & filepath);
+	void ExportWordlistToDCF(const std::string & filepath);
+	bool IsSentenceOkay(const std::string& message, int gmLevel);
+
+private:
+	bool m_DontGenerateDCF;
+	std::vector<size_t> m_Words;
+	std::vector<size_t> m_UserUnapprovedWordCache;
+
+	//Private functions:
+	size_t CalculateHash(const std::string& word);
+	bool IsInWordlist(size_t word);
+};

dChatServer/ChatPacketHandler.cpp

@@ -0,0 +1,844 @@
+#include "ChatPacketHandler.h"
+#include "PlayerContainer.h"
+#include "Database.h"
+#include <vector>
+#include "PacketUtils.h"
+#include "dMessageIdentifiers.h"
+#include "Game.h"
+#include "dServer.h"
+#include "GeneralUtils.h"
+#include "dLogger.h"
+
+extern PlayerContainer playerContainer;
+
+void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
+	//Get from the packet which player we want to do something with:
+	CINSTREAM;
+	LWOOBJID playerID = 0;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+
+	auto player = playerContainer.GetPlayerData(playerID);
+	if (!player) return;
+
+	//Get our friends list from the Db:
+	auto stmt = Database::CreatePreppedStmt("SELECT * FROM friends WHERE player_id = ? OR friend_id = ?");
+	stmt->setUInt64(1, playerID);
+	stmt->setUInt64(2, playerID);
+
+	std::vector<FriendData> friends;
+
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		FriendData fd;
+		fd.isFTP = false; // not a thing in DLU
+		fd.friendID = res->getInt64(1);
+		if (fd.friendID == playerID) fd.friendID = res->getUInt64(2);
+
+		fd.isBestFriend = res->getInt(3) == 2; //0 = friends, 1 = requested, 2 = bffs
+
+		//We need to find their name as well:
+		{
+			auto stmt = Database::CreatePreppedStmt("SELECT name FROM charinfo WHERE id=? limit 1");
+			stmt->setInt(1, fd.friendID);
+
+			auto res = stmt->executeQuery();
+			while (res->next()) {
+				fd.friendName = res->getString(1);
+			}
+
+			delete res;
+			delete stmt;
+		}
+
+		//Now check if they're online:
+		auto fr = playerContainer.GetPlayerData(fd.friendID);
+		if (fr) {
+			fd.isOnline = true;
+			fd.zoneID = fr->zoneID;
+
+			//Since this friend is online, we need to update them on the fact that we've just logged in:
+			SendFriendUpdate(fr, player, 1);
+		}
+		else {
+			fd.isOnline = false;
+			fd.zoneID = LWOZONEID();
+		}
+
+		friends.push_back(fd);
+	}
+
+	delete res;
+	delete stmt;
+
+	//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);
+	bitStream.Write(playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE);
+	bitStream.Write<uint8_t>(0);
+	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
+	bitStream.Write((uint16_t)friends.size());
+	
+	for (auto& data : friends) {
+		data.Serialize(bitStream);
+	}
+
+	player->friends = friends;
+
+	SystemAddress sysAddr = player->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	std::string playerName = PacketUtils::ReadString(0x14, packet, true);
+	//There's another bool here to determine if it's a best friend request, but we're not handling it right now.
+
+	//PacketUtils::SavePacket("FriendRequest.bin", (char*)inStream.GetData(), inStream.GetNumberOfBytesUsed());
+
+	//We need to check to see if the player is actually online or not:
+	auto targetData = playerContainer.GetPlayerData(playerName);
+	if (targetData) {
+		SendFriendRequest(targetData, playerContainer.GetPlayerData(playerID));
+	}
+}
+
+void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	
+	uint8_t responseCode = packet->data[0x14];
+	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
+
+	Game::logger->Log("ChatPacketHandler", "Friend response code: %i\n", responseCode);
+
+	if (responseCode != 0) return; //If we're not accepting the request, end here, do not insert to friends table.
+
+	PacketUtils::SavePacket("HandleFriendResponse.bin", (char*)inStream.GetData(), inStream.GetNumberOfBytesUsed());
+
+	//Now to try and find both of these:
+	auto goonA = playerContainer.GetPlayerData(playerID);
+	auto goonB = playerContainer.GetPlayerData(friendName);
+	if (!goonA || !goonB) return;
+
+	SendFriendResponse(goonB, goonA, responseCode);
+	SendFriendResponse(goonA, goonB, responseCode); //Do we need to send it to both? I think so so both get the updated friendlist but... idk.
+
+	auto stmt = Database::CreatePreppedStmt("INSERT INTO `friends`(`player_id`, `friend_id`, `best_friend`) VALUES (?,?,?)");
+	stmt->setUInt64(1, goonA->playerID);
+	stmt->setUInt64(2, goonB->playerID);
+	stmt->setInt(3, 0);
+	stmt->execute();
+	delete stmt;
+}
+
+void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	std::string friendName = PacketUtils::ReadString(16, packet, true);
+
+	//we'll have to query the db here to find the user, since you can delete them while they're offline.
+	//First, we need to find their ID:
+	auto stmt = Database::CreatePreppedStmt("select id from charinfo where name=? limit 1;");
+	stmt->setString(1, friendName.c_str());
+
+	LWOOBJID friendID = 0;
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		friendID = res->getUInt64(1);
+	}
+
+	delete res;
+	delete stmt;
+
+	//Set our bits to convert to the BIG BOY objectID.
+	friendID = GeneralUtils::ClearBit(friendID, OBJECT_BIT_CHARACTER);
+	friendID = GeneralUtils::ClearBit(friendID, OBJECT_BIT_PERSISTENT);
+
+	//YEET:
+	auto deletestmt = Database::CreatePreppedStmt("DELETE FROM `friends` WHERE player_id=? AND friend_id=? LIMIT 1");
+	deletestmt->setUInt64(1, playerID);
+	deletestmt->setUInt64(2, friendID);
+	deletestmt->execute();
+	delete deletestmt;
+
+	//because I'm lazy and they can be reversed:
+	{
+		auto deletestmt = Database::CreatePreppedStmt("DELETE FROM `friends` WHERE player_id=? AND friend_id=? LIMIT 1");
+		deletestmt->setUInt64(1, friendID);
+		deletestmt->setUInt64(2, playerID);
+		deletestmt->execute();
+		delete deletestmt;
+	}
+
+	//Now, we need to send an update to notify the sender (and possibly, receiver) that their friendship has been ended:
+	auto goonA = playerContainer.GetPlayerData(playerID);
+	if (goonA) {
+		SendRemoveFriend(goonA, friendName, true);
+	}
+	
+	auto goonB = playerContainer.GetPlayerData(friendID);
+	if (!goonB) return;
+	std::string goonAName = GeneralUtils::UTF16ToWTF8(playerContainer.GetName(playerID));
+	SendRemoveFriend(goonB, goonAName, true);
+}
+
+void ChatPacketHandler::HandleChatMessage(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+
+	auto* sender = playerContainer.GetPlayerData(playerID);
+
+	if (sender == nullptr) return;
+
+	if (playerContainer.GetIsMuted(sender)) return;
+
+	const auto senderName = std::string(sender->playerName.C_String());
+
+	inStream.SetReadOffset(0x14 * 8);
+
+	uint8_t channel = 0;
+	inStream.Read(channel);
+	
+	std::string message = PacketUtils::ReadString(0x66, packet, true);
+
+	Game::logger->Log("ChatPacketHandler", "Got a message from (%s) [%d]: %s\n", senderName.c_str(), channel, message.c_str());
+
+	//PacketUtils::SavePacket("chat.bin", reinterpret_cast<char*>(packet->data), packet->length);
+
+	if (channel != 8) return;
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	if (team == nullptr) return;
+
+	for (const auto memberId : team->memberIDs)
+	{
+		auto* otherMember = playerContainer.GetPlayerData(memberId);
+
+		if (otherMember == nullptr) return;
+
+		const auto otherName = std::string(otherMember->playerName.C_String());
+
+		CBITSTREAM;
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		bitStream.Write(otherMember->playerID);
+
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		bitStream.Write(otherMember->playerID);
+		bitStream.Write<uint8_t>(8);
+		bitStream.Write<unsigned int>(69);
+		PacketUtils::WritePacketWString(senderName, 33, &bitStream);
+		bitStream.Write(sender->playerID);
+		bitStream.Write<uint16_t>(0);
+		bitStream.Write<uint8_t>(0); //not mythran nametag
+		PacketUtils::WritePacketWString(otherName, 33, &bitStream);
+		bitStream.Write<uint8_t>(0); //not mythran for receiver
+		bitStream.Write<uint8_t>(0); //teams?
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
+
+		SystemAddress sysAddr = otherMember->sysAddr;
+		SEND_PACKET;
+	}
+}
+
+void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
+	LWOOBJID senderID = PacketUtils::ReadPacketS64(0x08, packet);
+	std::string receiverName = PacketUtils::ReadString(0x66, packet, true);
+	std::string message = PacketUtils::ReadString(0xAA, packet, true);
+
+	//Get the bois:
+	auto goonA = playerContainer.GetPlayerData(senderID);
+	auto goonB = playerContainer.GetPlayerData(receiverName);
+	if (!goonA || !goonB) return;
+
+	if (playerContainer.GetIsMuted(goonA)) return;
+
+	std::string goonAName = goonA->playerName.C_String();
+	std::string goonBName = goonB->playerName.C_String();
+
+	//To the sender:
+	{
+		CBITSTREAM;
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		bitStream.Write(goonA->playerID);
+
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		bitStream.Write(goonA->playerID);
+		bitStream.Write<uint8_t>(7);
+		bitStream.Write<unsigned int>(69);
+		PacketUtils::WritePacketWString(goonAName, 33, &bitStream);
+		bitStream.Write(goonA->playerID);
+		bitStream.Write<uint16_t>(0);
+		bitStream.Write<uint8_t>(0); //not mythran nametag
+		PacketUtils::WritePacketWString(goonBName, 33, &bitStream);
+		bitStream.Write<uint8_t>(0); //not mythran for receiver
+		bitStream.Write<uint8_t>(0); //success
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
+
+		SystemAddress sysAddr = goonA->sysAddr;
+		SEND_PACKET;
+	}
+
+	//To the receiver:
+	{
+		CBITSTREAM;
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		bitStream.Write(goonB->playerID);
+
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		bitStream.Write(goonA->playerID);
+		bitStream.Write<uint8_t>(7);
+		bitStream.Write<unsigned int>(69);
+		PacketUtils::WritePacketWString(goonAName, 33, &bitStream);
+		bitStream.Write(goonA->playerID);
+		bitStream.Write<uint16_t>(0);
+		bitStream.Write<uint8_t>(0); //not mythran nametag
+		PacketUtils::WritePacketWString(goonBName, 33, &bitStream);
+		bitStream.Write<uint8_t>(0); //not mythran for receiver
+		bitStream.Write<uint8_t>(3); //new whisper
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
+
+		SystemAddress sysAddr = goonB->sysAddr;
+		SEND_PACKET;
+	}
+}
+
+void ChatPacketHandler::HandleTeamInvite(Packet* packet)
+{
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true);
+
+	auto* player = playerContainer.GetPlayerData(playerID);
+
+	if (player == nullptr)
+	{
+		return;
+	}
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	if (team == nullptr)
+	{
+		team = playerContainer.CreateTeam(playerID);
+	}
+
+	auto* other = playerContainer.GetPlayerData(invitedPlayer);
+
+	if (other == nullptr)
+	{
+		return;
+	}
+
+	if (playerContainer.GetTeam(other->playerID) != nullptr)
+	{
+		return;
+	}
+
+	SendTeamInvite(other, player);
+
+	Game::logger->Log("ChatPacketHandler", "Got team invite: %llu -> %s\n", playerID, invitedPlayer.c_str());
+}
+
+void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+	char declined = 0;
+	inStream.Read(declined);
+	LWOOBJID leaderID = LWOOBJID_EMPTY;
+	inStream.Read(leaderID);
+
+	Game::logger->Log("ChatPacketHandler", "Accepted invite: %llu -> %llu (%d)\n", playerID, leaderID, declined);
+
+	if (declined)
+	{
+		return;
+	}
+
+	auto* team = playerContainer.GetTeam(leaderID);
+
+	if (team == nullptr)
+	{
+		Game::logger->Log("ChatPacketHandler", "Failed to find team for leader (%llu)\n", leaderID);
+
+		team = playerContainer.GetTeam(playerID);
+	}
+	
+	if (team == nullptr)
+	{
+		Game::logger->Log("ChatPacketHandler", "Failed to find team for player (%llu)\n", playerID);
+		return;
+	}
+
+	playerContainer.AddMember(team, playerID);
+}
+
+void ChatPacketHandler::HandleTeamLeave(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	Game::logger->Log("ChatPacketHandler", "(%llu) leaving team\n", playerID);
+
+	if (team != nullptr)
+	{
+		playerContainer.RemoveMember(team, playerID, false, false, true);
+	}
+}
+
+void ChatPacketHandler::HandleTeamKick(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	
+	std::string kickedPlayer = PacketUtils::ReadString(0x14, packet, true);
+
+	Game::logger->Log("ChatPacketHandler", "(%llu) kicking (%s) from team\n", playerID, kickedPlayer.c_str());
+
+	auto* kicked = playerContainer.GetPlayerData(kickedPlayer);
+
+	LWOOBJID kickedId = LWOOBJID_EMPTY;
+
+	if (kicked != nullptr)
+	{
+		kickedId = kicked->playerID;
+	}
+	else
+	{
+		kickedId = playerContainer.GetId(GeneralUtils::ASCIIToUTF16(kickedPlayer));
+	}
+
+	if (kickedId == LWOOBJID_EMPTY) return;
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	if (team != nullptr)
+	{
+		if (team->leaderID != playerID || team->leaderID == kickedId) return;
+
+		playerContainer.RemoveMember(team, kickedId, false, true, false);
+	}
+
+	//PacketUtils::SavePacket("kick.bin", reinterpret_cast<char*>(packet->data), packet->length);
+}
+
+void ChatPacketHandler::HandleTeamPromote(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	
+	std::string promotedPlayer = PacketUtils::ReadString(0x14, packet, true);
+
+	Game::logger->Log("ChatPacketHandler", "(%llu) promiting (%s) to team leader\n", playerID, promotedPlayer.c_str());
+
+	auto* promoted = playerContainer.GetPlayerData(promotedPlayer);
+
+	if (promoted == nullptr) return;
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	if (team != nullptr)
+	{
+		if (team->leaderID != playerID) return;
+
+		playerContainer.PromoteMember(team, promoted->playerID);
+	}
+
+	//PacketUtils::SavePacket("promote.bin", reinterpret_cast<char*>(packet->data), packet->length);
+}
+
+void ChatPacketHandler::HandleTeamLootOption(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+	uint32_t size = 0;
+	inStream.Read(size);
+	
+	char option;
+	inStream.Read(option);
+
+	auto* team = playerContainer.GetTeam(playerID);
+
+	if (team != nullptr)
+	{
+		if (team->leaderID != playerID) return;
+
+		team->lootFlag = option;
+
+		playerContainer.TeamStatusUpdate(team);
+	
+		playerContainer.UpdateTeamsOnWorld(team, false);
+	}
+
+	//PacketUtils::SavePacket("option.bin", reinterpret_cast<char*>(packet->data), packet->length);
+}
+
+void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	inStream.Read(playerID);
+	inStream.Read(playerID);
+
+	auto* team = playerContainer.GetTeam(playerID);
+	auto* data = playerContainer.GetPlayerData(playerID);
+
+	if (team != nullptr && data != nullptr)
+	{
+		if (team->local && data->zoneID.GetMapID() != team->zoneId.GetMapID() && data->zoneID.GetCloneID() != team->zoneId.GetCloneID())
+		{
+			playerContainer.RemoveMember(team, playerID, false, false, true, true);
+
+			return;
+		}
+
+		if (team->memberIDs.size() <= 1 && !team->local)
+		{
+			playerContainer.DisbandTeam(team);
+
+			return;
+		}
+
+		if (!team->local)
+		{
+			ChatPacketHandler::SendTeamSetLeader(data, team->leaderID);
+		}
+		else
+		{
+			ChatPacketHandler::SendTeamSetLeader(data, LWOOBJID_EMPTY);
+		}
+
+		playerContainer.TeamStatusUpdate(team);
+
+		const auto leaderName = GeneralUtils::ASCIIToUTF16(std::string(data->playerName.C_String()));
+
+		for (const auto memberId : team->memberIDs)
+		{
+			auto* otherMember = playerContainer.GetPlayerData(memberId);
+
+			if (memberId == playerID) continue;
+
+			const auto memberName = playerContainer.GetName(memberId);
+			
+			//ChatPacketHandler::SendTeamAddPlayer(otherMember, false, false, false, data->playerID, leaderName, data->zoneID);
+			if (otherMember != nullptr)
+			{
+				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data->playerID, data->zoneID);
+			}
+			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
+		}
+
+		playerContainer.UpdateTeamsOnWorld(team, false);
+	}
+}
+
+void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) 
+{
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	bitStream.Write(receiver->playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE);
+
+	PacketUtils::WritePacketWString(sender->playerName.C_String(), 33, &bitStream);
+	bitStream.Write(sender->playerID);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+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);
+	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(bLeaderIsFreeTrial);
+	bitStream.Write(i64LeaderID);
+	bitStream.Write(i64LeaderZoneID);
+	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
+	bitStream.Write(ucLootFlag);
+	bitStream.Write(ucNumOfOtherPlayers);
+	bitStream.Write(ucResponseCode);
+	bitStream.Write(static_cast<uint32_t>(wsLeaderName.size()));
+	for (const auto character : wsLeaderName)
+	{
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+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);
+	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(i64LeaderID);
+	bitStream.Write(i64LeaderZoneID);
+	bitStream.Write<uint32_t>(0); // BinaryBuffe, no clue what's in here
+	bitStream.Write(ucLootFlag);
+	bitStream.Write(ucNumOfOtherPlayers);
+	bitStream.Write(static_cast<uint32_t>(wsLeaderName.size()));
+	for (const auto character : wsLeaderName)
+	{
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) 
+{
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_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(i64PlayerID);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+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);
+	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(bIsFreeTrial);
+	bitStream.Write(bLocal);
+	bitStream.Write(bNoLootOnDeath);
+	bitStream.Write(i64PlayerID);
+	bitStream.Write(static_cast<uint32_t>(wsPlayerName.size()));
+	for (const auto character : wsPlayerName)
+	{
+		bitStream.Write(character);
+	}
+	bitStream.Write1();
+	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID())
+	{
+		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
+	}
+	bitStream.Write(zoneID);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendTeamRemovePlayer(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);
+	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(bDisband);
+	bitStream.Write(bIsKicked);
+	bitStream.Write(bIsLeaving);
+	bitStream.Write(bLocal);
+	bitStream.Write(i64LeaderID);
+	bitStream.Write(i64PlayerID);
+	bitStream.Write(static_cast<uint32_t>(wsPlayerName.size()));
+	for (const auto character : wsPlayerName)
+	{
+		bitStream.Write(character);
+	}
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) 
+{
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_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(i64PlayerID);
+	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID())
+	{
+		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
+	}
+	bitStream.Write(zoneID);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType) {
+	/*chat notification is displayed if log in / out and friend is updated in friends list
+		[u8] - update type
+		Update types
+		0 - friend logged out
+		1 - friend logged in
+		2 - friend changed world / updated
+		[wstring] - Name of friend
+		[u16] - World ID
+		[u16] - World Instance
+		[u32] - World Clone
+		[bool] - is best friend
+		[bool] - is FTP*/
+
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	bitStream.Write(friendData->playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY);
+	bitStream.Write<uint8_t>(notifyType);
+
+	std::string playerName = playerData->playerName.C_String();
+
+	PacketUtils::WritePacketWString(playerName, 33, &bitStream);
+
+	bitStream.Write(playerData->zoneID.GetMapID());
+	bitStream.Write(playerData->zoneID.GetInstanceID());
+
+	if (playerData->zoneID.GetCloneID() == friendData->zoneID.GetCloneID())
+	{
+		bitStream.Write(0);
+	}
+	else
+	{
+		bitStream.Write(playerData->zoneID.GetCloneID());
+	}
+
+	bitStream.Write<uint8_t>(0); //isBFF
+	bitStream.Write<uint8_t>(0); //isFTP
+
+	SystemAddress sysAddr = friendData->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* sender, bool isBFFReq) {
+	if (!receiver || !sender) return;
+
+	//Make sure people aren't requesting people that they're already friends with:
+	for (auto fr : receiver->friends) {
+		if (fr.friendID == sender->playerID) {
+			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);
+	bitStream.Write(receiver->playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST);
+	PacketUtils::WritePacketWString(sender->playerName.C_String(), 33, &bitStream);
+	bitStream.Write<uint8_t>(0);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, uint8_t responseCode) {
+	if (!receiver || !sender) return;
+
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	bitStream.Write(receiver->playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE);
+	bitStream.Write<uint8_t>(responseCode);
+	bitStream.Write<uint8_t>(1); //isOnline
+	PacketUtils::WritePacketWString(sender->playerName.C_String(), 33, &bitStream);
+	bitStream.Write(sender->playerID);
+	bitStream.Write(sender->zoneID);
+	bitStream.Write<uint8_t>(0); //isBFF
+	bitStream.Write<uint8_t>(0); //isFTP
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful) {
+	if (!receiver) return;
+
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	bitStream.Write(receiver->playerID);
+
+	//portion that will get routed:
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE);
+	bitStream.Write<uint8_t>(isSuccessful); //isOnline
+	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
+
+	SystemAddress sysAddr = receiver->sysAddr;
+	SEND_PACKET;
+}

dChatServer/ChatPacketHandler.h

@@ -0,0 +1,40 @@
+#pragma once
+#include "dCommonVars.h"
+#include "dNetCommon.h"
+#include "BitStream.h"
+
+struct PlayerData;
+
+namespace ChatPacketHandler {
+	void HandleFriendlistRequest(Packet* packet);
+	void HandleFriendRequest(Packet* packet);
+	void HandleFriendResponse(Packet* packet);
+	void HandleRemoveFriend(Packet* packet);
+
+	void HandleChatMessage(Packet* packet);
+	void HandlePrivateChatMessage(Packet* packet);
+
+	void HandleTeamInvite(Packet* packet);
+	void HandleTeamInviteResponse(Packet* packet);
+	void HandleTeamLeave(Packet* packet);
+	void HandleTeamKick(Packet* packet);
+	void HandleTeamPromote(Packet* packet);
+	void HandleTeamLootOption(Packet* packet);
+	void HandleTeamStatusRequest(Packet* packet);
+
+	void SendTeamInvite(PlayerData* receiver, PlayerData* sender);
+	void SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName);
+	void SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName);
+	void SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID);
+	void SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID);
+	void SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName);
+	void SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID);
+
+	//FriendData is the player we're SENDING this stuff to. Player is the friend that changed state.
+	void SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType);
+
+	void SendFriendRequest(PlayerData* receiver, PlayerData* sender, bool isBFFReq = false);
+	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, uint8_t responseCode = 3);
+	void SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful);
+};
+

dChatServer/ChatServer.cpp

@@ -0,0 +1,288 @@
+#include <iostream>
+#include <string>
+#include <chrono>
+#include <thread>
+
+//DLU Includes:
+#include "dCommonVars.h"
+#include "dServer.h"
+#include "dLogger.h"
+#include "Database.h"
+#include "dConfig.h"
+#include "dMessageIdentifiers.h"
+#include "dChatFilter.h"
+#include "Diagnostics.h"
+
+#include "PlayerContainer.h"
+#include "ChatPacketHandler.h"
+
+#include "Game.h"
+namespace Game {
+	dLogger* logger;
+	dServer* server;
+	dConfig* config;
+	dChatFilter* chatFilter;
+}
+
+//RakNet includes:
+#include "RakNetDefines.h"
+
+dLogger* SetupLogger();
+void HandlePacket(Packet* packet);
+
+PlayerContainer playerContainer;
+
+int main(int argc, char** argv) {
+	Diagnostics::SetProcessName("Chat");
+	Diagnostics::SetProcessFileName(argv[0]);
+	Diagnostics::Initialize();
+
+	//Create all the objects we need to run our service:
+	Game::logger = SetupLogger();
+	if (!Game::logger) return 0;
+	Game::logger->Log("ChatServer", "Starting Chat server...\n");
+	Game::logger->Log("ChatServer", "Version: %i.%i\n", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
+	Game::logger->Log("ChatServer", "Compiled on: %s\n", __TIMESTAMP__);
+
+	//Read our config:
+	dConfig config("chatconfig.ini");
+	Game::config = &config;
+	Game::logger->SetLogToConsole(bool(std::stoi(config.GetValue("log_to_console"))));
+
+	//Connect to the MySQL Database
+	std::string mysql_host = config.GetValue("mysql_host");
+	std::string mysql_database = config.GetValue("mysql_database");
+	std::string mysql_username = config.GetValue("mysql_username");
+	std::string mysql_password = config.GetValue("mysql_password");
+
+	try {
+		Database::Connect(mysql_host, mysql_database, mysql_username, mysql_password);
+	}
+	catch (sql::SQLException& ex) {
+		Game::logger->Log("ChatServer", "Got an error while connecting to the database: %s\n", ex.what());
+		Database::Destroy();
+		delete Game::server;
+		delete Game::logger;
+		return 0;
+	}
+
+	//Find out the master's IP:
+	std::string masterIP;
+	int masterPort = 1000;
+	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		masterIP = res->getString(1).c_str();
+		masterPort = res->getInt(2);
+	}
+
+	delete res;
+	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;
+	if (config.GetValue("max_clients") != "") maxClients = std::stoi(config.GetValue("max_clients"));
+	if (config.GetValue("port") != "") ourPort = std::atoi(config.GetValue("port").c_str());
+
+	Game::server = new dServer(config.GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat);
+
+	Game::chatFilter = new dChatFilter("./res/chatplus_en_us", bool(std::stoi(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;
+
+	while (true) {
+		//Check if we're still connected to master:
+		if (!Game::server->GetIsConnectedToMaster()) {
+			framesSinceMasterDisconnect++;
+
+			if (framesSinceMasterDisconnect >= 30)
+				break; //Exit our loop, shut down.
+		}
+		else framesSinceMasterDisconnect = 0;
+
+		//In world we'd update our other systems here.
+
+		//Check for packets here:
+		Game::server->ReceiveFromMaster(); //ReceiveFromMaster also handles the master packets if needed.
+		packet = Game::server->Receive();
+		if (packet) {
+			HandlePacket(packet);
+			Game::server->DeallocatePacket(packet);
+			packet = nullptr;
+		}
+
+		//Push our log every 30s:
+		if (framesSinceLastFlush >= 900) {
+			Game::logger->Flush();
+			framesSinceLastFlush = 0;
+		}
+		else framesSinceLastFlush++;
+
+		//Every 10 min we ping our sql server to keep it alive hopefully:
+		if (framesSinceLastSQLPing >= 40000) {
+			//Find out the master's IP for absolutely no reason:
+			std::string masterIP;
+			int masterPort;
+			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+			auto res = stmt->executeQuery();
+			while (res->next()) {
+				masterIP = res->getString(1).c_str();
+				masterPort = res->getInt(2);
+			}
+
+			delete res;
+			delete stmt;
+
+			framesSinceLastSQLPing = 0;
+		}
+		else framesSinceLastSQLPing++;
+
+		//Sleep our thread since auth can afford to.
+		t += std::chrono::milliseconds(mediumFramerate); //Chat can run at a lower "fps"
+		std::this_thread::sleep_until(t);
+	}
+
+	//Delete our objects here:
+	Database::Destroy();
+	delete Game::server;
+	delete Game::logger;
+
+	return 0;
+}
+
+dLogger* SetupLogger() {
+	std::string logPath = "./logs/ChatServer_" + std::to_string(time(nullptr)) + ".log";
+	bool logToConsole = false;
+#ifdef _DEBUG
+	logToConsole = true;
+#endif
+
+	return new dLogger(logPath, logToConsole);
+}
+
+void HandlePacket(Packet* packet) {
+	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
+		Game::logger->Log("ChatServer", "A server has disconnected, erasing their connected players from the list.\n");
+	}
+
+	if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
+		Game::logger->Log("ChatServer", "A server is connecting, awaiting user list.\n");
+	}
+
+	if (packet->data[1] == CHAT_INTERNAL) {
+		switch (packet->data[3]) {
+		case MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION:
+			playerContainer.InsertPlayer(packet);
+			break;
+
+		case MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION:
+			playerContainer.RemovePlayer(packet);
+			break;
+
+		case MSG_CHAT_INTERNAL_MUTE_UPDATE:
+			playerContainer.MuteUpdate(packet);
+			break;
+
+		case MSG_CHAT_INTERNAL_CREATE_TEAM:
+			playerContainer.CreateTeamServer(packet);
+			break;
+
+		case MSG_CHAT_INTERNAL_ANNOUNCEMENT: {
+			//we just forward this packet to every connected server
+			CINSTREAM;
+			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
+			break;
+		}
+
+		default:
+			Game::logger->Log("ChatServer", "Unknown CHAT_INTERNAL id: %i\n", int(packet->data[3]));
+		}
+	}
+
+	if (packet->data[1] == CHAT) {
+		switch (packet->data[3]) {
+		case MSG_CHAT_GET_FRIENDS_LIST:
+			ChatPacketHandler::HandleFriendlistRequest(packet);
+			break;
+
+		case MSG_CHAT_GET_IGNORE_LIST:
+			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.\n");
+			break;
+
+		case MSG_CHAT_TEAM_GET_STATUS:
+			ChatPacketHandler::HandleTeamStatusRequest(packet);
+			break;
+
+		case MSG_CHAT_ADD_FRIEND_REQUEST:
+			//this involves someone sending the initial request, the response is below, response as in from the other player.
+			//We basically just check to see if this player is online or not and route the packet.
+			ChatPacketHandler::HandleFriendRequest(packet);
+			break;
+
+		case MSG_CHAT_ADD_FRIEND_RESPONSE:
+			//This isn't the response a server sent, rather it is a player's response to a received request.
+			//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
+			ChatPacketHandler::HandleFriendResponse(packet);
+			break;
+
+		case MSG_CHAT_REMOVE_FRIEND:
+			ChatPacketHandler::HandleRemoveFriend(packet);
+			break;
+
+		case MSG_CHAT_GENERAL_CHAT_MESSAGE:
+			ChatPacketHandler::HandleChatMessage(packet);
+			break;
+
+		case MSG_CHAT_PRIVATE_CHAT_MESSAGE:
+			//This message is supposed to be echo'd to both the sender and the receiver
+			//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
+			ChatPacketHandler::HandlePrivateChatMessage(packet);
+			break;
+
+		case MSG_CHAT_TEAM_INVITE:
+			ChatPacketHandler::HandleTeamInvite(packet);
+			break;
+
+		case MSG_CHAT_TEAM_INVITE_RESPONSE:
+			ChatPacketHandler::HandleTeamInviteResponse(packet);
+			break;
+
+		case MSG_CHAT_TEAM_LEAVE:
+			ChatPacketHandler::HandleTeamLeave(packet);
+			break;
+
+		case MSG_CHAT_TEAM_SET_LEADER:
+			ChatPacketHandler::HandleTeamPromote(packet);
+			break;
+
+		case MSG_CHAT_TEAM_KICK:
+			ChatPacketHandler::HandleTeamKick(packet);
+			break;
+
+		case MSG_CHAT_TEAM_SET_LOOT:
+			ChatPacketHandler::HandleTeamLootOption(packet);
+			break;
+		
+		default:
+			Game::logger->Log("ChatServer", "Unknown CHAT id: %i\n", int(packet->data[3]));
+		}
+	}
+
+	if (packet->data[1] == WORLD) {
+		switch (packet->data[3]) {
+		case MSG_WORLD_CLIENT_ROUTE_PACKET: {
+			printf("routing packet from world\n");
+			break;
+		}
+
+		default:
+			Game::logger->Log("ChatServer", "Unknown World id: %i\n", int(packet->data[3]));
+		}
+	}
+}

dChatServer/PlayerContainer.cpp

@@ -0,0 +1,441 @@
+#include "PlayerContainer.h"
+#include "dNetCommon.h"
+#include <iostream>
+#include <algorithm>
+#include "Game.h"
+#include "dLogger.h"
+#include "ChatPacketHandler.h"
+#include "GeneralUtils.h"
+#include "dMessageIdentifiers.h"
+#include "PacketUtils.h"
+#include "Database.h"
+
+PlayerContainer::PlayerContainer() {
+}
+
+PlayerContainer::~PlayerContainer() {
+	mPlayers.clear();
+}
+
+void PlayerContainer::InsertPlayer(Packet* packet) {
+	CINSTREAM;
+	PlayerData* data = new PlayerData();
+	inStream.Read(data->playerID);
+	inStream.Read(data->playerID);
+	inStream.Read(data->playerName);
+	inStream.Read(data->zoneID);
+	inStream.Read(data->muteExpire);
+	data->sysAddr = packet->systemAddress;
+
+	mNames[data->playerID] = GeneralUtils::ASCIIToUTF16(std::string(data->playerName.C_String()));
+
+	mPlayers.insert(std::make_pair(data->playerID, data));
+	Game::logger->Log("PlayerContainer", "Added user: %s (%llu), zone: %i\n", data->playerName.C_String(), data->playerID, data->zoneID.GetMapID());
+
+	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
+
+	insertLog->setInt(1, data->playerID);
+	insertLog->setInt(2, 0);
+	insertLog->setUInt64(3, time(nullptr));
+	insertLog->setInt(4, data->zoneID.GetMapID());
+
+	insertLog->executeUpdate();
+}
+
+void PlayerContainer::RemovePlayer(Packet* packet) {
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
+	inStream.Read(playerID);
+
+	//Before they get kicked, we need to also send a message to their friends saying that they disconnected.
+	auto player = this->GetPlayerData(playerID);
+
+	if (player == nullptr) {
+		return;
+	}
+
+	for (auto& fr : player->friends) {
+		//if (!fr.isOnline) continue;
+
+		auto fd = this->GetPlayerData(fr.friendID);
+		if (fd) ChatPacketHandler::SendFriendUpdate(fd, player, 0);
+	}
+
+	auto* team = GetTeam(playerID);
+
+	if (team != nullptr)
+	{
+		//TeamStatusUpdate(team);
+
+		const auto memberName = GeneralUtils::ASCIIToUTF16(std::string(player->playerName.C_String()));
+		
+		for (const auto memberId : team->memberIDs)
+		{
+			auto* otherMember = GetPlayerData(memberId);
+
+			if (otherMember == nullptr) continue;
+
+			ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, playerID, {0, 0, 0});
+			//ChatPacketHandler::SendTeamRemovePlayer(otherMember, false, false, true, false, team->leaderID, player->playerID, memberName);
+		}
+	}
+
+	Game::logger->Log("PlayerContainer", "Removed user: %llu\n", playerID);
+	mPlayers.erase(playerID);
+
+	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
+
+	insertLog->setInt(1, playerID);
+	insertLog->setInt(2, 1);
+	insertLog->setUInt64(3, time(nullptr));
+	insertLog->setInt(4, player->zoneID.GetMapID());
+
+	insertLog->executeUpdate();
+}
+
+void PlayerContainer::MuteUpdate(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
+	inStream.Read(playerID);
+	time_t expire = 0;
+	inStream.Read(expire);
+
+	auto* player = this->GetPlayerData(playerID);
+
+	if (player == nullptr)
+	{
+		Game::logger->Log("PlayerContainer", "Failed to find user: %llu\n", playerID);
+
+		return;
+	}
+
+	player->muteExpire = expire;
+
+	BroadcastMuteUpdate(playerID, expire);
+}
+
+void PlayerContainer::CreateTeamServer(Packet* packet) 
+{
+	CINSTREAM;
+	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
+	inStream.Read(playerID);
+	size_t membersSize = 0;
+	inStream.Read(membersSize);
+
+	std::vector<LWOOBJID> members;
+
+	members.reserve(membersSize);
+
+	for (size_t i = 0; i < membersSize; i++)
+	{
+		LWOOBJID member;
+		inStream.Read(member);
+		members.push_back(member);
+	}
+
+	LWOZONEID zoneId;
+
+	inStream.Read(zoneId);
+	
+	auto* team = CreateLocalTeam(members);
+
+	if (team != nullptr)
+	{
+		team->zoneId = zoneId;
+	}
+
+	UpdateTeamsOnWorld(team, false);
+}
+
+void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) 
+{
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
+
+	bitStream.Write(player);
+	bitStream.Write(time);
+
+	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+}
+
+TeamData* PlayerContainer::CreateLocalTeam(std::vector<LWOOBJID> members) 
+{
+	if (members.empty())
+	{
+		return nullptr;
+	}
+
+	TeamData* newTeam = nullptr;
+
+	for (const auto member : members)
+	{
+		auto* team = GetTeam(member);
+
+		if (team != nullptr)
+		{
+			RemoveMember(team, member, false, false, true);
+		}
+
+		if (newTeam == nullptr)
+		{
+			newTeam = CreateTeam(member, true);
+		}
+		else
+		{
+			AddMember(newTeam, member);
+		}
+	}
+
+	newTeam->lootFlag = 1;
+
+	TeamStatusUpdate(newTeam);
+
+	return newTeam;
+}
+
+TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) 
+{
+	auto* team = new TeamData();
+	
+	team->teamID = ++mTeamIDCounter;
+	team->leaderID = leader;
+	team->local = local;
+	
+	mTeams.push_back(team);
+
+	AddMember(team, leader);
+
+	return team;
+}
+
+TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) 
+{
+	for (auto* team : mTeams)
+	{
+		if (std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID) == team->memberIDs.end()) continue;
+
+		return team;
+	}
+	
+	return nullptr;
+}
+
+void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) 
+{
+	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
+
+	if (index != team->memberIDs.end()) return;
+
+	team->memberIDs.push_back(playerID);
+
+	auto* leader = GetPlayerData(team->leaderID);
+	auto* member = GetPlayerData(playerID);
+
+	if (leader == nullptr || member == nullptr) return;
+
+	const auto leaderName = GeneralUtils::ASCIIToUTF16(std::string(leader->playerName.C_String()));
+	const auto memberName = GeneralUtils::ASCIIToUTF16(std::string(member->playerName.C_String()));
+
+	ChatPacketHandler::SendTeamInviteConfirm(member, false, leader->playerID, leader->zoneID, team->lootFlag, 0, 0, leaderName);
+	
+	/*
+	ChatPacketHandler::SendTeamAddPlayer(member, false, false, false, leader->playerID, leaderName, leader->zoneID);
+
+	Game::logger->Log("PlayerContainer", "Team invite successfully accepted, leader: %s, member: %s\n", leader->playerName.C_String(), member->playerName.C_String());
+	*/
+
+	if (!team->local)
+	{
+		ChatPacketHandler::SendTeamSetLeader(member, leader->playerID);
+	}
+	else
+	{
+		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
+	}
+
+	UpdateTeamsOnWorld(team, false);
+
+	for (const auto memberId : team->memberIDs)
+	{
+		auto* otherMember = GetPlayerData(memberId);
+
+		if (otherMember == member) continue;
+
+		const auto otherMemberName = GetName(memberId);
+		
+		ChatPacketHandler::SendTeamAddPlayer(member, false, team->local, false, memberId, otherMemberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
+
+		if (otherMember != nullptr)
+		{
+			ChatPacketHandler::SendTeamAddPlayer(otherMember, false, team->local, false, member->playerID, memberName, member->zoneID);
+		}
+	}
+}
+
+void PlayerContainer::RemoveMember(TeamData* team, LWOOBJID playerID, bool disband, bool kicked, bool leaving, bool silent) 
+{
+	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
+
+	if (index == team->memberIDs.end()) return;
+
+	auto* member = GetPlayerData(playerID);
+	
+	if (member != nullptr && !silent)
+	{
+		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
+	}
+
+	const auto memberName = GetName(playerID);
+
+	for (const auto memberId : team->memberIDs)
+	{
+		if (silent && memberId == playerID)
+		{
+			continue;
+		}
+
+		auto* otherMember = GetPlayerData(memberId);
+
+		if (otherMember == nullptr) continue;
+
+		ChatPacketHandler::SendTeamRemovePlayer(otherMember, disband, kicked, leaving, false, team->leaderID, playerID, memberName);
+	}
+
+	team->memberIDs.erase(index);
+
+	UpdateTeamsOnWorld(team, false);
+
+	if (team->memberIDs.size() <= 1)
+	{
+		DisbandTeam(team);
+	}
+	else
+	{
+		if (playerID == team->leaderID)
+		{
+			PromoteMember(team, team->memberIDs[0]);
+		}
+	}
+}
+
+void PlayerContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) 
+{
+	team->leaderID = newLeader;
+
+	for (const auto memberId : team->memberIDs)
+	{
+		auto* otherMember = GetPlayerData(memberId);
+
+		if (otherMember == nullptr) continue;
+
+		ChatPacketHandler::SendTeamSetLeader(otherMember, newLeader);
+	}
+}
+
+void PlayerContainer::DisbandTeam(TeamData* team) 
+{
+	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
+
+	if (index == mTeams.end()) return;
+
+	for (const auto memberId : team->memberIDs)
+	{
+		auto* otherMember = GetPlayerData(memberId);
+
+		if (otherMember == nullptr) continue;
+
+		const auto memberName = GeneralUtils::ASCIIToUTF16(std::string(otherMember->playerName.C_String()));
+
+		ChatPacketHandler::SendTeamSetLeader(otherMember, LWOOBJID_EMPTY);
+		ChatPacketHandler::SendTeamRemovePlayer(otherMember, true, false, false, team->local, team->leaderID, otherMember->playerID, memberName);
+	}
+	
+	UpdateTeamsOnWorld(team, true);
+
+	mTeams.erase(index);
+
+	delete team;
+}
+
+void PlayerContainer::TeamStatusUpdate(TeamData* team) 
+{
+	const auto index = std::find(mTeams.begin(), mTeams.end(), team);
+
+	if (index == mTeams.end()) return;
+
+	auto* leader = GetPlayerData(team->leaderID);
+
+	if (leader == nullptr) return;
+
+	const auto leaderName = GeneralUtils::ASCIIToUTF16(std::string(leader->playerName.C_String()));
+
+	for (const auto memberId : team->memberIDs)
+	{
+		auto* otherMember = GetPlayerData(memberId);
+
+		if (otherMember == nullptr) continue;
+
+		if (!team->local)
+		{
+			ChatPacketHandler::SendTeamStatus(otherMember, team->leaderID, leader->zoneID, team->lootFlag, 0, leaderName);
+		}
+		else
+		{
+			//ChatPacketHandler::SendTeamStatus(otherMember, LWOOBJID_EMPTY, LWOZONEID(0, 0, 0), 1, 0, u"");
+		}
+	}
+
+	UpdateTeamsOnWorld(team, false);
+}
+
+void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) 
+{
+	CBITSTREAM;
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE);
+
+	bitStream.Write(team->teamID);
+	bitStream.Write(deleteTeam);
+
+	if (!deleteTeam)
+	{
+		bitStream.Write(team->lootFlag);
+		bitStream.Write(static_cast<char>(team->memberIDs.size()));
+		for (const auto memberID : team->memberIDs)
+		{
+			bitStream.Write(memberID);
+		}
+	}
+
+	Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+}
+
+std::u16string PlayerContainer::GetName(LWOOBJID playerID) 
+{
+	const auto& pair = mNames.find(playerID);
+
+	if (pair == mNames.end()) return u"";
+
+	return pair->second;
+}
+
+LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) 
+{
+	for (const auto& pair : mNames)
+	{
+		if (pair.second == playerName)
+		{
+			return pair.first;
+		}
+	}
+	
+	return LWOOBJID_EMPTY;
+}
+
+bool PlayerContainer::GetIsMuted(PlayerData* data) 
+{
+	return data->muteExpire == 1 || data->muteExpire > time(NULL);
+}

dChatServer/PlayerContainer.h

@@ -0,0 +1,77 @@
+#pragma once
+#include <map>
+#include "dCommonVars.h"
+#include "RakString.h"
+#include <vector>
+#include "Game.h"
+#include "dServer.h"
+#include <unordered_map>
+
+struct PlayerData {
+	LWOOBJID playerID;
+	RakNet::RakString playerName;
+	SystemAddress sysAddr;
+	LWOZONEID zoneID;
+	std::vector<FriendData> friends;
+	time_t muteExpire;
+};
+
+struct TeamData {
+	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
+	LWOOBJID leaderID = LWOOBJID_EMPTY;
+	std::vector<LWOOBJID> memberIDs {};
+	uint8_t lootFlag = 0;
+	bool local = false;
+	LWOZONEID zoneId = {};
+};
+
+class PlayerContainer {
+public:
+	PlayerContainer();
+	~PlayerContainer();
+
+	void InsertPlayer(Packet* packet);
+	void RemovePlayer(Packet* packet);
+	void MuteUpdate(Packet* packet);
+	void CreateTeamServer(Packet* packet);
+	void BroadcastMuteUpdate(LWOOBJID player, time_t time);
+
+	PlayerData* GetPlayerData(const LWOOBJID& playerID) {
+		auto it = mPlayers.find(playerID);
+		if (it != mPlayers.end()) return it->second;
+		return nullptr;
+	}
+
+	PlayerData* GetPlayerData(const std::string& playerName) {
+		for (auto player : mPlayers) {
+			if (player.second) {
+				std::string pn = player.second->playerName.C_String();
+				if (pn == playerName) return player.second;
+			}
+		}
+
+		return nullptr;
+	}
+
+	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
+	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
+	TeamData* GetTeam(LWOOBJID playerID);
+	void AddMember(TeamData* team, LWOOBJID playerID);
+	void RemoveMember(TeamData* team, LWOOBJID playerID, bool disband, bool kicked, bool leaving, bool silent = false);
+	void PromoteMember(TeamData* team, LWOOBJID newLeader);
+	void DisbandTeam(TeamData* team);
+	void TeamStatusUpdate(TeamData* team);
+	void UpdateTeamsOnWorld(TeamData* team, bool deleteTeam);
+	std::u16string GetName(LWOOBJID playerID);
+	LWOOBJID GetId(const std::u16string& playerName);
+	bool GetIsMuted(PlayerData* data);
+
+	std::map<LWOOBJID, PlayerData*>& GetAllPlayerData() { return mPlayers; }
+
+private:
+	LWOOBJID mTeamIDCounter = 0;
+	std::map<LWOOBJID, PlayerData*> mPlayers;
+	std::vector<TeamData*> mTeams;
+	std::unordered_map<LWOOBJID, std::u16string> mNames;
+};
+

dCommon/AMFFormat.cpp

@@ -0,0 +1,157 @@
+#include "AMFFormat.h"
+
+// AMFInteger
+void AMFIntegerValue::SetIntegerValue(uint32_t value) {
+    this->value = value;
+}
+
+uint32_t AMFIntegerValue::GetIntegerValue() {
+    return this->value;
+}
+
+// AMFDouble
+void AMFDoubleValue::SetDoubleValue(double value) {
+    this->value = value;
+}
+
+double AMFDoubleValue::GetDoubleValue() {
+    return this->value;
+}
+
+// AMFString
+void AMFStringValue::SetStringValue(const std::string& value) {
+    this->value = value;
+}
+
+std::string AMFStringValue::GetStringValue() {
+    return this->value;
+}
+
+// AMFXMLDoc
+void AMFXMLDocValue::SetXMLDocValue(const std::string& value) {
+    this->xmlData = value;
+}
+
+std::string AMFXMLDocValue::GetXMLDocValue() {
+    return this->xmlData;
+}
+
+// AMFDate
+void AMFDateValue::SetDateValue(uint64_t value) {
+    this->millisecondTimestamp = value;
+}
+
+uint64_t AMFDateValue::GetDateValue() {
+    return this->millisecondTimestamp;
+}
+
+// AMFArray Insert Value
+void AMFArrayValue::InsertValue(const std::string& key, AMFValue* value) {
+    this->associative.insert(std::make_pair(key, value));
+}
+
+// AMFArray Remove Value
+void AMFArrayValue::RemoveValue(const std::string& key) {
+    _AMFArrayMap_::iterator it = this->associative.find(key);
+    if (it != this->associative.end()) {
+        this->associative.erase(it);
+    }
+}
+
+// AMFArray Find Value
+AMFValue* AMFArrayValue::FindValue(const std::string& key) {
+    _AMFArrayMap_::iterator it = this->associative.find(key);
+    if (it != this->associative.end()) {
+        return it->second;
+    }
+    
+    return nullptr;
+}
+
+// AMFArray Get Associative Iterator Begin
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueBegin() {
+    return this->associative.begin();
+}
+
+// AMFArray Get Associative Iterator End
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueEnd() {
+    return this->associative.end();
+}
+
+// AMFArray Push Back Value
+void AMFArrayValue::PushBackValue(AMFValue* value) {
+    this->dense.push_back(value);
+}
+
+// AMFArray Pop Back Value
+void AMFArrayValue::PopBackValue() {
+    this->dense.pop_back();
+}
+
+// AMFArray Get Dense List Size
+uint32_t AMFArrayValue::GetDenseValueSize() {
+    return (uint32_t)this->dense.size();
+}
+
+// AMFArray Get value at index in Dense List
+AMFValue* AMFArrayValue::GetValueAt(uint32_t index) {
+    return this->dense.at(index);
+}
+
+// AMFArray Get Dense Iterator Begin
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorBegin() {
+    return this->dense.begin();
+}
+
+// AMFArray Get Dense Iterator End
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorEnd() {
+    return this->dense.end();
+}
+
+
+// AMFObject Constructor
+AMFObjectValue::AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits) {
+    this->traits.reserve(traits.size());
+    std::vector<std::pair<std::string, AMFValueType>>::iterator it = traits.begin();
+    while (it != traits.end()) {
+        this->traits.insert(std::make_pair(it->first, std::make_pair(it->second, new AMFNullValue())));
+        it++;
+    }
+}
+
+// AMFObject Set Value
+void AMFObjectValue::SetTraitValue(const std::string& trait, AMFValue* value) {
+    if (value) {
+        _AMFObjectTraits_::iterator it = this->traits.find(trait);
+        if (it != this->traits.end()) {
+            if (it->second.first == value->GetValueType()) {
+                it->second.second = value;
+            }
+        }
+    }
+}
+
+// AMFObject Get Value
+AMFValue* AMFObjectValue::GetTraitValue(const std::string& trait) {
+    _AMFObjectTraits_::iterator it = this->traits.find(trait);
+    if (it != this->traits.end()) {
+        return it->second.second;
+    }
+    
+    return nullptr;
+}
+
+// AMFObject Get Trait Iterator Begin
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorBegin() {
+    return this->traits.begin();
+}
+
+// AMFObject Get Trait Iterator End
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorEnd() {
+    return this->traits.end();
+}
+
+// AMFObject Get Trait Size
+uint32_t AMFObjectValue::GetTraitArrayCount() {
+    return (uint32_t)this->traits.size();
+}

dCommon/AMFFormat.h

@@ -0,0 +1,368 @@
+#pragma once
+
+// Custom Classes
+#include "dCommonVars.h"
+
+// C++
+#include <unordered_map>
+#include <vector>
+
+/*!
+  \file AMFFormat.hpp
+  \brief A class for managing AMF values
+ */
+
+class AMFValue;     // Forward declaration
+
+// Definitions
+#define _AMFArrayMap_               std::unordered_map<std::string, AMFValue*>
+#define _AMFArrayList_              std::vector<AMFValue*>
+
+#define _AMFObjectTraits_           std::unordered_map<std::string, std::pair<AMFValueType, AMFValue*>>
+#define _AMFObjectDynamicTraits_    std::unordered_map<std::string, AMFValue*>
+
+//! An enum for each AMF value type
+enum AMFValueType : unsigned char {
+    AMFUndefined = 0x00,            //!< An undefined AMF Value
+    AMFNull = 0x01,                 //!< A null AMF value
+    AMFFalse = 0x02,                //!< A false AMF value
+    AMFTrue = 0x03,                 //!< A true AMF value
+    AMFInteger = 0x04,              //!< An integer AMF value
+    AMFDouble = 0x05,               //!< A double AMF value
+    AMFString = 0x06,               //!< A string AMF value
+    AMFXMLDoc = 0x07,               //!< An XML Doc AMF value
+    AMFDate = 0x08,                 //!< A date AMF value
+    AMFArray = 0x09,                //!< An array AMF value
+    AMFObject = 0x0A,               //!< An object AMF value
+    AMFXML = 0x0B,                  //!< An XML AMF value
+    AMFByteArray = 0x0C,            //!< A byte array AMF value
+    AMFVectorInt = 0x0D,            //!< An integer vector AMF value
+    AMFVectorUInt = 0x0E,           //!< An unsigned integer AMF value
+    AMFVectorDouble = 0x0F,         //!< A double vector AMF value
+    AMFVectorObject = 0x10,         //!< An object vector AMF value
+    AMFDictionary = 0x11            //!< A dictionary AMF value
+};
+
+//! An enum for the object value types
+enum AMFObjectValueType : unsigned char {
+    AMFObjectAnonymous = 0x01,
+    AMFObjectTyped = 0x02,
+    AMFObjectDynamic = 0x03,
+    AMFObjectExternalizable = 0x04
+};
+
+//! The base AMF value class
+class AMFValue {
+public:
+    //! Returns the AMF value type
+    /*!
+      \return The AMF value type
+     */
+    virtual AMFValueType GetValueType() = 0;
+};
+
+//! A typedef for a pointer to an AMF value
+typedef AMFValue* NDGFxValue;
+
+
+// The various AMF value types
+
+//! The undefined value AMF type
+class AMFUndefinedValue : public AMFValue {
+private:
+    //! Returns the AMF value type
+    /*!
+      \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFUndefined; }
+};
+
+//! The null value AMF type
+class AMFNullValue : public AMFValue {
+private:
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFNull; }
+};
+
+//! The false value AMF type
+class AMFFalseValue : public AMFValue {
+private:
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFFalse; }
+};
+
+//! The true value AMF type
+class AMFTrueValue : public AMFValue {
+private:
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFTrue; }
+};
+
+//! The integer value AMF type
+class AMFIntegerValue : public AMFValue {
+private:
+    uint32_t value;         //!< The value of the AMF type
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFInteger; }
+    
+public:
+    //! Sets the integer value
+    /*!
+      \param value The value to set
+     */
+    void SetIntegerValue(uint32_t value);
+    
+    //! Gets the integer value
+    /*!
+      \return The integer value
+     */
+    uint32_t GetIntegerValue();
+};
+
+//! The double value AMF type
+class AMFDoubleValue : public AMFValue {
+private:
+    double value;           //!< The value of the AMF type
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFDouble; }
+    
+public:
+    //! Sets the double value
+    /*!
+      \param value The value to set to
+     */
+    void SetDoubleValue(double value);
+    
+    //! Gets the double value
+    /*!
+      \return The double value
+     */
+    double GetDoubleValue();
+};
+
+//! The string value AMF type
+class AMFStringValue : public AMFValue {
+private:
+    std::string value;          //!< The value of the AMF type
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFString; }
+    
+public:
+    //! Sets the string value
+    /*!
+      \param value The string value to set to
+     */
+    void SetStringValue(const std::string& value);
+    
+    //! Gets the string value
+    /*!
+      \return The string value
+     */
+    std::string GetStringValue();
+};
+
+//! The XML doc value AMF type
+class AMFXMLDocValue : public AMFValue {
+private:
+    std::string xmlData;            //!< The value of the AMF type
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFXMLDoc; }
+    
+public:
+    //! Sets the XML Doc value
+    /*!
+      \param value The value to set to
+     */
+    void SetXMLDocValue(const std::string& value);
+    
+    //! Gets the XML Doc value
+    /*!
+      \return The XML Doc value
+     */
+    std::string GetXMLDocValue();
+};
+
+//! The date value AMF type
+class AMFDateValue : public AMFValue {
+private:
+    uint64_t millisecondTimestamp;      //!< The time in milliseconds since the ephoch
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFDate; }
+    
+public:
+    //! Sets the date time
+    /*!
+      \param value The value to set to
+     */
+    void SetDateValue(uint64_t value);
+    
+    //! Gets the date value
+    /*!
+      \return The date value in milliseconds since the epoch
+     */
+    uint64_t GetDateValue();
+};
+
+//! The array value AMF type
+class AMFArrayValue : public AMFValue {
+private:
+    _AMFArrayMap_ associative;      //!< The array map (associative part)
+    _AMFArrayList_ dense;           //!< The array list (dense part)
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFArray; }
+    
+public:
+    //! Inserts an item into the array map for a specific key
+    /*!
+      \param key The key to set
+      \param value The value to add
+     */
+    void InsertValue(const std::string& key, AMFValue* value);
+    
+    //! Removes an item for a specific key
+    /*!
+      \param key The key to remove
+     */
+    void RemoveValue(const std::string& key);
+    
+    //! Finds an AMF value
+    /*!
+      \return The AMF value if found, nullptr otherwise
+     */
+    AMFValue* FindValue(const std::string& key);
+    
+    //! Returns where the associative iterator begins
+    /*!
+      \return Where the array map iterator begins
+     */
+    _AMFArrayMap_::iterator GetAssociativeIteratorValueBegin();
+    
+    //! Returns where the associative iterator ends
+    /*!
+      \return Where the array map iterator ends
+     */
+    _AMFArrayMap_::iterator GetAssociativeIteratorValueEnd();
+    
+    //! Pushes back a value into the array list
+    /*!
+      \param value The value to push back
+     */
+    void PushBackValue(AMFValue* value);
+    
+    //! Pops back the last value in the array list
+    void PopBackValue();
+    
+    //! Gets the count of the dense list
+    /*!
+      \return The dense list size
+     */
+    uint32_t GetDenseValueSize();
+    
+    //! Gets a specific value from the list for the specified index
+    /*!
+      \param index The index to get
+     */
+    AMFValue* GetValueAt(uint32_t index);
+    
+    //! Returns where the dense iterator begins
+    /*!
+      \return Where the iterator begins
+     */
+    _AMFArrayList_::iterator GetDenseIteratorBegin();
+    
+    //! Returns where the dense iterator ends
+    /*!
+      \return Where the iterator ends
+     */
+    _AMFArrayList_::iterator GetDenseIteratorEnd();
+};
+
+//! The anonymous object value AMF type
+class AMFObjectValue : public AMFValue {
+private:
+    _AMFObjectTraits_ traits;           //!< The object traits
+    
+    //! Returns the AMF value type
+    /*!
+     \return The AMF value type
+     */
+    AMFValueType GetValueType() { return AMFObject; }
+    
+public:
+    //! Constructor
+    /*!
+      \param traits The traits to set
+     */
+    AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits);
+    
+    //! Gets the object value type
+    /*!
+      \return The object value type
+     */
+    virtual AMFObjectValueType GetObjectValueType() { return AMFObjectAnonymous; }
+    
+    //! Sets the value of a trait
+    /*!
+      \param trait The trait to set the value for
+      \param value The AMF value to set
+     */
+    void SetTraitValue(const std::string& trait, AMFValue* value);
+    
+    //! Gets a trait value
+    /*!
+      \param trait The trait to get the value for
+      \return The trait value
+     */
+    AMFValue* GetTraitValue(const std::string& trait);
+    
+    //! Gets the beginning of the object traits iterator
+    /*!
+      \return The AMF trait array iterator begin
+     */
+    _AMFObjectTraits_::iterator GetTraitsIteratorBegin();
+    
+    //! Gets the end of the object traits iterator
+    /*!
+      \return The AMF trait array iterator begin
+     */
+    _AMFObjectTraits_::iterator GetTraitsIteratorEnd();
+    
+    //! Gets the amount of traits
+    /*!
+      \return The amount of traits
+     */
+    uint32_t GetTraitArrayCount();
+};

dCommon/AMFFormat_BitStream.cpp

@@ -0,0 +1,271 @@
+#include "AMFFormat_BitStream.h"
+
+// Writes an AMFValue pointer to a RakNet::BitStream
+template<>
+void RakNet::BitStream::Write<AMFValue*>(AMFValue* value) {
+    if (value != nullptr) {
+        AMFValueType type = value->GetValueType();
+        
+        switch (type) {
+            case AMFUndefined: {
+                AMFUndefinedValue* v = (AMFUndefinedValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFNull: {
+                AMFNullValue* v = (AMFNullValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFFalse: {
+                AMFFalseValue* v = (AMFFalseValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFTrue: {
+                AMFTrueValue* v = (AMFTrueValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFInteger: {
+                AMFIntegerValue* v = (AMFIntegerValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFString: {
+                AMFStringValue* v = (AMFStringValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFXMLDoc: {
+                AMFXMLDocValue* v = (AMFXMLDocValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFDate: {
+                AMFDateValue* v = (AMFDateValue*)value;
+                this->Write(*v);
+                break;
+            }
+                
+            case AMFArray: {
+                AMFArrayValue* v = (AMFArrayValue*)value;
+                this->Write(*v);
+                break;
+            }
+        }
+    }
+}
+
+// A private function to write an value to a RakNet::BitStream
+void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
+    unsigned char b4 = (unsigned char)v;
+    if (v < 0x00200000) {
+        b4 = b4 & 0x7F;
+        if (v > 0x7F) {
+            unsigned char b3;
+            v = v >> 7;
+            b3 = ((unsigned char)(v)) | 0x80;
+            if (v > 0x7F) {
+                unsigned char b2;
+                v = v >> 7;
+                b2 = ((unsigned char)(v)) | 0x80;
+                bs->Write(b2);
+            }
+            
+            bs->Write(b3);
+        }
+    } else {
+        unsigned char b1;
+        unsigned char b2;
+        unsigned char b3;
+        
+        v = v >> 8;
+        b3 = ((unsigned char)(v)) | 0x80;
+        v = v >> 7;
+        b2 = ((unsigned char)(v)) | 0x80;
+        v = v >> 7;
+        b1 = ((unsigned char)(v)) | 0x80;
+        
+        bs->Write(b1);
+        bs->Write(b2);
+        bs->Write(b3);
+    }
+    
+    bs->Write(b4);
+}
+
+// Writes a flag number to a RakNet::BitStream
+void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
+    v = (v << 1) | 0x01;
+    WriteUInt29(bs, v);
+}
+
+// Writes an AMFString to a RakNet::BitStream
+void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
+    WriteFlagNumber(bs, (uint32_t)str.size());
+    bs->Write(str.c_str(), (uint32_t)str.size());
+}
+
+// Writes an AMF U16 to a RakNet::BitStream
+void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
+    unsigned char b2;
+    b2 = (unsigned char)value;
+    value = value >> 8;
+    bs->Write((unsigned char)value);
+    bs->Write(b2);
+}
+
+// Writes an AMF U32 to RakNet::BitStream
+void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
+    unsigned char b2;
+    unsigned char b3;
+    unsigned char b4;
+    
+    b4 = (unsigned char)value;
+    value = value >> 8;
+    b3 = (unsigned char)value;
+    value = value >> 8;
+    b2 = (unsigned char)value;
+    value = value >> 8;
+    
+    bs->Write((unsigned char)value);
+    bs->Write(b2);
+    bs->Write(b3);
+    bs->Write(b4);
+}
+
+// Writes an AMF U64 to RakNet::BitStream
+void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
+    unsigned char b2;
+    unsigned char b3;
+    unsigned char b4;
+    unsigned char b5;
+    unsigned char b6;
+    unsigned char b7;
+    unsigned char b8;
+    
+    b8 = (unsigned char)value;
+    value = value >> 8;
+    b7 = (unsigned char)value;
+    value = value >> 8;
+    b6 = (unsigned char)value;
+    value = value >> 8;
+    b5 = (unsigned char)value;
+    value = value >> 8;
+    b4 = (unsigned char)value;
+    value = value >> 8;
+    b3 = (unsigned char)value;
+    value = value >> 8;
+    b2 = (unsigned char)value;
+    value = value >> 8;
+    
+    bs->Write((unsigned char)value);
+    bs->Write(b2);
+    bs->Write(b3);
+    bs->Write(b4);
+    bs->Write(b5);
+    bs->Write(b6);
+    bs->Write(b7);
+    bs->Write(b8);
+}
+
+
+// Writes an AMFUndefinedValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value) {
+    this->Write(AMFUndefined);
+}
+
+// Writes an AMFNullValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value) {
+    this->Write(AMFNull);
+}
+
+// Writes an AMFFalseValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value) {
+    this->Write(AMFFalse);
+}
+
+// Writes an AMFTrueValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value) {
+    this->Write(AMFTrue);
+}
+
+// Writes an AMFIntegerValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value) {
+    this->Write(AMFInteger);
+    WriteUInt29(this, value.GetIntegerValue());
+}
+
+// Writes an AMFDoubleValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value) {
+    this->Write(AMFDouble);
+    double d = value.GetDoubleValue();
+    WriteAMFU64(this, *((unsigned long long*)&d));
+}
+
+// Writes an AMFStringValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value) {
+    this->Write(AMFString);
+    std::string v = value.GetStringValue();
+    WriteAMFString(this, v);
+}
+
+// Writes an AMFXMLDocValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value) {
+    this->Write(AMFXMLDoc);
+    std::string v = value.GetXMLDocValue();
+    WriteAMFString(this, v);
+}
+
+// Writes an AMFDateValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value) {
+    this->Write(AMFDate);
+    uint64_t date = value.GetDateValue();
+    WriteAMFU64(this, date);
+}
+
+// Writes an AMFArrayValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFArrayValue>(AMFArrayValue value) {
+    this->Write(AMFArray);
+    uint32_t denseSize = value.GetDenseValueSize();
+    WriteFlagNumber(this, denseSize);
+    
+    _AMFArrayMap_::iterator it = value.GetAssociativeIteratorValueBegin();
+    _AMFArrayMap_::iterator end = value.GetAssociativeIteratorValueEnd();
+    
+    while (it != end) {
+        WriteAMFString(this, it->first);
+        this->Write(it->second);
+        it++;
+    }
+    
+    this->Write(AMFNull);
+    
+    if (denseSize > 0) {
+        _AMFArrayList_::iterator it2 = value.GetDenseIteratorBegin();
+        _AMFArrayList_::iterator end2 = value.GetDenseIteratorEnd();
+        
+        while (it2 != end2) {
+            this->Write(*it2);
+            it2++;
+        }
+    }
+}

dCommon/AMFFormat_BitStream.h

@@ -0,0 +1,92 @@
+#pragma once
+
+// Custom Classes
+#include "AMFFormat.h"
+
+// RakNet
+#include <BitStream.h>
+
+/*!
+  \file AMFBitStream.hpp
+  \brief A class that implements native writing of AMF values to RakNet::BitStream
+ */
+
+// We are using the RakNet namespace
+namespace RakNet {
+    //! Writes an AMFValue pointer to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFValue*>(AMFValue* value);
+    
+    //! Writes an AMFUndefinedValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value);
+    
+    //! Writes an AMFNullValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value);
+    
+    //! Writes an AMFFalseValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value);
+    
+    //! Writes an AMFTrueValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value);
+    
+    //! Writes an AMFIntegerValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value);
+    
+    //! Writes an AMFDoubleValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value);
+    
+    //! Writes an AMFStringValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value);
+    
+    //! Writes an AMFXMLDocValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value);
+    
+    //! Writes an AMFDateValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value);
+    
+    //! Writes an AMFArrayValue to a RakNet::BitStream
+    /*!
+     \param value The value to write
+     */
+    template<>
+    void RakNet::BitStream::Write<AMFArrayValue>(AMFArrayValue value);
+}

dCommon/BinaryIO.cpp

@@ -0,0 +1,58 @@
+#include "BinaryIO.h"
+#include <string>
+
+void BinaryIO::WriteString(const std::string& stringToWrite, std::ofstream& outstream) {
+	//BinaryWrite(outstream, uint32_t(stringToWrite.length()));
+
+	for (size_t i = 0; i < size_t(stringToWrite.length()); ++i) {
+		BinaryIO::BinaryWrite(outstream, stringToWrite[i]);
+	}
+}
+
+//For reading null-terminated strings
+std::string BinaryIO::ReadString(std::ifstream & instream) {
+	std::string toReturn;
+	char buffer;
+
+	BinaryIO::BinaryRead(instream, buffer);
+
+	while (buffer != 0x00) {
+		toReturn += buffer;
+		BinaryRead(instream, buffer);
+	}
+
+	return toReturn;
+}
+
+//For reading strings of a specific size
+std::string BinaryIO::ReadString(std::ifstream& instream, size_t size) {
+	std::string toReturn;
+	char buffer;
+
+	for (size_t i = 0; i < size; ++i) {
+		BinaryIO::BinaryRead(instream, buffer);
+		toReturn += buffer;
+	}
+
+	return toReturn;
+}
+
+std::string BinaryIO::ReadWString(std::ifstream & instream) {
+	size_t size;
+	BinaryRead(instream, size);
+	//toReturn.resize(size);
+	std::string test;
+	unsigned char buf;
+
+	for (size_t i = 0; i < size; ++i) {
+		//instream.ignore(1);
+		BinaryRead(instream, buf);
+		test += buf;
+	}
+
+	//printf("%s\n", test.c_str());
+
+	//instream.read((char*)&toReturn[0], size * 2);
+	//std::string str(toReturn.begin(), toReturn.end());
+	return test;
+}

dCommon/BinaryIO.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <iostream>
+#include <fstream>
+
+namespace BinaryIO {
+	template<typename T>
+	std::ostream& BinaryWrite(std::ostream& stream, const T& value) {
+		return stream.write(reinterpret_cast<const char*>(&value), sizeof(T));
+	}
+
+	template<typename T>
+	std::istream & BinaryRead(std::istream& stream, T& value) {
+		if (!stream.good()) 
+			printf("bla");
+
+		return stream.read(reinterpret_cast<char*>(&value), sizeof(T));
+	}
+
+	void WriteString(const std::string& stringToWrite, std::ofstream& outstream);
+	std::string ReadString(std::ifstream & instream);
+	std::string ReadString(std::ifstream& instream, size_t size);
+	std::string ReadWString(std::ifstream& instream);
+
+	inline bool DoesFileExist(const std::string& name) {
+		std::ifstream f(name.c_str());
+		return f.good();
+	}
+}

dCommon/Diagnostics.cpp

@@ -0,0 +1,255 @@
+#include "Diagnostics.h"
+
+// If we're on Win32, we'll include our minidump writer
+#ifdef _WIN32
+#include <Dbghelp.h>
+#include <Windows.h>
+
+#include "Game.h"
+#include "dLogger.h"
+
+void make_minidump(EXCEPTION_POINTERS* e) {
+    auto hDbgHelp = LoadLibraryA("dbghelp");
+    if (hDbgHelp == nullptr)
+        return;
+    auto pMiniDumpWriteDump = (decltype(&MiniDumpWriteDump))GetProcAddress(hDbgHelp, "MiniDumpWriteDump");
+    if (pMiniDumpWriteDump == nullptr)
+        return;
+
+    char name[MAX_PATH];
+    {
+        auto nameEnd = name + GetModuleFileNameA(GetModuleHandleA(0), name, MAX_PATH);
+        SYSTEMTIME t;
+        GetSystemTime(&t);
+        wsprintfA(nameEnd - strlen(".exe"),
+                  "_%4d%02d%02d_%02d%02d%02d.dmp",
+                  t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond);
+    }
+
+    auto hFile = CreateFileA(name, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+    if (hFile == INVALID_HANDLE_VALUE)
+        return;
+
+    MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
+    exceptionInfo.ThreadId = GetCurrentThreadId();
+    exceptionInfo.ExceptionPointers = e;
+    exceptionInfo.ClientPointers = FALSE;
+
+    auto dumped = pMiniDumpWriteDump(
+        GetCurrentProcess(),
+        GetCurrentProcessId(),
+        hFile,
+        MINIDUMP_TYPE(MiniDumpWithIndirectlyReferencedMemory | MiniDumpScanMemory),
+        e ? &exceptionInfo : nullptr,
+        nullptr,
+        nullptr);
+
+    CloseHandle(hFile);
+
+    return;
+}
+
+LONG CALLBACK unhandled_handler(EXCEPTION_POINTERS* e) {
+    make_minidump(e);
+    if (Game::logger)
+        Game::logger->Flush(); // Flush our log if we have one, before exiting.
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+#endif
+
+#if defined(__linux__) //&& !defined(__clang__) // backtrace is a gcc exclusive system library
+#include <execinfo.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+
+#if defined(__include_backtrace__)
+#include <backtrace.h>
+
+#include <backtrace-supported.h>
+
+struct bt_ctx {
+    struct backtrace_state* state;
+    int error;
+};
+
+static inline void Bt(struct backtrace_state* state) {
+    std::string fileName = Diagnostics::GetOutDirectory() + "crash_" + Diagnostics::GetProcessName() + "_" + std::to_string(getpid()) + ".log";
+    FILE* file = fopen(fileName.c_str(), "w+");
+    if (file != nullptr) {
+        backtrace_print(state, 2, file);
+        fclose(file);
+    }
+
+    backtrace_print(state, 2, stdout);
+}
+
+static void ErrorCallback(void* data, const char* msg, int errnum) {
+    auto* ctx = (struct bt_ctx*)data;
+    fprintf(stderr, "ERROR: %s (%d)", msg, errnum);
+    ctx->error = 1;
+
+    std::string fileName = Diagnostics::GetOutDirectory() + "crash_" + Diagnostics::GetProcessName() + "_" + std::to_string(getpid()) + ".log";
+    FILE* file = fopen(fileName.c_str(), "w+");
+    if (file != nullptr) {
+        fprintf(file, "ERROR: %s (%d)", msg, errnum);
+        fclose(file);
+    }
+}
+#endif
+
+#include "Type.h"
+
+void GenerateDump() {
+    std::string cmd = "sudo gcore " + std::to_string(getpid());
+    system(cmd.c_str());
+}
+
+void CatchUnhandled(int sig) {
+#ifndef __include_backtrace__
+
+    if (Diagnostics::GetProduceMemoryDump()) {
+        GenerateDump();
+    }
+
+    void* array[10];
+    size_t size;
+
+    // get void*'s for all entries on the stack
+    size = backtrace(array, 10);
+
+    printf("Fatal error %i\nStacktrace:\n", sig);
+#if defined(__GNUG__) and defined(__dynamic)
+
+    // Loop through the returned addresses, and get the symbols to be demangled
+    char** strings = backtrace_symbols(array, size);
+
+    // Print the stack trace
+    for (size_t i = 0; i < size; i++) {
+        // Take a string like './WorldServer(_ZN19SlashCommandHandler17HandleChatCommandERKSbIDsSt11char_traitsIDsESaIDsEEP6EntityRK13SystemAddress+0x6187) [0x55869c44ecf7]' and extract the function name
+        std::string functionName = strings[i];
+        std::string::size_type start = functionName.find('(');
+        std::string::size_type end = functionName.find('+');
+        if (start != std::string::npos && end != std::string::npos) {
+            std::string demangled = functionName.substr(start + 1, end - start - 1);
+
+            demangled = demangle(functionName.c_str());
+
+            if (demangled.empty()) {
+                printf("[%02d] %s\n", i, demangled.c_str());
+            } else {
+                printf("[%02d] %s\n", i, functionName.c_str());
+            }
+        } else {
+            printf("[%02d] %s\n", i, functionName.c_str());
+        }
+    }
+#else
+    backtrace_symbols_fd(array, size, STDOUT_FILENO);
+#endif
+
+    std::string fileName = Diagnostics::GetOutDirectory() + "crash_" + Diagnostics::GetProcessName() + "_" + std::to_string(getpid()) + ".log";
+    FILE* file = fopen(fileName.c_str(), "w+");
+    if (file != NULL) {
+        // print out all the frames to stderr
+        fprintf(file, "Error: signal %d:\n", sig);
+        backtrace_symbols_fd(array, size, fileno(file));
+        fclose(file);
+    }
+
+#else
+
+    struct backtrace_state* state = backtrace_create_state(
+        Diagnostics::GetProcessFileName().c_str(),
+        BACKTRACE_SUPPORTS_THREADS,
+        ErrorCallback,
+        nullptr);
+
+    struct bt_ctx ctx = {state, 0};
+    Bt(state);
+
+#endif
+
+    exit(EXIT_FAILURE);
+}
+
+void CritErrHdlr(int sig_num, siginfo_t* info, void* ucontext) {
+    CatchUnhandled(sig_num);
+}
+
+void OnTerminate() {
+    CatchUnhandled(-1);
+}
+
+void MakeBacktrace() {
+    struct sigaction sigact;
+
+    sigact.sa_sigaction = CritErrHdlr;
+    sigact.sa_flags = SA_RESTART | SA_SIGINFO;
+
+    if (sigaction(SIGSEGV, &sigact, (struct sigaction*)nullptr) != 0 ||
+        sigaction(SIGFPE, &sigact, (struct sigaction*)nullptr) != 0 ||
+        sigaction(SIGABRT, &sigact, (struct sigaction*)nullptr) != 0 ||
+        sigaction(SIGILL, &sigact, (struct sigaction*)nullptr) != 0) {
+        fprintf(stderr, "error setting signal handler for %d (%s)\n",
+                SIGSEGV,
+                strsignal(SIGSEGV));
+
+        exit(EXIT_FAILURE);
+    }
+
+    std::set_terminate(OnTerminate);
+}
+#endif
+
+void Diagnostics::Initialize() {
+#ifdef _WIN32
+    SetUnhandledExceptionFilter(unhandled_handler);
+#elif defined(__linux__) //&& !defined(__clang__)
+    MakeBacktrace();
+#else
+    fprintf(stderr, "Diagnostics not supported on this platform.\n");
+#endif
+}
+
+std::string Diagnostics::m_ProcessName{};
+std::string Diagnostics::m_ProcessFileName{};
+std::string Diagnostics::m_OutDirectory{};
+bool Diagnostics::m_ProduceMemoryDump{};
+
+void Diagnostics::SetProcessName(const std::string& name) {
+    m_ProcessName = name;
+}
+
+void Diagnostics::SetProcessFileName(const std::string& name) {
+    m_ProcessFileName = name;
+}
+
+void Diagnostics::SetOutDirectory(const std::string& path) {
+    m_OutDirectory = path;
+}
+
+void Diagnostics::SetProduceMemoryDump(bool value) {
+    m_ProduceMemoryDump = value;
+}
+
+const std::string& Diagnostics::GetProcessName() {
+    return m_ProcessName;
+}
+
+const std::string& Diagnostics::GetProcessFileName() {
+    return m_ProcessFileName;
+}
+
+const std::string& Diagnostics::GetOutDirectory() {
+    return m_OutDirectory;
+}
+
+bool Diagnostics::GetProduceMemoryDump() {
+    return m_ProduceMemoryDump;
+}

dCommon/Diagnostics.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+class Diagnostics
+{
+public:
+    static void Initialize();
+
+    static void SetProcessName(const std::string& name);
+
+    static void SetProcessFileName(const std::string& name);
+
+    static void SetOutDirectory(const std::string& path);
+
+    static void SetProduceMemoryDump(bool value);
+
+    static const std::string& GetProcessName();
+
+    static const std::string& GetProcessFileName();
+
+    static const std::string& GetOutDirectory();
+
+    static bool GetProduceMemoryDump();
+
+private:
+    static std::string m_ProcessName;
+    static std::string m_ProcessFileName;
+    static std::string m_OutDirectory;
+    static bool m_ProduceMemoryDump;
+};

dCommon/Game.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <random>
+
+class dServer;
+class dLogger;
+class InstanceManager;
+class dpWorld;
+class dChatFilter;
+class dConfig;
+class dLocale;
+class RakPeerInterface;
+struct SystemAddress;
+
+namespace Game {
+	extern dLogger* logger;
+	extern dServer* server;
+	extern InstanceManager* im;
+	extern dpWorld* physicsWorld;
+	extern dChatFilter* chatFilter;
+	extern dConfig* config;
+	extern dLocale* locale;
+	extern std::mt19937 randomEngine;
+	extern RakPeerInterface* chatServer;
+	extern SystemAddress chatSysAddr;
+}

dCommon/GeneralUtils.cpp

@@ -0,0 +1,190 @@
+#include "GeneralUtils.h"
+
+// C++
+#include <cstdint>
+#include <cassert>
+#include <algorithm>
+
+template <typename T>
+inline size_t MinSize(size_t size, const std::basic_string<T>& string) {
+    if (size == size_t(-1) || size > string.size()) {
+        return string.size();
+    } else {
+        return size;
+    }
+}
+
+inline bool IsLeadSurrogate(char16_t c) {
+    return (0xD800 <= c) && (c <= 0xDBFF);
+}
+
+inline bool IsTrailSurrogate(char16_t c) {
+    return (0xDC00 <= c) && (c <= 0xDFFF);
+}
+
+inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
+    if (cp <= 0x007F) {
+        ret.push_back(cp);
+    } else if (cp <= 0x07FF) {
+        ret.push_back(0xC0 | (cp >> 6));
+        ret.push_back(0x80 | (cp & 0x3F));
+    } else if (cp <= 0xFFFF) {
+        ret.push_back(0xE0 | (cp >> 12));
+        ret.push_back(0x80 | ((cp >> 6) & 0x3F));
+        ret.push_back(0x80 | (cp & 0x3F));
+    } else if (cp <= 0x10FFFF) {
+        ret.push_back(0xF0 | (cp >> 18));
+        ret.push_back(0x80 | ((cp >> 12) & 0x3F));
+        ret.push_back(0x80 | ((cp >> 6) & 0x3F));
+        ret.push_back(0x80 | (cp & 0x3F));
+    } else {
+        assert(false);
+    }
+}
+
+//! Converts an std::string (ASCII) to UCS-2 / UTF-16
+std::u16string GeneralUtils::ASCIIToUTF16(const std::string& string, size_t size) {
+    size_t newSize = MinSize(size, string);
+    std::u16string ret;
+    ret.reserve(newSize);
+
+    for (size_t i = 0; i < newSize; i++) {
+        char c = string[i];
+        assert(c > 0 && c <= 127);
+        ret.push_back(static_cast<char16_t>(c));
+    }
+
+    return ret;
+}
+
+//! Converts a (potentially-ill-formed) UTF-16 string to UTF-8
+//! See: <http://simonsapin.github.io/wtf-8/#decoding-ill-formed-utf-16>
+std::string GeneralUtils::UTF16ToWTF8(const std::u16string& string, size_t size) {
+    size_t newSize = MinSize(size, string);
+    std::string ret;
+    ret.reserve(newSize);
+
+    for (size_t i = 0; i < newSize; i++) {
+        char16_t u = string[i];
+        if (IsLeadSurrogate(u) && (i + 1) < newSize) {
+            char16_t next = string[i + 1];
+            if (IsTrailSurrogate(next)) {
+                i += 1;
+                char32_t cp = 0x10000
+                    + ((static_cast<char32_t>(u) - 0xD800) << 10)
+                    + (static_cast<char32_t>(next) - 0xDC00);
+                PushUTF8CodePoint(ret, cp);
+            } else {
+                PushUTF8CodePoint(ret, u);
+            }
+        } else {
+            PushUTF8CodePoint(ret, u);
+        }
+    }
+
+    return ret;
+}
+
+bool GeneralUtils::CaseInsensitiveStringCompare(const std::string& a, const std::string& b) {
+    return std::equal(a.begin(), a.end (), b.begin(), b.end(),[](char a, char b) { return tolower(a) == tolower(b); });
+}
+
+// MARK: Bits
+
+//! Sets a specific bit in a signed 64-bit integer
+int64_t GeneralUtils::SetBit(int64_t value, uint32_t index) {
+    return value |= 1ULL << index;
+}
+
+//! Clears a specific bit in a signed 64-bit integer
+int64_t GeneralUtils::ClearBit(int64_t value, uint32_t index) {
+    return value &= ~(1ULL << index);
+}
+
+//! Checks a specific bit in a signed 64-bit integer
+bool GeneralUtils::CheckBit(int64_t value, uint32_t index) {
+    return value & (1ULL << index);
+}
+
+bool GeneralUtils::ReplaceInString(std::string& str, const std::string& from, const std::string& to) {
+    size_t start_pos = str.find(from);
+    if(start_pos == std::string::npos)
+        return false;
+    str.replace(start_pos, from.length(), to);
+    return true;
+}
+
+std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t delimiter)
+{
+    std::vector<std::wstring> vector = std::vector<std::wstring>();
+    std::wstring current;
+
+    for (const auto& c : str) {
+        if (c == delimiter) {
+            vector.push_back(current);
+            current = L"";
+        } else {
+            current += c;
+        }
+    }
+
+    vector.push_back(current);
+    return vector;
+}
+
+std::vector<std::u16string> GeneralUtils::SplitString(std::u16string& str, char16_t delimiter)
+{
+    std::vector<std::u16string> vector = std::vector<std::u16string>();
+    std::u16string current;
+
+    for (const auto& c : str) {
+        if (c == delimiter) {
+            vector.push_back(current);
+            current = u"";
+        } else {
+            current += c;
+        }
+    }
+
+    vector.push_back(current);
+    return vector;
+}
+
+std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char delimiter)
+{
+	std::vector<std::string> vector = std::vector<std::string>();
+	std::string current = "";
+
+	for (size_t i = 0; i < str.length(); i++)
+	{
+		char c = str[i];
+
+		if (c == delimiter)
+		{
+			vector.push_back(current);
+			current = "";
+		}
+		else
+		{
+			current += c;
+		}
+	}
+
+	vector.push_back(current);
+
+	return vector;
+}
+
+std::u16string GeneralUtils::ReadWString(RakNet::BitStream *inStream) {
+    uint32_t length;
+    inStream->Read<uint32_t>(length);
+
+    std::u16string string;
+    for (auto i = 0; i < length; i++) {
+        uint16_t c;
+        inStream->Read(c);
+        string.push_back(c);
+    }
+
+    return string;
+}

dCommon/GeneralUtils.h

@@ -0,0 +1,210 @@
+#pragma once
+
+// C++
+#include <stdint.h>
+#include <random>
+#include <time.h>
+#include <string>
+#include <type_traits>
+#include <functional>
+#include <type_traits>
+#include <stdexcept>
+#include <BitStream.h>
+
+#include "Game.h"
+
+/*!
+  \file GeneralUtils.hpp
+  \brief A namespace containing general utility functions
+ */
+
+//! The general utils namespace
+namespace GeneralUtils {
+    //! Converts a plain ASCII string to a UTF-16 string
+    /*!
+      \param string The string to convert
+      \param size A size to trim the string to. Default is -1 (No trimming)
+      \return An UTF-16 representation of the string
+     */
+    std::u16string ASCIIToUTF16(const std::string& string, size_t size = -1);
+
+    //! Converts a UTF-16 string to a UTF-8 string
+    /*!
+      \param string The string to convert
+      \param size A size to trim the string to. Default is -1 (No trimming)
+      \return An UTF-8 representation of the string
+     */
+    std::string UTF16ToWTF8(const std::u16string& string, size_t size = -1);
+
+    /**
+     * Compares two basic strings but does so ignoring case sensitivity
+     * \param a the first string to compare against the second string
+     * \param b the second string to compare against the first string
+     * @return if the two strings are equal
+     */
+    bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b);
+
+    // MARK: Bits
+
+    // MARK: Bits
+
+    //! Sets a bit on a numerical value
+    template <typename T>
+    void SetBit(T& value, size_t index) {
+        static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
+        
+        if (index > (sizeof(T) * 8) - 1) {
+            return;
+        }
+        
+        value |= static_cast<T>(1) << index;
+    }
+    
+    //! Clears a bit on a numerical value
+    template <typename T>
+    void ClearBit(T& value, size_t index) {
+        static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
+        
+        if (index > (sizeof(T) * 8 - 1)) {
+            return;
+        }
+        
+        value &= ~(static_cast<T>(1) << index);
+    }
+    
+    //! Sets a specific bit in a signed 64-bit integer
+    /*!
+      \param value The value to set the bit for
+      \param index The index of the bit
+     */
+    int64_t SetBit(int64_t value, uint32_t index);
+    
+    //! Clears a specific bit in a signed 64-bit integer
+    /*!
+      \param value The value to clear the bit from
+      \param index The index of the bit
+     */
+    int64_t ClearBit(int64_t value, uint32_t index);
+    
+    //! Checks a specific bit in a signed 64-bit integer
+    /*!
+      \parma value The value to check the bit in
+      \param index The index of the bit
+      \return Whether or not the bit is set
+     */
+    bool CheckBit(int64_t value, uint32_t index);
+
+    // MARK: Random Number Generation
+
+    //! Generates a random number
+    /*!
+      \param min The minimum the generate from
+      \param max The maximum to generate to
+     */
+    template <typename T>
+    inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
+        // Make sure it is a numeric type
+        static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
+
+        if constexpr (std::is_integral_v<T>) {  // constexpr only necessary on first statement
+            std::uniform_int_distribution<T> distribution(min, max);
+            return distribution(Game::randomEngine);
+        }
+        else if (std::is_floating_point_v<T>) {
+            std::uniform_real_distribution<T> distribution(min, max);
+            return distribution(Game::randomEngine);
+        }
+
+        return T();
+    }
+    
+	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);
+
+    std::u16string ReadWString(RakNet::BitStream *inStream);
+
+	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::string> SplitString(const std::string& str, char delimiter);
+
+    template <typename T>
+    T Parse(const char* value);
+
+	template <>
+    inline int32_t Parse(const char* value)
+	{
+        return std::stoi(value);
+	}
+
+    template <>
+    inline int64_t Parse(const char* value)
+    {
+        return std::stoll(value);
+    }
+
+    template <>
+    inline float Parse(const char* value)
+    {
+        return std::stof(value);
+    }
+
+    template <>
+    inline double Parse(const char* value)
+    {
+        return std::stod(value);
+    }
+	
+    template <>
+    inline uint32_t Parse(const char* value)
+    {
+        return std::stoul(value);
+    }
+
+    template <>
+    inline uint64_t Parse(const char* value)
+    {
+        return std::stoull(value);
+    }
+	
+    template <typename T>
+    bool TryParse(const char* value, T& dst)
+    {
+        try
+        {
+            dst = Parse<T>(value);
+
+            return true;
+        }
+        catch (...)
+        {
+            return false;
+        }
+    }
+
+    template <typename T>
+    T Parse(const std::string& value)
+    {
+        return Parse<T>(value.c_str());
+    }
+
+    template <typename T>
+    bool TryParse(const std::string& value, T& dst)
+    {
+        return TryParse<T>(value.c_str(), dst);
+    }
+
+    template<typename T>
+    std::u16string to_u16string(T value)
+    {
+        return GeneralUtils::ASCIIToUTF16(std::to_string(value));
+    }
+
+    // From boost::hash_combine
+    template <class T>
+    void hash_combine(std::size_t& s, const T& v)
+    {
+        std::hash<T> h;
+        s ^= h(v) + 0x9e3779b9 + (s << 6) + (s >> 2);
+    }
+}

dCommon/LDFFormat.cpp

@@ -0,0 +1,134 @@
+#include "LDFFormat.h"
+
+// Custom Classes
+#include "GeneralUtils.h"
+
+// C++
+#include <sstream>
+#include <vector>
+
+//! Returns a pointer to a LDFData value based on string format
+LDFBaseData * LDFBaseData::DataFromString(const std::string& format) {
+    
+    // First, check the format
+    std::istringstream ssFormat(format);
+    std::string token;
+    
+    std::vector<std::string> keyValueArray;
+    while (std::getline(ssFormat, token, '=')) {
+        keyValueArray.push_back(token);
+    }
+    
+    if (keyValueArray.size() == 2) {
+        std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
+        
+        std::vector<std::string> dataArray;
+        std::istringstream ssData(keyValueArray[1]);
+        while (std::getline(ssData, token, ':')) {
+            dataArray.push_back(token);
+        }
+
+		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;
+		}
+        
+        if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
+            dataArray.push_back("");
+        }
+        
+        if (dataArray.size() == 2) {
+            eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
+            
+            switch (type) {
+                case LDF_TYPE_UTF_16: {
+                    std::u16string data = GeneralUtils::ASCIIToUTF16(dataArray[1]);
+                    return new LDFData<std::u16string>(key, data);
+                }
+                    
+                case LDF_TYPE_S32: {
+                    int32_t data = static_cast<int32_t>(stol(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: {
+                    return nullptr;
+                }
+            }
+        }
+    }
+    
+    return nullptr;
+    
+}

dCommon/LDFFormat.h

@@ -0,0 +1,253 @@
+#pragma once
+
+// Custom Classes
+#include "dCommonVars.h"
+#include "GeneralUtils.h"
+
+// C++
+#include <string>
+#include <sstream>
+
+// RakNet
+
+#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
+    LDF_TYPE_S32 = 1,               //!< Signed 32-bit data type
+    LDF_TYPE_FLOAT = 3,             //!< Float data type
+    LDF_TYPE_DOUBLE = 4,            //!< Double data type
+    LDF_TYPE_U32 = 5,               //!< Unsigned 32-bit data type
+    LDF_TYPE_BOOLEAN = 7,           //!< Boolean data type
+    LDF_TYPE_U64 = 8,               //!< Unsigned 64-bit data type (originally signed, templates won't work with both S64 & OBJID
+    LDF_TYPE_OBJID = 9,             //!< Signed 64-bit data type (reserved for object IDs)
+    LDF_TYPE_UTF_8 = 13,            //!< UTF-8 string data type
+};
+
+//! A base class for the LDF data
+class LDFBaseData {
+public:
+    
+    //! Destructor
+    virtual ~LDFBaseData(void) { }
+    
+    //! 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;
+    
+    //! Gets the value type
+    /*!
+      \return The value type
+     */
+    virtual eLDFType GetValueType(void) = 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
+     */
+    virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;
+    
+    virtual std::string GetValueAsString() = 0;
+
+    virtual LDFBaseData * Copy() = 0;
+    
+    // MARK: Functions
+    
+    //! Returns a pointer to a LDFData value based on string format
+    /*!
+      \param format The format
+     */
+    static LDFBaseData * DataFromString(const std::string& format);
+
+};
+
+//! A structure for an LDF key-value pair
+template<typename T>
+class LDFData : public LDFBaseData {
+private:
+    std::u16string key;
+    T value;
+    
+    //! Writes the key to the packet
+    void WriteKey(RakNet::BitStream * packet) {
+        packet->Write(static_cast<uint8_t>(this->key.length() * sizeof(uint16_t)));
+        for (uint32_t i = 0; i < this->key.length(); ++i) {
+            packet->Write(static_cast<uint16_t>(this->key[i]));
+        }
+    }
+    
+    //! Writes the value to the packet
+    void WriteValue(RakNet::BitStream * packet) {
+        packet->Write(static_cast<uint8_t>(this->GetValueType()));
+        packet->Write(this->value);
+    }
+
+public:
+    
+    //! Initializer
+    LDFData(const std::u16string& key, const T& value) {
+        this->key = key;
+        this->value = value;
+    }
+    
+    //! Destructor
+    ~LDFData(void) override { }
+    
+    //! Gets the value
+    /*!
+      \return The value
+     */
+    const T& GetValue(void) { return this->value; }
+    
+    //! Sets the value
+    /*!
+      \param value The value to set to
+     */
+    void SetValue(T value) { this->value = value; };
+
+    //! Gets the value string
+    /*!
+      \return The value string
+     */
+    std::string GetValueString(void) { return ""; }
+    
+    //! Writes the data to a packet
+    /*!
+      \param packet The packet
+     */
+    void WriteToPacket(RakNet::BitStream * packet) override {
+        this->WriteKey(packet);
+        this->WriteValue(packet);
+    }
+    
+    //! Gets the key
+    /*!
+     \return The key
+     */
+    const std::u16string& GetKey(void) override { return this->key; }
+    
+    //! Gets the LDF Type
+    /*!
+     \return The LDF value type
+     */
+    eLDFType GetValueType(void) override { return LDF_TYPE_UNKNOWN; }
+    
+    //! Gets the string data
+    /*!
+      \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
+     */
+    std::string GetString(const bool includeKey = true, const bool includeTypeId = true) override {
+        if (GetValueType() == -1) {
+            return GeneralUtils::UTF16ToWTF8(this->key) + "=-1:<server variable>";
+        }
+
+        std::stringstream stream;
+
+        if (includeKey) {
+            const std::string& sKey = GeneralUtils::UTF16ToWTF8(this->key, this->key.size());
+        	
+            stream << sKey << "=";
+        }
+
+    	if (includeTypeId) {
+	        const std::string& sType = std::to_string(this->GetValueType());
+
+    		
+            stream << sType << ":";
+    	}
+
+        const std::string& sData = this->GetValueString();
+    	
+        stream << sData;
+
+        return stream.str();
+    }
+    
+    std::string GetValueAsString() override {
+        return this->GetValueString();
+    }
+    
+    LDFBaseData * Copy() override {
+        return new LDFData<T>(key, value);
+    }
+    
+    inline static T Default = {};
+};
+
+// LDF Types
+template<> inline eLDFType LDFData<std::u16string>::GetValueType(void) { return LDF_TYPE_UTF_16; };
+template<> inline eLDFType LDFData<int32_t>::GetValueType(void) { return LDF_TYPE_S32; };
+template<> inline eLDFType LDFData<float>::GetValueType(void) { return LDF_TYPE_FLOAT; };
+template<> inline eLDFType LDFData<double>::GetValueType(void) { return LDF_TYPE_DOUBLE; };
+template<> inline eLDFType LDFData<uint32_t>::GetValueType(void) { return LDF_TYPE_U32; };
+template<> inline eLDFType LDFData<bool>::GetValueType(void) { return LDF_TYPE_BOOLEAN; };
+template<> inline eLDFType LDFData<uint64_t>::GetValueType(void) { return LDF_TYPE_U64; };
+template<> inline eLDFType LDFData<LWOOBJID>::GetValueType(void) { return LDF_TYPE_OBJID; };
+template<> inline eLDFType LDFData<std::string>::GetValueType(void) { return LDF_TYPE_UTF_8; };
+
+// The specialized version for std::u16string (UTF-16)
+template<>
+inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream * packet) {
+    packet->Write(static_cast<uint8_t>(this->GetValueType()));
+    
+    packet->Write(static_cast<uint32_t>(this->value.length()));
+    for (uint32_t i = 0; i < this->value.length(); ++i) {
+        packet->Write(static_cast<uint16_t>(this->value[i]));
+    }
+}
+
+// The specialized version for bool
+template<>
+inline void LDFData<bool>::WriteValue(RakNet::BitStream * packet) {
+    packet->Write(static_cast<uint8_t>(this->GetValueType()));
+    
+    packet->Write(static_cast<uint8_t>(this->value));
+}
+
+// The specialized version for std::string (UTF-8)
+template<>
+inline void LDFData<std::string>::WriteValue(RakNet::BitStream * packet) {
+    packet->Write(static_cast<uint8_t>(this->GetValueType()));
+    
+    packet->Write(static_cast<uint32_t>(this->value.length()));
+    for (uint32_t i = 0; i < this->value.length(); ++i) {
+        packet->Write(static_cast<uint8_t>(this->value[i]));
+    }
+}
+
+// MARK: String Data
+template<> inline std::string LDFData<std::u16string>::GetValueString(void) {
+    //std::string toReturn(this->value.begin(), this->value.end());
+    //return toReturn;
+
+	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<std::string>::GetValueString(void) { return this->value; }

dCommon/MD5.cpp

@@ -0,0 +1,362 @@
+/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+ 
+ based on:
+ 
+ md5.h and md5.c
+ reference implemantion of RFC 1321
+ 
+ Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+ rights reserved.
+ 
+ License to copy and use this software is granted provided that it
+ is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+ Algorithm" in all material mentioning or referencing this software
+ or this function.
+ 
+ License is also granted to make and use derivative works provided
+ that such works are identified as "derived from the RSA Data
+ Security, Inc. MD5 Message-Digest Algorithm" in all material
+ mentioning or referencing the derived work.
+ 
+ RSA Data Security, Inc. makes no representations concerning either
+ the merchantability of this software or the suitability of this
+ software for any particular purpose. It is provided "as is"
+ without express or implied warranty of any kind.
+ 
+ These notices must be retained in any copies of any part of this
+ documentation and/or software.
+ 
+ */
+
+/* interface header */
+#include "MD5.h"
+
+/* system implementation headers */
+#include <cstdio>
+
+
+// Constants for MD5Transform routine.
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+///////////////////////////////////////////////
+
+// F, G, H and I are basic MD5 functions.
+inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
+    return x&y | ~x&z;
+}
+
+inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
+    return x&z | y&~z;
+}
+
+inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
+    return x^y^z;
+}
+
+inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
+    return y ^ (x | ~z);
+}
+
+// rotate_left rotates x left n bits.
+inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
+    return (x << n) | (x >> (32 - n));
+}
+
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+    a = rotate_left(a + F(b, c, d) + x + ac, s) + b;
+}
+
+inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+    a = rotate_left(a + G(b, c, d) + x + ac, s) + b;
+}
+
+inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+    a = rotate_left(a + H(b, c, d) + x + ac, s) + b;
+}
+
+inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+    a = rotate_left(a + I(b, c, d) + x + ac, s) + b;
+}
+
+//////////////////////////////////////////////
+
+// default ctor, just initailize
+MD5::MD5()
+{
+    init();
+}
+
+//////////////////////////////////////////////
+
+// nifty shortcut ctor, compute MD5 for string and finalize it right away
+MD5::MD5(const std::string &text)
+{
+    init();
+    update(text.c_str(), text.length());
+    finalize();
+}
+
+//////////////////////////////
+
+void MD5::init()
+{
+    finalized = false;
+    
+    count[0] = 0;
+    count[1] = 0;
+    
+    // load magic initialization constants.
+    state[0] = 0x67452301;
+    state[1] = 0xefcdab89;
+    state[2] = 0x98badcfe;
+    state[3] = 0x10325476;
+}
+
+//////////////////////////////
+
+// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
+void MD5::decode(uint4 output[], const uint1 input[], size_type len)
+{
+    for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
+        output[i] = ((uint4)input[j]) | (((uint4)input[j + 1]) << 8) |
+        (((uint4)input[j + 2]) << 16) | (((uint4)input[j + 3]) << 24);
+}
+
+//////////////////////////////
+
+// encodes input (uint4) into output (unsigned char). Assumes len is
+// a multiple of 4.
+void MD5::encode(uint1 output[], const uint4 input[], size_type len)
+{
+    for (size_type i = 0, j = 0; j < len; i++, j += 4) {
+        output[j] = input[i] & 0xff;
+        output[j + 1] = (input[i] >> 8) & 0xff;
+        output[j + 2] = (input[i] >> 16) & 0xff;
+        output[j + 3] = (input[i] >> 24) & 0xff;
+    }
+}
+
+//////////////////////////////
+
+// apply MD5 algo on a block
+void MD5::transform(const uint1 block[blocksize])
+{
+    uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+    decode(x, block, blocksize);
+    
+    /* Round 1 */
+    FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
+    FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
+    FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
+    FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
+    FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
+    FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
+    FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
+    FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
+    FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
+    FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
+    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+    
+    /* Round 2 */
+    GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
+    GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
+    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
+    GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
+    GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
+    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
+    GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
+    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+    GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
+    GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
+    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+    GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
+    GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
+    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+    
+    /* Round 3 */
+    HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
+    HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
+    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+    HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
+    HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
+    HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
+    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+    HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
+    HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
+    HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
+    HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
+    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+    HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
+    
+    /* Round 4 */
+    II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
+    II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
+    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+    II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
+    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+    II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
+    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+    II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
+    II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
+    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+    II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
+    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+    II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
+    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+    II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
+    II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
+    
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+    
+    // Zeroize sensitive information.
+    memset(x, 0, sizeof x);
+}
+
+//////////////////////////////
+
+// MD5 block update operation. Continues an MD5 message-digest
+// operation, processing another message block
+void MD5::update(const unsigned char input[], size_type length)
+{
+    // compute number of bytes mod 64
+    size_type index = count[0] / 8 % blocksize;
+    
+    // Update number of bits
+    if ((count[0] += (length << 3)) < (length << 3))
+        count[1]++;
+    count[1] += (length >> 29);
+    
+    // number of bytes we need to fill in buffer
+    size_type firstpart = 64 - index;
+    
+    size_type i;
+    
+    // transform as many times as possible.
+    if (length >= firstpart)
+    {
+        // fill buffer first, transform
+        memcpy(&buffer[index], input, firstpart);
+        transform(buffer);
+        
+        // transform chunks of blocksize (64 bytes)
+        for (i = firstpart; i + blocksize <= length; i += blocksize)
+            transform(&input[i]);
+        
+        index = 0;
+    }
+    else
+        i = 0;
+    
+    // buffer remaining input
+    memcpy(&buffer[index], &input[i], length - i);
+}
+
+//////////////////////////////
+
+// for convenience provide a verson with signed char
+void MD5::update(const char input[], size_type length)
+{
+    update((const unsigned char*)input, length);
+}
+
+//////////////////////////////
+
+// MD5 finalization. Ends an MD5 message-digest operation, writing the
+// the message digest and zeroizing the context.
+MD5& MD5::finalize()
+{
+    static unsigned char padding[64] = {
+        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    
+    if (!finalized) {
+        // Save number of bits
+        unsigned char bits[8];
+        encode(bits, count, 8);
+        
+        // pad out to 56 mod 64.
+        size_type index = count[0] / 8 % 64;
+        size_type padLen = (index < 56) ? (56 - index) : (120 - index);
+        update(padding, padLen);
+        
+        // Append length (before padding)
+        update(bits, 8);
+        
+        // Store state in digest
+        encode(digest, state, 16);
+        
+        // Zeroize sensitive information.
+        memset(buffer, 0, sizeof buffer);
+        memset(count, 0, sizeof count);
+        
+        finalized = true;
+    }
+    
+    return *this;
+}
+
+//////////////////////////////
+
+// return hex representation of digest as string
+std::string MD5::hexdigest() const
+{
+    if (!finalized)
+        return "";
+    
+    char buf[33];
+    for (int i = 0; i<16; i++)
+        sprintf(buf + i * 2, "%02x", digest[i]);
+    buf[32] = 0;
+    
+    return std::string(buf);
+}
+
+//////////////////////////////
+
+std::ostream& operator<<(std::ostream& out, MD5 md5)
+{
+    return out << md5.hexdigest();
+}
+
+//////////////////////////////
+
+std::string md5(const std::string str)
+{
+    MD5 md5 = MD5(str);
+    
+    return md5.hexdigest();
+}

dCommon/MD5.h

@@ -0,0 +1,93 @@
+/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+ 
+ based on:
+ 
+ md5.h and md5.c
+ reference implementation of RFC 1321
+ 
+ Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+ rights reserved.
+ 
+ License to copy and use this software is granted provided that it
+ is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+ Algorithm" in all material mentioning or referencing this software
+ or this function.
+ 
+ License is also granted to make and use derivative works provided
+ that such works are identified as "derived from the RSA Data
+ Security, Inc. MD5 Message-Digest Algorithm" in all material
+ mentioning or referencing the derived work.
+ 
+ RSA Data Security, Inc. makes no representations concerning either
+ the merchantability of this software or the suitability of this
+ software for any particular purpose. It is provided "as is"
+ without express or implied warranty of any kind.
+ 
+ These notices must be retained in any copies of any part of this
+ documentation and/or software.
+ 
+ */
+
+#ifndef BZF_MD5_H
+#define BZF_MD5_H
+
+#include <cstring>
+#include <iostream>
+
+
+// a small class for calculating MD5 hashes of strings or byte arrays
+// it is not meant to be fast or secure
+//
+// usage: 1) feed it blocks of uchars with update()
+//      2) finalize()
+//      3) get hexdigest() string
+//      or
+//      MD5(std::string).hexdigest()
+//
+// assumes that char is 8 bit and int is 32 bit
+class MD5
+{
+public:
+    typedef unsigned int size_type; // must be 32bit
+    
+    MD5();
+    MD5(const std::string& text);
+    void update(const unsigned char *buf, size_type length);
+    void update(const char *buf, size_type length);
+    MD5& finalize();
+    std::string hexdigest() const;
+    friend std::ostream& operator<<(std::ostream&, MD5 md5);
+    
+private:
+    void init();
+    typedef unsigned char uint1; //  8bit
+    typedef unsigned int uint4;  // 32bit
+    enum { blocksize = 64 }; // VC6 won't eat a const static int here
+    
+    void transform(const uint1 block[blocksize]);
+    static void decode(uint4 output[], const uint1 input[], size_type len);
+    static void encode(uint1 output[], const uint4 input[], size_type len);
+    
+    bool finalized;
+    uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
+    uint4 count[2];   // 64bit counter for number of bits (lo, hi)
+    uint4 state[4];   // digest so far
+    uint1 digest[16]; // the result
+    
+    // low level logic operations
+    static inline uint4 F(uint4 x, uint4 y, uint4 z);
+    static inline uint4 G(uint4 x, uint4 y, uint4 z);
+    static inline uint4 H(uint4 x, uint4 y, uint4 z);
+    static inline uint4 I(uint4 x, uint4 y, uint4 z);
+    static inline uint4 rotate_left(uint4 x, int n);
+    static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+    static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+    static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+    static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+};
+
+std::string md5(const std::string str);
+
+#endif

dCommon/Metrics.cpp

@@ -0,0 +1,303 @@
+#include "Metrics.hpp"
+
+#include <chrono>
+
+std::unordered_map<MetricVariable, Metric*> Metrics::m_Metrics = {};
+std::vector<MetricVariable> Metrics::m_Variables = {
+    MetricVariable::GameLoop,
+    MetricVariable::PacketHandling,
+    MetricVariable::UpdateEntities,
+    MetricVariable::UpdateSpawners,
+    MetricVariable::Physics,
+    MetricVariable::UpdateReplica,
+    MetricVariable::Ghosting,
+    MetricVariable::CPUTime,
+    MetricVariable::Sleep,
+    MetricVariable::Frame,
+};
+
+void Metrics::AddMeasurement(MetricVariable variable, int64_t value) 
+{   
+    const auto& iter = m_Metrics.find(variable);
+
+    Metric* metric;
+
+    if (iter == m_Metrics.end())
+    {
+        metric = new Metric();
+
+        m_Metrics[variable] = metric;
+    }
+    else
+    {
+        metric = iter->second;
+    }
+
+    AddMeasurement(metric, value);
+}
+
+void Metrics::AddMeasurement(Metric* metric, int64_t value) 
+{
+    const auto index = metric->measurementIndex;
+
+    metric->measurements[index] = value;
+
+    if (metric->max == -1 || value > metric->max)
+    {
+        metric->max = value;
+    }
+    else if (metric->min == -1 || metric->min > value)
+    {
+        metric->min = value;
+    }
+
+    if (metric->measurementSize < MAX_MEASURMENT_POINTS)
+    {
+        metric->measurementSize++;
+    }
+
+    metric->measurementIndex = (index + 1) % MAX_MEASURMENT_POINTS;
+}
+
+const Metric* Metrics::GetMetric(MetricVariable variable)
+{
+    const auto& iter = m_Metrics.find(variable);
+
+    if (iter == m_Metrics.end())
+    {
+        return nullptr;
+    }
+
+    Metric* metric = iter->second;
+
+    int64_t average = 0;
+
+    for (size_t i = 0; i < metric->measurementSize; i++)
+    {
+        average += metric->measurements[i];
+    }
+
+    average /= metric->measurementSize;
+
+    metric->average = average;
+    
+    return metric;
+}
+
+void Metrics::StartMeasurement(MetricVariable variable) 
+{
+    const auto& iter = m_Metrics.find(variable);
+
+    Metric* metric;
+
+    if (iter == m_Metrics.end())
+    {
+        metric = new Metric();
+
+        m_Metrics[variable] = metric;
+    }
+    else
+    {
+        metric = iter->second;
+    }
+
+    metric->activeMeasurement = std::chrono::high_resolution_clock::now();
+}
+
+void Metrics::EndMeasurement(MetricVariable variable) 
+{
+    const auto end = std::chrono::high_resolution_clock::now();
+
+    const auto& iter = m_Metrics.find(variable);
+
+    if (iter == m_Metrics.end())
+    {
+        return;
+    }
+
+    Metric* metric = iter->second;
+
+    const auto elapsed = end - metric->activeMeasurement;
+
+    const auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
+
+    AddMeasurement(metric, nanoseconds);
+}
+
+float Metrics::ToMiliseconds(int64_t nanoseconds) 
+{
+    return (float) nanoseconds / 1e6;
+}
+
+std::string Metrics::MetricVariableToString(MetricVariable variable) 
+{
+    switch (variable)
+    {
+    case MetricVariable::GameLoop:
+        return "GameLoop";
+    case MetricVariable::PacketHandling:
+        return "PacketHandling";
+    case MetricVariable::UpdateEntities:
+        return "UpdateEntities";
+    case MetricVariable::UpdateSpawners:
+        return "UpdateSpawners";
+    case MetricVariable::Physics:
+        return "Physics";
+    case MetricVariable::UpdateReplica:
+        return "UpdateReplica";
+    case MetricVariable::Sleep:
+        return "Sleep";
+    case MetricVariable::CPUTime:
+        return "CPUTime";
+    case MetricVariable::Frame:
+        return "Frame";
+    case MetricVariable::Ghosting:
+        return "Ghosting";
+    
+    default:
+        return "Invalid";
+    }
+}
+
+const std::vector<MetricVariable>& Metrics::GetAllMetrics() 
+{
+    return m_Variables;
+}
+
+void Metrics::Clear() 
+{
+    for (const auto& pair : m_Metrics)
+    {
+        delete pair.second;
+    }
+    
+    m_Metrics.clear();
+}
+
+/* RSS Memory utilities
+ *
+ * Author:  David Robert Nadeau
+ * Site:    http://NadeauSoftware.com/
+ * License: Creative Commons Attribution 3.0 Unported License
+ *          http://creativecommons.org/licenses/by/3.0/deed.en_US
+ */
+
+
+#if defined(_WIN32)
+#include <windows.h>
+#include <psapi.h>
+
+#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
+#include <unistd.h>
+#include <sys/resource.h>
+
+#if defined(__APPLE__) && defined(__MACH__)
+#include <mach/mach.h>
+
+#elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
+#include <fcntl.h>
+#include <procfs.h>
+
+#elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
+#include <stdio.h>
+
+#endif
+
+#else
+#error "Cannot define getPeakRSS( ) or getCurrentRSS( ) for an unknown OS."
+#endif
+
+/**
+ * Returns the peak (maximum so far) resident set size (physical
+ * memory use) measured in bytes, or zero if the value cannot be
+ * determined on this OS.
+ */
+size_t Metrics::GetPeakRSS()
+{
+#if defined(_WIN32)
+    /* Windows -------------------------------------------------- */
+    PROCESS_MEMORY_COUNTERS info;
+    GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
+    return (size_t)info.PeakWorkingSetSize;
+
+#elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
+    /* AIX and Solaris ------------------------------------------ */
+    struct psinfo psinfo;
+    int fd = -1;
+    if ( (fd = open( "/proc/self/psinfo", O_RDONLY )) == -1 )
+        return (size_t)0L;      /* Can't open? */
+    if ( read( fd, &psinfo, sizeof(psinfo) ) != sizeof(psinfo) )
+    {
+        close( fd );
+        return (size_t)0L;      /* Can't read? */
+    }
+    close( fd );
+    return (size_t)(psinfo.pr_rssize * 1024L);
+
+#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
+    /* BSD, Linux, and OSX -------------------------------------- */
+    struct rusage rusage;
+    getrusage( RUSAGE_SELF, &rusage );
+#if defined(__APPLE__) && defined(__MACH__)
+    return (size_t)rusage.ru_maxrss;
+#else
+    return (size_t)(rusage.ru_maxrss * 1024L);
+#endif
+
+#else
+    /* Unknown OS ----------------------------------------------- */
+    return (size_t)0L;          /* Unsupported. */
+#endif
+
+}
+
+/**
+ * Returns the current resident set size (physical memory use) measured
+ * in bytes, or zero if the value cannot be determined on this OS.
+ */
+size_t Metrics::GetCurrentRSS()
+{
+#if defined(_WIN32)
+    /* Windows -------------------------------------------------- */
+    PROCESS_MEMORY_COUNTERS info;
+    GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
+    return (size_t)info.WorkingSetSize;
+
+#elif defined(__APPLE__) && defined(__MACH__)
+    /* OSX ------------------------------------------------------ */
+    struct mach_task_basic_info info;
+    mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
+    if ( task_info( mach_task_self( ), MACH_TASK_BASIC_INFO,
+        (task_info_t)&info, &infoCount ) != KERN_SUCCESS )
+        return (size_t)0L;      /* Can't access? */
+    return (size_t)info.resident_size;
+
+#elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
+    /* Linux ---------------------------------------------------- */
+    long rss = 0L;
+    FILE* fp = NULL;
+    if ( (fp = fopen( "/proc/self/statm", "r" )) == NULL )
+        return (size_t)0L;      /* Can't open? */
+    if ( fscanf( fp, "%*s%ld", &rss ) != 1 )
+    {
+        fclose( fp );
+        return (size_t)0L;      /* Can't read? */
+    }
+    fclose( fp );
+    return (size_t)rss * (size_t)sysconf( _SC_PAGESIZE);
+
+#else
+    /* AIX, BSD, Solaris, and Unknown OS ------------------------ */
+    return (size_t)0L;          /* Unsupported. */
+#endif
+
+}
+
+size_t Metrics::GetProcessID() 
+{
+#if defined(_WIN32)
+    return GetCurrentProcessId();
+#else
+    return getpid();
+#endif
+}

dCommon/Metrics.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "dCommonVars.h"
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <chrono>
+
+#define MAX_MEASURMENT_POINTS 1024
+
+enum class MetricVariable : int32_t
+{
+    GameLoop,
+    PacketHandling,
+    UpdateEntities,
+    UpdateSpawners,
+    Physics,
+    UpdateReplica,
+    Ghosting,
+    CPUTime,
+    Sleep,
+    Frame,
+};
+
+struct Metric
+{
+    int64_t measurements[MAX_MEASURMENT_POINTS] = {};
+    size_t measurementIndex = 0;
+    size_t measurementSize = 0;
+    int64_t max = -1;
+    int64_t min = -1;
+    int64_t average = 0;
+    std::chrono::time_point<std::chrono::high_resolution_clock> activeMeasurement;
+};
+
+class Metrics
+{
+public:
+    ~Metrics();
+
+    static void AddMeasurement(MetricVariable variable, int64_t value);
+    static void AddMeasurement(Metric* metric, int64_t value);
+    static const Metric* GetMetric(MetricVariable variable);
+    static void StartMeasurement(MetricVariable variable);
+    static void EndMeasurement(MetricVariable variable);
+    static float ToMiliseconds(int64_t nanoseconds);
+    static std::string MetricVariableToString(MetricVariable variable);
+    static const std::vector<MetricVariable>& GetAllMetrics();
+
+    static size_t GetPeakRSS();
+    static size_t GetCurrentRSS();
+    static size_t GetProcessID();
+
+    static void Clear();
+
+private:
+    Metrics();
+
+    static std::unordered_map<MetricVariable, Metric*> m_Metrics;
+    static std::vector<MetricVariable> m_Variables;
+};

dCommon/NiPoint3.cpp

@@ -0,0 +1,261 @@
+#include "NiPoint3.h"
+#include "NiQuaternion.h"
+
+// C++
+#include <cmath>
+
+// Static Variables
+const NiPoint3 NiPoint3::ZERO(0.0f, 0.0f, 0.0f);
+const NiPoint3 NiPoint3::UNIT_X(1.0f, 0.0f, 0.0f);
+const NiPoint3 NiPoint3::UNIT_Y(0.0f, 1.0f, 0.0f);
+const NiPoint3 NiPoint3::UNIT_Z(0.0f, 0.0f, 1.0f);
+const NiPoint3 NiPoint3::UNIT_ALL(1.0f, 1.0f, 1.0f);
+
+//! Initializer
+NiPoint3::NiPoint3(void) {
+    this->x = 0;
+    this->y = 0;
+    this->z = 0;
+}
+
+//! Initializer
+NiPoint3::NiPoint3(float x, float y, float z) {
+    this->x = x;
+    this->y = y;
+    this->z = z;
+}
+
+//! Copy Constructor
+NiPoint3::NiPoint3(const NiPoint3& point) {
+    this->x = point.x;
+    this->y = point.y;
+    this->z = point.z;
+}
+
+//! Destructor
+NiPoint3::~NiPoint3(void) {}
+
+// MARK: Getters / Setters
+
+//! Gets the X coordinate
+float NiPoint3::GetX(void) const {
+    return this->x;
+}
+
+//! Sets the X coordinate
+void NiPoint3::SetX(float x) {
+    this->x = x;
+}
+
+//! Gets the Y coordinate
+float NiPoint3::GetY(void) const {
+    return this->y;
+}
+
+//! Sets the Y coordinate
+void NiPoint3::SetY(float y) {
+    this->y = y;
+}
+
+//! Gets the Z coordinate
+float NiPoint3::GetZ(void) const {
+    return this->z;
+}
+
+//! Sets the Z coordinate
+void NiPoint3::SetZ(float z) {
+    this->z = z;
+}
+
+// MARK: Functions
+
+//! Gets the length of the vector
+float NiPoint3::Length(void) const {
+    return sqrt(x*x + y*y + z*z);
+}
+
+//! Gets the squared length of a vector
+float NiPoint3::SquaredLength(void) const {
+    return (x*x + y*y + z*z);
+}
+
+//! Returns the dot product of the vector dotted with another vector
+float NiPoint3::DotProduct(const Vector3& vec) const {
+    return ((this->x * vec.x) + (this->y * vec.y) + (this->z * vec.z));
+}
+
+//! Returns the cross product of the vector crossed with another vector
+Vector3 NiPoint3::CrossProduct(const Vector3& vec) const {
+    return Vector3(((this->y * vec.z) - (this->z * vec.y)),
+                   ((this->z * vec.x) - (this->x * vec.z)),
+                   ((this->x * vec.y) - (this->y * vec.x)));
+}
+
+//! Unitize the vector
+NiPoint3 NiPoint3::Unitize(void) const {
+    NiPoint3 unitVec;
+    float length = this->Length();
+
+    unitVec.x = length != 0 ? this->x / length : 0;
+    unitVec.y = length != 0 ? this->y / length : 0;
+    unitVec.z = length != 0 ? this->z / length : 0;
+
+    return unitVec;
+}
+
+
+// MARK: Operators
+
+//! Operator to check for equality
+bool NiPoint3::operator==(const NiPoint3& point) const {
+    return point.x == this->x && point.y == this->y && point.z == this->z;
+}
+
+//! Operator to check for inequality
+bool NiPoint3::operator!=(const NiPoint3& point) const {
+    return !(*this == point);
+}
+
+//! Operator for subscripting
+float& NiPoint3::operator[](int i) {
+    float * base = &x;
+    return (float&)base[i];
+}
+
+//! Operator for subscripting
+const float& NiPoint3::operator[](int i) const {
+    const float * base = &x;
+    return (float&)base[i];
+}
+
+//! 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);
+}
+
+//! Operator for addition of a scalar on all vector components
+NiPoint3 NiPoint3::operator+(float fScalar) const {
+    return NiPoint3(this->x + fScalar, this->y + fScalar, this->z + fScalar);
+}
+
+//! Operator for subtraction of a scalar on all vector components
+NiPoint3 NiPoint3::operator-(float fScalar) const {
+    return NiPoint3(this->x - fScalar, this->y - fScalar, this->z - fScalar);
+}
+
+//! Operator for scalar multiplication of a vector
+NiPoint3 NiPoint3::operator*(float fScalar) const {
+    return NiPoint3(this->x * fScalar, this->y * fScalar, this->z * fScalar);
+}
+
+//! Operator for scalar division of a vector
+NiPoint3 NiPoint3::operator/(float fScalar) const {
+    float retX = this->x != 0 ? this->x / fScalar : 0;
+    float retY = this->y != 0 ? this->y / fScalar : 0;
+    float retZ = this->z != 0 ? this->z / fScalar : 0;
+    return NiPoint3(retX, retY, retZ);
+}
+
+
+// MARK: Helper Functions
+
+//! Checks to see if the point (or vector) is with an Axis-Aligned Bounding Box
+bool NiPoint3::IsWithinAxisAlignedBox(const NiPoint3& minPoint, const NiPoint3& maxPoint) {
+    if (this->x < minPoint.x) return false;
+    if (this->x > maxPoint.x) return false;
+    if (this->y < minPoint.y) return false;
+    if (this->y > maxPoint.y) return false;
+
+    return (this->z < maxPoint.z && this->z > minPoint.z);
+}
+
+//! Checks to see if the point (or vector) is within a sphere
+bool NiPoint3::IsWithinSpehere(const NiPoint3& sphereCenter, float radius) {
+    Vector3 diffVec = Vector3(x - sphereCenter.GetX(), y - sphereCenter.GetY(), z - sphereCenter.GetZ());
+    return (diffVec.SquaredLength() <= (radius * radius));
+}
+
+NiPoint3 NiPoint3::ClosestPointOnLine(const NiPoint3& a, const NiPoint3& b, const NiPoint3& p) 
+{
+    if (a == b) return a;
+
+    const auto pa = p - a;
+    const auto ab = b - a;
+
+    const auto t = pa.DotProduct(ab) / ab.SquaredLength();
+
+    if (t <= 0.0f) return a;
+    
+    if (t >= 1.0f) return b;
+    
+    return a + ab * t;
+}
+
+float NiPoint3::Angle(const NiPoint3& a, const NiPoint3& b)
+{
+    const auto dot = a.DotProduct(b);
+    const auto lenA = a.SquaredLength();
+    const auto lenB = a.SquaredLength();
+    return acos(dot / sqrt(lenA * lenB));
+}
+
+float NiPoint3::Distance(const NiPoint3& a, const NiPoint3& b)
+{
+    const auto dx = a.x - b.x;
+    const auto dy = a.y - b.y;
+    const auto dz = a.z - b.z;
+
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+float NiPoint3::DistanceSquared(const NiPoint3& a, const NiPoint3& b)
+{
+    const auto dx = a.x - b.x;
+    const auto dy = a.y - b.y;
+    const auto dz = a.z - b.z;
+
+    return dx * dx + dy * dy + dz * dz;
+}
+
+NiPoint3 NiPoint3::MoveTowards(const NiPoint3& current, const NiPoint3& target, float maxDistanceDelta) 
+{
+    float dx = target.x - current.x;
+    float dy = target.y - current.y;
+    float dz = target.z - current.z;
+    float lengthSquared = (float) ((double) dx * (double) dx + (double) dy * (double) dy + (double) dz * (double) dz);
+    if ((double) lengthSquared == 0.0 || (double) maxDistanceDelta >= 0.0 && (double) lengthSquared <= (double) maxDistanceDelta * (double) maxDistanceDelta)
+        return target;
+    float length = (float) std::sqrt((double) lengthSquared);
+    return NiPoint3(current.x + dx / length * maxDistanceDelta, current.y + dy / length * maxDistanceDelta, current.z + dz / length * maxDistanceDelta);
+}
+
+//This code is yoinked from the MS XNA code, so it should be right, even if it's horrible.
+NiPoint3 NiPoint3::RotateByQuaternion(const NiQuaternion& rotation) {
+    Vector3 vector;
+    float num12 = rotation.x + rotation.x;
+    float num2 = rotation.y + rotation.y;
+    float num = rotation.z + rotation.z;
+    float num11 = rotation.w * num12;
+    float num10 = rotation.w * num2;
+    float num9 = rotation.w * num;
+    float num8 = rotation.x * num12;
+    float num7 = rotation.x * num2;
+    float num6 = rotation.x * num;
+    float num5 = rotation.y * num2;
+    float num4 = rotation.y * num;
+    float num3 = rotation.z * num;
+
+    NiPoint3 value = *this;
+    float num15 = ((value.x * ((1.0f - num5) - num3)) + (value.y * (num7 - num9))) + (value.z * (num6 + num10));
+    float num14 = ((value.x * (num7 + num9)) + (value.y * ((1.0f - num8) - num3))) + (value.z * (num4 - num11));
+    float num13 = ((value.x * (num6 - num10)) + (value.y * (num4 + num11))) + (value.z * ((1.0f - num8) - num5));
+    vector.x = num15;
+    vector.y = num14;
+    vector.z = num13;
+    return vector;
+}

dCommon/NiPoint3.h

@@ -0,0 +1,188 @@
+#pragma once
+
+/*!
+  \file NiPoint3.hpp
+  \brief Defines a point in space in XYZ coordinates
+ */
+
+class NiPoint3;
+class NiQuaternion;
+typedef NiPoint3 Vector3;       //!< The Vector3 class is technically the NiPoint3 class, but typedef'd for clarity in some cases
+
+//! A custom class the defines a point in space
+class NiPoint3 {
+public:
+    float x;            //!< The x position
+    float y;            //!< The y position
+    float z;            //!< The z position
+
+
+    //! Initializer
+    NiPoint3(void);
+
+    //! Initializer
+    /*!
+      \param x The x coordinate
+      \param y The y coordinate
+      \param z The z coordinate
+     */
+    NiPoint3(float x, float y, float z);
+
+    //! Copy Constructor
+    /*!
+      \param point The point to copy
+     */
+    NiPoint3(const NiPoint3& point);
+
+    //! Destructor
+    ~NiPoint3(void);
+
+    // MARK: Constants
+    static const NiPoint3 ZERO;         //!< Point(0, 0, 0)
+    static const NiPoint3 UNIT_X;       //!< Point(1, 0, 0)
+    static const NiPoint3 UNIT_Y;       //!< Point(0, 1, 0)
+    static const NiPoint3 UNIT_Z;       //!< Point(0, 0, 1)
+    static const NiPoint3 UNIT_ALL;     //!< Point(1, 1, 1)
+
+    // MARK: Getters / Setters
+
+    //! Gets the X coordinate
+    /*!
+      \return The x coordinate
+     */
+    float GetX(void) const;
+
+    //! Sets the X coordinate
+    /*!
+      \param x The x coordinate
+     */
+    void SetX(float x);
+
+    //! Gets the Y coordinate
+    /*!
+      \return The y coordinate
+     */
+    float GetY(void) const;
+
+    //! Sets the Y coordinate
+    /*!
+      \param y The y coordinate
+     */
+    void SetY(float y);
+
+    //! Gets the Z coordinate
+    /*!
+      \return The z coordinate
+     */
+    float GetZ(void) const;
+
+    //! Sets the Z coordinate
+    /*!
+      \param z The z coordinate
+     */
+    void SetZ(float z);
+
+
+    // MARK: Member Functions
+
+    //! Gets the length of the vector
+    /*!
+      \return The scalar length of the vector
+     */
+    float Length(void) const;
+
+    //! Gets the squared length of a vector
+    /*!
+      \return The squared length of a vector
+     */
+    float SquaredLength(void) const;
+
+    //! Returns the dot product of the vector dotted with another vector
+    /*!
+      \param vec The second vector
+      \return The dot product of the two vectors
+     */
+    float DotProduct(const Vector3& vec) const;
+
+    //! Returns the cross product of the vector crossed with another vector
+    /*!
+      \param vec The second vector
+      \return The cross product of the two vectors
+     */
+    Vector3 CrossProduct(const Vector3& vec) const;
+
+    //! Unitize the vector
+    /*!
+      \returns The current vector
+     */
+    NiPoint3 Unitize(void) const;
+
+
+    // MARK: Operators
+
+    //! Operator to check for equality
+    bool operator==(const NiPoint3& point) const;
+
+    //! Operator to check for inequality
+    bool operator!=(const NiPoint3& point) const;
+
+    //! Operator for subscripting
+    float& operator[](int i);
+
+    //! Operator for subscripting
+    const float& operator[](int i) const;
+
+    //! Operator for addition of vectors
+    NiPoint3 operator+(const NiPoint3& point) const;
+
+    //! Operator for subtraction of vectors
+    NiPoint3 operator-(const NiPoint3& point) const;
+
+    //! Operator for addition of a scalar on all vector components
+    NiPoint3 operator+(float fScalar) const;
+
+    //! Operator for subtraction of a scalar on all vector components
+    NiPoint3 operator-(float fScalar) const;
+
+    //! Operator for scalar multiplication of a vector
+    NiPoint3 operator*(float fScalar) const;
+
+    //! Operator for scalar division of a vector
+    NiPoint3 operator/(float fScalar) const;
+
+
+    // MARK: Helper Functions
+
+    //! Checks to see if the point (or vector) is with an Axis-Aligned Bounding Box
+    /*!
+      \param minPoint The minimum point of the bounding box
+      \param maxPoint The maximum point of the bounding box
+      \return Whether or not this point lies within the box
+     */
+    bool IsWithinAxisAlignedBox(const NiPoint3& minPoint, const NiPoint3& maxPoint);
+
+    //! Checks to see if the point (or vector) is within a sphere
+    /*!
+      \param sphereCenter The sphere center
+      \param radius The radius
+     */
+    bool IsWithinSpehere(const NiPoint3& sphereCenter, float radius);
+
+    /*!
+      \param a Start of line
+      \param b End of line
+      \param p Refrence point
+      \return The point of line AB which is closest to P
+    */
+    static NiPoint3 ClosestPointOnLine(const NiPoint3& a, const NiPoint3& b, const NiPoint3& p);
+
+	  static float Angle(const NiPoint3& a, const NiPoint3& b);
+
+    static float Distance(const NiPoint3& a, const NiPoint3& b);
+    
+    static float DistanceSquared(const NiPoint3& a, const NiPoint3& b);
+
+    static NiPoint3 MoveTowards(const NiPoint3& current, const NiPoint3& target, float maxDistanceDelta);
+
+    NiPoint3 RotateByQuaternion(const NiQuaternion& rotation);
+};

dCommon/NiQuaternion.cpp

@@ -0,0 +1,199 @@
+#include "NiQuaternion.h"
+
+// C++
+#include <cmath>
+
+// Static Variables
+const NiQuaternion NiQuaternion::IDENTITY(1, 0, 0, 0);
+
+//! The initializer
+NiQuaternion::NiQuaternion(void) {
+    this->w = 1;
+    this->x = 0;
+    this->y = 0;
+    this->z = 0;
+}
+
+//! The initializer
+NiQuaternion::NiQuaternion(float w, float x, float y, float z) {
+    this->w = w;
+    this->x = x;
+    this->y = y;
+    this->z = z;
+}
+
+//! Destructor
+NiQuaternion::~NiQuaternion(void) {}
+
+
+// MARK: Setters / Getters
+
+//! Gets the W coordinate
+float NiQuaternion::GetW(void) const {
+    return this->w;
+}
+
+//! Sets the W coordinate
+void NiQuaternion::SetW(float w) {
+    this->w = w;
+}
+
+//! Gets the X coordinate
+float NiQuaternion::GetX(void) const {
+    return this->x;
+}
+
+//! Sets the X coordinate
+void NiQuaternion::SetX(float x) {
+    this->x = x;
+}
+
+//! Gets the Y coordinate
+float NiQuaternion::GetY(void) const {
+    return this->y;
+}
+
+//! Sets the Y coordinate
+void NiQuaternion::SetY(float y) {
+    this->y = y;
+}
+
+//! Gets the Z coordinate
+float NiQuaternion::GetZ(void) const {
+    return this->z;
+}
+
+//! Sets the Z coordinate
+void NiQuaternion::SetZ(float z) {
+    this->z = z;
+}
+
+
+// MARK: Member Functions
+
+//! Returns the forward vector from the quaternion
+Vector3 NiQuaternion::GetForwardVector(void) const {
+    return Vector3(2 * (x * z + w * y), 2 * (y * z - w * x), 1 - 2 * (x * x + y * y));
+}
+
+//! Returns the up vector from the quaternion
+Vector3 NiQuaternion::GetUpVector(void) const {
+    return Vector3(2 * (x * y - w * z), 1 - 2 * (x * x + z * z), 2 * (y * z + w * x));
+}
+
+//! Returns the right vector from the quaternion
+Vector3 NiQuaternion::GetRightVector(void) const {
+    return Vector3(1 - 2 * (y * y + z * z), 2 * (x * y + w * z), 2 * (x * z - w * y));
+}
+
+Vector3 NiQuaternion::GetEulerAngles() const {
+    Vector3 angles;
+
+    // roll (x-axis rotation)
+    const float sinr_cosp = 2 * (w * x + y * z);
+    const float cosr_cosp = 1 - 2 * (x * x + y * y);
+    angles.x = std::atan2(sinr_cosp, cosr_cosp);
+
+    // pitch (y-axis rotation)
+    const float sinp = 2 * (w * y - z * x);
+	
+    if (std::abs(sinp) >= 1) {
+        angles.y = std::copysign(3.14 / 2, sinp); // use 90 degrees if out of range
+    }
+    else {
+        angles.y = std::asin(sinp);
+    }
+
+    // yaw (z-axis rotation)
+    const float siny_cosp = 2 * (w * z + x * y);
+    const float cosy_cosp = 1 - 2 * (y * y + z * z);
+    angles.z = std::atan2(siny_cosp, cosy_cosp);
+
+    return angles;
+}
+
+// MARK: Operators
+
+//! Operator to check for equality
+bool NiQuaternion::operator==(const NiQuaternion& rot) const {
+    return rot.x == this->x && rot.y == this->y && rot.z == this->z && rot.w == this->w;
+}
+
+//! Operator to check for inequality
+bool NiQuaternion::operator!=(const NiQuaternion& rot) const {
+    return !(*this == rot);
+}
+
+
+// MARK: Helper Functions
+
+//! Look from a specific point in space to another point in space
+NiQuaternion NiQuaternion::LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint) {
+	//To make sure we don't orient around the X/Z axis:
+	NiPoint3 source = sourcePoint;
+	NiPoint3 dest = destPoint;
+	source.y = 0.0f;
+	dest.y = 0.0f;
+
+    NiPoint3 forwardVector = NiPoint3(dest - source).Unitize();
+    
+    NiPoint3 posZ = NiPoint3::UNIT_Z;
+    NiPoint3 vecA = posZ.CrossProduct(forwardVector).Unitize();
+    
+    float dot = posZ.DotProduct(forwardVector);
+    float rotAngle = static_cast<float>(acos(dot));
+    
+    NiPoint3 vecB = vecA.CrossProduct(posZ);
+    
+    if (vecB.DotProduct(forwardVector) < 0) rotAngle = -rotAngle;
+    return NiQuaternion::CreateFromAxisAngle(vecA, rotAngle);
+}
+
+NiQuaternion NiQuaternion::LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint) 
+{
+    NiPoint3 forwardVector = NiPoint3(destPoint - sourcePoint).Unitize();
+    
+    NiPoint3 posZ = NiPoint3::UNIT_Z;
+    NiPoint3 vecA = posZ.CrossProduct(forwardVector).Unitize();
+    
+    float dot = posZ.DotProduct(forwardVector);
+    float rotAngle = static_cast<float>(acos(dot));
+    
+    NiPoint3 vecB = vecA.CrossProduct(posZ);
+    
+    if (vecB.DotProduct(forwardVector) < 0) rotAngle = -rotAngle;
+    return NiQuaternion::CreateFromAxisAngle(vecA, rotAngle);
+}
+
+//! Creates a Quaternion from a specific axis and angle relative to that axis
+NiQuaternion NiQuaternion::CreateFromAxisAngle(const Vector3& axis, float angle) {
+    float halfAngle = angle * 0.5f;
+    float s = static_cast<float>(sin(halfAngle));
+    
+    NiQuaternion q;
+    q.x = axis.GetX() * s;
+    q.y = axis.GetY() * s;
+    q.z = axis.GetZ() * s;
+    q.w = static_cast<float>(cos(halfAngle));
+    
+    return q;
+}
+
+NiQuaternion NiQuaternion::FromEulerAngles(const NiPoint3& eulerAngles) 
+{
+    // Abbreviations for the various angular functions
+    float cy = cos(eulerAngles.z * 0.5);
+    float sy = sin(eulerAngles.z * 0.5);
+    float cp = cos(eulerAngles.y * 0.5);
+    float sp = sin(eulerAngles.y * 0.5);
+    float cr = cos(eulerAngles.x * 0.5);
+    float sr = sin(eulerAngles.x * 0.5);
+
+    NiQuaternion q;
+    q.w = cr * cp * cy + sr * sp * sy;
+    q.x = sr * cp * cy - cr * sp * sy;
+    q.y = cr * sp * cy + sr * cp * sy;
+    q.z = cr * cp * sy - sr * sp * cy;
+
+    return q;
+}

dCommon/NiQuaternion.h

@@ -0,0 +1,151 @@
+#pragma once
+
+// Custom Classes
+#include "NiPoint3.h"
+
+/*!
+  \file NiQuaternion.hpp
+  \brief Defines a quaternion in space in WXYZ coordinates
+ */
+
+class NiQuaternion;
+typedef NiQuaternion Quaternion;        //!< A typedef for a shorthand version of NiQuaternion
+
+//! A class that defines a rotation in space
+class NiQuaternion {
+public:
+    float w;            //!< The w coordinate
+    float x;            //!< The x coordinate
+    float y;            //!< The y coordinate
+    float z;            //!< The z coordinate
+    
+    
+    //! The initializer
+    NiQuaternion(void);
+    
+    //! The initializer
+    /*!
+      \param w The w coordinate
+      \param x The x coordinate
+      \param y The y coordinate
+      \param z The z coordinate
+     */
+    NiQuaternion(float w, float x, float y, float z);
+    
+    //! Destructor
+    ~NiQuaternion(void);
+    
+    // MARK: Constants
+    static const NiQuaternion IDENTITY;         //!< Quaternion(1, 0, 0, 0)
+    
+    // MARK: Setters / Getters
+    
+    //! Gets the W coordinate
+    /*!
+      \return The w coordinate
+     */
+    float GetW(void) const;
+    
+    //! Sets the W coordinate
+    /*!
+      \param w The w coordinate
+     */
+    void SetW(float w);
+    
+    //! Gets the X coordinate
+    /*!
+      \return The x coordinate
+     */
+    float GetX(void) const;
+    
+    //! Sets the X coordinate
+    /*!
+      \param x The x coordinate
+     */
+    void SetX(float x);
+    
+    //! Gets the Y coordinate
+    /*!
+      \return The y coordinate
+     */
+    float GetY(void) const;
+    
+    //! Sets the Y coordinate
+    /*!
+      \param y The y coordinate
+     */
+    void SetY(float y);
+    
+    //! Gets the Z coordinate
+    /*!
+      \return The z coordinate
+     */
+    float GetZ(void) const;
+    
+    //! Sets the Z coordinate
+    /*!
+      \param z The z coordinate
+     */
+    void SetZ(float z);
+    
+    
+    // MARK: Member Functions
+    
+    //! Returns the forward vector from the quaternion
+    /*!
+      \return The forward vector of the quaternion
+     */
+    Vector3 GetForwardVector(void) const;
+    
+    //! Returns the up vector from the quaternion
+    /*!
+      \return The up vector fo the quaternion
+     */
+    Vector3 GetUpVector(void) const;
+    
+    //! Returns the right vector from the quaternion
+    /*!
+      \return The right vector of the quaternion
+     */
+    Vector3 GetRightVector(void) const;
+
+    Vector3 GetEulerAngles() const;
+    
+    
+    // MARK: Operators
+    
+    //! Operator to check for equality
+    bool operator==(const NiQuaternion& rot) const;
+    
+    //! Operator to check for inequality
+    bool operator!=(const NiQuaternion& rot) const;
+    
+    
+    // MARK: Helper Functions
+    
+    //! Look from a specific point in space to another point in space (Y-locked)
+    /*!
+      \param sourcePoint The source location
+      \param destPoint The destination location
+      \return The Quaternion with the rotation towards the destination
+     */
+    static NiQuaternion LookAt(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
+    
+    //! Look from a specific point in space to another point in space
+    /*!
+      \param sourcePoint The source location
+      \param destPoint The destination location
+      \return The Quaternion with the rotation towards the destination
+     */
+    static NiQuaternion LookAtUnlocked(const NiPoint3& sourcePoint, const NiPoint3& destPoint);
+    
+    //! Creates a Quaternion from a specific axis and angle relative to that axis
+    /*!
+      \param axis The axis that is used
+      \param angle The angle relative to this axis
+      \return A quaternion created from the axis and angle
+     */
+    static NiQuaternion CreateFromAxisAngle(const Vector3& axis, float angle);
+
+    static NiQuaternion FromEulerAngles(const NiPoint3& eulerAngles);
+};

dCommon/PermissionMap.h

@@ -0,0 +1,42 @@
+#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/SHA512.cpp

@@ -0,0 +1,157 @@
+#include "SHA512.h"
+
+#include <cstring>
+#include <fstream>
+
+const unsigned long long SHA512::sha512_k[80] = //ULL = uint64
+{ 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+    0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+    0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+    0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+    0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+    0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+    0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+    0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+    0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+    0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+    0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+    0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+    0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+    0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+    0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+    0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+    0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+    0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+    0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+    0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+    0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+    0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+    0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+    0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+    0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+    0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+    0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+    0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+    0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+    0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+    0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+    0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+    0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+    0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+    0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+    0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+    0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+    0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+    0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+    0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL };
+
+void SHA512::transform(const unsigned char *message, unsigned int block_nb)
+{
+    uint64 w[80];
+    uint64 wv[8];
+    uint64 t1, t2;
+    const unsigned char *sub_block;
+    int i, j;
+    for (i = 0; i < (int)block_nb; i++) {
+        sub_block = message + (i << 7);
+        for (j = 0; j < 16; j++) {
+            SHA2_PACK64(&sub_block[j << 3], &w[j]);
+        }
+        for (j = 16; j < 80; j++) {
+            w[j] = SHA512_F4(w[j - 2]) + w[j - 7] + SHA512_F3(w[j - 15]) + w[j - 16];
+        }
+        for (j = 0; j < 8; j++) {
+            wv[j] = m_h[j];
+        }
+        for (j = 0; j < 80; j++) {
+            t1 = wv[7] + SHA512_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
+            + sha512_k[j] + w[j];
+            t2 = SHA512_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
+            wv[7] = wv[6];
+            wv[6] = wv[5];
+            wv[5] = wv[4];
+            wv[4] = wv[3] + t1;
+            wv[3] = wv[2];
+            wv[2] = wv[1];
+            wv[1] = wv[0];
+            wv[0] = t1 + t2;
+        }
+        for (j = 0; j < 8; j++) {
+            m_h[j] += wv[j];
+        }
+        
+    }
+}
+
+void SHA512::init()
+{
+    m_h[0] = 0x6a09e667f3bcc908ULL;
+    m_h[1] = 0xbb67ae8584caa73bULL;
+    m_h[2] = 0x3c6ef372fe94f82bULL;
+    m_h[3] = 0xa54ff53a5f1d36f1ULL;
+    m_h[4] = 0x510e527fade682d1ULL;
+    m_h[5] = 0x9b05688c2b3e6c1fULL;
+    m_h[6] = 0x1f83d9abfb41bd6bULL;
+    m_h[7] = 0x5be0cd19137e2179ULL;
+    m_len = 0;
+    m_tot_len = 0;
+}
+
+void SHA512::update(const unsigned char *message, unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+    tmp_len = SHA384_512_BLOCK_SIZE - m_len;
+    rem_len = len < tmp_len ? len : tmp_len;
+    memcpy(&m_block[m_len], message, rem_len);
+    if (m_len + len < SHA384_512_BLOCK_SIZE) {
+        m_len += len;
+        return;
+    }
+    new_len = len - rem_len;
+    block_nb = new_len / SHA384_512_BLOCK_SIZE;
+    shifted_message = message + rem_len;
+    transform(m_block, 1);
+    transform(shifted_message, block_nb);
+    rem_len = new_len % SHA384_512_BLOCK_SIZE;
+    memcpy(m_block, &shifted_message[block_nb << 7], rem_len);
+    m_len = rem_len;
+    m_tot_len += (block_nb + 1) << 7;
+}
+
+void SHA512::final(unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+    int i;
+    block_nb = 1 + ((SHA384_512_BLOCK_SIZE - 17)
+                    < (m_len % SHA384_512_BLOCK_SIZE));
+    len_b = (m_tot_len + m_len) << 3;
+    pm_len = block_nb << 7;
+    memset(m_block + m_len, 0, pm_len - m_len);
+    m_block[m_len] = 0x80;
+    SHA2_UNPACK32(len_b, m_block + pm_len - 4);
+    transform(m_block, block_nb);
+    for (i = 0; i < 8; i++) {
+        SHA2_UNPACK64(m_h[i], &digest[i << 3]);
+    }
+}
+
+std::string sha512(std::string input)
+{
+    unsigned char digest[SHA512::DIGEST_SIZE];
+    memset(digest, 0, SHA512::DIGEST_SIZE);
+    class SHA512 ctx;
+    ctx.init();
+    ctx.update((unsigned char*)input.c_str(), input.length());
+    ctx.final(digest);
+
+    char buf[2 * SHA512::DIGEST_SIZE + 1];
+    buf[2 * SHA512::DIGEST_SIZE] = 0;
+    for (int i = 0; i < SHA512::DIGEST_SIZE; i++)
+        sprintf(buf + i * 2, "%02x", digest[i]);
+
+    return std::string(buf);
+}

dCommon/SHA512.h

@@ -0,0 +1,68 @@
+#pragma once
+
+// C++
+#include <string>
+
+class SHA512 {
+protected:
+    typedef unsigned char uint8;
+    typedef unsigned int uint32;
+    typedef unsigned long long uint64;
+    
+    const static uint64 sha512_k[];
+    static const unsigned int SHA384_512_BLOCK_SIZE = (1024 / 8);
+    
+public:
+    void init();
+    void update(const unsigned char *message, unsigned int len);
+    void final(unsigned char *digest);
+    static const unsigned int DIGEST_SIZE = (512 / 8);
+    
+protected:
+    void transform(const unsigned char *message, unsigned int block_nb);
+    unsigned int m_tot_len;
+    unsigned int m_len;
+    unsigned char m_block[2 * SHA384_512_BLOCK_SIZE];
+    uint64 m_h[8];
+};
+
+std::string sha512(std::string input);
+
+#define SHA2_SHFR(x, n)    (x >> n)
+#define SHA2_ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
+#define SHA2_ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
+#define SHA2_CH(x, y, z)  ((x & y) ^ (~x & z))
+#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
+#define SHA512_F1(x) (SHA2_ROTR(x, 28) ^ SHA2_ROTR(x, 34) ^ SHA2_ROTR(x, 39))
+#define SHA512_F2(x) (SHA2_ROTR(x, 14) ^ SHA2_ROTR(x, 18) ^ SHA2_ROTR(x, 41))
+#define SHA512_F3(x) (SHA2_ROTR(x,  1) ^ SHA2_ROTR(x,  8) ^ SHA2_SHFR(x,  7))
+#define SHA512_F4(x) (SHA2_ROTR(x, 19) ^ SHA2_ROTR(x, 61) ^ SHA2_SHFR(x,  6))
+#define SHA2_UNPACK32(x, str)                 \
+{                                             \
+*((str) + 3) = (uint8) ((x)      );       \
+*((str) + 2) = (uint8) ((x) >>  8);       \
+*((str) + 1) = (uint8) ((x) >> 16);       \
+*((str) + 0) = (uint8) ((x) >> 24);       \
+}
+#define SHA2_UNPACK64(x, str)                 \
+{                                             \
+*((str) + 7) = (uint8) ((x)      );       \
+*((str) + 6) = (uint8) ((x) >>  8);       \
+*((str) + 5) = (uint8) ((x) >> 16);       \
+*((str) + 4) = (uint8) ((x) >> 24);       \
+*((str) + 3) = (uint8) ((x) >> 32);       \
+*((str) + 2) = (uint8) ((x) >> 40);       \
+*((str) + 1) = (uint8) ((x) >> 48);       \
+*((str) + 0) = (uint8) ((x) >> 56);       \
+}
+#define SHA2_PACK64(str, x)                   \
+{                                             \
+*(x) =   ((uint64) *((str) + 7)      )    \
+| ((uint64) *((str) + 6) <<  8)    \
+| ((uint64) *((str) + 5) << 16)    \
+| ((uint64) *((str) + 4) << 24)    \
+| ((uint64) *((str) + 3) << 32)    \
+| ((uint64) *((str) + 2) << 40)    \
+| ((uint64) *((str) + 1) << 48)    \
+| ((uint64) *((str) + 0) << 56);   \
+}

dCommon/Type.cpp

@@ -0,0 +1,27 @@
+#include "Type.h"
+#ifdef __GNUG__
+#include <cstdlib>
+#include <memory>
+#include <cxxabi.h>
+
+std::string demangle(const char* name) {
+
+    int status = -4; // some arbitrary value to eliminate the compiler warning
+
+    // enable c++11 by passing the flag -std=c++11 to g++
+    std::unique_ptr<char, void(*)(void*)> res {
+        abi::__cxa_demangle(name, NULL, NULL, &status),
+        std::free
+    };
+
+    return (status==0) ? res.get() : name ;
+}
+
+#else
+
+// does nothing if not g++
+std::string demangle(const char* name) {
+    return name;
+}
+
+#endif

dCommon/Type.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <typeinfo>
+
+std::string demangle(const char* name);
+
+template <class T>
+std::string type(const T& t) {
+
+    return demangle(typeid(t).name());
+}

dCommon/ZCompression.cpp

@@ -0,0 +1,73 @@
+#include "ZCompression.h"
+
+#include <zlib.h>
+
+namespace ZCompression
+{
+    int32_t GetMaxCompressedLength(int32_t nLenSrc)
+    {
+        int32_t n16kBlocks = (nLenSrc + 16383) / 16384; // round up any fraction of a block
+        return (nLenSrc + 6 + (n16kBlocks * 5));
+    }
+
+    int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst)
+    {
+        z_stream zInfo = { 0 };
+        zInfo.total_in = zInfo.avail_in = nLenSrc;
+        zInfo.total_out = zInfo.avail_out = nLenDst;
+        zInfo.next_in = const_cast<Bytef*>(abSrc);
+        zInfo.next_out = abDst;
+
+        int nErr, nRet = -1;
+        nErr = deflateInit(&zInfo, Z_DEFAULT_COMPRESSION); // zlib function
+        if (nErr == Z_OK) {
+            nErr = deflate(&zInfo, Z_FINISH);              // zlib function
+            if (nErr == Z_STREAM_END) {
+                nRet = zInfo.total_out;
+            }
+        }
+        deflateEnd(&zInfo);    // zlib function
+        return(nRet);
+
+    }
+
+    int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr)
+    {
+        // Get the size of the decompressed data
+        z_stream zInfo = { 0 };
+        zInfo.total_in = zInfo.avail_in = nLenSrc;
+        zInfo.total_out = zInfo.avail_out = nLenDst;
+        zInfo.next_in = const_cast<Bytef*>(abSrc);
+        zInfo.next_out = abDst;
+
+        int nRet = -1;
+        nErr = inflateInit(&zInfo); // zlib function
+        if (nErr == Z_OK) {
+            nErr = inflate(&zInfo, Z_FINISH); // zlib function
+            if (nErr == Z_STREAM_END) {
+                nRet = zInfo.total_out;
+            }
+        }
+        inflateEnd(&zInfo); // zlib function
+        return(nRet);
+        
+        /*
+        z_stream zInfo = { 0 };
+        zInfo.total_in = zInfo.avail_in = nLenSrc;
+        zInfo.total_out = zInfo.avail_out = nLenDst;
+        zInfo.next_in = const_cast<Bytef*>(abSrc);
+        zInfo.next_out = const_cast<Bytef*>(abDst);
+
+        int nRet = -1;
+        nErr = inflateInit(&zInfo);               // zlib function
+        if (nErr == Z_OK) {
+            nErr = inflate(&zInfo, Z_FINISH);     // zlib function
+            if (nErr == Z_STREAM_END) {
+                nRet = zInfo.total_out;
+            }
+        }
+        inflateEnd(&zInfo);   // zlib function
+        return(nRet); // -1 or len of output
+        */
+    }
+}

dCommon/ZCompression.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ZCompression
+{
+	int32_t GetMaxCompressedLength(int32_t nLenSrc);
+
+	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst);
+
+	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr);
+}

dCommon/dCommonVars.h

@@ -0,0 +1,642 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <set>
+#include "../thirdparty/raknet/Source/BitStream.h"
+
+#pragma warning (disable:4251) //Disables SQL warnings
+
+typedef int RESTICKET;
+
+const int highFrameRate = 16;	//60fps
+const int mediumFramerate = 33;	//30fps
+const int lowFramerate = 66;	//15fps
+
+//========== 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 SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
+#define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+
+//=========== TYPEDEFS ==========
+
+typedef int32_t LOT;                        //!< A LOT
+typedef int64_t LWOOBJID;                   //!< An object ID (should be unsigned actually but ok)
+typedef int32_t TSkillID;                   //!< A skill ID
+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 int32_t PetTamingPiece;             //!< Pet Taming Pieces
+
+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 {
+public:
+	LWOSCENEID() { m_sceneID = -1; m_layerID = 0; }
+	LWOSCENEID(int sceneID) { m_sceneID = sceneID; m_layerID = 0; }
+	LWOSCENEID(int sceneID, unsigned int layerID) { m_sceneID = sceneID; m_layerID = layerID; }
+
+	LWOSCENEID& operator=(const LWOSCENEID& rhs) { m_sceneID = rhs.m_sceneID; m_layerID = rhs.m_layerID; return *this; }
+	LWOSCENEID& operator=(const int rhs) { m_sceneID = rhs; m_layerID = 0; return *this; }
+
+	bool operator<(const LWOSCENEID& rhs) const { return (m_sceneID < rhs.m_sceneID || (m_sceneID == rhs.m_sceneID && m_layerID < rhs.m_layerID)); }
+	bool operator<(const int rhs) const { return m_sceneID < rhs; }
+
+	bool operator==(const LWOSCENEID& rhs) const { return (m_sceneID == rhs.m_sceneID && m_layerID == rhs.m_layerID); }
+	bool operator==(const int rhs) const { return m_sceneID == rhs; }
+
+	const int GetSceneID() const { return m_sceneID; }
+	const unsigned int GetLayerID() const { return m_layerID; }
+
+	void SetSceneID(const int sceneID) { m_sceneID = sceneID; }
+	void SetLayerID(const unsigned int layerID) { m_layerID = layerID; }
+
+private:
+	int m_sceneID;
+	unsigned int m_layerID;
+};
+
+struct LWOZONEID {
+public:
+	const LWOMAPID& GetMapID() const { return m_MapID; }
+	const LWOINSTANCEID& GetInstanceID() const { return m_InstanceID; }
+	const LWOCLONEID& GetCloneID() const { return m_CloneID; }
+
+	//In order: def constr, constr, assign op
+	LWOZONEID() { m_MapID = LWOMAPID_INVALID; m_InstanceID = LWOINSTANCEID_INVALID; m_CloneID = LWOCLONEID_INVALID; }
+	LWOZONEID(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) { m_MapID = mapID; m_InstanceID = instanceID; m_CloneID = cloneID; }
+	LWOZONEID(const LWOZONEID& replacement) { *this = replacement; }
+
+private:
+	LWOMAPID m_MapID; //1000 for VE, 1100 for AG, etc...
+	LWOINSTANCEID m_InstanceID; //Instances host the same world, but on a different dWorld process.
+	LWOCLONEID m_CloneID; //To differentiate between "your property" and "my property". Always 0 for non-prop worlds.
+};
+
+const LWOSCENEID LWOSCENEID_INVALID = -1;
+
+struct LWONameValue {
+    uint32_t length = 0;        //!< The length of the name
+    std::u16string name;			//!< The name
+    
+    LWONameValue(void) {}
+ 
+    LWONameValue(const std::u16string& name) {
+        this->name = name;
+        this->length = static_cast<uint32_t>(name.length());
+    }
+    
+    ~LWONameValue(void) {}
+};
+
+struct FriendData {
+public:
+    bool isOnline = false;
+    bool isBestFriend = false;
+    bool isFTP = false;
+    LWOZONEID zoneID;
+    LWOOBJID friendID;
+    std::string friendName;
+
+    void Serialize(RakNet::BitStream& bitStream) {
+        bitStream.Write<uint8_t>(isOnline);
+        bitStream.Write<uint8_t>(isBestFriend);
+        bitStream.Write<uint8_t>(isFTP);
+        bitStream.Write<uint32_t>(0); //???
+        bitStream.Write<uint8_t>(0);  //???
+        bitStream.Write(zoneID.GetMapID());
+        bitStream.Write(zoneID.GetInstanceID());
+        bitStream.Write(zoneID.GetCloneID());
+        bitStream.Write(friendID);
+        
+        uint32_t maxSize = 33;
+        uint32_t size = static_cast<uint32_t>(friendName.length());
+        uint32_t remSize = static_cast<uint32_t>(maxSize - size);
+
+        if (size > maxSize) size = maxSize;
+
+        for (uint32_t i = 0; i < size; ++i) {
+            bitStream.Write(static_cast<uint16_t>(friendName[i]));
+        }
+
+        for (uint32_t j = 0; j < remSize; ++j) {
+            bitStream.Write(static_cast<uint16_t>(0));
+        }
+
+        bitStream.Write<uint32_t>(0); //???
+        bitStream.Write<uint16_t>(0); //???
+    }
+};
+
+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_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 Exhibit 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,
+    COMPONENT_TYPE_POSSESSOR                = 107,          //!< The Component 107
+    COMPONENT_TYPE_POSSESSABLE              = 108,          //!< The Component 108
+	COMPONENT_TYPE_BUILD_BORDER             = 114,          //!< The Build Border Component
+    COMPONENT_TYPE_DESTROYABLE              = 1000,         //!< The Destroyable Component
+
+    COMPONENT_TYPE_MODEL = 5398484 //look man idk
+};
+
+/**
+ * Represents the different types of inventories an entity may have
+ */
+enum eInventoryType : uint32_t {
+    ITEMS = 0,
+    VAULT_ITEMS,
+    BRICKS,
+    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 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
+};
+
+enum eRebuildState : uint32_t {
+	REBUILD_OPEN,
+	REBUILD_COMPLETED = 2,
+	REBUILD_RESETTING = 4,
+	REBUILD_BUILDING,
+	REBUILD_INCOMPLETE
+};
+
+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,
+    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_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;
+}

dCommon/dConfig.cpp

@@ -0,0 +1,45 @@
+#include "dConfig.h"
+#include <sstream>
+
+dConfig::dConfig(const std::string& filepath) {
+	m_EmptyString = "";
+	std::ifstream in(filepath);
+	if (!in.good()) return;
+
+	std::string line;
+	while (std::getline(in, line)) {
+		if (line.length() > 0) {
+			if (line[0] != '#') ProcessLine(line);
+		}
+	}
+} 
+
+dConfig::~dConfig(void) {
+}
+
+const std::string& dConfig::GetValue(std::string key) {
+	for (size_t i = 0; i < m_Keys.size(); ++i) {
+		if (m_Keys[i] == key) return m_Values[i];
+	}
+
+	return m_EmptyString;
+}
+
+void dConfig::ProcessLine(const std::string& line) {
+	std::stringstream ss(line);
+	std::string segment;
+	std::vector<std::string> seglist;
+
+	while (std::getline(ss, segment, '=')) {
+	   seglist.push_back(segment);
+	}
+
+	if (seglist.size() != 2) return;
+
+	//Make sure that on Linux, we remove special characters:
+	if (!seglist[1].empty() && seglist[1][seglist[1].size() - 1] == '\r')
+    	seglist[1].erase(seglist[1].size() - 1);
+
+	m_Keys.push_back(seglist[0]);
+	m_Values.push_back(seglist[1]);
+}

dCommon/dConfig.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <fstream>
+#include <string>
+#include <vector>
+
+class dConfig {
+public:
+	dConfig(const std::string& filepath);
+	~dConfig(void);
+
+	const std::string& GetValue(std::string key);
+
+private:
+	void ProcessLine(const std::string& line);
+
+private:
+	std::vector<std::string> m_Keys;
+	std::vector<std::string> m_Values;
+	std::string m_EmptyString;
+};

dCommon/dLogger.cpp

@@ -0,0 +1,143 @@
+#include "dLogger.h"
+
+dLogger::dLogger(const std::string& outpath, bool logToConsole) {
+	m_logToConsole = logToConsole;
+	m_outpath = outpath;
+
+#ifdef _WIN32
+	mFile = std::ofstream(m_outpath);
+	if (!mFile) { printf("Couldn't open %s for writing!\n", outpath.c_str()); }
+#else
+	fp = fopen(outpath.c_str(), "wt");
+    if (fp == NULL) { printf("Couldn't open %s for writing!\n", outpath.c_str()); }
+#endif
+}
+
+dLogger::~dLogger() {
+#ifdef _WIN32
+	mFile.close();
+#else
+	if (fp != nullptr) {
+		fclose(fp);
+		fp = nullptr;
+	}
+#endif
+}
+
+void dLogger::LogBasic(const std::string & message) {
+	LogBasic(message.c_str());
+}
+
+void dLogger::LogBasic(const char * format, ...) {
+#ifdef _WIN32
+	time_t t = time(NULL);
+	struct tm time;
+	localtime_s(&time, &t);
+
+	char timeStr[70];
+	
+	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", &time);
+
+	char message[2048];
+	va_list args;
+	va_start(args, format);
+	vsprintf_s(message, format, args);
+	va_end(args);
+
+	if (m_logToConsole) std::cout << "[" << "time machine broke" << "] " << message;
+	mFile << "[" << "time" << "] " << message;
+#else
+	time_t t = time(NULL);
+    struct tm * time = localtime(&t);
+    char timeStr[70];
+    strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", time);
+	
+	char message[2048];
+    va_list args;
+    va_start(args, format);
+    vsprintf(message, format, args);
+    va_end(args);
+    
+    if (m_logToConsole) {
+		fputs("[", stdout);
+		fputs(timeStr, stdout);
+		fputs("] ", stdout);
+		fputs(message, stdout);
+    }
+    
+    if (fp != nullptr) {
+		fputs("[", fp);
+		fputs(timeStr, fp);
+		fputs("] ", fp);
+		fputs(message, fp);
+    } else {
+    	printf("Logger not initialized!\n");
+    }
+#endif
+}
+
+void dLogger::Log(const char * className, const char * format, ...) {
+#ifdef _WIN32
+	time_t t = time(NULL);
+	struct tm time;
+	localtime_s(&time, &t);
+
+	char timeStr[70];
+	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", &time);
+
+	char message[2048];
+	va_list args;
+	va_start(args, format);
+	vsprintf_s(message, format, args);
+
+	va_end(args);
+
+	if (m_logToConsole) std::cout << "[" << "timeStr" << "] [" << className << "]: " << message;
+	mFile << "[" << "timeStr" << "] [" << className << "]: " << message;
+#else
+	time_t t = time(NULL);
+    struct tm * time = localtime(&t);
+    char timeStr[70];
+    strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", time);
+	
+	char message[2048];
+    va_list args;
+    va_start(args, format);
+    vsprintf(message, format, args);
+    va_end(args);
+    
+    if (m_logToConsole) {
+		fputs("[", stdout);
+		fputs(timeStr, stdout);
+		fputs("] ", stdout);
+		fputs("[", stdout);
+		fputs(className, stdout);
+		fputs("]: ", stdout);
+		fputs(message, stdout);
+    }
+    
+    if (fp != NULL) {
+		fputs("[", fp);
+		fputs(timeStr, fp);
+		fputs("] ", fp);
+		fputs("[", fp);
+		fputs(className, fp);
+		fputs("]: ", fp);
+		fputs(message, fp);
+    }
+#endif
+}
+
+void dLogger::Log(const std::string & className, const std::string & message) {
+	Log(className.c_str(), message.c_str());
+}
+
+void dLogger::Flush() {
+#ifdef _WIN32
+	mFile.flush();
+#else
+	if (fp != nullptr) {
+		std::fflush(fp);
+	}
+#endif
+}

dCommon/dLogger.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <ctime>
+#include <cstdarg>
+#include <string>
+#include <fstream>
+#include <iostream>
+
+class dLogger {
+public:
+	dLogger(const std::string& outpath, bool logToConsole);
+	~dLogger();
+
+	void SetLogToConsole(bool logToConsole) { m_logToConsole = logToConsole; }
+
+	void LogBasic(const std::string& message);
+	void LogBasic(const char* format, ...);
+	void Log(const char* className, const char* format, ...);
+	void Log(const std::string& className, const std::string& message);
+
+	void Flush();
+
+	const bool GetIsLoggingToConsole() const { return m_logToConsole; }
+
+private:
+	bool m_logToConsole;
+	std::string m_outpath;
+	std::ofstream mFile;
+
+	#ifndef _WIN32
+		//Glorious linux can run with SPEED:
+		FILE* fp = nullptr;
+	#endif
+};

dDatabase/CDClientDatabase.cpp

@@ -0,0 +1,15 @@
+#include "CDClientDatabase.h"
+#include "CDComponentsRegistryTable.h"
+
+// Static Variables
+static CppSQLite3DB * conn = new CppSQLite3DB();
+
+//! Opens a connection with the CDClient
+void CDClientDatabase::Connect(const std::string& filename) {
+    conn->open(filename.c_str());
+}
+
+//! Queries the CDClient
+CppSQLite3Query CDClientDatabase::ExecuteQuery(const std::string& query) {
+    return conn->execQuery(query.c_str());
+}

dDatabase/CDClientDatabase.h

@@ -0,0 +1,43 @@
+#pragma once
+
+// C++
+#include <string>
+
+// SQLite
+#include "CppSQLite3.h"
+
+/*
+ * Optimization settings
+ */
+
+#include <sstream>
+#include <iostream>
+
+// Enable this to cache all entries in each table for fast access, comes with more memory cost
+//#define CDCLIENT_CACHE_ALL
+
+// Enable this to skip some unused columns in some tables
+#define UNUSED(v)
+
+/*!
+  \file CDClientDatabase.hpp
+  \brief An interface between the CDClient.sqlite file and the server
+ */
+
+//! The CDClient Database namespace
+namespace CDClientDatabase {
+    
+    //! Opens a connection with the CDClient
+    /*!
+      \param filename The filename
+     */
+    void Connect(const std::string& filename);
+    
+    //! Queries the CDClient
+    /*!
+      \param query The query
+      \return The results of the query
+     */
+    CppSQLite3Query ExecuteQuery(const std::string& query);
+    
+};

dDatabase/CDClientManager.cpp

@@ -0,0 +1,46 @@
+#include "CDClientManager.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()));
+	UNUSED(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()));
+}

dDatabase/CDClientManager.h

@@ -0,0 +1,96 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+// Tables
+#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"
+
+// C++
+#include <type_traits>
+#include <unordered_map>
+
+/*!
+  \file CDClientManager.hpp
+  \brief A manager for the CDClient tables
+ */
+
+//! Manages all data from the CDClient
+class CDClientManager {
+private:
+    static CDClientManager * m_Address;                 //!< The singleton address
+    
+    std::unordered_map<std::string, CDTable*> tables;   //!< The tables
+    
+public:
+    
+    //! The singleton method
+    static CDClientManager * Instance() {
+        if (m_Address == 0) {
+            m_Address = new CDClientManager;
+        }
+        
+        return m_Address;
+    }
+    
+    //! Initializes the manager
+    void Initialize(void);
+    
+    //! Fetches a CDClient table
+    /*!
+      This function uses typename T which must be a subclass of CDTable.
+      It returns the class that conforms to the class name
+     
+      \param tableName The table name
+      \return The class or nullptr
+     */
+    template<typename T>
+    T * GetTable(const std::string& tableName) {
+        static_assert(std::is_base_of<CDTable, T>::value, "T should inherit from CDTable!");
+        
+        for (auto itr = this->tables.begin(); itr != this->tables.end(); ++itr) {
+            if (itr->first == tableName) {
+                return dynamic_cast<T*>(itr->second);
+            }
+        }
+        
+        return nullptr;
+    }
+};

dDatabase/Database.cpp

@@ -0,0 +1,76 @@
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "dLogger.h"
+using namespace std;
+
+#pragma warning (disable:4251) //Disables SQL warnings
+
+sql::Driver * Database::driver;
+sql::Connection * Database::con;
+
+void Database::Connect(const string& host, const string& database, const string& username, const string& password) {
+	driver = get_driver_instance();
+
+	//To bypass debug issues:
+	std::string newHost = "tcp://" + host;
+	const char* szHost = newHost.c_str();
+	const char* szDatabase = database.c_str();
+	const char* szUsername = username.c_str();
+	const char* szPassword = password.c_str();
+
+	con = driver->connect(szHost, szUsername, szPassword);
+	con->setSchema(szDatabase);
+
+	bool myTrue = true;
+	con->setClientOption("MYSQL_OPT_RECONNECT", &myTrue);
+} //Connect
+
+void Database::Destroy() {
+	if (!con) return;
+	cout << "Destroying MySQL connection!" << endl;
+	con->close();
+	delete con;
+} //Destroy
+
+sql::Statement* Database::CreateStmt() {
+	sql::Statement* toReturn = con->createStatement();
+	return toReturn;
+} //CreateStmt
+
+sql::PreparedStatement* Database::CreatePreppedStmt(const std::string& query) {
+	const char* test = query.c_str();
+	size_t size = query.length();
+	sql::SQLString str(test, size);
+
+	if (!con) {
+		//Connect to the MySQL Database
+		std::string mysql_host = Game::config->GetValue("mysql_host");
+		std::string mysql_database = Game::config->GetValue("mysql_database");
+		std::string mysql_username = Game::config->GetValue("mysql_username");
+		std::string mysql_password = Game::config->GetValue("mysql_password");
+
+		Connect(mysql_host, mysql_database, mysql_username, mysql_password);
+		Game::logger->Log("Database", "Trying to reconnect to MySQL\n");
+	}
+
+	if (!con->isValid() || con->isClosed())
+	{
+		delete con;
+
+		con = nullptr;
+
+		//Connect to the MySQL Database
+		std::string mysql_host = Game::config->GetValue("mysql_host");
+		std::string mysql_database = Game::config->GetValue("mysql_database");
+		std::string mysql_username = Game::config->GetValue("mysql_username");
+		std::string mysql_password = Game::config->GetValue("mysql_password");
+
+		Connect(mysql_host, mysql_database, mysql_username, mysql_password);
+		Game::logger->Log("Database", "Trying to reconnect to MySQL from invalid or closed connection\n");
+	}
+	
+	auto* stmt = con->prepareStatement(str);
+
+	return stmt;
+} //CreatePreppedStmt

dDatabase/Database.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+#include <mysql_connection.h>
+#include <cppconn/driver.h>
+#include <cppconn/exception.h>
+#include <cppconn/resultset.h>
+#include <cppconn/statement.h>
+#include <cppconn/prepared_statement.h>
+#include <cppconn/sqlstring.h>
+
+class MySqlException : public std::runtime_error {
+public:
+	MySqlException() : std::runtime_error("MySQL error!") {}
+	MySqlException(const std::string& msg) : std::runtime_error(msg.c_str()) {}
+};
+
+class Database {
+private:
+	static sql::Driver *driver;
+	static sql::Connection *con;
+
+public:
+	static void Connect(const std::string& host, const std::string& database, const std::string& username, const std::string& password);
+	static void Destroy();
+	static sql::Statement* CreateStmt();
+	static sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
+};

dDatabase/Tables/CDActivitiesTable.cpp

@@ -0,0 +1,72 @@
+#include "CDActivitiesTable.h"
+
+//! Constructor
+CDActivitiesTable::CDActivitiesTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Activities");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
+	// Now get the data
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Activities");
+	while (!tableData.eof()) {
+		CDActivities entry;
+		entry.ActivityID = tableData.getIntField(0, -1);
+		entry.locStatus = tableData.getIntField(1, -1);
+		entry.instanceMapID = tableData.getIntField(2, -1);
+		entry.minTeams = tableData.getIntField(3, -1);
+		entry.maxTeams = tableData.getIntField(4, -1);
+		entry.minTeamSize = tableData.getIntField(5, -1);
+		entry.maxTeamSize = tableData.getIntField(6, -1);
+		entry.waitTime = tableData.getIntField(7, -1);
+		entry.startDelay = tableData.getIntField(8, -1);
+		entry.requiresUniqueData = tableData.getIntField(9, -1);
+		entry.leaderboardType = tableData.getIntField(10, -1);
+		entry.localize = tableData.getIntField(11, -1);
+		entry.optionalCostLOT = tableData.getIntField(12, -1);
+		entry.optionalCostCount = tableData.getIntField(13, -1);
+		entry.showUIRewards = tableData.getIntField(14, -1);
+		entry.CommunityActivityFlagID = tableData.getIntField(15, -1);
+		entry.gate_version = tableData.getStringField(16, "");
+		entry.noTeamLootOnDeath = tableData.getIntField(17, -1);
+		entry.optionalPercentage = tableData.getFloatField(18, -1.0f);
+
+		this->entries.push_back(entry);
+		tableData.nextRow();
+	}
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDActivitiesTable::~CDActivitiesTable(void) { }
+
+//! Returns the table's name
+std::string CDActivitiesTable::GetName(void) const {
+	return "Activities";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActivities)> predicate) {
+
+	std::vector<CDActivities> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDActivities> CDActivitiesTable::GetEntries(void) const {
+	return this->entries;
+}

dDatabase/Tables/CDActivitiesTable.h

@@ -0,0 +1,66 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDActivitiesTable.hpp
+ \brief Contains data for the Activities table
+ */
+
+ //! Activities Entry Struct
+struct CDActivities {
+	unsigned int ActivityID;
+	unsigned int locStatus;
+	unsigned int instanceMapID;
+	unsigned int minTeams;
+	unsigned int maxTeams;
+	unsigned int minTeamSize;
+	unsigned int maxTeamSize;
+	unsigned int waitTime;
+	unsigned int startDelay;
+	bool requiresUniqueData;
+	unsigned int leaderboardType;
+	bool localize;
+	int optionalCostLOT;
+	int optionalCostCount;
+	bool showUIRewards;
+	unsigned int CommunityActivityFlagID;
+	std::string gate_version;
+	bool noTeamLootOnDeath;
+	float optionalPercentage;
+};
+
+
+//! Activities table
+class CDActivitiesTable : public CDTable {
+private:
+	std::vector<CDActivities> entries;
+
+public:
+
+	//! Constructor
+	CDActivitiesTable(void);
+
+	//! Destructor
+	~CDActivitiesTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
+	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
+
+	//! Gets all the entries in the table
+	/*!
+	  \return The entries
+	 */
+	std::vector<CDActivities> GetEntries(void) const;
+
+};

dDatabase/Tables/CDActivityRewardsTable.cpp

@@ -0,0 +1,60 @@
+#include "CDActivityRewardsTable.h"
+
+//! Constructor
+CDActivityRewardsTable::CDActivityRewardsTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ActivityRewards");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ActivityRewards");
+    while (!tableData.eof()) {
+        CDActivityRewards entry;
+        entry.objectTemplate = tableData.getIntField(0, -1);
+        entry.ActivityRewardIndex = tableData.getIntField(1, -1);
+        entry.activityRating = tableData.getIntField(2, -1);
+        entry.LootMatrixIndex = tableData.getIntField(3, -1);
+        entry.CurrencyIndex = tableData.getIntField(4, -1);
+        entry.ChallengeRating = tableData.getIntField(5, -1);
+        entry.description = tableData.getStringField(6, "");
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDActivityRewardsTable::~CDActivityRewardsTable(void) { }
+
+//! Returns the table's name
+std::string CDActivityRewardsTable::GetName(void) const {
+    return "ActivityRewards";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDActivityRewards> CDActivityRewardsTable::Query(std::function<bool(CDActivityRewards)> predicate) {
+    
+    std::vector<CDActivityRewards> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDActivityRewards> CDActivityRewardsTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDActivityRewardsTable.h

@@ -0,0 +1,54 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDActivityRewardsTable.hpp
+ \brief Contains data for the ActivityRewards table
+ */
+
+//! ActivityRewards Entry Struct
+struct CDActivityRewards {
+    unsigned int objectTemplate;        //!< The object template (?)
+    unsigned int ActivityRewardIndex;   //!< The activity reward index
+    int activityRating;                 //!< The activity rating
+    unsigned int LootMatrixIndex;       //!< The loot matrix index
+    unsigned int CurrencyIndex;         //!< The currency index
+    unsigned int ChallengeRating;       //!< The challenge rating
+    std::string description;            //!< The description
+};
+
+
+//! ActivityRewards table
+class CDActivityRewardsTable : public CDTable {
+private:
+    std::vector<CDActivityRewards> entries;
+    
+public:
+    
+    //! Constructor
+    CDActivityRewardsTable(void);
+    
+    //! Destructor
+    ~CDActivityRewardsTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDActivityRewards> Query(std::function<bool(CDActivityRewards)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDActivityRewards> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDAnimationsTable.cpp

@@ -0,0 +1,66 @@
+#include "CDAnimationsTable.h"
+
+//! Constructor
+CDAnimationsTable::CDAnimationsTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Animations");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Animations");
+    while (!tableData.eof()) {
+        CDAnimations entry;
+        entry.animationGroupID = tableData.getIntField(0, -1);
+        entry.animation_type = tableData.getStringField(1, "");
+        entry.animation_name = tableData.getStringField(2, "");
+        entry.chance_to_play = tableData.getFloatField(3, -1.0f);
+        entry.min_loops = tableData.getIntField(4, -1);
+        entry.max_loops = tableData.getIntField(5, -1);
+        entry.animation_length = tableData.getFloatField(6, -1.0f);
+        entry.hideEquip = tableData.getIntField(7, -1) == 1 ? true : false;
+        entry.ignoreUpperBody = tableData.getIntField(8, -1) == 1 ? true : false;
+        entry.restartable = tableData.getIntField(9, -1) == 1 ? true : false;
+        entry.face_animation_name = tableData.getStringField(10, "");
+        entry.priority = tableData.getFloatField(11, -1.0f);
+        entry.blendTime = tableData.getFloatField(12, -1.0f);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDAnimationsTable::~CDAnimationsTable(void) { }
+
+//! Returns the table's name
+std::string CDAnimationsTable::GetName(void) const {
+    return "Animations";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDAnimations> CDAnimationsTable::Query(std::function<bool(CDAnimations)> predicate) {
+    
+    std::vector<CDAnimations> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDAnimations> CDAnimationsTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDAnimationsTable.h

@@ -0,0 +1,60 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDAnimationsTable.hpp
+ \brief Contains data for the Animations table
+ */
+
+//! Animations Entry Struct
+struct CDAnimations {
+    unsigned int animationGroupID;          //!< The animation group ID
+    std::string animation_type;        //!< The animation type
+    std::string animation_name;        //!< The animation name
+    float chance_to_play;           //!< The chance to play the animation
+    unsigned int min_loops;                 //!< The minimum number of loops
+    unsigned int max_loops;                 //!< The maximum number of loops
+    float animation_length;         //!< The animation length
+    bool hideEquip;                 //!< Whether or not to hide the equip
+    bool ignoreUpperBody;           //!< Whether or not to ignore the upper body
+    bool restartable;               //!< Whether or not the animation is restartable
+    std::string face_animation_name;   //!< The face animation name
+    float priority;                 //!< The priority
+    float blendTime;                //!< The blend time
+};
+
+
+//! Animations table
+class CDAnimationsTable : public CDTable {
+private:
+    std::vector<CDAnimations> entries;
+    
+public:
+    
+    //! Constructor
+    CDAnimationsTable(void);
+    
+    //! Destructor
+    ~CDAnimationsTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDAnimations> Query(std::function<bool(CDAnimations)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDAnimations> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDBehaviorParameterTable.cpp

@@ -0,0 +1,90 @@
+#include "CDBehaviorParameterTable.h"
+#include "GeneralUtils.h"
+
+//! Constructor
+CDBehaviorParameterTable::CDBehaviorParameterTable(void) {
+#ifdef CDCLIENT_CACHE_ALL
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorParameter");
+    while (!tableData.eof()) {
+        CDBehaviorParameter entry;
+        entry.behaviorID = tableData.getIntField(0, -1);
+        entry.parameterID = tableData.getStringField(1, "");
+        entry.value = tableData.getFloatField(2, -1.0f);
+
+		//Check if we have an entry with this ID:
+		auto it = m_entries.find(entry.behaviorID);
+		if (it != m_entries.end()) {
+			it->second.insert(std::make_pair(entry.parameterID, entry.value));
+		}
+		else { 
+			//Otherwise, insert it:
+			m_entries.insert(std::make_pair(entry.behaviorID, std::map<std::string, float>()));
+			auto jit = m_entries.find(entry.behaviorID);
+
+			//Add our value as well:
+			jit->second.insert(std::make_pair(entry.parameterID, entry.value));
+		}
+
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+#endif
+}
+
+//! Destructor
+CDBehaviorParameterTable::~CDBehaviorParameterTable(void) { }
+
+//! Returns the table's name
+std::string CDBehaviorParameterTable::GetName(void) const {
+    return "BehaviorParameter";
+}
+
+float CDBehaviorParameterTable::GetEntry(const uint32_t behaviorID, const std::string& name) 
+{
+	size_t hash = 0;
+	GeneralUtils::hash_combine(hash, behaviorID);
+	GeneralUtils::hash_combine(hash, name);
+
+	// Search for specific perameter
+	const auto& it = m_Entries.find(hash);
+	if (it != m_Entries.end()) {
+		return it->second;
+	}
+
+	// Check if this behavior has already been checked
+	const auto& itChecked = m_Entries.find(behaviorID);
+	if (itChecked != m_Entries.end()) {
+		return itChecked->second;
+	}
+
+#ifndef CDCLIENT_CACHE_ALL
+	std::stringstream query;
+
+	query << "SELECT parameterID, value FROM BehaviorParameter WHERE behaviorID = " << std::to_string(behaviorID);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
+
+	m_Entries.insert_or_assign(behaviorID, 0);
+	
+	while (!tableData.eof()) {
+        const std::string parameterID = tableData.getStringField(0, "");
+        const float value = tableData.getFloatField(1, 0);
+
+		size_t parameterHash = 0;
+		GeneralUtils::hash_combine(parameterHash, behaviorID);
+		GeneralUtils::hash_combine(parameterHash, parameterID);
+
+		m_Entries.insert_or_assign(parameterHash, value);
+
+        tableData.nextRow();
+    }
+
+	const auto& it2 = m_Entries.find(hash);
+	if (it2 != m_Entries.end()) {
+		return it2->second;
+	}
+#endif
+
+	return 0;
+}

dDatabase/Tables/CDBehaviorParameterTable.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+#include <map>
+
+/*!
+ \file CDBehaviorParameterTable.hpp
+ \brief Contains data for the BehaviorParameter table
+ */
+
+//! BehaviorParameter Entry Struct
+struct CDBehaviorParameter {
+    unsigned int behaviorID;            //!< The Behavior ID
+    std::string parameterID;       //!< The Parameter ID
+    float value;                 //!< The value of the behavior template
+};
+
+//! BehaviorParameter table
+class CDBehaviorParameterTable : public CDTable {
+private:
+    std::map<size_t, float> m_Entries;
+    
+public:
+    
+    //! Constructor
+    CDBehaviorParameterTable(void);
+    
+    //! Destructor
+    ~CDBehaviorParameterTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+	float GetEntry(const uint32_t behaviorID, const std::string& name);
+};

dDatabase/Tables/CDBehaviorTemplateTable.cpp

@@ -0,0 +1,57 @@
+#include "CDBehaviorTemplateTable.h"
+
+//! Constructor
+CDBehaviorTemplateTable::CDBehaviorTemplateTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM BehaviorTemplate");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+    
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorTemplate");
+    while (!tableData.eof()) {
+        CDBehaviorTemplate entry;
+        entry.behaviorID = tableData.getIntField(0, -1);
+        entry.templateID = tableData.getIntField(1, -1);
+        entry.effectID = tableData.getIntField(2, -1);
+        entry.effectHandle = tableData.getStringField(3, "");
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDBehaviorTemplateTable::~CDBehaviorTemplateTable(void) { }
+
+//! Returns the table's name
+std::string CDBehaviorTemplateTable::GetName(void) const {
+    return "BehaviorTemplate";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::Query(std::function<bool(CDBehaviorTemplate)> predicate) {
+    
+    std::vector<CDBehaviorTemplate> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDBehaviorTemplateTable.h

@@ -0,0 +1,51 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDBehaviorTemplateTable.hpp
+ \brief Contains data for the BehaviorTemplate table
+ */
+
+//! BehaviorTemplate Entry Struct
+struct CDBehaviorTemplate {
+    unsigned int behaviorID;                //!< The Behavior ID
+    unsigned int templateID;                //!< The Template ID (LOT)
+    unsigned int effectID;                  //!< The Effect ID attached
+    std::string effectHandle;          //!< The effect handle
+};
+
+
+//! BehaviorTemplate table
+class CDBehaviorTemplateTable : public CDTable {
+private:
+    std::vector<CDBehaviorTemplate> entries;
+    
+public:
+    
+    //! Constructor
+    CDBehaviorTemplateTable(void);
+    
+    //! Destructor
+    ~CDBehaviorTemplateTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDBehaviorTemplate> Query(std::function<bool(CDBehaviorTemplate)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+       \return The entries
+     */
+    std::vector<CDBehaviorTemplate> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDBrickIDTableTable.cpp

@@ -0,0 +1,55 @@
+#include "CDBrickIDTableTable.h"
+
+//! Constructor
+CDBrickIDTableTable::CDBrickIDTableTable(void) {
+
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM BrickIDTable");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+
+		tableSize.nextRow();
+	}
+    
+	tableSize.finalize();
+    
+	// Reserve the size
+	this->entries.reserve(size);
+
+	// Now get the data
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BrickIDTable");
+	while (!tableData.eof()) {
+		CDBrickIDTable entry;
+		entry.NDObjectID = tableData.getIntField(0, -1);
+		entry.LEGOBrickID = tableData.getIntField(1, -1);
+
+		this->entries.push_back(entry);
+		tableData.nextRow();
+	}
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDBrickIDTableTable::~CDBrickIDTableTable(void) { }
+
+//! Returns the table's name
+std::string CDBrickIDTableTable::GetName(void) const {
+	return "BrickIDTable";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDBrickIDTable> CDBrickIDTableTable::Query(std::function<bool(CDBrickIDTable)> predicate) {
+
+	std::vector<CDBrickIDTable> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDBrickIDTable> CDBrickIDTableTable::GetEntries(void) const {
+	return this->entries;
+}

dDatabase/Tables/CDBrickIDTableTable.h

@@ -0,0 +1,49 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDBrickIDTableTable.hpp
+ \brief Contains data for the BrickIDTable table
+ */
+
+ //! BrickIDTable Entry Struct
+struct CDBrickIDTable {
+	unsigned int NDObjectID;
+	unsigned int LEGOBrickID;
+};
+
+
+//! BrickIDTable table
+class CDBrickIDTableTable : public CDTable {
+private:
+	std::vector<CDBrickIDTable> entries;
+
+public:
+
+	//! Constructor
+	CDBrickIDTableTable(void);
+
+	//! Destructor
+	~CDBrickIDTableTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
+	std::vector<CDBrickIDTable> Query(std::function<bool(CDBrickIDTable)> predicate);
+
+	//! Gets all the entries in the table
+	/*!
+	   \return The entries
+	 */
+	std::vector<CDBrickIDTable> GetEntries(void) const;
+
+};

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -0,0 +1,131 @@
+#include "CDComponentsRegistryTable.h"
+
+#define CDCLIENT_CACHE_ALL
+
+//! Constructor
+CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
+    
+#ifdef CDCLIENT_CACHE_ALL
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ComponentsRegistry");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    //this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ComponentsRegistry");
+    while (!tableData.eof()) {
+        CDComponentsRegistry entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.component_type = tableData.getIntField(1, -1);
+        entry.component_id = tableData.getIntField(2, -1);
+
+		this->mappedEntries.insert_or_assign(((uint64_t) entry.component_type) << 32 | ((uint64_t) entry.id), entry.component_id);
+        
+        //this->entries.push_back(entry);
+
+		/*
+		//Darwin's stuff:
+		const auto& it = this->mappedEntries.find(entry.id);
+		if (it != mappedEntries.end()) {
+			const auto& iter = it->second.find(entry.component_type);
+			if (iter == it->second.end()) {
+				it->second.insert(std::make_pair(entry.component_type, entry.component_id));
+			}
+		}
+		else {
+			std::map<unsigned int, unsigned int> map;
+			map.insert(std::make_pair(entry.component_type, entry.component_id));
+			this->mappedEntries.insert(std::make_pair(entry.id, map));
+		}
+		*/
+
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+#endif
+}
+
+//! Destructor
+CDComponentsRegistryTable::~CDComponentsRegistryTable(void) { }
+
+//! Returns the table's name
+std::string CDComponentsRegistryTable::GetName(void) const {
+    return "ComponentsRegistry";
+}
+
+int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue) 
+{
+	const auto& iter = this->mappedEntries.find(((uint64_t) componentType) << 32 | ((uint64_t) id));
+
+	if (iter == this->mappedEntries.end())
+	{
+		return defaultValue;
+	}
+
+	return iter->second;
+
+	/*
+	const auto& it = this->mappedEntries.find(id);
+	if (it != mappedEntries.end()) {
+		const auto& iter = it->second.find(componentType);
+		if (iter != it->second.end()) {
+			return iter->second;
+		}
+	}
+	*/
+
+#ifndef CDCLIENT_CACHE_ALL
+    // Now get the data
+	std::stringstream query;
+
+	query << "SELECT * FROM ComponentsRegistry WHERE id = " << std::to_string(id);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
+    while (!tableData.eof()) {
+        CDComponentsRegistry entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.component_type = tableData.getIntField(1, -1);
+        entry.component_id = tableData.getIntField(2, -1);
+        
+        //this->entries.push_back(entry);
+
+		//Darwin's stuff:
+		const auto& it = this->mappedEntries.find(entry.id);
+		if (it != mappedEntries.end()) {
+			const auto& iter = it->second.find(entry.component_type);
+			if (iter == it->second.end()) {
+				it->second.insert(std::make_pair(entry.component_type, entry.component_id));
+			}
+		}
+		else {
+			std::map<unsigned int, unsigned int> map;
+			map.insert(std::make_pair(entry.component_type, entry.component_id));
+			this->mappedEntries.insert(std::make_pair(entry.id, map));
+		}
+
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+
+	const auto& it2 = this->mappedEntries.find(id);
+	if (it2 != mappedEntries.end()) {
+		const auto& iter = it2->second.find(componentType);
+		if (iter != it2->second.end()) {
+			return iter->second;
+		}
+	}
+
+	return defaultValue;
+#endif
+}

dDatabase/Tables/CDComponentsRegistryTable.h

@@ -0,0 +1,40 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+  \file CDComponentsRegistryTable.hpp
+  \brief Contains data for the ComponentsRegistry table
+ */
+
+//! ComponentsRegistry Entry Struct
+struct CDComponentsRegistry {
+    unsigned int id;                    //!< The LOT is used as the ID
+    unsigned int component_type;        //!< See ComponentTypes enum for values
+    unsigned int component_id;          //!< The ID used within the component's table (0 may either mean it's non-networked, or that the ID is actually 0
+};
+
+
+//! ComponentsRegistry table
+class CDComponentsRegistryTable : public CDTable {
+private:
+    //std::vector<CDComponentsRegistry> entries;
+    std::map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
+    
+public:
+    
+    //! Constructor
+    CDComponentsRegistryTable(void);
+    
+    //! Destructor
+    ~CDComponentsRegistryTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+
+    int32_t GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue = 0);
+};

dDatabase/Tables/CDCurrencyTableTable.cpp

@@ -0,0 +1,58 @@
+#include "CDCurrencyTableTable.h"
+
+//! Constructor
+CDCurrencyTableTable::CDCurrencyTableTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM CurrencyTable");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM CurrencyTable");
+    while (!tableData.eof()) {
+        CDCurrencyTable entry;
+        entry.currencyIndex = tableData.getIntField(0, -1);
+        entry.npcminlevel = tableData.getIntField(1, -1);
+        entry.minvalue = tableData.getIntField(2, -1);
+        entry.maxvalue = tableData.getIntField(3, -1);
+        entry.id = tableData.getIntField(4, -1);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDCurrencyTableTable::~CDCurrencyTableTable(void) { }
+
+//! Returns the table's name
+std::string CDCurrencyTableTable::GetName(void) const {
+    return "CurrencyTable";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDCurrencyTable> CDCurrencyTableTable::Query(std::function<bool(CDCurrencyTable)> predicate) {
+    
+    std::vector<CDCurrencyTable> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDCurrencyTable> CDCurrencyTableTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDCurrencyTableTable.h

@@ -0,0 +1,51 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDCurrencyTableTable.hpp
+ \brief Contains data for the CurrencyTable table
+ */
+
+//! CurrencyTable Struct
+struct CDCurrencyTable {
+    unsigned int currencyIndex;         //!< The Currency Index
+    unsigned int npcminlevel;           //!< The minimum level of the npc
+    unsigned int minvalue;              //!< The minimum currency
+    unsigned int maxvalue;              //!< The maximum currency
+    unsigned int id;                    //!< The ID of the currency index
+};
+
+//! CurrencyTable table
+class CDCurrencyTableTable : public CDTable {
+private:
+    std::vector<CDCurrencyTable> entries;
+    
+public:
+    
+    //! Constructor
+    CDCurrencyTableTable(void);
+    
+    //! Destructor
+    ~CDCurrencyTableTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDCurrencyTable> Query(std::function<bool(CDCurrencyTable)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDCurrencyTable> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDDestructibleComponentTable.cpp

@@ -0,0 +1,67 @@
+#include "CDDestructibleComponentTable.h"
+
+//! Constructor
+CDDestructibleComponentTable::CDDestructibleComponentTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM DestructibleComponent");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM DestructibleComponent");
+    while (!tableData.eof()) {
+        CDDestructibleComponent entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.faction = tableData.getIntField(1, -1);
+        entry.factionList = tableData.getStringField(2, "");
+        entry.life = tableData.getIntField(3, -1);
+        entry.imagination = tableData.getIntField(4, -1);
+        entry.LootMatrixIndex = tableData.getIntField(5, -1);
+        entry.CurrencyIndex = tableData.getIntField(6, -1);
+        entry.level = tableData.getIntField(7, -1);
+        entry.armor = tableData.getFloatField(8, -1.0f);
+        entry.death_behavior = tableData.getIntField(9, -1);
+        entry.isnpc = tableData.getIntField(10, -1) == 1 ? true : false;
+        entry.attack_priority = tableData.getIntField(11, -1);
+        entry.isSmashable = tableData.getIntField(12, -1) == 1 ? true : false;
+        entry.difficultyLevel = tableData.getIntField(13, -1);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDDestructibleComponentTable::~CDDestructibleComponentTable(void) { }
+
+//! Returns the table's name
+std::string CDDestructibleComponentTable::GetName(void) const {
+    return "DestructibleComponent";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDDestructibleComponent> CDDestructibleComponentTable::Query(std::function<bool(CDDestructibleComponent)> predicate) {
+    
+    std::vector<CDDestructibleComponent> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDDestructibleComponent> CDDestructibleComponentTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDDestructibleComponentTable.h

@@ -0,0 +1,60 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDDestructibleComponentTable.hpp
+ \brief Contains data for the DestructibleComponent table
+ */
+
+//! ItemComponent Struct
+struct CDDestructibleComponent {
+    unsigned int id;                            //!< The component ID from the ComponentsRegistry Table
+    int faction;                       //!< The Faction ID of the object
+    std::string factionList;               //!< A list of the faction IDs
+    int life;                          //!< The amount of life of the object
+    unsigned int imagination;                   //!< The amount of imagination of the object
+    int LootMatrixIndex;               //!< The Loot Matrix Index
+    int CurrencyIndex;                 //!< The Currency Index
+    unsigned int level;                         //!< ???
+    float armor;                        //!< The amount of armor of the object
+    unsigned int death_behavior;                //!< The behavior ID of the death behavior
+    bool isnpc;                         //!< Whether or not the object is an NPC
+    unsigned int attack_priority;               //!< ???
+    bool isSmashable;                   //!< Whether or not the object is smashable
+    int difficultyLevel;               //!< ???
+};
+
+//! ItemComponent table
+class CDDestructibleComponentTable : public CDTable {
+private:
+    std::vector<CDDestructibleComponent> entries;
+    
+public:
+    
+    //! Constructor
+    CDDestructibleComponentTable(void);
+    
+    //! Destructor
+    ~CDDestructibleComponentTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDDestructibleComponent> Query(std::function<bool(CDDestructibleComponent)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDDestructibleComponent> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDEmoteTable.cpp

@@ -0,0 +1,44 @@
+#include "CDEmoteTable.h"
+
+//! Constructor
+CDEmoteTableTable::CDEmoteTableTable(void) {
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Emotes");
+    while (!tableData.eof()) {
+        CDEmoteTable* entry = new CDEmoteTable();
+        entry->ID = tableData.getIntField(0, -1);
+        entry->animationName = tableData.getStringField(1, "");
+        entry->iconFilename = tableData.getStringField(2, "");
+        entry->channel = tableData.getIntField(3, -1);
+        entry->locked = tableData.getIntField(5, -1) != 0;
+        entry->localize = tableData.getIntField(6, -1) != 0;
+        entry->locState = tableData.getIntField(7, -1);
+        entry->gateVersion = tableData.getIntField(8, -1);
+
+        entries.insert(std::make_pair(entry->ID, entry));
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDEmoteTableTable::~CDEmoteTableTable(void) {
+    for (auto e : entries) {
+        if (e.second) delete e.second;
+    }
+    
+    entries.clear();
+}
+
+//! Returns the table's name
+std::string CDEmoteTableTable::GetName(void) const {
+    return "Emotes";
+}
+
+CDEmoteTable * CDEmoteTableTable::GetEmote(int id) {
+    for (auto e : entries) {
+        if (e.first == id) return e.second;
+    }
+    
+    return nullptr;
+}

dDatabase/Tables/CDEmoteTable.h

@@ -0,0 +1,56 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+#include <map>
+
+/*!
+ \file CDEmoteTable.hpp
+ \brief Contains data for the CDEmoteTable table
+ */
+
+//! CDEmoteEntry Struct
+struct CDEmoteTable {
+	CDEmoteTable() {
+		ID = -1;
+		animationName = "";
+		iconFilename = "";
+		locState = -1;
+		channel = -1;
+		locked = false;
+		localize = false;
+		gateVersion = -1;
+	}
+
+    int ID;
+    std::string animationName;
+    std::string iconFilename;
+    int locState;
+    int channel;
+    bool locked;
+    bool localize;
+    int gateVersion;
+};
+
+//! CDEmoteTable table
+class CDEmoteTableTable : public CDTable {
+private:
+    std::map<int, CDEmoteTable*> entries;
+
+public:
+
+    //! Constructor
+    CDEmoteTableTable(void);
+
+    //! Destructor
+    ~CDEmoteTableTable(void);
+
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Returns an emote by ID
+    CDEmoteTable* GetEmote(int id);
+};

dDatabase/Tables/CDFeatureGatingTable.cpp

@@ -0,0 +1,71 @@
+#include "CDFeatureGatingTable.h"
+
+//! Constructor
+CDFeatureGatingTable::CDFeatureGatingTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM FeatureGating");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM FeatureGating");
+    while (!tableData.eof()) {
+        CDFeatureGating entry;
+        entry.featureName = tableData.getStringField(0, "");
+        entry.major = tableData.getIntField(1, -1);
+        entry.current = tableData.getIntField(2, -1);
+        entry.minor = tableData.getIntField(3, -1);
+        entry.description = tableData.getStringField(4, "");
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDFeatureGatingTable::~CDFeatureGatingTable(void) { }
+
+//! Returns the table's name
+std::string CDFeatureGatingTable::GetName(void) const {
+    return "FeatureGating";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDFeatureGating> CDFeatureGatingTable::Query(std::function<bool(CDFeatureGating)> predicate) {
+    
+    std::vector<CDFeatureGating> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+bool CDFeatureGatingTable::FeatureUnlocked(const std::string& feature) const
+{
+    for (const auto& entry : entries)
+    {
+        if (entry.featureName == feature)
+        {
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+//! Gets all the entries in the table
+std::vector<CDFeatureGating> CDFeatureGatingTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDFeatureGatingTable.h

@@ -0,0 +1,52 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDFeatureGatingTable.hpp
+ */
+
+//! ItemComponent Struct
+struct CDFeatureGating {
+    std::string featureName;
+    int32_t major;
+    int32_t current;
+    int32_t minor;
+    std::string description;
+};
+
+//! ItemComponent table
+class CDFeatureGatingTable : public CDTable {
+private:
+    std::vector<CDFeatureGating> entries;
+    
+public:
+    
+    //! Constructor
+    CDFeatureGatingTable(void);
+    
+    //! Destructor
+    ~CDFeatureGatingTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDFeatureGating> Query(std::function<bool(CDFeatureGating)> predicate);
+
+    bool FeatureUnlocked(const std::string& feature) const;
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDFeatureGating> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDInventoryComponentTable.cpp

@@ -0,0 +1,57 @@
+#include "CDInventoryComponentTable.h"
+
+//! Constructor
+CDInventoryComponentTable::CDInventoryComponentTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM InventoryComponent");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM InventoryComponent");
+    while (!tableData.eof()) {
+        CDInventoryComponent entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.itemid = tableData.getIntField(1, -1);
+        entry.count = tableData.getIntField(2, -1);
+        entry.equip = tableData.getIntField(3, -1) == 1 ? true : false;
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDInventoryComponentTable::~CDInventoryComponentTable(void) { }
+
+//! Returns the table's name
+std::string CDInventoryComponentTable::GetName(void) const {
+    return "InventoryComponent";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDInventoryComponent> CDInventoryComponentTable::Query(std::function<bool(CDInventoryComponent)> predicate) {
+    
+    std::vector<CDInventoryComponent> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDInventoryComponent> CDInventoryComponentTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDInventoryComponentTable.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDInventoryComponentTable.hpp
+ \brief Contains data for the InventoryComponent table
+ */
+
+//! ItemComponent Struct
+struct CDInventoryComponent {
+    unsigned int id;                //!< The component ID for this object
+    unsigned int itemid;            //!< The LOT of the object
+    unsigned int count;             //!< The count of the items the object has
+    bool equip;             //!< Whether or not to equip the item
+};
+
+//! ItemComponent table
+class CDInventoryComponentTable : public CDTable {
+private:
+    std::vector<CDInventoryComponent> entries;
+    
+public:
+    
+    //! Constructor
+    CDInventoryComponentTable(void);
+    
+    //! Destructor
+    ~CDInventoryComponentTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDInventoryComponent> Query(std::function<bool(CDInventoryComponent)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDInventoryComponent> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDItemComponentTable.cpp

@@ -0,0 +1,179 @@
+#include "CDItemComponentTable.h"
+#include "GeneralUtils.h"
+
+CDItemComponent CDItemComponentTable::Default = {};
+
+//! Constructor
+CDItemComponentTable::CDItemComponentTable(void) {
+    Default = CDItemComponent();
+    
+#ifdef CDCLIENT_CACHE_ALL
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemComponent");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemComponent");
+    while (!tableData.eof()) {
+        CDItemComponent entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.equipLocation = tableData.getStringField(1, "");
+        entry.baseValue = tableData.getIntField(2, -1);
+        entry.isKitPiece = tableData.getIntField(3, -1) == 1 ? true : false;
+        entry.rarity = tableData.getIntField(4, 0);
+        entry.itemType = tableData.getIntField(5, -1);
+        entry.itemInfo = tableData.getInt64Field(6, -1);
+        entry.inLootTable = tableData.getIntField(7, -1) == 1 ? true : false;
+        entry.inVendor = tableData.getIntField(8, -1) == 1 ? true : false;
+        entry.isUnique = tableData.getIntField(9, -1) == 1 ? true : false;
+        entry.isBOP = tableData.getIntField(10, -1) == 1 ? true : false;
+        entry.isBOE = tableData.getIntField(11, -1) == 1 ? true : false;
+        entry.reqFlagID = tableData.getIntField(12, -1);
+        entry.reqSpecialtyID = tableData.getIntField(13, -1);
+        entry.reqSpecRank = tableData.getIntField(14, -1);
+        entry.reqAchievementID = tableData.getIntField(15, -1);
+        entry.stackSize = tableData.getIntField(16, -1);
+        entry.color1 = tableData.getIntField(17, -1);
+        entry.decal = tableData.getIntField(18, -1);
+        entry.offsetGroupID = tableData.getIntField(19, -1);
+        entry.buildTypes = tableData.getIntField(20, -1);
+        entry.reqPrecondition = tableData.getStringField(21, "");
+        entry.animationFlag = tableData.getIntField(22, -1);
+        entry.equipEffects = tableData.getIntField(23, -1);
+        entry.readyForQA = tableData.getIntField(24, -1) == 1 ? true : false;
+        entry.itemRating = tableData.getIntField(25, -1);
+        entry.isTwoHanded = tableData.getIntField(26, -1) == 1 ? true : false;
+        entry.minNumRequired = tableData.getIntField(27, -1);
+        entry.delResIndex = tableData.getIntField(28, -1);
+        entry.currencyLOT = tableData.getIntField(29, -1);
+        entry.altCurrencyCost = tableData.getIntField(30, -1);
+        entry.subItems = tableData.getStringField(31, "");
+        entry.audioEventUse = tableData.getStringField(32, "");
+        entry.noEquipAnimation = tableData.getIntField(33, -1) == 1 ? true : false;
+        entry.commendationLOT = tableData.getIntField(34, -1);
+        entry.commendationCost = tableData.getIntField(35, -1);
+        entry.audioEquipMetaEventSet = tableData.getStringField(36, "");
+        entry.currencyCosts = tableData.getStringField(37, "");
+        entry.ingredientInfo = tableData.getStringField(38, "");
+        entry.locStatus = tableData.getIntField(39, -1);
+        entry.forgeType = tableData.getIntField(40, -1);
+        entry.SellMultiplier = tableData.getFloatField(41, -1.0f);
+        
+		this->entries.insert(std::make_pair(entry.id, entry));
+		tableData.nextRow();
+    }
+
+	tableData.finalize();
+#endif
+}
+
+//! Destructor
+CDItemComponentTable::~CDItemComponentTable(void) { }
+
+//! Returns the table's name
+std::string CDItemComponentTable::GetName(void) const {
+    return "ItemComponent";
+}
+
+const CDItemComponent & CDItemComponentTable::GetItemComponentByID(unsigned int skillID) {
+	const auto& it = this->entries.find(skillID);
+	if (it != this->entries.end()) {
+		return it->second;
+	}
+
+#ifndef CDCLIENT_CACHE_ALL
+	std::stringstream query;
+
+	query << "SELECT * FROM ItemComponent WHERE id = " << std::to_string(skillID);
+
+	auto tableData = CDClientDatabase::ExecuteQuery(query.str());
+    if (tableData.eof()) {
+		entries.insert(std::make_pair(skillID, Default));
+		return Default;
+	}
+
+    while (!tableData.eof()) {
+        CDItemComponent entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.equipLocation = tableData.getStringField(1, "");
+        entry.baseValue = tableData.getIntField(2, -1);
+        entry.isKitPiece = tableData.getIntField(3, -1) == 1 ? true : false;
+        entry.rarity = tableData.getIntField(4, 0);
+        entry.itemType = tableData.getIntField(5, -1);
+        entry.itemInfo = tableData.getInt64Field(6, -1);
+        entry.inLootTable = tableData.getIntField(7, -1) == 1 ? true : false;
+        entry.inVendor = tableData.getIntField(8, -1) == 1 ? true : false;
+        entry.isUnique = tableData.getIntField(9, -1) == 1 ? true : false;
+        entry.isBOP = tableData.getIntField(10, -1) == 1 ? true : false;
+        entry.isBOE = tableData.getIntField(11, -1) == 1 ? true : false;
+        entry.reqFlagID = tableData.getIntField(12, -1);
+        entry.reqSpecialtyID = tableData.getIntField(13, -1);
+        entry.reqSpecRank = tableData.getIntField(14, -1);
+        entry.reqAchievementID = tableData.getIntField(15, -1);
+        entry.stackSize = tableData.getIntField(16, -1);
+        entry.color1 = tableData.getIntField(17, -1);
+        entry.decal = tableData.getIntField(18, -1);
+        entry.offsetGroupID = tableData.getIntField(19, -1);
+        entry.buildTypes = tableData.getIntField(20, -1);
+        entry.reqPrecondition = tableData.getStringField(21, "");
+        entry.animationFlag = tableData.getIntField(22, -1);
+        entry.equipEffects = tableData.getIntField(23, -1);
+        entry.readyForQA = tableData.getIntField(24, -1) == 1 ? true : false;
+        entry.itemRating = tableData.getIntField(25, -1);
+        entry.isTwoHanded = tableData.getIntField(26, -1) == 1 ? true : false;
+        entry.minNumRequired = tableData.getIntField(27, -1);
+        entry.delResIndex = tableData.getIntField(28, -1);
+        entry.currencyLOT = tableData.getIntField(29, -1);
+        entry.altCurrencyCost = tableData.getIntField(30, -1);
+        entry.subItems = tableData.getStringField(31, "");
+        UNUSED(entry.audioEventUse = tableData.getStringField(32, ""));
+        entry.noEquipAnimation = tableData.getIntField(33, -1) == 1 ? true : false;
+        entry.commendationLOT = tableData.getIntField(34, -1);
+        entry.commendationCost = tableData.getIntField(35, -1);
+        UNUSED(entry.audioEquipMetaEventSet = tableData.getStringField(36, ""));
+        entry.currencyCosts = tableData.getStringField(37, "");
+        UNUSED(entry.ingredientInfo = tableData.getStringField(38, ""));
+        entry.locStatus = tableData.getIntField(39, -1);
+        entry.forgeType = tableData.getIntField(40, -1);
+        entry.SellMultiplier = tableData.getFloatField(41, -1.0f);
+        
+		this->entries.insert(std::make_pair(entry.id, entry));
+		tableData.nextRow();
+    }
+
+	const auto& it2 = this->entries.find(skillID);
+	if (it2 != this->entries.end()) {
+		return it2->second;
+	}
+#endif
+
+    return Default;
+}
+
+std::map<LOT, uint32_t> CDItemComponentTable::ParseCraftingCurrencies(const CDItemComponent& itemComponent) {
+    std::map<LOT, uint32_t> currencies = {};
+
+    if (!itemComponent.currencyCosts.empty()) {
+        auto currencySplit = GeneralUtils::SplitString(itemComponent.currencyCosts, ',');
+        for (const auto& currencyAmount : currencySplit) {
+            auto amountSplit = GeneralUtils::SplitString(currencyAmount, ':');
+
+            // Checking for 2 here, not sure what to do when there's more stuff than expected
+            if (amountSplit.size() == 2) {
+                currencies.insert({
+                    std::stol(amountSplit[0]),
+                    std::stoi(amountSplit[1])
+                });
+            }
+        }
+    }
+
+    return currencies;
+}

dDatabase/Tables/CDItemComponentTable.h

@@ -0,0 +1,83 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+#include "dCommonVars.h"
+
+/*!
+  \file CDItemComponentTable.hpp
+  \brief Contains data for the ItemComponent table
+ */
+
+//! ItemComponent Struct
+struct CDItemComponent {
+    unsigned int id;                        //!< The Component ID
+    std::string equipLocation;         //!< The equip location
+    unsigned int baseValue;                 //!< The monetary base value of the item
+    bool isKitPiece;                //!< Whether or not the item belongs to a kit
+    unsigned int rarity;                    //!< The rarity of the item
+    unsigned int itemType;                  //!< The item type
+    int64_t itemInfo;                  //!< The item info
+    bool inLootTable;               //!< Whether or not the item is in a loot table
+    bool inVendor;                  //!< Whether or not the item is in a vendor inventory
+    bool isUnique;                  //!< ???
+    bool isBOP;                     //!< ???
+    bool isBOE;                     //!< ???
+    unsigned int reqFlagID;                 //!< User must have completed this flag to get the item
+    unsigned int reqSpecialtyID;            //!< ???
+    unsigned int reqSpecRank;               //!< ???
+    unsigned int reqAchievementID;          //!< The required achievement must be completed
+    unsigned int stackSize;                 //!< The stack size of the item
+    unsigned int color1;                    //!< Something to do with item color...
+    unsigned int decal;                     //!< The decal of the item
+    unsigned int offsetGroupID;             //!< Something to do with group IDs
+    unsigned int buildTypes;                //!< Something to do with building
+    std::string reqPrecondition;       //!< The required precondition
+    unsigned int animationFlag;             //!< The Animation Flag
+    unsigned int equipEffects;              //!< The effect played when the item is equipped
+    bool readyForQA;                //!< ???
+    unsigned int itemRating;                //!< ???
+    bool isTwoHanded;               //!< Whether or not the item is double handed
+    unsigned int minNumRequired;            //!< Maybe the minimum number required for a mission, or to own this object?
+    unsigned int delResIndex;               //!< ???
+    unsigned int currencyLOT;               //!< ???
+    unsigned int altCurrencyCost;           //!< ???
+    std::string subItems;              //!< A comma seperate string of sub items (maybe for multi-itemed things like faction test gear set)
+    UNUSED(std::string audioEventUse);         //!< ???
+    bool noEquipAnimation;          //!< Whether or not there is an equip animation
+    unsigned int commendationLOT;           //!< The commendation LOT
+    unsigned int commendationCost;          //!< The commendation cost
+    UNUSED(std::string audioEquipMetaEventSet);    //!< ???
+    std::string currencyCosts;         //!< Used for crafting
+    UNUSED(std::string ingredientInfo);        //!< Unused
+    unsigned int locStatus;                 //!< ???
+    unsigned int forgeType;                 //!< Forge Type
+    float SellMultiplier;           //!< Something to do with early vendors perhaps (but replaced)
+};
+
+//! ItemComponent table
+class CDItemComponentTable : public CDTable {
+private:
+    std::map<unsigned int, CDItemComponent> entries;
+    
+public:
+    
+    //! Constructor
+    CDItemComponentTable(void);
+    
+    //! Destructor
+    ~CDItemComponentTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+
+    static std::map<LOT, uint32_t> ParseCraftingCurrencies(const CDItemComponent& itemComponent);
+    
+	//! Gets an entry by ID
+	const CDItemComponent& GetItemComponentByID(unsigned int skillID);
+    
+    static CDItemComponent Default;
+};

dDatabase/Tables/CDItemSetSkillsTable.cpp

@@ -0,0 +1,68 @@
+#include "CDItemSetSkillsTable.h"
+
+//! Constructor
+CDItemSetSkillsTable::CDItemSetSkillsTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemSetSkills");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemSetSkills");
+    while (!tableData.eof()) {
+        CDItemSetSkills entry;
+        entry.SkillSetID = tableData.getIntField(0, -1);
+        entry.SkillID = tableData.getIntField(1, -1);
+        entry.SkillCastType = tableData.getIntField(2, -1);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDItemSetSkillsTable::~CDItemSetSkillsTable(void) { }
+
+//! Returns the table's name
+std::string CDItemSetSkillsTable::GetName(void) const {
+    return "ItemSetSkills";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDItemSetSkills> CDItemSetSkillsTable::Query(std::function<bool(CDItemSetSkills)> predicate) {
+    
+    std::vector<CDItemSetSkills> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetEntries(void) const {
+    return this->entries;
+}
+
+std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetBySkillID(unsigned int SkillSetID)
+{
+	std::vector<CDItemSetSkills> toReturn;
+	
+	for (CDItemSetSkills entry : this->entries) {
+		if (entry.SkillSetID == SkillSetID) toReturn.push_back(entry);
+		if (entry.SkillSetID > SkillSetID) return toReturn; //stop seeking in the db if it's not needed.
+	}
+
+	return toReturn;
+}

dDatabase/Tables/CDItemSetSkillsTable.h

@@ -0,0 +1,52 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDItemSetSkillsTable.hpp
+ \brief Contains data for the ItemSetSkills table
+ */
+
+//! ZoneTable Struct
+struct CDItemSetSkills {
+    unsigned int SkillSetID;            //!< The skill set ID
+    unsigned int SkillID;               //!< The skill ID
+    unsigned int SkillCastType;         //!< The skill cast type
+};
+
+//! ItemSets table
+class CDItemSetSkillsTable : public CDTable {
+private:
+    std::vector<CDItemSetSkills> entries;
+    
+public:
+    
+    //! Constructor
+    CDItemSetSkillsTable(void);
+    
+    //! Destructor
+    ~CDItemSetSkillsTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDItemSetSkills> Query(std::function<bool(CDItemSetSkills)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDItemSetSkills> GetEntries(void) const;
+
+	std::vector<CDItemSetSkills> GetBySkillID(unsigned int SkillSetID);
+    
+};
+

dDatabase/Tables/CDItemSetsTable.cpp

@@ -0,0 +1,68 @@
+#include "CDItemSetsTable.h"
+
+//! Constructor
+CDItemSetsTable::CDItemSetsTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemSets");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ItemSets");
+    while (!tableData.eof()) {
+        CDItemSets entry;
+        entry.setID = tableData.getIntField(0, -1);
+        entry.locStatus = tableData.getIntField(1, -1);
+        entry.itemIDs = tableData.getStringField(2, "");
+        entry.kitType = tableData.getIntField(3, -1);
+        entry.kitRank = tableData.getIntField(4, -1);
+        entry.kitImage = tableData.getIntField(5, -1);
+        entry.skillSetWith2 = tableData.getIntField(6, -1);
+        entry.skillSetWith3 = tableData.getIntField(7, -1);
+        entry.skillSetWith4 = tableData.getIntField(8, -1);
+        entry.skillSetWith5 = tableData.getIntField(9, -1);
+        entry.skillSetWith6 = tableData.getIntField(10, -1);
+        entry.localize = tableData.getIntField(11, -1) == 1 ? true : false;
+        entry.gate_version = tableData.getStringField(12, "");
+        entry.kitID = tableData.getIntField(13, -1);
+        entry.priority = tableData.getFloatField(14, -1.0f);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDItemSetsTable::~CDItemSetsTable(void) { }
+
+//! Returns the table's name
+std::string CDItemSetsTable::GetName(void) const {
+    return "ItemSets";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDItemSets> CDItemSetsTable::Query(std::function<bool(CDItemSets)> predicate) {
+    
+    std::vector<CDItemSets> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDItemSets> CDItemSetsTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDItemSetsTable.h

@@ -0,0 +1,62 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDItemSetsTable.hpp
+ \brief Contains data for the ItemSets table
+ */
+
+//! ZoneTable Struct
+struct CDItemSets {
+    unsigned int setID;             //!< The item set ID
+    unsigned int locStatus;         //!< The loc status
+    std::string itemIDs;       //!< THe item IDs
+    unsigned int kitType;           //!< The item kit type
+    unsigned int kitRank;           //!< The item kit rank
+    unsigned int kitImage;          //!< The item kit image
+    unsigned int skillSetWith2;     //!< The skill set with 2
+    unsigned int skillSetWith3;     //!< The skill set with 3
+    unsigned int skillSetWith4;     //!< The skill set with 4
+    unsigned int skillSetWith5;     //!< The skill set with 5
+    unsigned int skillSetWith6;     //!< The skill set with 6
+    bool localize;          //!< Whether or localize
+    std::string gate_version;  //!< The gate version
+    unsigned int kitID;             //!< The kit ID
+    float priority;         //!< The priority
+};
+
+//! ItemSets table
+class CDItemSetsTable : public CDTable {
+private:
+    std::vector<CDItemSets> entries;
+    
+public:
+    
+    //! Constructor
+    CDItemSetsTable(void);
+    
+    //! Destructor
+    ~CDItemSetsTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDItemSets> Query(std::function<bool(CDItemSets)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDItemSets> GetEntries(void) const;
+    
+};
+

dDatabase/Tables/CDLevelProgressionLookupTable.cpp

@@ -0,0 +1,56 @@
+#include "CDLevelProgressionLookupTable.h"
+
+//! Constructor
+CDLevelProgressionLookupTable::CDLevelProgressionLookupTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LevelProgressionLookup");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LevelProgressionLookup");
+    while (!tableData.eof()) {
+        CDLevelProgressionLookup entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.requiredUScore = tableData.getIntField(1, -1);
+        entry.BehaviorEffect = tableData.getStringField(2, "");
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDLevelProgressionLookupTable::~CDLevelProgressionLookupTable(void) { }
+
+//! Returns the table's name
+std::string CDLevelProgressionLookupTable::GetName(void) const {
+    return "LevelProgressionLookup";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDLevelProgressionLookup> CDLevelProgressionLookupTable::Query(std::function<bool(CDLevelProgressionLookup)> predicate) {
+    
+    std::vector<CDLevelProgressionLookup> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDLevelProgressionLookup> CDLevelProgressionLookupTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDLevelProgressionLookupTable.h

@@ -0,0 +1,49 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDLevelProgressionLookupTable.hpp
+ \brief Contains data for the LevelProgressionLookup table
+ */
+
+//! LevelProgressionLookup Entry Struct
+struct CDLevelProgressionLookup {
+    unsigned int id;                    //!< The Level ID
+    unsigned int requiredUScore;        //!< The required LEGO Score
+    std::string BehaviorEffect;    //!< The behavior effect attached to this
+};
+
+//! LevelProgressionLookup table
+class CDLevelProgressionLookupTable : public CDTable {
+private:
+    std::vector<CDLevelProgressionLookup> entries;
+    
+public:
+    
+    //! Constructor
+    CDLevelProgressionLookupTable(void);
+    
+    //! Destructor
+    ~CDLevelProgressionLookupTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDLevelProgressionLookup> Query(std::function<bool(CDLevelProgressionLookup)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDLevelProgressionLookup> GetEntries(void) const;
+    
+};

dDatabase/Tables/CDLootMatrixTable.cpp

@@ -0,0 +1,62 @@
+#include "CDLootMatrixTable.h"
+
+//! Constructor
+CDLootMatrixTable::CDLootMatrixTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootMatrix");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootMatrix");
+    while (!tableData.eof()) {
+        CDLootMatrix entry;
+        entry.LootMatrixIndex = tableData.getIntField(0, -1);
+        entry.LootTableIndex = tableData.getIntField(1, -1);
+        entry.RarityTableIndex = tableData.getIntField(2, -1);
+        entry.percent = tableData.getFloatField(3, -1.0f);
+        entry.minToDrop = tableData.getIntField(4, -1);
+        entry.maxToDrop = tableData.getIntField(5, -1);
+        entry.id = tableData.getIntField(6, -1);
+        entry.flagID = tableData.getIntField(7, -1);
+        UNUSED(entry.gate_version = tableData.getStringField(8, ""));
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDLootMatrixTable::~CDLootMatrixTable(void) { }
+
+//! Returns the table's name
+std::string CDLootMatrixTable::GetName(void) const {
+    return "LootMatrix";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDLootMatrix> CDLootMatrixTable::Query(std::function<bool(CDLootMatrix)> predicate) {
+    
+    std::vector<CDLootMatrix> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDLootMatrix> CDLootMatrixTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDLootMatrixTable.h

@@ -0,0 +1,56 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDLootMatrixTable.hpp
+ \brief Contains data for the ObjectSkills table
+ */
+
+//! LootMatrix Struct
+struct CDLootMatrix {
+    unsigned int LootMatrixIndex;           //!< The Loot Matrix Index
+    unsigned int LootTableIndex;            //!< The Loot Table Index
+    unsigned int RarityTableIndex;          //!< The Rarity Table Index
+    float percent;                   //!< The percent that this matrix is used?
+    unsigned int minToDrop;                 //!< The minimum amount of loot from this matrix to drop
+    unsigned int maxToDrop;                 //!< The maximum amount of loot from this matrix to drop
+    unsigned int id;                        //!< The ID of the Loot Matrix
+    unsigned int flagID;                    //!< ???
+    UNUSED(std::string gate_version);          //!< The Gate Version
+};
+
+//! MissionNPCComponent table
+class CDLootMatrixTable : public CDTable {
+private:
+    std::vector<CDLootMatrix> entries;
+    
+public:
+    
+    //! Constructor
+    CDLootMatrixTable(void);
+    
+    //! Destructor
+    ~CDLootMatrixTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDLootMatrix> Query(std::function<bool(CDLootMatrix)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDLootMatrix> GetEntries(void) const;
+    
+};
+

dDatabase/Tables/CDLootTableTable.cpp

@@ -0,0 +1,59 @@
+#include "CDLootTableTable.h"
+
+//! Constructor
+CDLootTableTable::CDLootTableTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootTable");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootTable");
+    while (!tableData.eof()) {
+        CDLootTable entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.itemid = tableData.getIntField(0, -1);
+        entry.LootTableIndex = tableData.getIntField(1, -1);
+        entry.id = tableData.getIntField(2, -1);
+        entry.MissionDrop = tableData.getIntField(3, -1) == 1 ? true : false;
+        entry.sortPriority = tableData.getIntField(4, -1);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDLootTableTable::~CDLootTableTable(void) { }
+
+//! Returns the table's name
+std::string CDLootTableTable::GetName(void) const {
+    return "LootTable";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDLootTable> CDLootTableTable::Query(std::function<bool(CDLootTable)> predicate) {
+    
+    std::vector<CDLootTable> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDLootTable> CDLootTableTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDLootTableTable.h

@@ -0,0 +1,52 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDLootTableTable.hpp
+ \brief Contains data for the LootTable table
+ */
+
+//! LootTable Struct
+struct CDLootTable {
+    unsigned int itemid;                 //!< The LOT of the item
+    unsigned int LootTableIndex;         //!< The Loot Table Index
+    unsigned int id;                     //!< The ID
+    bool MissionDrop;               //!< Whether or not this loot table is a mission drop
+    unsigned int sortPriority;           //!< The sorting priority
+};
+
+//! LootTable table
+class CDLootTableTable : public CDTable {
+private:
+    std::vector<CDLootTable> entries;
+    
+public:
+    
+    //! Constructor
+    CDLootTableTable(void);
+    
+    //! Destructor
+    ~CDLootTableTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDLootTable> Query(std::function<bool(CDLootTable)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDLootTable> GetEntries(void) const;
+    
+};
+

dDatabase/Tables/CDMissionEmailTable.cpp

@@ -0,0 +1,61 @@
+#include "CDMissionEmailTable.h"
+
+//! Constructor
+CDMissionEmailTable::CDMissionEmailTable(void) {
+
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionEmail");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+
+        tableSize.nextRow();
+    }
+    
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionEmail");
+    while (!tableData.eof()) {
+        CDMissionEmail entry;
+        entry.ID = tableData.getIntField(0, -1);
+        entry.messageType = tableData.getIntField(1, -1);
+        entry.notificationGroup = tableData.getIntField(2, -1);
+        entry.missionID = tableData.getIntField(3, -1);
+        entry.attachmentLOT = tableData.getIntField(4, 0);
+        entry.localize = (bool)tableData.getIntField(5, -1);
+        entry.locStatus = tableData.getIntField(6, -1);
+        entry.gate_version = tableData.getStringField(7, "");
+
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDMissionEmailTable::~CDMissionEmailTable(void) { }
+
+//! Returns the table's name
+std::string CDMissionEmailTable::GetName(void) const {
+    return "MissionEmail";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDMissionEmail> CDMissionEmailTable::Query(std::function<bool(CDMissionEmail)> predicate) {
+
+    std::vector<CDMissionEmail> data = cpplinq::from(this->entries)
+        >> cpplinq::where(predicate)
+        >> cpplinq::to_vector();
+
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDMissionEmail> CDMissionEmailTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDMissionEmailTable.h

@@ -0,0 +1,55 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDMissionEmailTable.hpp
+ \brief Contains data for the MissionEmail table
+ */
+
+ //! MissionEmail Entry Struct
+struct CDMissionEmail {
+    unsigned int ID;
+    unsigned int messageType;
+    unsigned int notificationGroup;
+    unsigned int missionID;
+    unsigned int attachmentLOT;
+    bool localize;
+    unsigned int locStatus;
+    std::string gate_version;
+};
+
+
+//! MissionEmail table
+class CDMissionEmailTable : public CDTable {
+private:
+    std::vector<CDMissionEmail> entries;
+
+public:
+
+    //! Constructor
+    CDMissionEmailTable(void);
+
+    //! Destructor
+    ~CDMissionEmailTable(void);
+
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDMissionEmail> Query(std::function<bool(CDMissionEmail)> predicate);
+
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDMissionEmail> GetEntries(void) const;
+
+};

dDatabase/Tables/CDMissionNPCComponentTable.cpp

@@ -0,0 +1,58 @@
+#include "CDMissionNPCComponentTable.h"
+
+//! Constructor
+CDMissionNPCComponentTable::CDMissionNPCComponentTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionNPCComponent");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionNPCComponent");
+    while (!tableData.eof()) {
+        CDMissionNPCComponent entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.missionID = tableData.getIntField(1, -1);
+        entry.offersMission = tableData.getIntField(2, -1) == 1 ? true : false;
+        entry.acceptsMission = tableData.getIntField(3, -1) == 1 ? true : false;
+        entry.gate_version = tableData.getStringField(4, "");
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDMissionNPCComponentTable::~CDMissionNPCComponentTable(void) { }
+
+//! Returns the table's name
+std::string CDMissionNPCComponentTable::GetName(void) const {
+    return "MissionNPCComponent";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDMissionNPCComponent> CDMissionNPCComponentTable::Query(std::function<bool(CDMissionNPCComponent)> predicate) {
+    
+    std::vector<CDMissionNPCComponent> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+std::vector<CDMissionNPCComponent> CDMissionNPCComponentTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDMissionNPCComponentTable.h

@@ -0,0 +1,52 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDMissionNPCComponentTable.hpp
+ \brief Contains data for the ObjectSkills table
+ */
+
+//! MissionNPCComponent Struct
+struct CDMissionNPCComponent {
+    unsigned int id;                //!< The ID
+    unsigned int missionID;         //!< The Mission ID
+    bool offersMission;     //!< Whether or not this NPC offers a mission
+    bool acceptsMission;    //!< Whether or not this NPC accepts a mission
+    std::string gate_version;  //!< The gate version
+};
+
+//! MissionNPCComponent table
+class CDMissionNPCComponentTable : public CDTable {
+private:
+    std::vector<CDMissionNPCComponent> entries;
+    
+public:
+    
+    //! Constructor
+    CDMissionNPCComponentTable(void);
+    
+    //! Destructor
+    ~CDMissionNPCComponentTable(void);
+    
+    //! Returns the table's name
+    /*!
+      \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+      \param predicate The predicate
+     */
+    std::vector<CDMissionNPCComponent> Query(std::function<bool(CDMissionNPCComponent)> predicate);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    std::vector<CDMissionNPCComponent> GetEntries(void) const;
+    
+};
+

dDatabase/Tables/CDMissionTasksTable.cpp

@@ -0,0 +1,83 @@
+#include "CDMissionTasksTable.h"
+
+//! Constructor
+CDMissionTasksTable::CDMissionTasksTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionTasks");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionTasks");
+    while (!tableData.eof()) {
+        CDMissionTasks entry;
+        entry.id = tableData.getIntField(0, -1);
+        UNUSED(entry.locStatus = tableData.getIntField(1, -1));
+        entry.taskType = tableData.getIntField(2, -1);
+        entry.target = tableData.getIntField(3, -1);
+        entry.targetGroup = tableData.getStringField(4, "");
+        entry.targetValue = tableData.getIntField(5, -1);
+        entry.taskParam1 = tableData.getStringField(6, "");
+        UNUSED(entry.largeTaskIcon = tableData.getStringField(7, ""));
+        UNUSED(entry.IconID = tableData.getIntField(8, -1));
+        entry.uid = tableData.getIntField(9, -1);
+        UNUSED(entry.largeTaskIconID = tableData.getIntField(10, -1));
+        UNUSED(entry.localize = tableData.getIntField(11, -1) == 1 ? true : false);
+        UNUSED(entry.gate_version = tableData.getStringField(12, ""));
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+}
+
+//! Destructor
+CDMissionTasksTable::~CDMissionTasksTable(void) { }
+
+//! Returns the table's name
+std::string CDMissionTasksTable::GetName(void) const {
+    return "MissionTasks";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMissionTasks)> predicate) {
+    
+    std::vector<CDMissionTasks> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(uint32_t missionID)
+{
+    std::vector<CDMissionTasks*> tasks;
+
+    for (auto& entry : this->entries)
+    {
+        if (entry.id == missionID)
+        {
+            CDMissionTasks* task = const_cast<CDMissionTasks*>(&entry);
+
+            tasks.push_back(task);
+        }
+    }
+
+    return tasks;
+}
+
+//! Gets all the entries in the table
+const std::vector<CDMissionTasks>& CDMissionTasksTable::GetEntries(void) const {
+    return this->entries;
+}

dDatabase/Tables/CDMissionTasksTable.h

@@ -0,0 +1,61 @@
+#pragma once
+
+// Custom Classes
+#include "CDTable.h"
+
+/*!
+ \file CDMissionTasksTable.hpp
+ \brief Contains data for the MissionTasks table
+ */
+
+//! ObjectSkills Struct
+struct CDMissionTasks {
+    unsigned int id;                //!< The Mission ID that the task belongs to
+    UNUSED(unsigned int locStatus);         //!< ???
+    unsigned int taskType;          //!< The task type
+    unsigned int target;            //!< The mission target
+    std::string targetGroup;        //!< The mission target group
+    int targetValue;       //!< The target value
+    std::string taskParam1;    //!< The task param 1
+    UNUSED(std::string largeTaskIcon); //!< ???
+    UNUSED(unsigned int IconID);            //!< ???
+    unsigned int uid;               //!< ???
+    UNUSED(unsigned int largeTaskIconID);   //!< ???
+    UNUSED(bool localize);          //!< Whether or not the task should be localized
+    UNUSED(std::string gate_version);  //!< ???
+};
+
+//! ObjectSkills table
+class CDMissionTasksTable : public CDTable {
+private:
+    std::vector<CDMissionTasks> entries;
+    
+public:
+    
+    //! Constructor
+    CDMissionTasksTable(void);
+    
+    //! Destructor
+    ~CDMissionTasksTable(void);
+    
+    //! Returns the table's name
+    /*!
+     \return The table name
+     */
+    std::string GetName(void) const override;
+    
+    //! Queries the table with a custom "where" clause
+    /*!
+     \param predicate The predicate
+     */
+    std::vector<CDMissionTasks> Query(std::function<bool(CDMissionTasks)> predicate);
+
+    std::vector<CDMissionTasks*> GetByMissionID(uint32_t missionID);
+    
+    //! Gets all the entries in the table
+    /*!
+      \return The entries
+     */
+    const std::vector<CDMissionTasks>& GetEntries(void) const;
+};
+

dDatabase/Tables/CDMissionsTable.cpp

@@ -0,0 +1,139 @@
+#include "CDMissionsTable.h"
+
+CDMissions CDMissionsTable::Default = {};
+
+//! Constructor
+CDMissionsTable::CDMissionsTable(void) {
+    
+    // First, get the size of the table
+    unsigned int size = 0;
+    auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Missions");
+    while (!tableSize.eof()) {
+        size = tableSize.getIntField(0, 0);
+        
+        tableSize.nextRow();
+    }
+        
+	tableSize.finalize();
+    
+    // Reserve the size
+    this->entries.reserve(size);
+    
+    // Now get the data
+    auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Missions");
+    while (!tableData.eof()) {
+        CDMissions entry;
+        entry.id = tableData.getIntField(0, -1);
+        entry.defined_type = tableData.getStringField(1, "");
+        entry.defined_subtype = tableData.getStringField(2, "");
+        entry.UISortOrder = tableData.getIntField(3, -1);
+        entry.offer_objectID = tableData.getIntField(4, -1);
+        entry.target_objectID = tableData.getIntField(5, -1);
+        entry.reward_currency = tableData.getInt64Field(6, -1);
+        entry.LegoScore = tableData.getIntField(7, -1);
+        entry.reward_reputation = tableData.getIntField(8, -1);
+        entry.isChoiceReward = tableData.getIntField(9, -1) == 1 ? true : false;
+        entry.reward_item1 = tableData.getIntField(10, 0);
+        entry.reward_item1_count = tableData.getIntField(11, 0);
+        entry.reward_item2 = tableData.getIntField(12, 0);
+        entry.reward_item2_count = tableData.getIntField(13, 0);
+        entry.reward_item3 = tableData.getIntField(14, 0);
+        entry.reward_item3_count = tableData.getIntField(15, 0);
+        entry.reward_item4 = tableData.getIntField(16, 0);
+        entry.reward_item4_count = tableData.getIntField(17, 0);
+        entry.reward_emote = tableData.getIntField(18, -1);
+        entry.reward_emote2 = tableData.getIntField(19, -1);
+        entry.reward_emote3 = tableData.getIntField(20, -1);
+        entry.reward_emote4 = tableData.getIntField(21, -1);
+        entry.reward_maximagination = tableData.getIntField(22, -1);
+        entry.reward_maxhealth = tableData.getIntField(23, -1);
+        entry.reward_maxinventory = tableData.getIntField(24, -1);
+        entry.reward_maxmodel = tableData.getIntField(25, -1);
+        entry.reward_maxwidget = tableData.getIntField(26, -1);
+        entry.reward_maxwallet = tableData.getIntField(27, -1);
+        entry.repeatable = tableData.getIntField(28, -1) == 1 ? true : false;
+        entry.reward_currency_repeatable = tableData.getIntField(29, -1);
+        entry.reward_item1_repeatable = tableData.getIntField(30, -1);
+        entry.reward_item1_repeat_count = tableData.getIntField(31, -1);
+        entry.reward_item2_repeatable = tableData.getIntField(32, -1);
+        entry.reward_item2_repeat_count = tableData.getIntField(33, -1);
+        entry.reward_item3_repeatable = tableData.getIntField(34, -1);
+        entry.reward_item3_repeat_count = tableData.getIntField(34, -1);
+        entry.reward_item4_repeatable = tableData.getIntField(36, -1);
+        entry.reward_item4_repeat_count = tableData.getIntField(37, -1);
+        entry.time_limit = tableData.getIntField(38, -1);
+        entry.isMission = tableData.getIntField(39, -1) ? true : false;
+        entry.missionIconID = tableData.getIntField(40, -1);
+        entry.prereqMissionID = tableData.getStringField(41, "");
+        entry.localize = tableData.getIntField(42, -1) == 1 ? true : false;
+        entry.inMOTD = tableData.getIntField(43, -1) == 1 ? true : false;
+        entry.cooldownTime = tableData.getInt64Field(44, -1);
+        entry.isRandom = tableData.getIntField(45, -1) == 1 ? true : false;
+        entry.randomPool = tableData.getStringField(46, "");
+        entry.UIPrereqID = tableData.getIntField(47, -1);
+        UNUSED(entry.gate_version = tableData.getStringField(48, ""));
+        UNUSED(entry.HUDStates = tableData.getStringField(49, ""));
+        UNUSED(entry.locStatus = tableData.getIntField(50, -1));
+        entry.reward_bankinventory = tableData.getIntField(51, -1);
+        
+        this->entries.push_back(entry);
+        tableData.nextRow();
+    }
+
+	tableData.finalize();
+
+    Default.id = -1;
+}
+
+//! Destructor
+CDMissionsTable::~CDMissionsTable(void) { }
+
+//! Returns the table's name
+std::string CDMissionsTable::GetName(void) const {
+    return "Missions";
+}
+
+//! Queries the table with a custom "where" clause
+std::vector<CDMissions> CDMissionsTable::Query(std::function<bool(CDMissions)> predicate) {
+    
+    std::vector<CDMissions> data = cpplinq::from(this->entries)
+    >> cpplinq::where(predicate)
+    >> cpplinq::to_vector();
+    
+    return data;
+}
+
+//! Gets all the entries in the table
+const std::vector<CDMissions>& CDMissionsTable::GetEntries(void) const {
+    return this->entries;
+}
+
+const CDMissions* CDMissionsTable::GetPtrByMissionID(uint32_t missionID) const
+{
+    for (const auto& entry : entries)
+    {
+        if (entry.id == missionID)
+        {
+            return const_cast<CDMissions*>(&entry);
+        }
+    }
+
+    return &Default;
+}
+
+const CDMissions& CDMissionsTable::GetByMissionID(uint32_t missionID, bool& found) const
+{
+    for (const auto& entry : entries)
+    {
+        if (entry.id == missionID)
+        {
+            found = true;
+
+            return entry;
+        }
+    }
+
+    found = false;
+
+    return Default;
+}