Reworking interface for shared memory, initial commit with new low level classes, not yet working

Added a VS ignore for x64 compiles

.devcontainer/devcontainer.json

@@ -0,0 +1,21 @@
+// For format details, see https://aka.ms/vscode-remote/devcontainer.json or this file's README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.101.1/containers/ubuntu-18.04-git
+{	
+	"name": "Ubuntu 18.04 EQEMU",
+	// Moved from dockerfile to image so it builds faster
+	"image": "eqemu/devcontainer:0.0.2",
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": { 
+		"terminal.integrated.shell.linux": "/bin/bash"
+	},
+
+	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
+	
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": ["ms-vscode.cpptools", "ms-azuretools.vscode-docker"],
+	"mounts": ["source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind"],
+	"remoteEnv": {
+		"HOST_PROJECT_PATH": "${localWorkspaceFolder}"
+	}
+}

.gitignore

@@ -17,6 +17,8 @@
 *.out
 *.app
 
+.bash_history
+
 # CMake
 CMakeCache.txt
 CMakeFiles
@@ -27,9 +29,28 @@ install_manifest.txt
 log/
 logs/
 vcpkg/
+perl/
 
 .idea/*
 *cbp
 
 submodules/*
-cmake-build-debug/
+cmake-build-debug/
+
+.nfs.*
+
+# Visual Studio and CMAKE Generated Files
+/.vs/
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+*.cmake
+*.ilk
+*.pdb
+*.sln
+*.dir/
+libs/
+bin/
+/Win32
+/x64
+/client_files/**/CMakeFiles/

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "submodules/recastnavigation"]
 	path = submodules/recastnavigation
 	url = https://github.com/EQEmu/recastnavigation.git
+[submodule "submodules/expected"]
+	path = submodules/expected
+	url = https://github.com/TartanLlama/expected.git

.travis.yml

@@ -1,26 +1,18 @@
 language: cpp
 compiler: gcc
-dist: trusty
+dist: bionic
 
-before_install:
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo apt-get update -qq
-  - mkdir $HOME/usr
-  - export PATH="$HOME/usr/bin:$PATH"
-  - wget https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.sh
-  - chmod +x cmake-3.11.2-Linux-x86_64.sh
-  - ./cmake-3.11.2-Linux-x86_64.sh --prefix=$HOME/usr --exclude-subdir --skip-license
+addons:
+  apt:
+    packages:
+      - libmysqlclient-dev
+      - libperl-dev
+      - libboost-dev
+      - liblua5.1-0-dev
+      - zlib1g-dev
+      - uuid-dev
+      - libssl-dev
 
-install:
-  - sudo apt-get install -qq g++-7
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
-  - sudo apt-get install libmysqlclient-dev
-  - sudo apt-get install libperl-dev
-  - sudo apt-get install libboost-dev
-  - sudo apt-get install liblua5.1-0-dev
-  - sudo apt-get install zlib1g-dev
-  - sudo apt-get install uuid-dev
-  - sudo apt-get install libssl-dev  
 script:
   - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON
   - make -j2

.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "/usr/include/mysql"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "c11",
+            "cppStandard": "c++17"
+        }
+    ],
+    "version": 4
+}

.vscode/tasks.json

@@ -0,0 +1,155 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "make",
+            "type": "shell",
+            "command": "cd build && make",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "make clean",
+            "type": "shell",
+            "command": "cd build && make clean",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "cmake",
+            "type": "shell",
+            "command": "mkdir -p build && cd build && rm CMakeCache.txt && cmake -DEQEMU_BUILD_LOGIN=ON -DEQEMU_BUILD_LUA=ON -G 'Unix Makefiles' ..",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher":{
+                "owner": "cpp",
+                "fileLocation": "relative",
+                "pattern":[
+                    {
+                        "regexp": "([\\w+|\\\\]*\\.\\w+)\\((\\d+)\\)\\: (warning|error) (.*)$",
+                        "file": 1,
+                        "location": 2,
+                        "severity": 3,
+                        "message": 4
+                    }
+                ]
+            }
+        },
+        {
+            "label": "download maps",
+            "type": "shell",
+            "command": "mkdir -p build/bin && cd build/bin && wget https://codeload.github.com/Akkadius/EQEmuMaps/zip/master -O maps.zip && unzip -o maps.zip && rm ./maps -rf && mv EQEmuMaps-master maps && rm maps.zip",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "download quests",
+            "type": "shell",
+            "command": "mkdir -p build/bin && cd build/bin && cd server && git -C ./quests pull 2> /dev/null || git clone https://github.com/ProjectEQ/projecteqquests.git quests",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "download eqemu_config",
+            "type": "shell",
+            "command": "mkdir -p build/bin && cd build/bin && wget --no-check-certificate https://raw.githubusercontent.com/Akkadius/EQEmuInstall/master/eqemu_config_docker.json -O eqemu_config.json",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "rebuild database (mariadb must be started)",
+            "type": "shell",
+            "command": "mkdir -p build/bin && cd build/bin && docker run -i --rm --privileged -v ${HOST_PROJECT_PATH}/build/bin:/src --network=eqemu -it eqemu/server:0.0.3 bash -c './eqemu_server.pl source_peq_db && ./eqemu_server.pl check_db_updates && ./eqemu_server.pl linux_login_server_setup'",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "zone 7000",
+            "type": "shell",
+            "command": "docker stop zone7000 | true && docker network create eqemu | true && docker run -i --rm --name zone7000 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --privileged -v ${HOST_PROJECT_PATH}/build/bin:/src --ulimit core=10000000 --network=eqemu -p 7000:7000/udp -e LD_LIBRARY_PATH=/src/ eqemu/server:0.0.3 gdb -ex run --args ./zone dynamic_zone7000:7000",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "zone 7001",
+            "type": "shell",
+            "command": "docker stop zone7001 | true && docker network create eqemu | true && docker run -i --rm --name zone7001 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --privileged -v ${HOST_PROJECT_PATH}/build/bin:/src --ulimit core=10000000 --network=eqemu -p 7001:7001/udp -e LD_LIBRARY_PATH=/src/ eqemu/server:0.0.3 gdb -ex run --args ./zone dynamic_zone7001:7001",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "loginserver",
+            "type": "shell",
+            "command": "docker stop loginserver | true && docker network create eqemu | true && docker run -i --rm --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --privileged -v ${HOST_PROJECT_PATH}/build/bin:/src --ulimit core=10000000 --network=eqemu --name loginserver -p 5999:5999/udp -p 5998:5998/udp -e LD_LIBRARY_PATH=/src/ eqemu/server:0.0.3 gdb -ex run --args ./loginserver",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "shared_memory, world",
+            "type": "shell",
+            "command": "docker stop sharedmemory | true &&  docker stop world | true && docker network create eqemu | true && docker run --rm -v ${HOST_PROJECT_PATH}/build/bin:/src --network=eqemu --name sharedmemory eqemu/server:0.0.3 ./shared_memory && docker run --rm -v ${HOST_PROJECT_PATH}/build/bin:/src --ulimit core=10000000 -e LD_LIBRARY_PATH=/src/ --network=eqemu --name world -p 9000:9000 -p 9000:9000/udp -p 9001:9001 -p 9080:9080 eqemu/server:0.0.3 gdb -ex run ./world",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "queryserv",
+            "type": "shell",
+            "command": "docker stop queryserv | true && docker run --rm -v ${HOST_PROJECT_PATH}/build/bin:/src --ulimit core=10000000 -e LD_LIBRARY_PATH=/src/ --network=eqemu --name queryserv eqemu/server:0.0.3 gdb -ex run ./queryserv",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "mariadb",
+            "type": "shell",
+            "command": "docker stop mariadb | true && cd build/bin && docker network create eqemu | true && docker run --rm -v ${HOST_PROJECT_PATH}/build/bin/db:/bitnami/mariadb -p 3306:3306 -e MARIADB_DATABASE=peq -e MARIADB_USER=eqemu -e MARIADB_PASSWORD=eqemupass -e ALLOW_EMPTY_PASSWORD=yes --name mariadb --network=eqemu bitnami/mariadb:latest",
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            }
+        }
+    ]
+}

BUILD.md

@@ -0,0 +1,64 @@
+# Guide To Building From Source Without Installer
+
+This guide is far from exhaustive, you should expect to have some experience with building C++ code before considering compiling the code from scratch.  You should instead consider using the installer scripts if you don't want to hack on the code directly.
+
+### CMake
+
+EQEmu uses CMake as the build system on all platforms.  You will need CMake 3.2 or higher to build from source.
+
+### Dependencies
+
+The following libraries are required to build from source:
+- [boost](https://www.boost.org/ "boost")
+- [zlib](https://www.zlib.net/ "zlib") (If not included the source will build [zlib-ng](https://github.com/zlib-ng/zlib-ng "zlib-ng") instead)
+- [libmysql](https://dev.mysql.com/downloads/connector/c/ "libmysql") or [libmariadb](https://github.com/MariaDB/mariadb-connector-c "libmariadb")
+
+The following libraries are not strictly required but in many cased recommended.
+- [OpenSSL](https://www.openssl.org/ "OpenSSL") or [mbedTLS](https://tls.mbed.org/ "mbedTLS") (Required for the loginserver and headless client)
+- [libsodium](https://github.com/jedisct1/libsodium "libsodium") (Required for strong password hashing on the loginserver)
+- [Lua 5.1](https://www.lua.org/ "Lua 5.1") or [LuaJit](http://luajit.org/ "LuaJit") (Required for Lua Quest Scripting)
+- [Perl](https://www.perl.org/ "Perl") (Required for Perl Quest Scripting)
+
+##### Windows
+For windows it is suggested you make use of [vcpkg](https://github.com/microsoft/vcpkg "vcpkg") if you wish to build your own dependencies.
+
+If you wish to use Perl then you should use whichever version of Perl you have installed on the target system.
+
+You can also download a vcpkg export from our releases section for Visual Studio [x86](https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x86.zip "x86") or [x64](https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x64.zip "x64") that includes a toolchain file you can pass to CMake.
+
+##### Linux
+For Linux you simply can install the dependencies from your package manager, below is an example of doing it on Ubuntu using apt-get.
+
+    sudo apt-get install libmysqlclient-dev libperl-dev libboost-dev liblua5.1-0-dev zlib1g-dev uuid-dev libssl-dev
+
+### Running CMake
+
+##### Windows
+The following is a modified command our automated build server uses to run CMake via the release vcpkg export and its toolchain file. 
+
+Assuming it is starting in c:/projects/eqemu and the x64 dependencies were extracted to c:/projects/eqemu/vcpkg.
+
+	mkdir build
+	cd build
+	cmake -G "Visual Studio 15 2017 Win64" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -DEQEMU_BUILD_ZLIB=ON -DEQEMU_ENABLE_BOTS=ON -DCMAKE_TOOLCHAIN_FILE="c:/projects/eqemu/vcpkg/vcpkg-export-20180828-145455/scripts/buildsystems/vcpkg.cmake" ..
+
+##### Linux
+Similarly to Windows running CMake on Linux is simple it just omits the toolchain file and uses a different generator.
+
+	mkdir build
+	cd build
+	cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON ..
+
+### Building
+
+##### Windows
+Inside the build directory a file EQEmu.sln should be produced by a successful run of the CMake command.  You can either open this with Visual Studio or build it directly with MSBuild via the command line.
+
+	msbuild EQEmu.sln /p:Configuration=Release
+
+##### Linux
+From the build directory you can simply call make to build.  
+
+For example.
+
+	make -j4

CMakeLists.txt

@@ -1,120 +1,28 @@
-#EQEmu CMake
-#Variables used:
-#EQEMU_DISABLE_CRT_SECURE_WARNINGS
-#EQEMU_FAST_FLOATINGPOINT
-#EQEMU_ENABLE_CRASH_LOGGING
-#EQEMU_DISABLE_SAFESEH
-#EQEMU_BUILD_MSVC_MP
-#EQEMU_DEBUG_LEVEL
-#EQEMU_LOG_LEVEL_DEBUG
-#EQEMU_ENABLE_BOTS
-#EQEMU_COMMANDS_LOGGING
-#EQEMU_BUILD_SERVER
-#EQEMU_BUILD_LOGIN
-#EQEMU_BUILD_TESTS
-#EQEMU_BUILD_PERL
-#EQEMU_BUILD_LUA
-#EQEMU_SANITIZE_LUA_LIBS
-#EQEMU_BUILD_CLIENT_FILES
-#EQEMU_USE_MAP_MMFS
-#EQEMU_MAP_DIR
-#EQEMU_ARCH
-#EQEMU_ARCH_ALT
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-IF(POLICY CMP0074)
-	cmake_policy(SET CMP0074 NEW)
-ENDIF()
-
-#FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
 
-#Our project name is EQEmu
+IF(POLICY CMP0074)
+	CMAKE_POLICY(SET CMP0074 NEW)
+ENDIF()
+
 PROJECT(EQEmu)
 
-#Default build type is set to RelWithDebInfo for generators that honor that like makefiles
 IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
 ENDIF(NOT CMAKE_BUILD_TYPE)
 
-SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
-
-#Add our various windows definitions
-IF(MSVC OR MINGW)
-	ADD_DEFINITIONS(-D_WINDOWS)
-	IF(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN64)
-	ELSE(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN32)
-	ENDIF(CMAKE_CL_64)
-ENDIF(MSVC OR MINGW)
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
 
 IF(MSVC)
-	IF(CMAKE_CL_64)
-		SET(EQEMU_ARCH "x64")
-		SET(EQEMU_ARCH_ALT "x64")
-	ELSE(CMAKE_CL_64)
-		SET(EQEMU_ARCH "x86")
-		SET(EQEMU_ARCH_ALT "Win32")
-	ENDIF(CMAKE_CL_64)
-	
-	SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_${EQEMU_ARCH}")
-	
-	IF(VCPKG_TOOLCHAIN)
-		IF(NOT MSVC_VERSION GREATER 1800)
-			SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-		ENDIF()
-	ELSE(VCPKG_TOOLCHAIN)
-		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_${EQEMU_ARCH}")
-		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_${EQEMU_ARCH}")
-		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_${EQEMU_ARCH}")
-		
-		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-	ENDIF(VCPKG_TOOLCHAIN)
-	
-	IF(SODIUM_INCLUDE_HINTS)
-		IF(MSVC_VERSION GREATER 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/${EQEMU_ARCH_ALT}/Release/v140/dynamic")
-		ELSEIF(MSVC_VERSION EQUAL 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/${EQEMU_ARCH_ALT}/Release/v120/dynamic")
-		ELSE()
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/${EQEMU_ARCH_ALT}/Release/v110/dynamic")
-		ENDIF()
-	ENDIF(SODIUM_INCLUDE_HINTS)
-	
-	#disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
-	OPTION(EQEMU_DISABLE_CRT_SECURE_WARNINGS "Disable Secure CRT Warnings" ON)
-	IF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-		ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
-	ENDIF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-
-	#fast FP if you'd like it
-	OPTION(EQEMU_FAST_FLOATINGPOINT "Use MSVC /fp:fast option" ON)
-	IF(EQEMU_FAST_FLOATINGPOINT)
-		ADD_DEFINITIONS(/fp:fast)
-	ENDIF(EQEMU_FAST_FLOATINGPOINT)
-
-	#crash logging currently only works on windows x86/x64
-	OPTION(EQEMU_ENABLE_CRASH_LOGGING "Enable crash logging" ON)
-	IF(EQEMU_ENABLE_CRASH_LOGGING)
-		ADD_DEFINITIONS(-DCRASH_LOGGING)
-	ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
-
-	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
-	IF(EQEMU_BUILD_MSVC_MP)
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-	ENDIF(EQEMU_BUILD_MSVC_MP)
-
-	#We want to compile /MT not /MD so we change that
-	FOREACH(flag_var CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
-		IF(${flag_var} MATCHES "/MD")
-			STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-		ENDIF(${flag_var} MATCHES "/MD")
-	ENDFOREACH(flag_var)
-
+	ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-DNOMINMAX)
+	ADD_DEFINITIONS(-DCRASH_LOGGING)
+	
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 ELSE(MSVC)
-	#Normally set by perl but we don't use the perl flags anymore so we set it.
 	ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
 ENDIF(MSVC)
 
@@ -131,128 +39,285 @@ IF(UNIX)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
 ENDIF(UNIX)
 
-#debug level, 5 is default. Most people wont ever change this but it's there if you want to
-SET(EQEMU_DEBUG_LEVEL 5 CACHE STRING "EQEmu debug level:
-	0 - Quiet mode Errors to file Status and Normal ignored
-	1 - Status and Normal to console, Errors to logfile
-	2 - Status, Normal, and Error to console and logfile
-	3 - Light debug release errors and status
-	4 - Moderate debug release errors and status
-	5 - Maximum debug release errors and status
-	10 - More errors than you ever wanted to see"
-)
+ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
+ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
+ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
 
-SET(EQEMU_LOG_LEVEL_DEBUG 3 CACHE STRING "EQEmu logging level for [Debug]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+#MSVC can fetch dependencies automatically.
+IF(MSVC)
+	INCLUDE("${CMAKE_SOURCE_DIR}/cmake/DependencyHelperMSVC.cmake")
+ENDIF()
 
-OPTION(EQEMU_LSPX "" OFF)
-MARK_AS_ADVANCED(EQEMU_LSPX)
+#Find everything we need
+FIND_PACKAGE(Boost REQUIRED)
+FIND_PACKAGE(MySQL)
+FIND_PACKAGE(MariaDB)
+FIND_PACKAGE(ZLIB)
+FIND_PACKAGE(OpenSSL)
+FIND_PACKAGE(Lua51)
+FIND_PACKAGE(PerlLibs)
+FIND_PACKAGE(Sodium)
+FIND_PACKAGE(mbedTLS)
 
-MARK_AS_ADVANCED(EQEMU_LOG_LEVEL_DEBUG)
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Detection                              *")
+MESSAGE(STATUS "**************************************************")
 
-#Bots are a compile time option so on/off
+IF(MYSQL_FOUND)
+	MESSAGE(STATUS "* MySQL:                                   FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MySQL:                                 MISSING *")
+ENDIF()
+
+IF(MARIADB_FOUND)
+	MESSAGE(STATUS "* MariaDB:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MariaDB:                               MISSING *")
+ENDIF()
+
+IF(ZLIB_FOUND)
+	MESSAGE(STATUS "* ZLIB:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* ZLIB:                                  MISSING *")
+ENDIF()
+
+IF(Lua51_FOUND)
+	MESSAGE(STATUS "* Lua:                                     FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Lua:                                   MISSING *")
+ENDIF()
+
+IF(PerlLibs_FOUND)
+	MESSAGE(STATUS "* Perl:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Perl:                                  MISSING *")
+ENDIF()
+
+IF(SODIUM_FOUND)
+	MESSAGE(STATUS "* libsodium:                               FOUND *")
+ELSE()
+	MESSAGE(STATUS "* libsodium:                             MISSING *")
+ENDIF()
+
+IF(OpenSSL_FOUND)
+	MESSAGE(STATUS "* OpenSSL:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* OpenSSL:                               MISSING *")
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+	MESSAGE(STATUS "* mbedTLS:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* mbedTLS:                               MISSING *")
+ENDIF()
+
+MESSAGE(STATUS "**************************************************")
+
+#options
+OPTION(EQEMU_DEPOP_INVALIDATES_CACHE "#repop invalidates the npc_types cache (will cause a larger database hit on #repop but is more convienent)." ON)
 OPTION(EQEMU_ENABLE_BOTS "Enable Bots" OFF)
-
-#Enable GM Command log system
 OPTION(EQEMU_COMMANDS_LOGGING "Enable GM Command logs" ON)
+OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
+OPTION(EQEMU_BUILD_LOGIN "Build the login server." ON)
+OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
+OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
+OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
 
 IF(EQEMU_COMMANDS_LOGGING)
 	ADD_DEFINITIONS(-DCOMMANDS_LOGGING)
 ENDIF(EQEMU_COMMANDS_LOGGING)
 
-IF(EQEMU_LSPX)
-	ADD_DEFINITIONS(-DLSPX=ON)
-ENDIF(EQEMU_LSPX)
-
 IF(EQEMU_ENABLE_BOTS)
 	ADD_DEFINITIONS(-DBOTS)
 ENDIF(EQEMU_ENABLE_BOTS)
 
-#What to build
-OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
-OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
-OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
-OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
-OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
-OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
-OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
-
-#C++11 stuff
-IF(NOT MSVC)
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-	IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal")
+#database
+IF(MySQL_FOUND AND MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_SELECTION MySQL CACHE STRING "Database library to use:
+			MySQL
+			MariaDB"
+	)
+	
+	IF(DATABASE_LIBRARY_SELECTION STREQUAL "MySQL")
+		SET(DATABASE_LIBRARY_TYPE "  MySQL")
+		SET(DATABASE_LIBRARY_LIBS ${MySQL_LIBRARIES})
+		SET(DATABASE_LIBRARY_INCLUDE ${MySQL_INCLUDE_DIR})
+	ELSEIF(DATABASE_LIBRARY_SELECTION STREQUAL "MariaDB")
+		SET(DATABASE_LIBRARY_TYPE "MariaDB")
+		SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+		SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+	ELSE()
+		MESSAGE(FATAL_ERROR "Unknown database library set, should be one of: MySQL, MariaDB")
 	ENDIF()
-ENDIF(NOT MSVC)
+ELSEIF(MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "MariaDB")
+	SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+ELSEIF(MySQL_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "  MySQL")
+	SET(DATABASE_LIBRARY_LIBS ${MySQL_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MySQL_INCLUDE_DIR})
+ELSE()
+	MESSAGE(FATAL_ERROR "One of MySQL or MariaDB is a required dependency.")
+ENDIF()
 
-#Various definitions
-IF(EQEMU_BUILD_PERL)
-	ADD_DEFINITIONS(-DEMBPERL)
-	ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
-ENDIF(EQEMU_BUILD_PERL)
-IF(EQEMU_BUILD_LUA)
-	ADD_DEFINITIONS(-DLUA_EQEMU)
-ENDIF(EQEMU_BUILD_LUA)
+#security
+#prefer openssl to mbedtls (arbitrary)
+IF(OpenSSL_FOUND AND MBEDTLS_FOUND)
+	SET(TLS_LIBRARY_SELECTION OpenSSL CACHE STRING "TLS library to use:
+			OpenSSL
+			mbedTLS"
+	)
+	
+	IF(TLS_LIBRARY_SELECTION STREQUAL "OpenSSL")
+		SET(TLS_LIBRARY_TYPE " OpenSSL")
+		SET(TLS_LIBRARY_ENABLED ON)
+		SET(TLS_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+		SET(TLS_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+		ADD_DEFINITIONS(-DEQEMU_USE_OPENSSL)
+	ELSEIF(TLS_LIBRARY_SELECTION STREQUAL "mbedTLS")
+		SET(TLS_LIBRARY_TYPE " mbedTLS")
+		SET(TLS_LIBRARY_ENABLED ON)
+		SET(TLS_LIBRARY_LIBS ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+		SET(TLS_LIBRARY_INCLUDE ${MBEDTLS_INCLUDE_DIR})
+		ADD_DEFINITIONS(-DEQEMU_USE_MBEDTLS)
+	ELSE()
+		MESSAGE(FATAL_ERROR "Unknown TLS library set, should be one of: OpenSSL, mbedTLS")
+	ENDIF()
+ELSEIF(OpenSSL_FOUND)
+	SET(TLS_LIBRARY_TYPE " OpenSSL")
+	SET(TLS_LIBRARY_ENABLED ON)
+	SET(TLS_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+	SET(TLS_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+	ADD_DEFINITIONS(-DEQEMU_USE_OPENSSL)
+ELSEIF(MBEDTLS_FOUND)
+	SET(TLS_LIBRARY_TYPE " mbedTLS")
+	SET(TLS_LIBRARY_ENABLED ON)
+	SET(TLS_LIBRARY_LIBS ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+	SET(TLS_LIBRARY_INCLUDE ${MBEDTLS_INCLUDE_DIR})
+	ADD_DEFINITIONS(-DEQEMU_USE_MBEDTLS)
+ELSE()
+	SET(TLS_LIBRARY_TYPE "Disabled")
+	SET(TLS_LIBRARY_ENABLED OFF)
+ENDIF()
 
-#Disabled until reevaluation performed
-#OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-#IF(EQEMU_USE_MAP_MMFS)
-#	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-#ENDIF(EQEMU_USE_MAP_MMFS)
-
-SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
-
-ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
-ADD_DEFINITIONS(-DINVERSEXY)
-ADD_DEFINITIONS(-DFIELD_ITEMS)
-ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
-ADD_DEFINITIONS(-DLOG_LEVEL_DEBUG=${EQEMU_LOG_LEVEL_DEBUG})
-ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
-ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
-ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
-
-#Find everything we need
-FIND_PACKAGE(ZLIB)
-FIND_PACKAGE(MySQL REQUIRED)
-IF(EQEMU_BUILD_PERL)
-	FIND_PACKAGE(PerlLibs REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
-ENDIF(EQEMU_BUILD_PERL)
-
-SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} uv_a fmt RecastNavigation::Detour)
-
-FIND_PACKAGE(Sodium REQUIRED)
 IF(SODIUM_FOUND)
-	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
-	IF(EQEMU_ENABLE_SECURITY)
-		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
-		ADD_DEFINITIONS(-DENABLE_SECURITY)
-		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_TYPE "Libsodium")
+	SET(SODIUM_LIBRARY_ENABLED ON)
+	SET(SODIUM_LIBRARY_LIBS ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_INCLUDE ${SODIUM_INCLUDE_DIRS})
+	ADD_DEFINITIONS(-DENABLE_SECURITY)
+ELSE()
+	SET(SODIUM_LIBRARY_TYPE " Disabled")
+	SET(SODIUM_LIBRARY_ENABLED OFF)
+ENDIF()
+
+IF(Lua51_FOUND)
+	SET(LUA_LIBRARY_TYPE " Lua 5.1")
+	SET(LUA_LIBRARY_ENABLED ON)
+	SET(LUA_LIBRARY_LIBS ${LUA_LIBRARY} luabind)
+	SET(LUA_LIBRARY_INCLUDE ${LUA_INCLUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+ELSE()
+	SET(LUA_LIBRARY_TYPE "Disabled")
+	SET(LUA_LIBRARY_ENABLED OFF)
+ENDIF()
+
+IF(PerlLibs_FOUND)
+	SET(PERL_LIBRARY_TYPE "    Perl")
+	SET(PERL_LIBRARY_ENABLED ON)
+	SET(PERL_LIBRARY_LIBS ${PERL_LIBRARY})
+	SET(PERL_LIBRARY_INCLUDE ${PERL_INCLUDE_PATH})
+ELSE()
+	SET(PERL_LIBRARY_TYPE "Disabled")
+	SET(PERL_LIBRARY_ENABLED OFF)
+ENDIF()
+
+#use zlib if exists
+IF(ZLIB_FOUND)
+	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." ON)
+	IF(EQEMU_BUILD_ZLIB)
+		SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+		SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+		SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+	ELSE()
+		SET(ZLIB_LIBRARY_TYPE "   zlib")
+		SET(ZLIB_LIBRARY_LIBS ${ZLIB_LIBRARY})
+		SET(ZLIB_LIBRARY_INCLUDE ${ZLIB_INCLUDE_DIRS})
+	ENDIF()
+ELSE()
+	SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+	SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+	SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+ENDIF()
+
+MESSAGE(STATUS "")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Usage                                  *")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Database:                              ${DATABASE_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* TLS:                                  ${TLS_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Sodium:                              ${SODIUM_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Lua:                                  ${LUA_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Perl:                                 ${PERL_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* zlib:                                  ${ZLIB_LIBRARY_TYPE} *")
+MESSAGE(STATUS "**************************************************")
+
+#setup server libs and headers
+SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)
+
+INCLUDE_DIRECTORIES(SYSTEM "${DATABASE_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${Boost_INCLUDE_DIRS}")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/expected/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/fmt/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/libuv/include" )
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DebugUtils/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Detour/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourCrowd/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourTileCache/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Recast/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/websocketpp")
+
+OPTION(EQEMU_BUILD_LOGGING "Build Logging (To speed up compilation)" ON)
+IF(EQEMU_BUILD_LOGGING)
+	ADD_DEFINITIONS(-DBUILD_LOGGING)
+ENDIF()
+
+IF(TLS_LIBRARY_ENABLED)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${TLS_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${TLS_LIBRARY_INCLUDE}")
+ENDIF()
+
+IF(SODIUM_LIBRARY_ENABLED)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_LIBRARY_INCLUDE}")
+ENDIF()
+
+IF(LUA_LIBRARY_ENABLED)
+	OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
+	
+	IF(EQEMU_BUILD_LUA)
+		ADD_DEFINITIONS(-DLUA_EQEMU)
+		SET(SERVER_LIBS ${SERVER_LIBS} ${LUA_LIBRARY_LIBS})
+		INCLUDE_DIRECTORIES(SYSTEM "${LUA_LIBRARY_INCLUDE}")
+		
+		OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
+		IF(EQEMU_SANITIZE_LUA_LIBS)
+			ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
+		ENDIF()
 	ENDIF()
 ENDIF()
 
-IF(ZLIB_FOUND)
-	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." OFF)
-	
-	IF(EQEMU_BUILD_ZLIB)
-		INCLUDE_DIRECTORIES(BEFORE SYSTEM "${CMAKE_CURRENT_BINARY_DIR}/libs/zlibng" "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
-		SET(SERVER_LIBS ${SERVER_LIBS} "zlibstatic")
-	ELSE()
-		INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
-		SET(SERVER_LIBS ${SERVER_LIBS} ${ZLIB_LIBRARY})
+IF(PERL_LIBRARY_ENABLED)
+	OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
+	IF(EQEMU_BUILD_PERL)
+		SET(SERVER_LIBS ${SERVER_LIBS} ${PERL_LIBRARY_LIBS})
+		INCLUDE_DIRECTORIES(SYSTEM "${PERL_LIBRARY_INCLUDE}")
+		ADD_DEFINITIONS(-DEMBPERL)
+		ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
 	ENDIF()
-ELSE()
-	MESSAGE(STATUS "Could NOT find ZLIB - using ZLIBSTATIC package.")
-	SET(EQEMU_BUILD_ZLIB ON)
-	INCLUDE_DIRECTORIES(BEFORE SYSTEM "${CMAKE_CURRENT_BINARY_DIR}/libs/zlibng" "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
-	SET(SERVER_LIBS ${SERVER_LIBS} "zlibstatic")
 ENDIF()
 
 IF(WIN32)
@@ -267,52 +332,32 @@ IF(UNIX)
 	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
 ENDIF()
 
-IF(EQEMU_BUILD_LUA)
-	FIND_PACKAGE(EQLua51 REQUIRED)
-	SET(Boost_USE_STATIC_LIBS OFF)
-	SET(Boost_USE_MULTITHREADED ON)
-	SET(Boost_USE_STATIC_RUNTIME OFF)
-	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
+IF(EQEMU_BUILD_LOGIN AND NOT TLS_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Login server requires a TLS Library to build.")
+ENDIF()
 
-	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
-
-	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
-	IF(EQEMU_SANITIZE_LUA_LIBS)
-		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
-	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
-ENDIF(EQEMU_BUILD_LUA)
-
-INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/fmt/include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/libuv/include" )
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DebugUtils/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Detour/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourCrowd/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourTileCache/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Recast/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/websocketpp")
+IF(EQEMU_BUILD_HC AND NOT TLS_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Headless client requires a TLS Library to build.")
+ENDIF()
 
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)
 	ADD_SUBDIRECTORY(libs)
 	ADD_SUBDIRECTORY(submodules/fmt)
 	ADD_SUBDIRECTORY(submodules/libuv)
-
-	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
-	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
-	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
-	ADD_SUBDIRECTORY(submodules/recastnavigation)
 	
 	IF(EQEMU_BUILD_ZLIB)
 		SET(ZLIB_COMPAT ON CACHE BOOL "Compile with zlib compatible API")
 		SET(ZLIB_ENABLE_TESTS OFF CACHE BOOL "Build test binaries")
 		ADD_SUBDIRECTORY(libs/zlibng)
 	ENDIF()
+	
+	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
+	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
+	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
+	ADD_SUBDIRECTORY(submodules/recastnavigation)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
+
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -321,6 +366,7 @@ IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(queryserv)
 	ADD_SUBDIRECTORY(eqlaunch)
 ENDIF(EQEMU_BUILD_SERVER)
+
 IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)

README.md

@@ -1,7 +1,7 @@
 # EQEmulator Core Server
-|Travis CI (Linux)|Appveyor w/ Bots (Windows)   |Appveyor w/o Bots (Windows)   |
+|Travis CI (Linux)|Appveyor (Windows x86)   |Appveyor (Windows x64)   |
 |:---:|:---:|:---:| 
-|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Build status](https://ci.appveyor.com/api/projects/status/scr25kmntx36c1ub/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-87crp/branch/master)   |[![Build status](https://ci.appveyor.com/api/projects/status/mdwbr4o9l6mxqofj/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-w0pq2/branch/master)   |
+|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Build status](https://ci.appveyor.com/api/projects/status/v3utuu0dttm2cqd0?svg=true)](https://ci.appveyor.com/project/KimLS/server)   |[![Build status](https://ci.appveyor.com/api/projects/status/scr25kmntx36c1ub?svg=true)](https://ci.appveyor.com/project/KimLS/server-87crp)   |
 
 ***
 
@@ -17,7 +17,7 @@
 |:---:|:---:|:---:|
 |**Install Count**|![Windows Install Count](http://analytics.akkadius.com/?install_count&windows_count)|![Linux Install Count](http://analytics.akkadius.com/?install_count&linux_count)| 
 ### > Windows 
-* [Install](https://github.com/EQEmu/Server/wiki/Windows-Server)
+* [Install](https://eqemu.gitbook.io/server/categories/how-to-guides/installation/server-installation-windows)
 
 ### > Debian/Ubuntu/CentOS/Fedora
 * You can use curl or wget to kick off the installer (whichever your OS has)
@@ -52,7 +52,7 @@ forum, although pull requests will be much quicker and easier on all parties.
 
 ## Resources
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
-- [EQEmulator Wiki](https://github.com/EQEmu/Server/wiki)
+- [EQEmulator Wiki](https://eqemu.gitbook.io/)
 
 ## Related Repositories
 * [ProjectEQ Quests](https://github.com/ProjectEQ/projecteqquests)

client_files/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 add_subdirectory(import)
 add_subdirectory(export)

client_files/export/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(export_sources
 	main.cpp

client_files/import/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(import_sources
 	main.cpp

cmake/DependencyHelperMSVC.cmake

@@ -0,0 +1,94 @@
+OPTION(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG "Automatically fetch vcpkg dependencies for MSCV" ON)
+OPTION(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL "Automatically fetch perl dependencies for MSCV" ON)
+
+MARK_AS_ADVANCED(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG)
+MARK_AS_ADVANCED(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL)
+
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86 "https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x86.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64 "https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x64.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86 "http://strawberryperl.com/download/5.24.4.1/strawberry-perl-5.24.4.1-32bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64 "http://strawberryperl.com/download/5.24.4.1/strawberry-perl-5.24.4.1-64bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_ZIP "vcpkg-export-x86.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_ZIP "vcpkg-export-x64.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_DIR "vcpkg-export-x86")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_DIR "vcpkg-export-x64")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86_ZIP "strawberry-perl-5.24.4.1-32bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64_ZIP "strawberry-perl-5.24.4.1-64bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86_DIR "x86")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64_DIR "x64")
+
+IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
+	SET(EQEMU_VCPKG_URL ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64})
+	SET(EQEMU_PERL_URL ${EQEMU_MSVC_DEPENDENCIES_PERL_X64})
+	SET(EQEMU_VCPKG_ZIP ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_ZIP})
+	SET(EQEMU_VCPKG_DIR ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_DIR})
+	SET(EQEMU_PERL_ZIP ${EQEMU_MSVC_DEPENDENCIES_PERL_X64_ZIP})
+	SET(EQEMU_PERL_DIR ${EQEMU_MSVC_DEPENDENCIES_PERL_X64_DIR})
+ELSE()
+	SET(EQEMU_VCPKG_URL ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86})
+	SET(EQEMU_PERL_URL ${EQEMU_MSVC_DEPENDENCIES_PERL_X86})
+	SET(EQEMU_VCPKG_ZIP ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_ZIP})
+	SET(EQEMU_VCPKG_DIR ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_DIR})
+	SET(EQEMU_PERL_ZIP ${EQEMU_MSVC_DEPENDENCIES_PERL_X86_ZIP})
+	SET(EQEMU_PERL_DIR ${EQEMU_MSVC_DEPENDENCIES_PERL_X86_DIR})
+ENDIF()
+
+IF(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG)
+	MESSAGE(STATUS "Resolving vcpkg dependencies...")
+	
+	IF(NOT EXISTS ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP})
+		EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/vcpkg)
+		
+		MESSAGE(STATUS "Downloading existing vcpkg dependencies from releases...")
+		FILE(DOWNLOAD ${EQEMU_VCPKG_URL} ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP} 
+			SHOW_PROGRESS
+			STATUS DOWNLOAD_STATUS)
+			
+		LIST(GET DOWNLOAD_STATUS 0 STATUS_CODE)
+		IF(NOT STATUS_CODE EQUAL 0)
+			MESSAGE(FATAL_ERROR "Was unable to download dependencies from ${EQEMU_VCPKG_URL}")
+		ENDIF()
+		
+		MESSAGE(STATUS "Extracting files...")
+		EXECUTE_PROCESS(
+			COMMAND ${CMAKE_COMMAND} -E tar xzf ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP}
+			WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/vcpkg
+		)
+	ENDIF()
+	
+	INCLUDE(${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_DIR}/scripts/buildsystems/vcpkg.cmake)
+ENDIF()
+
+IF(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL)
+	#Try to find perl first, (so you can use your active install first)
+	FIND_PACKAGE(PerlLibs)
+	
+	IF(NOT PerlLibs_FOUND)
+		MESSAGE(STATUS "Resolving perl dependencies...")
+		
+		IF(NOT EXISTS ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP})
+			EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/perl)
+			EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR})
+			
+			MESSAGE(STATUS "Downloading portable perl...")
+			FILE(DOWNLOAD ${EQEMU_PERL_URL} ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP} 
+				SHOW_PROGRESS
+				STATUS DOWNLOAD_STATUS)
+				
+			LIST(GET DOWNLOAD_STATUS 0 STATUS_CODE)
+			IF(NOT STATUS_CODE EQUAL 0)
+				MESSAGE(FATAL_ERROR "Was unable to download dependencies from ${EQEMU_PERL_URL}")
+			ENDIF()
+			
+			MESSAGE(STATUS "Extracting files...")
+			EXECUTE_PROCESS(
+				COMMAND ${CMAKE_COMMAND} -E tar xzf ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP}
+				WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}
+			)
+		ENDIF()
+		
+		SET(PERL_EXECUTABLE ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/bin/perl.exe CACHE FILEPATH "Path to perl program" FORCE)
+		SET(PERL_INCLUDE_PATH ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/lib/CORE CACHE PATH "Path to perl include files" FORCE)
+		SET(PERL_LIBRARY ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/lib/CORE/libperl524.a CACHE FILEPATH "Path to perl library" FORCE)
+	ENDIF()
+ENDIF()

cmake/FindEQLua51.cmake

@@ -1,124 +0,0 @@
-#CMake - Cross Platform Makefile Generator
-#Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
-#All rights reserved.
-#
-#Redistribution and use in source and binary forms, with or without
-#modification, are permitted provided that the following conditions
-#are met:
-#
-#* Redistributions of source code must retain the above copyright
-#  notice, this list of conditions and the following disclaimer.
-#
-#* Redistributions in binary form must reproduce the above copyright
-#  notice, this list of conditions and the following disclaimer in the
-#  documentation and/or other materials provided with the distribution.
-#
-#* Neither the names of Kitware, Inc., the Insight Software Consortium,
-#  nor the names of their contributors may be used to endorse or promote
-#  products derived from this software without specific prior written
-#  permission.
-#
-#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-#"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-#HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-#LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-#DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-#THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# This module defines
-#  LUA51_FOUND, if false, do not try to link to Lua
-#  LUA_LIBRARIES
-#  LUA_INCLUDE_DIR, where to find lua.h
-#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
-
-IF(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include src
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ELSE(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ENDIF(LUA_ROOT)
-
-IF(LUA_LIBRARY)
-	# include the math library for Unix
-	IF(UNIX AND NOT APPLE)
-		FIND_LIBRARY(LUA_MATH_LIBRARY m)
-	SET(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
-	# For Windows and Mac, don't need to explicitly include the math library
-	ELSE()
-		SET( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
-	ENDIF()
-ENDIF()
-
-IF(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
-	FILE(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
-
-	STRING(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
-	UNSET(lua_version_str)
-ENDIF()
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
-                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
-                                  VERSION_VAR LUA_VERSION_STRING)
-
-MARK_AS_ADVANCED(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
-
-

cmake/FindLua51.cmake

@@ -0,0 +1,91 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+# Modified from the FindLua51 that comes with CMake
+
+#[=======================================================================[.rst:
+FindLua51
+---------
+
+
+
+Locate Lua51 library This module defines
+
+::
+
+  LUA51_FOUND, if false, do not try to link to Lua
+  LUA_LIBRARIES
+  LUA_INCLUDE_DIR, where to find lua.h
+  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+
+
+
+Note that the expected include convention is
+
+::
+
+  #include "lua.h"
+
+and not
+
+::
+
+  #include <lua/lua.h>
+
+This is because, the lua location is not standardized and may exist in
+locations other than lua/
+#]=======================================================================]
+
+find_path(LUA_INCLUDE_DIR lua.h
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES include/lua51 include/lua5.1 include/lua-5.1 include/lua include/luajit include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+find_library(LUA_LIBRARY
+  NAMES lua51 lua5.1 lua-5.1 lua luajit
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+if(LUA_LIBRARY)
+  # include the math library for Unix
+  if(UNIX AND NOT APPLE AND NOT BEOS AND NOT HAIKU)
+    find_library(LUA_MATH_LIBRARY m)
+    set( LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+  # For Windows and Mac, don't need to explicitly include the math library
+  else()
+    set( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+  endif()
+endif()
+
+if(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
+  file(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
+
+  string(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
+  unset(lua_version_str)
+endif()
+
+include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
+# handle the QUIETLY and REQUIRED arguments and set LUA51_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
+

cmake/FindMariaDB.cmake

@@ -0,0 +1,87 @@
+# - Find mariadbclient
+#
+# -*- cmake -*-
+#
+# Find the native MariaDB includes and library
+#
+#	MariaDB_INCLUDE_DIR	- where to find mysql.h, etc.
+#	MariaDB_LIBRARIES		- List of libraries when using MariaDB.
+#	MariaDB_FOUND			- True if MariaDB found.
+#	The following can be used as a hint as to where to search:
+#	MARIADB_ROOT
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+	# Already in cache, be silent
+	SET(MariaDB_FIND_QUIETLY TRUE)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+
+# Include dir
+IF(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATHS ${MARIADB_ROOT}/include
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+# Library
+SET(MariaDB_NAMES libmariadb)
+IF(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATHS ${MARIADB_ROOT}/lib
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES} mariadbclient_r mariadbclient
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND TRUE)
+	SET(MariaDB_LIBRARIES ${MariaDB_LIBRARY})
+ELSE (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND FALSE)
+	SET(MariaDB_LIBRARIES)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+
+
+# handle the QUIETLY and REQUIRED arguments and set MariaDB_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MariaDB DEFAULT_MSG MariaDB_LIBRARY MariaDB_INCLUDE_DIR)
+
+IF(MariaDB_FOUND)
+	SET( MariaDB_LIBRARY_RELEASE ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARY_DEBUG ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARIES ${MariaDB_LIBRARY_RELEASE} ${MariaDB_LIBRARY_DEBUG} )
+ELSE(MariaDB_FOUND)
+	SET( MariaDB_LIBRARIES )
+ENDIF(MariaDB_FOUND)
+
+MARK_AS_ADVANCED(
+	MariaDB_LIBRARY_DEBUG
+	MariaDB_LIBRARY_RELEASE
+	MariaDB_INCLUDE_DIR
+	)

cmake/FindmbedTLS.cmake

@@ -0,0 +1,93 @@
+# - Try to find mbedTLS
+# Once done this will define
+#
+# Read-Only variables
+#  MBEDTLS_FOUND - system has mbedTLS
+#  MBEDTLS_INCLUDE_DIR - the mbedTLS include directory
+#  MBEDTLS_LIBRARY_DIR - the mbedTLS library directory
+#  MBEDTLS_LIBRARIES - Link these to use mbedTLS
+#  MBEDTLS_LIBRARY - path to mbedTLS library
+#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
+#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
+#
+# Hint
+#  MBEDTLS_ROOT_DIR can be pointed to a local mbedTLS installation.
+
+SET(_MBEDTLS_ROOT_HINTS
+    ${MBEDTLS_ROOT_DIR}
+    ENV MBEDTLS_ROOT_DIR
+)
+
+SET(_MBEDTLS_ROOT_HINTS_AND_PATHS
+    HINTS ${_MBEDTLS_ROOT_HINTS}
+    PATHS ${_MBEDTLS_ROOT_PATHS}
+)
+
+FIND_PATH(MBEDTLS_INCLUDE_DIR
+    NAMES mbedtls/version.h
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES include
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
+    # Already in cache, be silent
+    SET(MBEDTLS_FIND_QUIETLY TRUE)
+ENDIF()
+
+FIND_LIBRARY(MBEDTLS_LIBRARY
+    NAMES mbedtls libmbedtls
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDX509_LIBRARY
+    NAMES mbedx509 libmbedx509
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDCRYPTO_LIBRARY
+    NAMES mbedcrypto libmbedcrypto
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
+     SET(MBEDTLS_FOUND TRUE)
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+    # split mbedTLS into -L and -l linker options, so we can set them for pkg-config
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_DIR ${MBEDTLS_LIBRARY} PATH)
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY} NAME_WE)
+    STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
+    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
+
+    IF(NOT MBEDTLS_FIND_QUIETLY)
+        MESSAGE(STATUS "Found mbedTLS:")
+        FILE(READ ${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h MBEDTLSCONTENT)
+        STRING(REGEX MATCH "MBEDTLS_VERSION_STRING +\"[0-9|.]+\"" MBEDTLSMATCH ${MBEDTLSCONTENT})
+        IF (MBEDTLSMATCH)
+            STRING(REGEX REPLACE "MBEDTLS_VERSION_STRING +\"([0-9|.]+)\"" "\\1" MBEDTLS_VERSION ${MBEDTLSMATCH})
+            MESSAGE(STATUS "  version ${MBEDTLS_VERSION}")
+        ENDIF(MBEDTLSMATCH)
+        MESSAGE(STATUS "  TLS: ${MBEDTLS_LIBRARY}")
+        MESSAGE(STATUS "  X509: ${MBEDX509_LIBRARY}")
+        MESSAGE(STATUS "  Crypto: ${MBEDCRYPTO_LIBRARY}")
+    ENDIF(NOT MBEDTLS_FIND_QUIETLY)
+ELSE(MBEDTLS_FOUND)
+    IF(MBEDTLS_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find mbedTLS")
+    ENDIF(MBEDTLS_FIND_REQUIRED)
+ENDIF(MBEDTLS_FOUND)
+
+MARK_AS_ADVANCED(
+    MBEDTLS_INCLUDE_DIR
+    MBEDTLS_LIBRARY_DIR
+    MBEDTLS_LIBRARIES
+    MBEDTLS_LIBRARY
+    MBEDX509_LIBRARY
+    MBEDCRYPTO_LIBRARY
+)

common/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(common_sources
 	base_packet.cpp
@@ -9,6 +9,7 @@ SET(common_sources
 	crash.cpp
 	crc16.cpp
 	crc32.cpp
+	database/database_dump_service.cpp
 	database.cpp
 	database_conversions.cpp
 	database_instances.cpp
@@ -31,6 +32,7 @@ SET(common_sources
 	event_sub.cpp
 	extprofile.cpp
 	faction.cpp
+	file_util.cpp
 	guild_base.cpp
 	guilds.cpp
 	inventory_profile.cpp
@@ -120,8 +122,10 @@ SET(common_headers
 	cli/argh.h
 	cli/eqemu_command_handler.h
 	cli/terminal_color.hpp
+	database/database_dump_service.h
 	data_verification.h
 	database.h
+	database_schema.h
 	dbcore.h
 	deity.h
 	emu_constants.h
@@ -147,8 +151,10 @@ SET(common_headers
 	eqtime.h
 	errmsg.h
 	event_sub.h
+	expected.h
 	extprofile.h
 	faction.h
+	file_util.h
 	features.h
 	fixed_memory_hash_set.h
 	fixed_memory_variable_hash_set.h
@@ -262,6 +268,13 @@ SET(common_headers
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
+	shared/shared_memory.h
+	shared/shared_memory_error.h
+	shared/shared_memory_handle.h
+	shared/shared_memory_list.h
+	shared/shared_memory_map.h
+	shared/shared_memory_string.h
+	shared/shared_memory_vector.h
 	StackWalker/StackWalker.h
 	util/memory_stream.h
 	util/directory.h
@@ -360,6 +373,16 @@ SOURCE_GROUP(Patches FILES
 	patches/uf_limits.cpp
 )
 
+SOURCE_GROUP(shared FILES
+	shared/shared_memory.h
+	shared/shared_memory_error.h
+	shared/shared_memory_handle.h
+	shared/shared_memory_list.h
+	shared/shared_memory_map.h
+	shared/shared_memory_string.h
+	shared/shared_memory_vector.h
+)
+
 SOURCE_GROUP(StackWalker FILES
 	StackWalker/StackWalker.h
 	StackWalker/StackWalker.cpp

common/classes.cpp

@@ -573,6 +573,20 @@ bool IsNonSpellFighterClass(uint8 class_id)
 	}
 }
 
+bool IsHybridClass(uint8 class_id)
+{
+	switch (class_id) {
+	case PALADIN:
+	case RANGER:
+	case SHADOWKNIGHT:
+	case BARD:
+	case BEASTLORD:
+		return true;
+	default:
+		return false;
+	}
+}
+
 bool IsCasterClass(uint8 class_id)
 {
 	switch (class_id) {

common/classes.h

@@ -135,6 +135,7 @@ uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit);
 bool IsFighterClass(uint8 class_id);
 bool IsSpellFighterClass(uint8 class_id);
 bool IsNonSpellFighterClass(uint8 class_id);
+bool IsHybridClass(uint8 class_id);
 bool IsCasterClass(uint8 class_id);
 bool IsINTCasterClass(uint8 class_id);
 bool IsWISCasterClass(uint8 class_id);

common/cli/eqemu_command_handler.cpp

@@ -38,10 +38,6 @@ namespace EQEmuCommand {
 	void DisplayDebug(argh::parser &cmd)
 	{
 		if (cmd[{"-d", "--debug"}]) {
-			std::cout << "Positional args:\n";
-			for (auto &pos_arg : cmd)
-				std::cout << '\t' << pos_arg << std::endl;
-
 			std::cout << "Positional args:\n";
 			for (auto &pos_arg : cmd.pos_args())
 				std::cout << '\t' << pos_arg << std::endl;
@@ -73,29 +69,37 @@ namespace EQEmuCommand {
 	{
 		bool arguments_filled = true;
 
+		int index = 2;
 		for (auto &arg : arguments) {
-			if (cmd(arg).str().empty()) {
+			if (cmd(arg).str().empty() && cmd(index).str().empty()) {
 				arguments_filled = false;
 			}
+			index++;
 		}
 
 		if (!arguments_filled || argc == 2) {
 			std::string arguments_string;
 			for (auto &arg : arguments) {
-				arguments_string += "  " + arg + "=*\n";
+				arguments_string += " " + arg;
 			}
 
 			std::string options_string;
-			for (auto &opt : options) {
+			for (auto   &opt : options) {
 				options_string += "  " + opt + "\n";
 			}
 
-			std::cout << fmt::format(
-				"Command\n\n{0} \n\nArgs\n{1}\nOptions\n{2}",
-				argv[1],
-				arguments_string,
-				options_string
-			) << std::endl;
+			std::stringstream command_string;
+
+			command_string <<
+						   termcolor::colorize <<
+						   termcolor::yellow <<
+						   "\nCommand" <<
+						   termcolor::reset << "\n\n" <<
+						   termcolor::green << argv[1] << arguments_string << termcolor::reset << "\n" <<
+						   termcolor::yellow << (!options_string.empty() ? "\nOptions\n\n" : "") <<
+						   termcolor::reset << termcolor::cyan << options_string << termcolor::reset;
+
+			std::cout << command_string.str() << std::endl;
 
 			exit(1);
 		}
@@ -123,10 +127,6 @@ namespace EQEmuCommand {
 		bool        ran_command = false;
 		for (auto   &it: in_function_map) {
 			if (it.first == argv[1]) {
-				std::cout << std::endl;
-				std::cout << "> " << termcolor::cyan << "Executing CLI Command" << termcolor::reset << std::endl;
-				std::cout << std::endl;
-
 				(it.second)(argc, argv, cmd, description);
 				ran_command = true;
 			}
@@ -182,12 +182,13 @@ namespace EQEmuCommand {
 			}
 
 			std::cout << std::endl;
-		}
-		else if	(!ran_command) {
-			std::cerr << "Unknown command [" << argv[1] << "] ! Try --help" << std::endl;
+
+			std::exit(1);
 		}
 
-		exit(1);
+		if (ran_command) {
+			std::exit(1);
+		}
 	}
 
 }

common/database.cpp

@@ -45,6 +45,7 @@
 #include "eq_packet_structs.h"
 #include "extprofile.h"
 #include "string_util.h"
+#include "database_schema.h"
 
 extern Client client;
 
@@ -97,7 +98,7 @@ uint32 Database::CheckLogin(const char* name, const char* password, const char *
 	DoEscapeString(tmpUN, name, strlen(name));
 	DoEscapeString(tmpPW, password, strlen(password));
 
-	std::string query = StringFormat("SELECT id, status FROM account WHERE name='%s' AND ls_id='%s' AND password is not null "
+	std::string query = StringFormat("SELECT id, status FROM account WHERE `name`='%s' AND ls_id='%s' AND password is not null "
 		"and length(password) > 0 and (password='%s' or password=MD5('%s'))",
 		tmpUN, EscapeString(loginserver).c_str(), tmpPW, tmpPW);
 
@@ -124,7 +125,7 @@ uint32 Database::CheckLogin(const char* name, const char* password, const char *
 //Get Banned IP Address List - Only return false if the incoming connection's IP address is not present in the banned_ips table.
 bool Database::CheckBannedIPs(const char* loginIP)
 {
-	std::string query = StringFormat("SELECT ip_address FROM Banned_IPs WHERE ip_address='%s'", loginIP);
+	std::string query = StringFormat("SELECT ip_address FROM banned_ips WHERE ip_address='%s'", loginIP);
 
 	auto results = QueryDatabase(query);
 
@@ -140,7 +141,7 @@ bool Database::CheckBannedIPs(const char* loginIP)
 }
 
 bool Database::AddBannedIP(char* bannedIP, const char* notes) {
-	std::string query = StringFormat("INSERT into Banned_IPs SET ip_address='%s', notes='%s'", bannedIP, notes);
+	std::string query = StringFormat("INSERT into banned_ips SET ip_address='%s', notes='%s'", bannedIP, notes);
 	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
@@ -251,7 +252,7 @@ uint32 Database::CreateAccount(
 }
 
 bool Database::DeleteAccount(const char* name, const char *loginserver) {
-	std::string query = StringFormat("DELETE FROM account WHERE name='%s' AND ls_id='%s'", name, loginserver);
+	std::string query = StringFormat("DELETE FROM account WHERE `name`='%s' AND ls_id='%s'", name, loginserver);
 	LogInfo("Account Attempting to be deleted:'[{}]:[{}]'", loginserver, name);
 
 	auto results = QueryDatabase(query);
@@ -293,6 +294,37 @@ bool Database::SetAccountStatus(const char* name, int16 status) {
 	return true;
 }
 
+/**
+ * @param account_name
+ * @param status
+ * @return
+ */
+bool Database::SetAccountStatus(const std::string& account_name, int16 status)
+{
+	LogInfo("Account [{}] is attempting to be set to status [{}]", account_name, status);
+
+	std::string query = fmt::format(
+		SQL(
+			UPDATE account SET status = {} WHERE name = '{}'
+		),
+		status,
+		account_name
+	);
+
+	auto results = QueryDatabase(query);
+
+	if (!results.Success()) {
+		return false;
+	}
+
+	if (results.RowsAffected() == 0) {
+		LogWarning("Account [{}] does not exist!", account_name);
+		return false;
+	}
+
+	return true;
+}
+
 /* This initially creates the character during character create */
 bool Database::ReserveName(uint32 account_id, char* name) {
 	std::string query = StringFormat("SELECT `account_id`, `name` FROM `character_data` WHERE `name` = '%s'", name);
@@ -307,70 +339,81 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 	query = StringFormat("INSERT INTO `character_data` SET `account_id` = %i, `name` = '%s'", account_id, name);
 	results = QueryDatabase(query);
 	if (!results.Success() || results.ErrorMessage() != ""){ return false; }
+	
+	// Put character into the default guild if rule is being used.
+	int guild_id = RuleI(Character, DefaultGuild);
+
+	if (guild_id != 0) {
+		int character_id=results.LastInsertedID();
+		if (character_id > -1) {
+			query = StringFormat("INSERT INTO `guild_members` SET `char_id` = %i, `guild_id` = '%i'", character_id, guild_id);
+			results = QueryDatabase(query);
+			if (!results.Success() || results.ErrorMessage() != ""){
+				LogInfo("Could not put character [{}] into default Guild", name);
+			}
+		}
+	}
+	
 	return true;
 }
 
-/*
-	Delete the character with the name "name"
-	returns false on failure, true otherwise
-*/
-bool Database::DeleteCharacter(char *name) {
-	uint32 charid = 0;
-	if(!name ||	!strlen(name)) {
+/**
+ * @param character_name
+ * @return
+ */
+bool Database::DeleteCharacter(char *character_name) {
+	uint32 character_id = 0;
+	if(!character_name || !strlen(character_name)) {
 		LogInfo("DeleteCharacter: request to delete without a name (empty char slot)");
 		return false;
 	}
-	LogInfo("Database::DeleteCharacter name : [{}]", name);
 
-	/* Get id from character_data before deleting record so we can clean up the rest of the tables */
-	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
-	auto results = QueryDatabase(query);
-	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-	if (charid <= 0){
-		LogError("Database::DeleteCharacter :: Character ({}) not found, stopping delete...", name);
+	std::string query   = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", character_name);
+	auto        results = QueryDatabase(query);
+	for (auto   row     = results.begin(); row != results.end(); ++row) {
+		character_id = atoi(row[0]);
+	}
+
+	if (character_id <= 0) {
+		LogError("DeleteCharacter | Invalid Character ID [{}]", character_name);
 		return false;
 	}
 
-	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_enabledtasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `completed_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `friends` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `mail` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `timers` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `inventory` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `char_recipe_list` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `adventure_stats` WHERE `player_id` ='%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `zone_flags` WHERE `charID` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `titles` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `player_titlesets` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `keyring` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `faction_values` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `instance_list_player` WHERE `charid` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_data` WHERE `id` = '%d'", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_skills` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_languages` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_bind` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_alternate_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_currency` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_data` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_spells` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_memmed_spells` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_disciplines` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_material` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_tribute` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_bandolier` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_potionbelt` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_inspect_messages` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_leadership_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
-	query = StringFormat("DELETE FROM `character_alt_currency` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
+	std::string delete_type = "hard-deleted";
+	if (RuleB(Character, SoftDeletes)) {
+		delete_type       = "soft-deleted";
+		std::string query = fmt::format(
+			SQL(
+				UPDATE
+				character_data
+				SET
+				name = SUBSTRING(CONCAT(name, '-deleted-', UNIX_TIMESTAMP()), 1, 64),
+				deleted_at = NOW()
+				WHERE
+				id = '{}'
+			),
+			character_id
+		);
+
+		QueryDatabase(query);
+
+		return true;
+	}
+
+	LogInfo("DeleteCharacter | Character [{}] ({}) is being [{}]", character_name, character_id, delete_type);
+
+	for (const auto& iter : DatabaseSchema::GetCharacterTables()) {
+		std::string table_name               = iter.first;
+		std::string character_id_column_name = iter.second;
+
+		QueryDatabase(fmt::format("DELETE FROM {} WHERE {} = {}", table_name, character_id_column_name, character_id));
+	}
+
 #ifdef BOTS
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid); // note: only use of GetMobTypeById()
-#else
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
-#endif
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", character_id); // note: only use of GetMobTypeById()
 	QueryDatabase(query);
+#endif
+
 
 	return true;
 }
@@ -652,6 +695,7 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 		pp->RestTimer					  // " RestTimer)                 "
 	);
 	auto results = QueryDatabase(query);
+
 	/* Save Bind Points */
 	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
@@ -881,6 +925,38 @@ void Database::GetCharName(uint32 char_id, char* name) {
 	}
 }
 
+const char* Database::GetCharNameByID(uint32 char_id) {
+	std::string query = fmt::format("SELECT `name` FROM `character_data` WHERE id = {}", char_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success()) {
+		return "";
+	}
+
+	if (results.RowCount() == 0) {
+		return "";
+	}
+
+	auto row = results.begin();
+	return row[0];
+}
+
+const char* Database::GetNPCNameByID(uint32 npc_id) {
+	std::string query = fmt::format("SELECT `name` FROM `npc_types` WHERE id = {}", npc_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success()) {
+		return "";
+	}
+
+	if (results.RowCount() == 0) {
+		return "";
+	}
+
+	auto row = results.begin();
+	return row[0];
+}
+
 bool Database::LoadVariables() {
 	auto results = QueryDatabase(StringFormat("SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache.last_update));
 
@@ -1226,7 +1302,7 @@ uint32 Database::GetAccountIDFromLSID(
 {
 	uint32 account_id = 0;
 	auto query = fmt::format(
-		"SELECT id, name, status FROM account WHERE lsaccount_id = {0} AND ls_id = '{1}'",
+		"SELECT id, `name`, status FROM account WHERE lsaccount_id = {0} AND ls_id = '{1}'",
 		in_loginserver_account_id,
 		in_loginserver_id
 	);
@@ -1257,7 +1333,7 @@ uint32 Database::GetAccountIDFromLSID(
 
 void Database::GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus) {
 
-	std::string query = StringFormat("SELECT name, status FROM account WHERE id=%i", id);
+	std::string query = StringFormat("SELECT `name`, status FROM account WHERE id=%i", id);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()){
@@ -2114,6 +2190,44 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)
 	return atoi(row[0]);
 }
 
+uint32 Database::GetGroupIDByCharID(uint32 character_id)
+{
+	std::string query = fmt::format(
+		SQL(
+			SELECT groupid
+			FROM group_id
+			WHERE charid = '{}'
+		),
+		character_id
+	);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+	return atoi(row[0]);
+}
+
+uint32 Database::GetRaidIDByCharID(uint32 character_id) {
+	std::string query = fmt::format(
+		SQL(
+			SELECT raidid
+			FROM raid_members
+			WHERE charid = '{}'
+		),
+		character_id
+	);
+	auto results = QueryDatabase(query);
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		return atoi(row[0]);
+	}
+	return 0;
+}
+
 /**
  * @param log_settings
  */
@@ -2291,3 +2405,4 @@ int Database::GetInstanceID(uint32 char_id, uint32 zone_id) {
 
 	return 0;
 }
+

common/database.h

@@ -107,7 +107,7 @@ public:
 
 	bool	AddToNameFilter(const char* name);
 	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
-	bool	DeleteCharacter(char* name);
+	bool	DeleteCharacter(char* character_name);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
 	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);
@@ -120,7 +120,7 @@ public:
 
 	/* General Information Queries */
 
-	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the Banned_IPs table.
+	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the banned_ips table.
 	bool	AddGMIP(char* ip_address, char* name);
 	bool	CheckBannedIPs(const char* loginIP); //Check incoming connection against banned IP table.
 	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
@@ -133,9 +133,13 @@ public:
 	uint32	GetCharacterID(const char *name);
 	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0, float* oX = 0, float* oY = 0, float* oZ = 0);
 	uint32	GetGuildIDByCharID(uint32 char_id);
+	uint32  GetGroupIDByCharID(uint32 char_id);
+	uint32  GetRaidIDByCharID(uint32 char_id);
 
 	void	GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID = 0);
 	void	GetCharName(uint32 char_id, char* name);
+	const char *GetCharNameByID(uint32 char_id);
+	const char *GetNPCNameByID(uint32 npc_id);
 	void	LoginIP(uint32 AccountID, const char* LoginIP);
 
 	/* Instancing */
@@ -179,6 +183,7 @@ public:
 	bool	DeleteAccount(const char *name, const char* loginserver);
 	bool	GetLiveChar(uint32 account_id, char* cname);
 	bool	SetAccountStatus(const char* name, int16 status);
+	bool	SetAccountStatus(const std::string& account_name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
 	bool	UpdateLiveChar(char* charname, uint32 account_id);
 
@@ -191,19 +196,19 @@ public:
 
 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
-	
+
 	int		GetIPExemption(std::string account_ip);
 
 	int		GetInstanceID(uint32 char_id, uint32 zone_id);
 
 
 	/* Groups */
-	
+
 	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
 	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
-	
+
 	uint32	GetGroupID(const char* name);
-	
+
 	void	ClearGroup(uint32 gid = 0);
 	void	ClearGroupLeader(uint32 gid = 0);
 	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);

common/database/database_dump_service.cpp

@@ -0,0 +1,569 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+*/
+
+#include <string>
+#include <cstdio>
+#include <iterator>
+#include "database_dump_service.h"
+#include "../eqemu_logsys.h"
+#include "../string_util.h"
+#include "../eqemu_config.h"
+#include "../database_schema.h"
+#include "../file_util.h"
+
+#include <ctime>
+
+#if _WIN32
+#include <windows.h>
+#else
+
+#include <sys/time.h>
+
+#endif
+
+#define DATABASE_DUMP_PATH "backups/"
+
+/**
+ * @param cmd
+ * @param return_result
+ * @return
+ */
+std::string DatabaseDumpService::execute(const std::string &cmd, bool return_result = true)
+{
+	const char *file_name = "db-exec-result.txt";
+
+	if (return_result) {
+#ifdef _WINDOWS
+		std::system((cmd + " > " + file_name + " 2>&1").c_str());
+#else
+		std::system((cmd + " > " + file_name).c_str());
+#endif
+	}
+	else {
+		std::system((cmd).c_str());
+	}
+
+	std::string result;
+
+	if (return_result) {
+		std::ifstream file(file_name);
+		result = {std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
+		std::remove(file_name);
+
+	}
+
+	return result;
+}
+
+/**
+ * @return bool
+ */
+bool DatabaseDumpService::IsMySQLInstalled()
+{
+	std::string version_output = GetMySQLVersion();
+
+	return version_output.find("mysql") != std::string::npos && version_output.find("Ver") != std::string::npos;
+}
+
+/**
+ * Linux
+ * @return bool
+ */
+bool DatabaseDumpService::IsTarAvailable()
+{
+	std::string version_output = execute("tar --version");
+
+	return version_output.find("GNU tar") != std::string::npos;
+}
+
+/**
+ * Windows
+ * @return bool
+ */
+bool DatabaseDumpService::Is7ZipAvailable()
+{
+	std::string version_output = execute("7z --help");
+
+	return version_output.find("7-Zip") != std::string::npos;
+}
+
+/**
+ * @return
+ */
+bool DatabaseDumpService::HasCompressionBinary()
+{
+	return IsTarAvailable() || Is7ZipAvailable();
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetMySQLVersion()
+{
+	std::string version_output = execute("mysql --version");
+
+	return trim(version_output);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetBaseMySQLDumpCommand()
+{
+	auto config = EQEmuConfig::get();
+
+	return fmt::format(
+		"mysqldump -u {} -p{} -h {} {}",
+		config->DatabaseUsername,
+		config->DatabasePassword,
+		config->DatabaseHost,
+		config->DatabaseDB
+	);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetPlayerTablesList()
+{
+	std::string              tables_list;
+	std::vector<std::string> tables = DatabaseSchema::GetPlayerTables();
+	for (const auto          &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetLoginTableList()
+{
+	std::string              tables_list;
+	std::vector<std::string> tables = DatabaseSchema::GetLoginTables();
+	for (const auto          &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetQueryServTables()
+{
+	std::string              tables_list;
+	std::vector<std::string> tables = DatabaseSchema::GetQueryServerTables();
+	for (const auto          &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetSystemTablesList()
+{
+	std::string tables_list;
+
+	std::vector<std::string> tables = DatabaseSchema::GetServerTables();
+	for (const auto          &table : tables) {
+		tables_list += table + " ";
+	}
+
+	tables = DatabaseSchema::GetVersionTables();
+	for (const auto &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetStateTablesList()
+{
+	std::string tables_list;
+
+	std::vector<std::string> tables = DatabaseSchema::GetStateTables();
+	for (const auto &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetContentTablesList()
+{
+	std::string tables_list;
+
+	std::vector<std::string> tables = DatabaseSchema::GetContentTables();
+	for (const auto          &table : tables) {
+		tables_list += table + " ";
+	}
+
+	return trim(tables_list);
+}
+
+/**
+ * @return
+ */
+std::string GetDumpDate()
+{
+
+	time_t    now = time(nullptr);
+	struct tm time_struct{};
+	char      buf[80];
+	time_struct = *localtime(&now);
+	strftime(buf, sizeof(buf), "%Y-%m-%d", &time_struct);
+
+	std::string time = buf;
+
+	return time;
+}
+
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetSetDumpPath()
+{
+	return !GetDumpPath().empty() ? GetDumpPath() : DATABASE_DUMP_PATH;
+}
+/**
+ * @return
+ */
+std::string DatabaseDumpService::GetDumpFileNameWithPath()
+{
+	return GetSetDumpPath() + GetDumpFileName();
+}
+
+void DatabaseDumpService::Dump()
+{
+	if (!IsMySQLInstalled()) {
+		LogError("MySQL is not installed; Please check your PATH for a valid MySQL installation");
+		return;
+	}
+
+	if (IsDumpDropTableSyntaxOnly()) {
+		SetDumpOutputToConsole(true);
+	}
+
+	if (IsDumpOutputToConsole()) {
+		LogSys.SilenceConsoleLogging();
+	}
+
+	LogInfo("MySQL installed [{}]", GetMySQLVersion());
+
+	SetDumpFileName(EQEmuConfig::get()->DatabaseDB + '-' + GetDumpDate());
+
+	auto config = EQEmuConfig::get();
+
+	LogInfo(
+		"Database [{}] Host [{}] Username [{}]",
+		config->DatabaseDB,
+		config->DatabaseHost,
+		config->DatabaseUsername
+	);
+
+	std::string options = "--allow-keywords --extended-insert";
+
+	if (IsDumpWithNoData()) {
+		options += " --no-data";
+	}
+
+	if (!IsDumpTableLock()) {
+		options += " --skip-lock-tables";
+	}
+
+	std::string tables_to_dump;
+	std::string dump_descriptor;
+
+	if (!IsDumpAllTables()) {
+		if (IsDumpPlayerTables()) {
+			tables_to_dump += GetPlayerTablesList() + " ";
+			dump_descriptor += "-player";
+		}
+
+		if (IsDumpSystemTables()) {
+			tables_to_dump += GetSystemTablesList() + " ";
+			dump_descriptor += "-system";
+		}
+
+		if (IsDumpStateTables()) {
+			tables_to_dump += GetStateTablesList() + " ";
+			dump_descriptor += "-state";
+		}
+
+		if (IsDumpContentTables()) {
+			tables_to_dump += GetContentTablesList() + " ";
+			dump_descriptor += "-content";
+		}
+
+		if (IsDumpLoginServerTables()) {
+			tables_to_dump += GetLoginTableList() + " ";
+			dump_descriptor += "-login";
+		}
+
+		if (IsDumpQueryServerTables()) {
+			tables_to_dump += GetQueryServTables();
+			dump_descriptor += "-queryserv";
+		}
+	}
+
+	if (!dump_descriptor.empty()) {
+		SetDumpFileName(GetDumpFileName() + dump_descriptor);
+	}
+
+	/**
+	 * If we are dumping to stdout then we don't generate a file
+	 */
+	std::string pipe_file;
+	if (!IsDumpOutputToConsole()) {
+		pipe_file = fmt::format(" > {}.sql", GetDumpFileNameWithPath());
+	}
+
+	std::string execute_command = fmt::format(
+		"{} {} {} {}",
+		GetBaseMySQLDumpCommand(),
+		options,
+		tables_to_dump,
+		pipe_file
+	);
+
+	if (!FileUtil::exists(GetSetDumpPath()) && !IsDumpOutputToConsole()) {
+		FileUtil::mkdir(GetSetDumpPath());
+	}
+
+	if (IsDumpDropTableSyntaxOnly()) {
+		std::vector<std::string> tables = SplitString(tables_to_dump, ' ');
+
+		for (auto &table : tables) {
+			std::cout << "DROP TABLE IF EXISTS `" << table << "`;" << std::endl;
+		}
+
+		if (tables_to_dump.empty()) {
+			std::cerr << "No tables were specified" << std::endl;
+		}
+	}
+	else {
+		std::string execution_result = execute(execute_command, IsDumpOutputToConsole());
+		if (!execution_result.empty()) {
+			std::cout << execution_result;
+		}
+	}
+
+	if (!tables_to_dump.empty()) {
+		LogInfo("Dumping Tables [{}]", tables_to_dump);
+	}
+
+	LogInfo("Database dump created at [{}.sql]", GetDumpFileNameWithPath());
+
+	if (IsDumpWithCompression() && !IsDumpOutputToConsole()) {
+		if (HasCompressionBinary()) {
+			LogInfo("Compression requested... Compressing dump [{}.sql]", GetDumpFileNameWithPath());
+
+			if (IsTarAvailable()) {
+				execute(
+					fmt::format(
+						"tar -zcvf {}.tar.gz -C {} {}.sql",
+						GetDumpFileNameWithPath(),
+						GetSetDumpPath(),
+						GetDumpFileName()
+					)
+				);
+				LogInfo("Compressed dump created at [{}.tar.gz]", GetDumpFileNameWithPath());
+			}
+			else if (Is7ZipAvailable()) {
+				execute(
+					fmt::format(
+						"7z a -t7z {}.zip {}.sql",
+						GetDumpFileNameWithPath(),
+						GetDumpFileNameWithPath()
+					)
+				);
+				LogInfo("Compressed dump created at [{}.zip]", GetDumpFileNameWithPath());
+			}
+			else {
+				LogInfo("Compression requested, but no available compression binary was found");
+			}
+		}
+		else {
+			LogWarning("Compression requested but binary not found... Skipping...");
+		}
+	}
+
+//	LogDebug("[{}] dump-to-console", IsDumpOutputToConsole());
+//	LogDebug("[{}] dump-path", GetSetDumpPath());
+//	LogDebug("[{}] compression", (IsDumpWithCompression() ? "true" : "false"));
+//	LogDebug("[{}] query-serv", (IsDumpQueryServerTables() ? "true" : "false"));
+//	LogDebug("[{}] has-compression-binary", (HasCompressionBinary() ? "true" : "false"));
+//	LogDebug("[{}] content", (IsDumpContentTables() ? "true" : "false"));
+//	LogDebug("[{}] no-data", (IsDumpWithNoData() ? "true" : "false"));
+//	LogDebug("[{}] login", (IsDumpLoginServerTables() ? "true" : "false"));
+//	LogDebug("[{}] player", (IsDumpPlayerTables() ? "true" : "false"));
+//	LogDebug("[{}] system", (IsDumpSystemTables() ? "true" : "false"));
+}
+
+bool DatabaseDumpService::IsDumpSystemTables() const
+{
+	return dump_system_tables;
+}
+
+void DatabaseDumpService::SetDumpSystemTables(bool dump_system_tables)
+{
+	DatabaseDumpService::dump_system_tables = dump_system_tables;
+}
+
+bool DatabaseDumpService::IsDumpContentTables() const
+{
+	return dump_content_tables;
+}
+
+void DatabaseDumpService::SetDumpContentTables(bool dump_content_tables)
+{
+	DatabaseDumpService::dump_content_tables = dump_content_tables;
+}
+
+bool DatabaseDumpService::IsDumpPlayerTables() const
+{
+	return dump_player_tables;
+}
+
+void DatabaseDumpService::SetDumpPlayerTables(bool dump_player_tables)
+{
+	DatabaseDumpService::dump_player_tables = dump_player_tables;
+}
+
+bool DatabaseDumpService::IsDumpLoginServerTables() const
+{
+	return dump_login_server_tables;
+}
+
+void DatabaseDumpService::SetDumpLoginServerTables(bool dump_login_server_tables)
+{
+	DatabaseDumpService::dump_login_server_tables = dump_login_server_tables;
+}
+
+bool DatabaseDumpService::IsDumpWithNoData() const
+{
+	return dump_with_no_data;
+}
+
+void DatabaseDumpService::SetDumpWithNoData(bool dump_with_no_data)
+{
+	DatabaseDumpService::dump_with_no_data = dump_with_no_data;
+}
+
+bool DatabaseDumpService::IsDumpAllTables() const
+{
+	return dump_all_tables;
+}
+
+void DatabaseDumpService::SetDumpAllTables(bool dump_all_tables)
+{
+	DatabaseDumpService::dump_all_tables = dump_all_tables;
+}
+
+bool DatabaseDumpService::IsDumpTableLock() const
+{
+	return dump_table_lock;
+}
+
+void DatabaseDumpService::SetDumpTableLock(bool dump_table_lock)
+{
+	DatabaseDumpService::dump_table_lock = dump_table_lock;
+}
+
+bool DatabaseDumpService::IsDumpWithCompression() const
+{
+	return dump_with_compression;
+}
+
+void DatabaseDumpService::SetDumpWithCompression(bool dump_with_compression)
+{
+	DatabaseDumpService::dump_with_compression = dump_with_compression;
+}
+
+const std::string &DatabaseDumpService::GetDumpPath() const
+{
+	return dump_path;
+}
+
+void DatabaseDumpService::SetDumpPath(const std::string &dump_path)
+{
+	DatabaseDumpService::dump_path = dump_path;
+}
+
+void DatabaseDumpService::SetDumpFileName(const std::string &dump_file_name)
+{
+	DatabaseDumpService::dump_file_name = dump_file_name;
+}
+
+const std::string &DatabaseDumpService::GetDumpFileName() const
+{
+	return dump_file_name;
+}
+
+bool DatabaseDumpService::IsDumpQueryServerTables() const
+{
+	return dump_query_server_tables;
+}
+
+void DatabaseDumpService::SetDumpQueryServerTables(bool dump_query_server_tables)
+{
+	DatabaseDumpService::dump_query_server_tables = dump_query_server_tables;
+}
+
+bool DatabaseDumpService::IsDumpOutputToConsole() const
+{
+	return dump_output_to_console;
+}
+
+void DatabaseDumpService::SetDumpOutputToConsole(bool dump_output_to_console)
+{
+	DatabaseDumpService::dump_output_to_console = dump_output_to_console;
+}
+
+bool DatabaseDumpService::IsDumpDropTableSyntaxOnly() const
+{
+	return dump_drop_table_syntax_only;
+}
+
+void DatabaseDumpService::SetDumpDropTableSyntaxOnly(bool dump_drop_table_syntax_only)
+{
+	DatabaseDumpService::dump_drop_table_syntax_only = dump_drop_table_syntax_only;
+}
+
+bool DatabaseDumpService::IsDumpStateTables() const
+{
+	return dump_state_tables;
+}
+
+void DatabaseDumpService::SetDumpStateTables(bool dump_state_tables)
+{
+	DatabaseDumpService::dump_state_tables = dump_state_tables;
+}

common/database/database_dump_service.h

@@ -0,0 +1,91 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+*/
+
+#ifndef EQEMU_DATABASE_DUMP_SERVICE_H
+#define EQEMU_DATABASE_DUMP_SERVICE_H
+
+
+class DatabaseDumpService {
+public:
+	void Dump();
+	bool IsDumpAllTables() const;
+	void SetDumpAllTables(bool dump_all_tables);
+	bool IsDumpWithNoData() const;
+	void SetDumpWithNoData(bool dump_with_no_data);
+	bool IsDumpSystemTables() const;
+	void SetDumpSystemTables(bool dump_system_tables);
+	bool IsDumpContentTables() const;
+	void SetDumpContentTables(bool dump_content_tables);
+	bool IsDumpPlayerTables() const;
+	void SetDumpPlayerTables(bool dump_player_tables);
+	bool IsDumpLoginServerTables() const;
+	void SetDumpLoginServerTables(bool dump_login_server_tables);
+	bool IsDumpTableLock() const;
+	void SetDumpTableLock(bool dump_table_lock);
+	bool IsDumpWithCompression() const;
+	void SetDumpWithCompression(bool dump_with_compression);
+	const std::string &GetDumpPath() const;
+	void SetDumpPath(const std::string &dump_path);
+	const std::string &GetDumpFileName() const;
+	void SetDumpFileName(const std::string &dump_file_name);
+	bool IsDumpQueryServerTables() const;
+	void SetDumpQueryServerTables(bool dump_query_server_tables);
+	bool IsDumpOutputToConsole() const;
+	void SetDumpOutputToConsole(bool dump_output_to_console);
+	bool IsDumpDropTableSyntaxOnly() const;
+	void SetDumpDropTableSyntaxOnly(bool dump_drop_table_syntax_only);
+	bool IsDumpStateTables() const;
+	void SetDumpStateTables(bool dump_state_tables);
+
+private:
+	bool        dump_all_tables             = false;
+	bool        dump_state_tables           = false;
+	bool        dump_system_tables          = false;
+	bool        dump_content_tables         = false;
+	bool        dump_player_tables          = false;
+	bool        dump_query_server_tables    = false;
+	bool        dump_login_server_tables    = false;
+	bool        dump_with_no_data           = false;
+	bool        dump_table_lock             = false;
+	bool        dump_with_compression       = false;
+	bool        dump_output_to_console      = false;
+	bool        dump_drop_table_syntax_only = false;
+	std::string dump_path;
+	std::string dump_file_name;
+
+	std::string execute(const std::string &cmd, bool return_result);
+	bool IsMySQLInstalled();
+	std::string GetMySQLVersion();
+	std::string GetBaseMySQLDumpCommand();
+	std::string GetPlayerTablesList();
+	std::string GetSystemTablesList();
+	std::string GetStateTablesList();
+	std::string GetContentTablesList();
+	std::string GetLoginTableList();
+	bool IsTarAvailable();
+	bool Is7ZipAvailable();
+	bool HasCompressionBinary();
+	std::string GetDumpFileNameWithPath();
+	std::string GetSetDumpPath();
+	std::string GetQueryServTables();
+};
+
+
+#endif //EQEMU_DATABASE_DUMP_SERVICE_H

common/database_instances.cpp

@@ -97,42 +97,53 @@ bool Database::CheckInstanceExists(uint16 instance_id) {
 bool Database::CheckInstanceExpired(uint16 instance_id)
 {
 
-	int32 start_time = 0;
-	int32 duration = 0;
+	int32  start_time    = 0;
+	int32  duration      = 0;
 	uint32 never_expires = 0;
 
-	std::string query = StringFormat("SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u", instance_id);
+	std::string query = StringFormat(
+		"SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u",
+		instance_id
+	);
+
 	auto results = QueryDatabase(query);
 
-	if (!results.Success())
+	if (!results.Success()) {
 		return true;
+	}
 
-	if (results.RowCount() == 0)
+	if (results.RowCount() == 0) {
 		return true;
+	}
 
 	auto row = results.begin();
 
-	start_time = atoi(row[0]);
-	duration = atoi(row[1]);
+	start_time    = atoi(row[0]);
+	duration      = atoi(row[1]);
 	never_expires = atoi(row[2]);
 
-	if (never_expires == 1)
+	if (never_expires == 1) {
 		return false;
+	}
 
-	timeval tv;
+	timeval tv{};
 	gettimeofday(&tv, nullptr);
 
-	if ((start_time + duration) <= tv.tv_sec)
-		return true;
+	return (start_time + duration) <= tv.tv_sec;
 
-	return false;
 }
 
 bool Database::CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration)
 {
-	std::string query = StringFormat("INSERT INTO instance_list (id, zone, version, start_time, duration)"
-		" values(%lu, %lu, %lu, UNIX_TIMESTAMP(), %lu)",
-		(unsigned long)instance_id, (unsigned long)zone_id, (unsigned long)version, (unsigned long)duration);
+	std::string query = StringFormat(
+		"INSERT INTO instance_list (id, zone, version, start_time, duration)"
+		" values (%u, %u, %u, UNIX_TIMESTAMP(), %u)",
+		instance_id,
+		zone_id,
+		version,
+		duration
+	);
+
 	auto results = QueryDatabase(query);
 
 	return results.Success();
@@ -140,66 +151,84 @@ bool Database::CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version
 
 bool Database::GetUnusedInstanceID(uint16 &instance_id)
 {
-	uint32 count = RuleI(Zone, ReservedInstances);
-	uint32 max = 65535;
+	uint32 max_reserved_instance_id = RuleI(Instances, ReservedInstances);
+	uint32 max                      = 32000;
+
+	std::string query = StringFormat(
+		"SELECT IFNULL(MAX(id),%u)+1 FROM instance_list WHERE id > %u",
+		max_reserved_instance_id,
+		max_reserved_instance_id
+	);
+
+	if (RuleB(Instances, RecycleInstanceIds)) {
+		query = (
+			SQL(
+				SELECT i.id + 1 AS next_available
+				FROM instance_list i
+				LEFT JOIN instance_list i2 ON i2.id = i.id + 1
+				WHERE i2.id IS NULL
+				ORDER BY i.id
+				LIMIT 0, 1;
+
+			)
+		);
+	}
 
-	std::string query = StringFormat("SELECT IFNULL(MAX(id),%u)+1 FROM instance_list  WHERE id > %u", count, count);
 	auto results = QueryDatabase(query);
 
-	if (!results.Success())
-	{
+	if (!results.Success()) {
 		instance_id = 0;
 		return false;
 	}
 
-	if (results.RowCount() == 0)
-	{
-		instance_id = 0;
-		return false;
+	if (results.RowCount() == 0) {
+		instance_id = max_reserved_instance_id;
+		return true;
 	}
 
 	auto row = results.begin();
 
-	if (atoi(row[0]) <= max)
-	{
+	if (atoi(row[0]) <= max) {
 		instance_id = atoi(row[0]);
+
 		return true;
 	}
 
-	query = StringFormat("SELECT id FROM instance_list where id > %u ORDER BY id", count);
+	if (instance_id < max_reserved_instance_id) {
+		instance_id = max_reserved_instance_id;
+		return true;
+	}
+
+	query   = StringFormat("SELECT id FROM instance_list where id > %u ORDER BY id", max_reserved_instance_id);
 	results = QueryDatabase(query);
 
-	if (!results.Success())
-	{
+	if (!results.Success()) {
 		instance_id = 0;
 		return false;
 	}
 
-	if (results.RowCount() == 0)
-	{
+	if (results.RowCount() == 0) {
 		instance_id = 0;
 		return false;
 	}
 
-	count++;
-	for (auto row = results.begin(); row != results.end(); ++row)
-	{
-		if (count < atoi(row[0]))
-		{
-			instance_id = count;
+	max_reserved_instance_id++;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		if (max_reserved_instance_id < atoi(row[0])) {
+			instance_id = max_reserved_instance_id;
 			return true;
 		}
 
-		if (count > max)
-		{
+		if (max_reserved_instance_id > max) {
 			instance_id = 0;
 			return false;
 		}
 
-		count++;
+		max_reserved_instance_id++;
 	}
 
-	instance_id = count;
+	instance_id = max_reserved_instance_id;
+
 	return true;
 }
 
@@ -548,17 +577,36 @@ void Database::GetCharactersInInstance(uint16 instance_id, std::list<uint32> &ch
 
 void Database::PurgeExpiredInstances()
 {
-	std::string query("SELECT id FROM instance_list where (start_time+duration) <= UNIX_TIMESTAMP() and never_expires = 0");
+
+	/**
+	 * Delay purging by a day so that we can continue using adjacent free instance id's
+	 * from the table without risking the chance we immediately re-allocate a zone that freshly expired but
+	 * has not been fully de-allocated
+	 */
+	std::string query =
+		SQL(
+			SELECT
+				id
+			FROM
+				instance_list
+			where
+			(start_time + duration) <= (UNIX_TIMESTAMP() - 86400)
+			and never_expires = 0
+		);
+
 	auto results = QueryDatabase(query);
 
-	if (!results.Success())
+	if (!results.Success()) {
 		return;
+	}
 
-	if (results.RowCount() == 0)
+	if (results.RowCount() == 0) {
 		return;
+	}
 
-	for (auto row = results.begin(); row != results.end(); ++row)
+	for (auto row = results.begin(); row != results.end(); ++row) {
 		DeleteInstance(atoi(row[0]));
+	}
 }
 
 void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
@@ -566,4 +614,4 @@ void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
 	std::string query = StringFormat("UPDATE `instance_list` SET start_time=UNIX_TIMESTAMP(), "
 		"duration=%u WHERE id=%u", new_duration, instance_id);
 	auto results = QueryDatabase(query);
-}
+}

common/database_schema.h

@@ -0,0 +1,369 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef EQEMU_DATABASE_SCHEMA_H
+#define EQEMU_DATABASE_SCHEMA_H
+
+#include <vector>
+#include <map>
+
+namespace DatabaseSchema {
+
+	/**
+	 * Character-specific tables
+	 *
+	 * Does not included related meta-data tables such as 'guilds', 'accounts'
+	 * @return
+	 */
+	static std::map<std::string, std::string> GetCharacterTables()
+	{
+		return {
+			{"adventure_stats",                "player_id"},
+			{"buyer",                          "charid"},
+			{"char_recipe_list",               "char_id"},
+			{"character_activities",           "charid"},
+			{"character_alt_currency",         "char_id"},
+			{"character_alternate_abilities",  "id"},
+			{"character_auras",                "id"},
+			{"character_bandolier",            "id"},
+			{"character_bind",                 "id"},
+			{"character_buffs",                "character_id"},
+			{"character_corpses",              "id"},
+			{"character_currency",             "id"},
+			{"character_data",                 "id"},
+			{"character_disciplines",          "id"},
+			{"character_enabledtasks",         "charid"},
+			{"character_inspect_messages",     "id"},
+			{"character_item_recast",          "id"},
+			{"character_languages",            "id"},
+			{"character_leadership_abilities", "id"},
+			{"character_material",             "id"},
+			{"character_memmed_spells",        "id"},
+			{"character_pet_buffs",            "char_id"},
+			{"character_pet_info",             "char_id"},
+			{"character_pet_inventory",        "char_id"},
+			{"character_potionbelt",           "id"},
+			{"character_skills",               "id"},
+			{"character_spells",               "id"},
+			{"character_tasks",                "charid"},
+			{"character_tribute",              "id"},
+			{"completed_tasks",                "charid"},
+			{"data_buckets",                   "id"},
+			{"faction_values",                 "char_id"},
+			{"friends",                        "charid"},
+			{"guild_members",                  "char_id"},
+			{"guilds",                         "id"},
+			{"instance_list_player",           "id"},
+			{"inventory",                      "charid"},
+			{"inventory_snapshots",            "charid"},
+			{"keyring",                        "char_id"},
+			{"mail",                           "charid"},
+			{"player_titlesets",               "char_id"},
+			{"quest_globals",                  "charid"},
+			{"timers",                         "char_id"},
+			{"titles",                         "char_id"},
+			{"trader",                         "char_id"},
+			{"zone_flags",                     "charID"}
+		};
+	}
+
+	/**
+	 * @description Gets all player and meta-data tables
+	 * @note These tables have no content in the PEQ daily dump
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetPlayerTables()
+	{
+		return {
+			"account",
+			"account_ip",
+			"account_flags",
+			"account_rewards",
+			"adventure_details",
+			"adventure_stats",
+			"buyer",
+			"char_recipe_list",
+			"character_activities",
+			"character_alt_currency",
+			"character_alternate_abilities",
+			"character_auras",
+			"character_bandolier",
+			"character_bind",
+			"character_buffs",
+			"character_corpse_items",
+			"character_corpses",
+			"character_currency",
+			"character_data",
+			"character_disciplines",
+			"character_enabledtasks",
+			"character_inspect_messages",
+			"character_item_recast",
+			"character_languages",
+			"character_leadership_abilities",
+			"character_material",
+			"character_memmed_spells",
+			"character_pet_buffs",
+			"character_pet_info",
+			"character_pet_inventory",
+			"character_potionbelt",
+			"character_skills",
+			"character_spells",
+			"character_tasks",
+			"character_tribute",
+			"completed_tasks",
+			"data_buckets",
+			"discovered_items",
+			"faction_values",
+			"friends",
+			"guild_bank",
+			"guild_members",
+			"guild_ranks",
+			"guild_relations",
+			"guilds",
+			"instance_list_player",
+			"inventory",
+			"inventory_snapshots",
+			"keyring",
+			"mail",
+			"petitions",
+			"player_titlesets",
+			"quest_globals",
+			"sharedbank",
+			"spell_buckets",
+			"spell_globals",
+			"timers",
+			"titles",
+			"trader",
+			"trader_audit",
+			"zone_flags"
+		};
+	}
+
+	/**
+	 * Gets content tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetContentTables()
+	{
+		return {
+			"aa_ability",
+			"aa_actions",
+			"aa_effects",
+			"aa_rank_effects",
+			"aa_rank_prereqs",
+			"aa_ranks",
+			"aa_required_level_cost",
+			"adventure_template",
+			"adventure_template_entry",
+			"adventure_template_entry_flavor",
+			"altadv_vars",
+			"alternate_currency",
+			"auras",
+			"base_data",
+			"blocked_spells",
+			"books",
+			"char_create_combinations",
+			"char_create_point_allocations",
+			"class_skill",
+			"damageshieldtypes",
+			"doors",
+			"faction_base_data",
+			"faction_list",
+			"faction_list_mod",
+			"fear_hints",
+			"fishing",
+			"forage",
+			"global_loot",
+			"goallists",
+			"graveyard",
+			"grid",
+			"grid_entries",
+			"ground_spawns",
+			"horses",
+			"instance_list",
+			"items",
+			"ldon_trap_entries",
+			"ldon_trap_templates",
+			"lootdrop",
+			"lootdrop_entries",
+			"loottable",
+			"loottable_entries",
+			"merchantlist",
+			"npc_emotes",
+			"npc_faction",
+			"npc_faction_entries",
+			"npc_scale_global_base",
+			"npc_spells",
+			"npc_spells_effects",
+			"npc_spells_effects_entries",
+			"npc_spells_entries",
+			"npc_types",
+			"npc_types_metadata",
+			"npc_types_tint",
+			"object",
+			"pets",
+			"pets_equipmentset",
+			"pets_equipmentset_entries",
+			"proximities",
+			"races",
+			"skill_caps",
+			"spawn2",
+			"spawn_condition_values",
+			"spawn_conditions",
+			"spawn_events",
+			"spawnentry",
+			"spawngroup",
+			"spells_new",
+			"start_zones",
+			"starting_items",
+			"task_activities",
+			"tasks",
+			"tasksets",
+			"tradeskill_recipe",
+			"tradeskill_recipe_entries",
+			"traps",
+			"tribute_levels",
+			"tributes",
+			"veteran_reward_templates",
+			"zone",
+			"zone_points",
+			"zone_server",
+			"zoneserver_auth",
+		};
+	}
+
+	/**
+	 * Gets server tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetServerTables()
+	{
+		return {
+			"chatchannels",
+			"command_settings",
+			"db_str",
+			"eqtime",
+			"launcher",
+			"launcher_zones",
+			"level_exp_mods",
+			"logsys_categories",
+			"name_filter",
+			"perl_event_export_settings",
+			"profanity_list",
+			"rule_sets",
+			"rule_values",
+			"variables",
+		};
+	}
+
+	/**
+	 * Gets QueryServer tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetQueryServerTables()
+	{
+		return {
+			"qs_merchant_transaction_record",
+			"qs_merchant_transaction_record_entries",
+			"qs_player_aa_rate_hourly",
+			"qs_player_delete_record",
+			"qs_player_delete_record_entries",
+			"qs_player_events",
+			"qs_player_handin_record",
+			"qs_player_handin_record_entries",
+			"qs_player_move_record",
+			"qs_player_move_record_entries",
+			"qs_player_npc_kill_record",
+			"qs_player_npc_kill_record_entries",
+			"qs_player_speech",
+			"qs_player_trade_record",
+			"qs_player_trade_record_entries",
+		};
+	}
+
+	/**
+	 * Gets state tables
+	 * Tables that keep track of server state
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetStateTables()
+	{
+		return {
+			"adventure_members",
+			"banned_ips",
+			"bug_reports",
+			"bugs",
+			"eventlog",
+			"gm_ips",
+			"group_id",
+			"group_leaders",
+			"hackers",
+			"ip_exemptions",
+			"item_tick",
+			"lfguild",
+			"merchantlist_temp",
+			"object_contents",
+			"raid_details",
+			"raid_leaders",
+			"raid_members",
+			"reports",
+			"respawn_times",
+			"saylink",
+
+		};
+	}
+
+	/**
+	 * Gets login tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetLoginTables()
+	{
+		return {
+			"login_accounts",
+			"login_api_tokens",
+			"login_server_admins",
+			"login_server_list_types",
+			"login_world_servers",
+		};
+	}
+
+	/**
+	 * Gets login tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetVersionTables()
+	{
+		return {
+			"db_version",
+			"inventory_versions",
+		};
+	}
+
+}
+
+#endif //EQEMU_DATABASE_SCHEMA_H

common/dbcore.cpp

@@ -115,14 +115,14 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
-		/* Implement Logging at the Root */
+		/**
+		 * Error logging
+		 */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0) {
-			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
-				Log(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
+			LogMySQLError("[{}] [{}]\n[{}]", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql), errorBuffer);
-
 	}
 
 	// successful query. get results.
@@ -143,10 +143,8 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 
 	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
 		if ((strncasecmp(query, "select", 6) == 0)) {
-			LogF(
-				Logs::General,
-				Logs::MySQLQuery,
-				"{0} ({1} row{2} returned) ({3}ms)",
+			LogMySQLQuery(
+				"{0} ({1} row{2} returned) ({3}s)",
 				query,
 				requestResult.RowCount(),
 				requestResult.RowCount() == 1 ? "" : "s",
@@ -154,10 +152,8 @@ MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, boo
 			);
 		}
 		else {
-			LogF(
-				Logs::General,
-				Logs::MySQLQuery,
-				"{0} ({1} row{2} affected) ({3}ms)",
+			LogMySQLQuery(
+				"{0} ({1} row{2} affected) ({3}s)",
 				query,
 				requestResult.RowsAffected(),
 				requestResult.RowsAffected() == 1 ? "" : "s",

common/emu_constants.h

@@ -317,6 +317,15 @@ namespace EQEmu
 		QuestControlGrid = -1
 	};
 
+	namespace consent {
+		enum eConsentType : uint8 {
+			Normal = 0,
+			Group,
+			Raid,
+			Guild
+		};
+	}; // namespace consent
+
 } /*EQEmu*/
 
 #endif /*COMMON_EMU_CONSTANTS_H*/

common/eq_packet_structs.h

@@ -35,6 +35,8 @@ static const uint32 MAX_MERC = 100;
 static const uint32 MAX_MERC_GRADES = 10;
 static const uint32 MAX_MERC_STANCES = 10;
 static const uint32 BLOCKED_BUFF_COUNT = 20;
+static const uint32 QUESTREWARD_COUNT = 8;
+static const uint32 ADVANCED_LORE_LENGTH = 8192;
 
 
 /*
@@ -1358,21 +1360,24 @@ struct BecomeCorpse_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ int32		delta_heading:10,	// change in heading
-					x_pos:19,			// x coord
-					padding0002:3;		// ***Placeholder
-/*0006*/ int32		y_pos:19,			// y coord
-					animation:10,		// animation
-					padding0006:3;		// ***Placeholder
-/*0010*/ int32		z_pos:19,			// z coord
-					delta_y:13;			// change in y
-/*0014*/ int32		delta_x:13,			// change in x
-					heading:12,			// heading
-					padding0014:7;		// ***Placeholder
-/*0018*/ int32		delta_z:13,			// change in z
-					padding0018:19;		// ***Placeholder
-/*0022*/
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_z : 13;		// change in z
+			signed		delta_x : 13;		// change in x
+			signed		padding0008 : 6;
+/*0012*/	signed		x_pos : 19;			// x coord
+			unsigned	heading : 12;		// heading
+			signed		padding0016 : 1;
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			signed		z_pos : 19;			// z coord
+			signed		padding0020 : 3;
+/*0020*/	signed		animation : 10;		// animation
+			signed		delta_y : 13;		// change in y
+			signed		padding0024 : 9;
+/*0024*/
 };
 
 /*
@@ -1383,21 +1388,23 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16	spawn_id;
-/*0002*/ uint16	sequence;			//increments one each packet
-/*0004*/ float	y_pos;				// y coord
-/*0008*/ float	delta_z;			// Change in z
-/*0012*/ float	delta_x;			// Change in x
-/*0016*/ float	delta_y;			// Change in y
-/*0020*/ int32	animation:10,		// animation
-				delta_heading:10,	// change in heading
-				padding0020:12;		// ***Placeholder (mostly 1)
-/*0024*/ float	x_pos;				// x coord
-/*0028*/ float	z_pos;				// z coord
-/*0032*/ uint16	heading:12,			// Directional heading
-				padding0004:4;		// ***Placeholder
-/*0034*/ uint8	unknown0006[2];		// ***Placeholder
-/*0036*/
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_x;			// Change in x
+/*0014*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 20;	// ***Placeholder
+/*0018*/	float		x_pos;				// x coord (2nd loc value)
+/*0022*/	float		delta_z;			// Change in z
+/*0026*/	float		z_pos;				// z coord (3rd loc value)
+/*0030*/	float		y_pos;				// y coord (1st loc value)
+/*0034*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 22;	// animation
+/*0038*/	float		delta_y;			// Change in y
+/*0042*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0041 : 22;	// ***Placeholder
+/*0046*/
 };
 
 struct SpawnPositionUpdate_Struct
@@ -2175,14 +2182,7 @@ struct QuestReward_Struct
 	/*024*/ uint32	silver;		// Gives silver to the client
 	/*028*/ uint32	gold;		// Gives gold to the client
 	/*032*/ uint32	platinum;	// Gives platinum to the client
-	/*036*/ uint32	item_id;
-	/*040*/ uint32	unknown040;
-	/*044*/ uint32	unknown044;
-	/*048*/ uint32	unknown048;
-	/*052*/ uint32	unknown052;
-	/*056*/ uint32	unknown056;
-	/*060*/ uint32	unknown060;
-	/*064*/ uint32	unknown064;
+	/*036*/ int32	item_id[QUESTREWARD_COUNT];	// -1 for nothing
 	/*068*/
 };
 
@@ -2967,6 +2967,12 @@ struct	ItemViewRequest_Struct {
 /*046*/	char	unknown046[2];
 };
 
+struct ItemAdvancedLoreText_Struct {
+	int32	item_id;
+	char	item_name[64];
+	char	advanced_lore[ADVANCED_LORE_LENGTH];
+};
+
 struct	LDONItemViewRequest_Struct {
 	uint32	item_id;
 	uint8	unknown004[4];

common/eqemu_config.h

@@ -165,7 +165,7 @@ class EQEmuConfig
 				fconfig >> _config->_root;
 				_config->parse_config();
 			}
-			catch (std::exception) {
+			catch (std::exception &) {
 				return false;
 			}			
 			return true;

common/eqemu_logsys.cpp

@@ -124,6 +124,8 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	log_settings[Logs::Loginserver].log_to_console    = static_cast<uint8>(Logs::General);
 	log_settings[Logs::HeadlessClient].log_to_console = static_cast<uint8>(Logs::General);
 	log_settings[Logs::NPCScaling].log_to_gmsay       = static_cast<uint8>(Logs::General);
+	log_settings[Logs::HotReload].log_to_gmsay        = static_cast<uint8>(Logs::General);
+	log_settings[Logs::HotReload].log_to_console      = static_cast<uint8>(Logs::General);
 
 	/**
 	 * RFC 5424
@@ -579,3 +581,25 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 		);
 	}
 }
+
+/**
+ * Silence console logging
+ */
+void EQEmuLogSys::SilenceConsoleLogging()
+{
+	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
+		log_settings[log_index].log_to_console      = 0;
+		log_settings[log_index].is_category_enabled = 0;
+	}
+}
+
+/**
+ * Enables console logging
+ */
+void EQEmuLogSys::EnableConsoleLogging()
+{
+	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
+		log_settings[log_index].log_to_console      = Logs::General;
+		log_settings[log_index].is_category_enabled = 1;
+	}
+}

common/eqemu_logsys.h

@@ -107,6 +107,14 @@ namespace Logs {
 		Emergency,
 		Alert,
 		Notice,
+		AIScanClose,
+		AIYellForHelp,
+		AICastBeneficialClose,
+		AoeCast,
+		EntityManagement,
+		Flee,
+		Aura,
+		HotReload,
 		MaxCategoryID /* Don't Remove this */
 	};
 
@@ -172,7 +180,15 @@ namespace Logs {
 		"Critical",
 		"Emergency",
 		"Alert",
-		"Notice"
+		"Notice",
+		"AI Scan Close",
+		"AI Yell For Help",
+		"AI Cast Beneficial Close",
+		"AOE Cast",
+		"Entity Management",
+		"Flee",
+		"Aura",
+		"HotReload",
 	};
 }
 
@@ -279,6 +295,16 @@ public:
 	 */
 	void SetConsoleHandler(std::function<void(uint16 debug_level, uint16 log_type, const std::string&)> f) { on_log_console_hook = f; }
 
+	/**
+	 * Silence console logging
+	 */
+	void SilenceConsoleLogging();
+
+	/**
+	 * Turn on all console logging
+	 */
+	void EnableConsoleLogging();
+
 private:
 
 	/**

common/eqemu_logsys_log_aliases.h

@@ -21,6 +21,8 @@
 #ifndef EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H
 #define EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H
 
+#ifdef BUILD_LOGGING
+
 /**
  * RFC 5424
  */
@@ -489,9 +491,85 @@
         OutF(LogSys, Logs::Detail, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
-/**
-* Misc
-*/
+#define LogAIScanClose(message, ...) do {\
+    if (LogSys.log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIScanCloseDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIYellForHelp(message, ...) do {\
+    if (LogSys.log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIYellForHelpDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAICastBeneficialClose(message, ...) do {\
+    if (LogSys.log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAICastBeneficialCloseDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAoeCast(message, ...) do {\
+    if (LogSys.log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAoeCastDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogEntityManagement(message, ...) do {\
+    if (LogSys.log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogEntityManagementDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFlee(message, ...) do {\
+    if (LogSys.log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFleeDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAura(message, ...) do {\
+    if (LogSys.log_settings[Logs::Aura].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::Aura, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAuraDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::Aura].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::Aura, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHotReload(message, ...) do {\
+    if (LogSys.log_settings[Logs::HotReload].is_category_enabled == 1)\
+        OutF(LogSys, Logs::General, Logs::HotReload, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHotReloadDetail(message, ...) do {\
+    if (LogSys.log_settings[Logs::HotReload].is_category_enabled == 1)\
+        OutF(LogSys, Logs::Detail, Logs::HotReload, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
 
 #define Log(debug_level, log_category, message, ...) do {\
     if (LogSys.log_settings[log_category].is_category_enabled == 1)\
@@ -503,5 +581,340 @@
         OutF(LogSys, debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
 } while (0)
 
+#else
+#define LogEmergency(message, ...) do {\
+} while (0)
+
+#define LogAlert(message, ...) do {\
+} while (0)
+
+#define LogCritical(message, ...) do {\
+} while (0)
+
+#define LogError(message, ...) do {\
+} while (0)
+
+#define LogWarning(message, ...) do {\
+} while (0)
+
+#define LogNotice(message, ...) do {\
+} while (0)
+
+#define LogInfo(message, ...) do {\
+} while (0)
+
+#define LogDebug(message, ...) do {\
+} while (0)
+
+/**
+ * Category
+ */
+
+#define LogAA(message, ...) do {\
+} while (0)
+
+#define LogAADetail(message, ...) do {\
+} while (0)
+
+#define LogAI(message, ...) do {\
+} while (0)
+
+#define LogAIDetail(message, ...) do {\
+} while (0)
+
+#define LogAggro(message, ...) do {\
+} while (0)
+
+#define LogAggroDetail(message, ...) do {\
+} while (0)
+
+#define LogAttack(message, ...) do {\
+} while (0)
+
+#define LogAttackDetail(message, ...) do {\
+} while (0)
+
+#define LogPacketClientServer(message, ...) do {\
+} while (0)
+
+#define LogPacketClientServerDetail(message, ...) do {\
+} while (0)
+
+#define LogCombat(message, ...) do {\
+} while (0)
+
+#define LogCombatDetail(message, ...) do {\
+} while (0)
+
+#define LogCommands(message, ...) do {\
+} while (0)
+
+#define LogCommandsDetail(message, ...) do {\
+} while (0)
+
+#define LogCrash(message, ...) do {\
+} while (0)
+
+#define LogCrashDetail(message, ...) do {\
+} while (0)
+
+#define LogDoors(message, ...) do {\
+} while (0)
+
+#define LogDoorsDetail(message, ...) do {\
+} while (0)
+
+#define LogGuilds(message, ...) do {\
+} while (0)
+
+#define LogGuildsDetail(message, ...) do {\
+} while (0)
+
+#define LogInventory(message, ...) do {\
+} while (0)
+
+#define LogInventoryDetail(message, ...) do {\
+} while (0)
+
+#define LogLauncher(message, ...) do {\
+} while (0)
+
+#define LogLauncherDetail(message, ...) do {\
+} while (0)
+
+#define LogNetcode(message, ...) do {\
+} while (0)
+
+#define LogNetcodeDetail(message, ...) do {\
+} while (0)
+
+#define LogNormal(message, ...) do {\
+} while (0)
+
+#define LogNormalDetail(message, ...) do {\
+} while (0)
+
+#define LogObject(message, ...) do {\
+} while (0)
+
+#define LogObjectDetail(message, ...) do {\
+} while (0)
+
+#define LogPathing(message, ...) do {\
+} while (0)
+
+#define LogPathingDetail(message, ...) do {\
+} while (0)
+
+#define LogQSServer(message, ...) do {\
+} while (0)
+
+#define LogQSServerDetail(message, ...) do {\
+} while (0)
+
+#define LogQuests(message, ...) do {\
+} while (0)
+
+#define LogQuestsDetail(message, ...) do {\
+} while (0)
+
+#define LogRules(message, ...) do {\
+} while (0)
+
+#define LogRulesDetail(message, ...) do {\
+} while (0)
+
+#define LogSkills(message, ...) do {\
+} while (0)
+
+#define LogSkillsDetail(message, ...) do {\
+} while (0)
+
+#define LogSpawns(message, ...) do {\
+} while (0)
+
+#define LogSpawnsDetail(message, ...) do {\
+} while (0)
+
+#define LogSpells(message, ...) do {\
+} while (0)
+
+#define LogSpellsDetail(message, ...) do {\
+} while (0)
+
+#define LogTCPConnection(message, ...) do {\
+} while (0)
+
+#define LogTCPConnectionDetail(message, ...) do {\
+} while (0)
+
+#define LogTasks(message, ...) do {\
+} while (0)
+
+#define LogTasksDetail(message, ...) do {\
+} while (0)
+
+#define LogTradeskills(message, ...) do {\
+} while (0)
+
+#define LogTradeskillsDetail(message, ...) do {\
+} while (0)
+
+#define LogTrading(message, ...) do {\
+} while (0)
+
+#define LogTradingDetail(message, ...) do {\
+} while (0)
+
+#define LogTribute(message, ...) do {\
+} while (0)
+
+#define LogTributeDetail(message, ...) do {\
+} while (0)
+
+#define LogMySQLError(message, ...) do {\
+} while (0)
+
+#define LogMySQLErrorDetail(message, ...) do {\
+} while (0)
+
+#define LogMySQLQuery(message, ...) do {\
+} while (0)
+
+#define LogMySQLQueryDetail(message, ...) do {\
+} while (0)
+
+#define LogMercenaries(message, ...) do {\
+} while (0)
+
+#define LogMercenariesDetail(message, ...) do {\
+} while (0)
+
+#define LogQuestDebug(message, ...) do {\
+} while (0)
+
+#define LogQuestDebugDetail(message, ...) do {\
+} while (0)
+
+#define LogLoginserver(message, ...) do {\
+} while (0)
+
+#define LogLoginserverDetail(message, ...) do {\
+} while (0)
+
+#define LogClientLogin(message, ...) do {\
+} while (0)
+
+#define LogClientLoginDetail(message, ...) do {\
+} while (0)
+
+#define LogHeadlessClient(message, ...) do {\
+} while (0)
+
+#define LogHeadlessClientDetail(message, ...) do {\
+} while (0)
+
+#define LogHPUpdate(message, ...) do {\
+} while (0)
+
+#define LogHPUpdateDetail(message, ...) do {\
+} while (0)
+
+#define LogFixZ(message, ...) do {\
+} while (0)
+
+#define LogFixZDetail(message, ...) do {\
+} while (0)
+
+#define LogFood(message, ...) do {\
+} while (0)
+
+#define LogFoodDetail(message, ...) do {\
+} while (0)
+
+#define LogTraps(message, ...) do {\
+} while (0)
+
+#define LogTrapsDetail(message, ...) do {\
+} while (0)
+
+#define LogNPCRoamBox(message, ...) do {\
+} while (0)
+
+#define LogNPCRoamBoxDetail(message, ...) do {\
+} while (0)
+
+#define LogNPCScaling(message, ...) do {\
+} while (0)
+
+#define LogNPCScalingDetail(message, ...) do {\
+} while (0)
+
+#define LogMobAppearance(message, ...) do {\
+} while (0)
+
+#define LogMobAppearanceDetail(message, ...) do {\
+} while (0)
+
+#define LogStatus(message, ...) do {\
+} while (0)
+
+#define LogStatusDetail(message, ...) do {\
+} while (0)
+
+#define LogAIScanClose(message, ...) do {\
+} while (0)
+
+#define LogAIScanCloseDetail(message, ...) do {\
+} while (0)
+
+#define LogAIYellForHelp(message, ...) do {\
+} while (0)
+
+#define LogAIYellForHelpDetail(message, ...) do {\
+} while (0)
+
+#define LogAICastBeneficialClose(message, ...) do {\
+} while (0)
+
+#define LogAICastBeneficialCloseDetail(message, ...) do {\
+} while (0)
+
+#define LogAoeCast(message, ...) do {\
+} while (0)
+
+#define LogAoeCastDetail(message, ...) do {\
+} while (0)
+
+#define LogEntityManagement(message, ...) do {\
+} while (0)
+
+#define LogEntityManagementDetail(message, ...) do {\
+} while (0)
+
+#define LogFlee(message, ...) do {\
+} while (0)
+
+#define LogFleeDetail(message, ...) do {\
+} while (0)
+
+#define LogAura(message, ...) do {\
+} while (0)
+
+#define LogAuraDetail(message, ...) do {\
+} while (0)
+
+#define LogHotReload(message, ...) do {\
+} while (0)
+
+#define LogHotReloadDetail(message, ...) do {\
+} while (0)
+
+#define Log(debug_level, log_category, message, ...) do {\
+} while (0)
+
+#define LogF(debug_level, log_category, message, ...) do {\
+} while (0)
+#endif
 
 #endif //EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H

common/event/event_loop.h

@@ -21,6 +21,14 @@ namespace EQ
 			uv_run(&m_loop, UV_RUN_NOWAIT);
 		}
 
+		void Run() {
+			uv_run(&m_loop, UV_RUN_DEFAULT);
+		}
+
+		void Shutdown() {
+			uv_stop(&m_loop);
+		}
+
 		uv_loop_t* Handle() { return &m_loop; }
 
 	private:

common/expected.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2004 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -13,10 +13,15 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */
-#ifndef OLDCODE_H
-#define OLDCODE_H
 
-#endif
+#pragma once
 
+#include <tl/expected.hpp>
+
+namespace eq
+{
+	using tl::expected;
+	using tl::make_unexpected;
+}

common/file_util.cpp

@@ -0,0 +1,67 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+*/
+
+#include <fstream>
+#include "file_util.h"
+
+#ifdef _WINDOWS
+#include <direct.h>
+#include <conio.h>
+#include <iostream>
+#include <dos.h>
+#include <windows.h>
+#include <process.h>
+#else
+
+#include <unistd.h>
+#include <sys/stat.h>
+
+#endif
+
+/**
+ * @param name
+ * @return
+ */
+bool FileUtil::exists(const std::string &name)
+{
+	std::ifstream f(name.c_str());
+
+	return f.good();
+}
+
+/**
+ * @param directory_name
+ */
+void FileUtil::mkdir(const std::string& directory_name)
+{
+
+#ifdef _WINDOWS
+	struct _stat st;
+	if (_stat(directory_name.c_str(), &st) == 0) // exists
+		return;
+	_mkdir(directory_name.c_str());
+#else
+	struct stat st{};
+	if (stat(directory_name.c_str(), &st) == 0) { // exists
+		return;
+	}
+	::mkdir(directory_name.c_str(), 0755);
+#endif
+}

common/file_util.h

@@ -0,0 +1,32 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+*/
+
+#ifndef EQEMU_FILE_UTIL_H
+#define EQEMU_FILE_UTIL_H
+
+
+class FileUtil {
+public:
+	static bool exists(const std::string &name);
+	static void mkdir(const std::string& directory_name);
+};
+
+
+#endif //EQEMU_FILE_UTIL_H

common/guild_base.cpp

@@ -912,7 +912,7 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		return(false);
 
 	//load up the rank info for each guild.
-	std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id);
+	std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d AND c.deleted_at IS NULL", guild_id);
 	auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
@@ -941,7 +941,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
-    std::string query = StringFormat(GuildMemberBaseQuery " WHERE c.name='%s'", esc);
+    std::string query = StringFormat(GuildMemberBaseQuery " WHERE c.name='%s' AND c.deleted_at IS NULL", esc);
     safe_delete_array(esc);
     auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {
@@ -969,9 +969,9 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 	//load up the rank info for each guild.
 	std::string query;
 #ifdef BOTS
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C'", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C' AND c.deleted_at IS NULL", char_id);
 #else
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.deleted_at IS NULL", char_id);
 #endif
     auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {

common/json/jsoncpp.cpp

@@ -5277,7 +5277,7 @@ void StreamWriterBuilder::setDefaults(Json::Value* settings)
 {
   //! [StreamWriterBuilderDefaults]
   (*settings)["commentStyle"] = "All";
-  (*settings)["indentation"] = "\t";
+  (*settings)["indentation"] = "  ";
   (*settings)["enableYAMLCompatibility"] = false;
   (*settings)["dropNullPlaceholders"] = false;
   (*settings)["useSpecialFloats"] = false;

common/json_config.cpp

@@ -32,7 +32,7 @@ EQ::JsonConfigFile EQ::JsonConfigFile::Load(
 	try {
 		ifs >> ret.m_root;
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return ret;
 	}
 
@@ -81,7 +81,7 @@ std::string EQ::JsonConfigFile::GetVariableString(
 			return m_root[title][parameter].asString();
 		}
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return default_value;
 	}
 
@@ -105,7 +105,7 @@ int EQ::JsonConfigFile::GetVariableInt(
 			return m_root[title][parameter].asInt();
 		}
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return default_value;
 	}
 
@@ -129,7 +129,7 @@ bool EQ::JsonConfigFile::GetVariableBool(
 			return m_root[title][parameter].asBool();
 		}
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return default_value;
 	}
 
@@ -153,7 +153,7 @@ double EQ::JsonConfigFile::GetVariableDouble(
 			return m_root[title][parameter].asDouble();
 		}
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return default_value;
 	}
 

common/linked_list.h

@@ -278,12 +278,6 @@ void LinkedListIterator<TYPE>::Replace(const TYPE& new_data)
 template<class TYPE>
 void LinkedListIterator<TYPE>::Reset()
 {
-	if (!(&list))
-	{
-		current_element=0;
-		return;
-	}
-
 	if (dir == FORWARD)
 	{
 		current_element = list.first;

common/misc.cpp

@@ -19,9 +19,6 @@
 #include "types.h"
 #include <cstring>
 
-#define ENC(c) (((c) & 0x3f) + ' ')
-#define DEC(c)	(((c) - ' ') & 0x3f)
-
 std::map<int,std::string> DBFieldNames;
 
 #ifndef WIN32
@@ -333,64 +330,6 @@ void LoadItemDBFieldNames() {
 	DBFieldNames[113]="unknown115";		// ? (end quote)
 }
 
-void encode_length(unsigned long length, char *out)
-{
-char buf[4];
-	memcpy(buf,&length,sizeof(unsigned long));
-	encode_chunk(buf,3,out);
-}
-
-unsigned long encode(char *in, unsigned long length, char *out)
-{
-unsigned long used=0,len=0;
-	while(used<length) {
-		encode_chunk(in+used,length-used,out+len);
-		used+=3;
-		len+=4;
-	}
-	*(out+len)=0;
-
-	return len;
-}
-
-unsigned long decode_length(char *in)
-{
-int length;
-char buf[4];
-	decode_chunk(in,&buf[0]);
-	buf[3]=0;
-	memcpy(&length,buf,sizeof(unsigned long));
-
-	return length;
-}
-
-void decode(char *in, char *out)
-{
-char *ptr=in;
-char *outptr=out;
-	while(*ptr) {
-		decode_chunk(ptr,outptr);
-		ptr+=4;
-		outptr+=3;
-	}
-	*outptr=0;
-}
-
-void encode_chunk(char *in, int len, char *out)
-{
-	*out=ENC(in[0] >> 2);
-	*(out+1)=ENC((in[0] << 4)|(((len<2 ? 0 : in[1]) >> 4) & 0xF));
-	*(out+2)=ENC(((len<2 ? 0 : in[1]) << 2)|(((len<3 ? 0 : in[2]) >> 6) & 0x3));
-	*(out+3)=ENC((len<3 ? 0 : in[2]));
-}
-
-void decode_chunk(char *in, char *out)
-{
-	*out = DEC(*in) << 2 | DEC(in[1]) >> 4;
-	*(out+1) = DEC(in[1]) << 4 | DEC(in[2]) >> 2;
-	*(out+2) = DEC(in[2]) << 6 | DEC(in[3]);
-}
-
 void dump_message_column(unsigned char *buffer, unsigned long length, std::string leader, FILE *to)
 {
 unsigned long i,j;

common/misc.h

@@ -17,13 +17,6 @@ int Tokenize(std::string s, std::map<int,std::string> & tokens, char delim='|');
 
 void LoadItemDBFieldNames();
 
-void encode_length(unsigned long length, char *out);
-unsigned long decode_length(char *in);
-unsigned long encode(char *in, unsigned long length, char *out);
-void decode(char *in, char *out);
-void encode_chunk(char *in, int len, char *out);
-void decode_chunk(char *in, char *out);
-
 #ifndef WIN32
 int print_stacktrace();
 #endif

common/net/console_server_connection.cpp

@@ -116,17 +116,21 @@ bool EQ::Net::ConsoleServerConnection::SendChannelMessage(const ServerChannelMes
 	}
 
 	switch (scm->chan_num) {
-		if (RuleB(Chat, ServerWideAuction)) {
-			case 4: {
+		case 4: {
+			if (RuleB(Chat, ServerWideAuction)) {
 				QueueMessage(fmt::format("{0} auctions, '{1}'", scm->from, scm->message));
 				break;
+			} else { // I think we want default action in this case?
+				return false;
 			}
 		}
 
-		if (RuleB(Chat, ServerWideOOC)) {
-			case 5: {
+		case 5: {
+			if (RuleB(Chat, ServerWideOOC)) {
 				QueueMessage(fmt::format("{0} says ooc, '{1}'", scm->from, scm->message));
 				break;
+			} else { // I think we want default action in this case?
+				return false;
 			}
 		}
 

common/net/daybreak_connection.cpp

@@ -399,7 +399,7 @@ void EQ::Net::DaybreakConnection::Process()
 
 		ProcessQueue();
 	}
-	catch (std::exception ex) {
+	catch (std::exception &ex) {
 		if (m_owner->m_on_error_message) {
 			m_owner->m_on_error_message(fmt::format("Error processing connection: {0}", ex.what()));
 		}
@@ -1047,12 +1047,14 @@ void EQ::Net::DaybreakConnection::Compress(Packet &p, size_t offset, size_t leng
 	uint8_t new_buffer[2048] = { 0 };
 	uint8_t *buffer = (uint8_t*)p.Data() + offset;
 	uint32_t new_length = 0;
+	bool send_uncompressed = true;
 
 	if (length > 30) {
 		new_length = Deflate(buffer, (uint32_t)length, new_buffer + 1, 2048) + 1;
 		new_buffer[0] = 0x5a;
+		send_uncompressed = (new_length > length);
 	}
-	else {
+	if (send_uncompressed) {
 		memcpy(new_buffer + 1, buffer, length);
 		new_buffer[0] = 0xa5;
 		new_length = length + 1;
@@ -1380,7 +1382,7 @@ void EQ::Net::DaybreakConnection::InternalQueuePacket(Packet &p, int stream_id,
 	}
 
 	auto stream = &m_streams[stream_id];
-	auto max_raw_size = m_max_packet_size - m_crc_bytes - DaybreakReliableHeader::size();
+	auto max_raw_size = m_max_packet_size - m_crc_bytes - DaybreakReliableHeader::size() - 1; // -1 for compress flag
 	size_t length = p.Length();
 	if (length > max_raw_size) {
 		DaybreakReliableFragmentHeader first_header;

common/net/packet.h

@@ -89,9 +89,9 @@ namespace EQ {
 		public:
 			StaticPacket(void *data, size_t size) { m_data = data; m_data_length = size; m_max_data_length = size; }
 			virtual ~StaticPacket() { }
-			StaticPacket(const StaticPacket &o) { m_data = o.m_data; m_data_length = o.m_data_length; }
+			StaticPacket(const StaticPacket &o) { m_data = o.m_data; m_data_length = o.m_data_length; m_max_data_length = o.m_max_data_length; }
 			StaticPacket& operator=(const StaticPacket &o) { m_data = o.m_data; m_data_length = o.m_data_length; return *this; }
-			StaticPacket(StaticPacket &&o) { m_data = o.m_data; m_data_length = o.m_data_length; }
+			StaticPacket(StaticPacket &&o) noexcept { m_data = o.m_data; m_data_length = o.m_data_length; }
 
 			virtual const void *Data() const { return m_data; }
 			virtual void *Data() { return m_data; }
@@ -112,7 +112,7 @@ namespace EQ {
 		public:
 			DynamicPacket() { }
 			virtual ~DynamicPacket() { }
-			DynamicPacket(DynamicPacket &&o) { m_data = std::move(o.m_data); }
+			DynamicPacket(DynamicPacket &&o) noexcept { m_data = std::move(o.m_data); }
 			DynamicPacket(const DynamicPacket &o) { m_data = o.m_data; }
 			DynamicPacket& operator=(const DynamicPacket &o) { m_data = o.m_data; return *this; }
 
@@ -127,4 +127,4 @@ namespace EQ {
 			std::vector<char> m_data;
 		};
 	}
-}
+}

common/net/tcp_connection.cpp

@@ -203,6 +203,10 @@ int EQ::Net::TCPConnection::LocalPort() const
 
 std::string EQ::Net::TCPConnection::RemoteIP() const
 {
+	if (!m_socket) {
+		return "";
+	}
+
 	sockaddr_storage addr;
 	int addr_len = sizeof(addr);
 	uv_tcp_getpeername(m_socket, (sockaddr*)&addr, &addr_len);
@@ -220,6 +224,10 @@ std::string EQ::Net::TCPConnection::RemoteIP() const
 
 int EQ::Net::TCPConnection::RemotePort() const
 {
+	if (!m_socket) {
+		return 0;
+	}
+
 	sockaddr_storage addr;
 	int addr_len = sizeof(addr);
 	uv_tcp_getpeername(m_socket, (sockaddr*)&addr, &addr_len);
@@ -236,3 +244,11 @@ int EQ::Net::TCPConnection::RemotePort() const
 
 	return 0;
 }
+
+/**
+ * @return
+ */
+bool EQ::Net::TCPConnection::IsConnected() const
+{
+	return m_socket != nullptr;
+}

common/net/tcp_connection.h

@@ -24,10 +24,12 @@ namespace EQ
 			void Read(const char *data, size_t count);
 			void Write(const char *data, size_t count);
 
+			bool IsConnected() const;
 			std::string LocalIP() const;
 			int LocalPort() const;
 			std::string RemoteIP() const;
 			int RemotePort() const;
+
 		private:
 			TCPConnection();
 

common/net/websocket_server.cpp

@@ -61,7 +61,7 @@ EQ::Net::WebsocketServer::WebsocketServer(const std::string &addr, int port)
 				auto &connection = iter->second;
 				connection->GetWebsocketConnection()->ping("keepalive");
 			}
-			catch (std::exception) {
+			catch (std::exception &) {
 				iter->second->GetTCPConnection()->Disconnect();
 			}
 
@@ -157,7 +157,7 @@ void EQ::Net::WebsocketServer::DispatchEvent(WebsocketSubscriptionEvent evt, Jso
 			}
 		}
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 	}
 }
 
@@ -190,7 +190,7 @@ Json::Value EQ::Net::WebsocketServer::Login(WebsocketServerConnection *connectio
 
 		return ret;
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		throw WebsocketException("Unable to process login request");
 	}
 }
@@ -212,7 +212,7 @@ Json::Value EQ::Net::WebsocketServer::Subscribe(WebsocketServerConnection *conne
 	catch (WebsocketException &ex) {
 		throw ex;
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		throw WebsocketException("Unable to process unsubscribe request");
 	}
 }
@@ -234,7 +234,7 @@ Json::Value EQ::Net::WebsocketServer::Unsubscribe(WebsocketServerConnection *con
 	catch (WebsocketException &ex) {
 		throw ex;
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		throw WebsocketException("Unable to process unsubscribe request");
 	}
 }

common/patches/rof.cpp

@@ -624,6 +624,7 @@ namespace RoF
 		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);
 
 		OUT(spawn_id);
+		OUT(vehicle_id);
 		OUT(x_pos);
 		OUT(delta_x);
 		OUT(delta_y);
@@ -4314,6 +4315,7 @@ namespace RoF
 		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);
 
 		IN(spawn_id);
+		IN(vehicle_id);
 		IN(sequence);
 		IN(x_pos);
 		IN(y_pos);

common/patches/rof2.cpp

@@ -37,6 +37,7 @@
 #include <sstream>
 #include <numeric>
 #include <cassert>
+#include <cinttypes>
 
 
 namespace RoF2
@@ -686,25 +687,6 @@ namespace RoF2
 		FINISH_ENCODE();
 	}
 
-	ENCODE(OP_ClientUpdate)
-	{
-		ENCODE_LENGTH_EXACT(PlayerPositionUpdateServer_Struct);
-		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);
-
-		OUT(spawn_id);
-		OUT(x_pos);
-		OUT(delta_x);
-		OUT(delta_y);
-		OUT(z_pos);
-		OUT(delta_heading);
-		OUT(y_pos);
-		OUT(delta_z);
-		OUT(animation);
-		OUT(heading);
-
-		FINISH_ENCODE();
-	}
-
 	ENCODE(OP_Consider)
 	{
 		ENCODE_LENGTH_EXACT(Consider_Struct);
@@ -3567,7 +3549,7 @@ namespace RoF2
 			{
 				eq->items[i].Unknown18 = 0;
 				if (i < 80) {
-					snprintf(eq->items[i].SerialNumber, sizeof(eq->items[i].SerialNumber), "%016d", emu->SerialNumber[i]);
+					snprintf(eq->items[i].SerialNumber, sizeof(eq->items[i].SerialNumber), "%016" PRId64, emu->SerialNumber[i]);
 					eq->ItemCost[i] = emu->ItemCost[i];
 				}
 				else {
@@ -4545,27 +4527,6 @@ namespace RoF2
 		FINISH_DIRECT_DECODE();
 	}
 
-	DECODE(OP_ClientUpdate)
-	{
-		// for some odd reason, there is an extra byte on the end of this on occasion..
-		DECODE_LENGTH_ATLEAST(structs::PlayerPositionUpdateClient_Struct);
-		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);
-
-		IN(spawn_id);
-		IN(sequence);
-		IN(x_pos);
-		IN(y_pos);
-		IN(z_pos);
-		IN(heading);
-		IN(delta_x);
-		IN(delta_y);
-		IN(delta_z);
-		IN(delta_heading);
-		IN(animation);
-
-		FINISH_DIRECT_DECODE();
-	}
-
 	DECODE(OP_Consider)
 	{
 		DECODE_LENGTH_EXACT(structs::Consider_Struct);

common/patches/rof2_ops.h

@@ -52,7 +52,6 @@ E(OP_CastSpell)
 E(OP_ChannelMessage)
 E(OP_CharInventory)
 E(OP_ClickObjectAction)
-E(OP_ClientUpdate)
 E(OP_Consider)
 E(OP_Damage)
 E(OP_DeleteCharge)
@@ -155,7 +154,6 @@ D(OP_BuffRemoveRequest)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)
-D(OP_ClientUpdate)
 D(OP_Consider)
 D(OP_ConsiderCorpse)
 D(OP_Consume)

common/patches/rof2_structs.h

@@ -1620,24 +1620,24 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-	/*0000*/	uint16	spawn_id;
-	/*0002*/	uint16	spawnId2;
-	/*0004*/	signed	padding0004 : 12;
-				signed	y_pos : 19;			// y coord
-				unsigned padding : 1;
-	/*0008*/	signed	delta_z : 13;			// change in z
-				signed	delta_x : 13;			// change in x
-				signed	padding0008 : 6;
-	/*0012*/	signed	x_pos : 19;			// x coord
-				unsigned heading : 12;		// heading
-				signed	padding0016 : 1;
-	/*0016*/	signed	delta_heading : 10;	// change in heading
-				signed	z_pos : 19;			// z coord
-				signed	padding0020 : 3;
-	/*0020*/	signed	animation : 10;		// animation
-				signed	delta_y : 13;			// change in y
-				signed	padding0024 : 9;
-	/*0024*/
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_z : 13;		// change in z
+			signed		delta_x : 13;		// change in x
+			signed		padding0008 : 6;
+/*0012*/	signed		x_pos : 19;			// x coord
+			unsigned	heading : 12;		// heading
+			signed		padding0016 : 1;
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			signed		z_pos : 19;			// z coord
+			signed		padding0020 : 3;
+/*0020*/	signed		animation : 10;		// animation
+			signed		delta_y : 13;		// change in y
+			signed		padding0024 : 9;
+/*0024*/
 };
 
 /*
@@ -1648,22 +1648,23 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-	/*0000*/	uint16		sequence;			// increments one each packet - Verified
-	/*0002*/	uint16		spawn_id;			// Player's spawn id
-	/*0004*/	uint8		unknown0004[6];		// ***Placeholder
-	/*0010*/	float		delta_x;			// Change in x
-	/*0014*/	unsigned	heading : 12;			// Directional heading
-				unsigned	padding0040 : 20;		// ***Placeholder
-	/*0018*/	float		x_pos;				// x coord (2nd loc value)
-	/*0022*/	float		delta_z;			// Change in z
-	/*0026*/	float		z_pos;				// z coord (3rd loc value)
-	/*0030*/	float		y_pos;				// y coord (1st loc value)
-	/*0034*/	unsigned	animation : 10;		// ***Placeholder
-				unsigned	padding0024 : 22;		// animation
-	/*0038*/	float		delta_y;			// Change in y
-	/*0042*/	signed		delta_heading : 10;	// change in heading
-				unsigned	padding0041 : 22;		// ***Placeholder
-	/*0046*/
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_x;			// Change in x
+/*0014*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 20;	// ***Placeholder
+/*0018*/	float		x_pos;				// x coord (2nd loc value)
+/*0022*/	float		delta_z;			// Change in z
+/*0026*/	float		z_pos;				// z coord (3rd loc value)
+/*0030*/	float		y_pos;				// y coord (1st loc value)
+/*0034*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 22;	// animation
+/*0038*/	float		delta_y;			// Change in y
+/*0042*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0041 : 22;	// ***Placeholder
+/*0046*/
 };
 
 /*
@@ -4400,7 +4401,7 @@ struct SendAA_Struct {
 /*0104*/	uint32 special_category;
 /*0108*/	uint8 shroud;
 /*0109*/	uint8 unknown109;
-/*0110*/	uint8 layonhands; // 1 for lay on hands -- doesn't seem to matter?
+/*0110*/	uint8 reset_on_death; // timer is reset on death
 /*0111*/	uint8 unknown111;
 /*0112*/	uint32 total_abilities;
 /*0116*/	AA_Ability abilities[0];

common/patches/rof_structs.h

@@ -1608,22 +1608,22 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16	spawn_id;
-/*0002*/ uint16	spawnId2;
-/*0004*/ signed	padding0004:12;
-         signed	y_pos:19;           // y coord
-	 unsigned padding:1;
-/*0008*/ signed	delta_x:13;      // change in x
-         signed	delta_heading:10;// change in heading
-         signed	padding0008:9;
-/*0012*/ signed	delta_y:13;      // change in y
-         signed	z_pos:19;           // z coord
-/*0016*/ signed	x_pos:19;           // x coord
-         signed	animation:10;   // animation
-         signed	padding0016:3;
-/*0020*/ unsigned heading:12;     // heading
-         signed	delta_z:13;      // change in z
-         signed	padding0020:7;
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_x : 13;		// change in x
+			signed		delta_heading : 10;	// change in heading
+			signed		padding0008 : 9;
+/*0012*/	signed		delta_y : 13;		// change in y
+			signed		z_pos : 19;			// z coord
+/*0016*/	signed		x_pos : 19;			// x coord
+			signed		animation : 10;		// animation
+			signed		padding0016 : 3;
+/*0020*/	unsigned	heading : 12;		// heading
+			signed		delta_z : 13;		// change in z
+			signed		padding0020 : 7;
 /*0024*/
 };
 
@@ -1636,21 +1636,22 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		sequence;			// increments one each packet - Verified
-/*0002*/ uint16		spawn_id;			// Player's spawn id
-/*0004*/ uint8		unknown0004[6];		// ***Placeholder
-/*0010*/ float		delta_y;			// Change in y
-/*0014*/ float		x_pos;				// x coord (2nd loc value)
-/*0018*/ float		y_pos;				// y coord (1st loc value)
-/*0022*/ signed		delta_heading:10;	// change in heading
-	 unsigned	animation:10;		// ***Placeholder
-         unsigned	padding0024:12;		// animation
-/*0026*/ float		delta_z;			// Change in z
-/*0030*/ float		delta_x;			// Change in x
-/*0034*/ float		z_pos;				// z coord (3rd loc value)
-/*0038*/ unsigned	heading:12;			// Directional heading
-         unsigned	padding0040:10;		// ***Placeholder
-         unsigned	padding0041:10;		// ***Placeholder
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_y;			// Change in y
+/*0014*/	float		x_pos;				// x coord (2nd loc value)
+/*0018*/	float		y_pos;				// y coord (1st loc value)
+/*0022*/	signed		delta_heading : 10;	// change in heading
+			unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 12;	// animation
+/*0026*/	float		delta_z;			// Change in z
+/*0030*/	float		delta_x;			// Change in x
+/*0034*/	float		z_pos;				// z coord (3rd loc value)
+/*0038*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 10;	// ***Placeholder
+			unsigned	padding0041 : 10;	// ***Placeholder
 /*0042*/
 };
 
@@ -4340,7 +4341,7 @@ struct SendAA_Struct {
 /*0104*/	uint32 special_category;
 /*0108*/	uint8 shroud;
 /*0109*/	uint8 unknown109;
-/*0110*/	uint8 layonhands; // 1 for lay on hands -- doesn't seem to matter?
+/*0110*/	uint8 reset_on_death; // timer is reset on death
 /*0111*/	uint8 unknown111;
 /*0112*/	uint32 total_abilities;
 /*0116*/	AA_Ability abilities[0];

common/patches/sod.cpp

@@ -2926,6 +2926,7 @@ namespace SoD
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;
 
 		FINISH_DIRECT_DECODE();
 	}

common/patches/sod_structs.h

@@ -1372,21 +1372,21 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ signed		padding0000:12; // ***Placeholder
-         signed		delta_x:13;      // change in x
-         signed		padding0005:7;  // ***Placeholder
-/*0006*/ signed		delta_heading:10;// change in heading
-         signed		delta_y:13;      // change in y
-         signed		padding0006:9;  // ***Placeholder
-/*0010*/ signed		y_pos:19;           // y coord
-         signed		animation:10;   // animation
-         signed		padding0010:3;  // ***Placeholder
-/*0014*/ unsigned	heading:12;     // heading
-         signed		x_pos:19;           // x coord
-         signed		padding0014:1;  // ***Placeholder
-/*0018*/ signed		z_pos:19;           // z coord
-         signed		delta_z:13;      // change in z
+/*0000*/	uint16		spawn_id;
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		delta_x : 13;		// change in x
+			signed		padding0005 : 7;	// ***Placeholder
+/*0006*/	signed		delta_heading : 10;	// change in heading
+			signed		delta_y : 13;		// change in y
+			signed		padding0006 : 9;	// ***Placeholder
+/*0010*/	signed		y_pos : 19;			// y coord
+			signed		animation : 10;		// animation
+			signed		padding0010 : 3;	// ***Placeholder
+/*0014*/	unsigned	heading : 12;		// heading
+			signed		x_pos : 19;			// x coord
+			signed		padding0014 : 1;	// ***Placeholder
+/*0018*/	signed		z_pos : 19;			// z coord
+			signed		delta_z : 13;		// change in z
 /*0022*/
 };
 
@@ -1399,21 +1399,21 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		spawn_id;			// Player's spawn id
-/*0002*/ uint16		sequence;			// increments one each packet - Verified
-/*0004*/ uint8		unknown0004[4];		// ***Placeholder
-/*0008*/ float		x_pos;				// x coord (2nd loc value)
-/*0012*/ float		y_pos;				// y coord (1st loc value)
-/*0016*/ signed		delta_heading:10;	// change in heading
-         unsigned	padding0036:10;		// animation
-         unsigned	padding0016:12;		// ***Placeholder
-/*0020*/ float		delta_x;			// Change in x
-/*0024*/ float		delta_y;			// Change in y
-/*0028*/ float		z_pos;				// z coord (3rd loc value)
-/*0032*/ float		delta_z;			// Change in z
-/*0036*/ unsigned	animation:10;		// ***Placeholder
-         unsigned	heading:12;			// Directional heading
-         unsigned	padding0037:10;		// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Player's spawn id
+/*0002*/	uint16		sequence;			// increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		x_pos;				// x coord (2nd loc value)
+/*0012*/	float		y_pos;				// y coord (1st loc value)
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0036 : 10;	// animation
+			unsigned	padding0016 : 12;	// ***Placeholder
+/*0020*/	float		delta_x;			// Change in x
+/*0024*/	float		delta_y;			// Change in y
+/*0028*/	float		z_pos;				// z coord (3rd loc value)
+/*0032*/	float		delta_z;			// Change in z
+/*0036*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	heading : 12;		// Directional heading
+			unsigned	padding0037 : 10;	// ***Placeholder
 /*0040*/
 };
 
@@ -3780,7 +3780,7 @@ struct SendAA_Struct {
 /*0092*/	uint32 special_category;
 /*0096*/	uint8 shroud;
 /*0097*/	uint8 unknown97;
-/*0098*/	uint8 layonhands; // 1 for lay on hands -- doesn't seem to matter?
+/*0098*/	uint8 reset_on_death; // timer is reset on death
 /*0099*/	uint8 unknown99;
 /*0100*/	uint32 total_abilities;
 /*0104*/	AA_Ability abilities[0];

common/patches/sof.cpp

@@ -2387,6 +2387,7 @@ namespace SoF
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;
 
 		FINISH_DIRECT_DECODE();
 	}

common/patches/sof_structs.h

@@ -1373,21 +1373,21 @@ struct RespawnWindow_Struct {
 
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16   spawn_id;			// Entity ID of the Spawn/Player
-/*0002*/ signed   padding0000:12;	// ***Placeholder
-		 signed   x_pos:19;			// x coord
-		 signed   padding0290:1;	// ***Placeholder
-/*0006*/ signed   delta_x:13;		// change in x
-		 signed   delta_y:13;		// change in y
-		 signed   padding0294:6;	// ***Placeholder
-/*0010*/ signed   z_pos:19;			// z coord
-		 signed   delta_heading:10;	// change in heading
-		 signed   padding0298:3;	// ***Placeholder
-/*0014*/ signed   y_pos:19;			// y coord
-		 signed   delta_z:13;		// change in z
-/*0022*/ signed   animation:10;		// animation
-		 unsigned heading:12;		// heading
-		 signed   padding0302:10;	// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Entity ID of the Spawn/Player
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		x_pos : 19;			// x coord
+			signed		padding0290 : 1;	// ***Placeholder
+/*0006*/	signed		delta_x : 13;		// change in x
+			signed		delta_y : 13;		// change in y
+			signed		padding0294 : 6;	// ***Placeholder
+/*0010*/	signed		z_pos : 19;			// z coord
+			signed		delta_heading : 10;	// change in heading
+			signed		padding0298 : 3;	// ***Placeholder
+/*0014*/	signed		y_pos : 19;			// y coord
+			signed		delta_z : 13;		// change in z
+/*0022*/	signed		animation : 10;		// animation
+			unsigned	heading : 12;		// heading
+			signed		padding0302 : 10;	// ***Placeholder
 /*0026*/
 };
 
@@ -1399,20 +1399,20 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16 spawn_id;			// Player's Entity ID - Verified
-/*0002*/ uint16	sequence;			//increments one each packet - Verified
-/*0004*/ uint8 unknown0004[4];		// ***Placeholder
-/*0008*/ float delta_z;				// Change in z
-/*0012*/ float x_pos;				// x coord - Verified
-/*0016*/ signed delta_heading:10;	// Change in heading
-		 signed animation:10;		// Animation
-         unsigned padding0028:12;	// Seems to always be 0
-/*0020*/ float y_pos;				// y coord - Verified
-/*0024*/ float delta_x;				// Change in x
-/*0028*/ unsigned heading:12;		// Directional heading - Verified
-         unsigned padding0032:20;	// ***Placeholder - Some Static Number
-/*0032*/ float delta_y;				// Change in y
-/*0036*/ float z_pos;				// z coord - Verified
+/*0000*/	uint16		spawn_id;			// Player's Entity ID - Verified
+/*0002*/	uint16		sequence;			//increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		delta_z;			// Change in z
+/*0012*/	float		x_pos;				// x coord - Verified
+/*0016*/	signed		delta_heading : 10;	// Change in heading
+			signed		animation : 10;		// Animation
+			unsigned	padding0028 : 12;	// Seems to always be 0
+/*0020*/	float		y_pos;				// y coord - Verified
+/*0024*/	float		delta_x;			// Change in x
+/*0028*/	unsigned	heading : 12;		// Directional heading - Verified
+			unsigned	padding0032 : 20;	// ***Placeholder - Some Static Number
+/*0032*/	float		delta_y;			// Change in y
+/*0036*/	float		z_pos;				// z coord - Verified
 /*0040*/
 };
 
@@ -3704,7 +3704,7 @@ struct SendAA_Struct {
 /*0088*/	uint32 aa_expansion;
 /*0092*/	uint32 special_category;
 /*0096*/	uint8 shroud;
-/*0097*/	uint8 unknown97;
+/*0097*/	uint8 reset_on_death; // timer is reset on death -- guess
 /*0098*/	uint32 total_abilities;
 /*0102*/	AA_Ability abilities[0];
 };

common/patches/titanium.cpp

@@ -350,6 +350,25 @@ namespace Titanium
 		dest->FastQueuePacket(&in, ack_req);
 	}
 
+	ENCODE(OP_ClientUpdate)
+	{
+		ENCODE_LENGTH_EXACT(PlayerPositionUpdateServer_Struct);
+		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);
+
+		OUT(spawn_id);
+		OUT(x_pos);
+		OUT(delta_x);
+		OUT(delta_y);
+		OUT(z_pos);
+		OUT(delta_heading);
+		OUT(y_pos);
+		OUT(delta_z);
+		OUT(animation);
+		OUT(heading);
+
+		FINISH_ENCODE();
+	}
+
 	ENCODE(OP_Damage)
 	{
 		ENCODE_LENGTH_EXACT(CombatDamage_Struct);
@@ -1878,6 +1897,28 @@ namespace Titanium
 		FINISH_DIRECT_DECODE();
 	}
 
+	DECODE(OP_ClientUpdate)
+	{
+		// for some odd reason, there is an extra byte on the end of this on occasion.. (copied from SoF..not sure if applies to Ti - TODO: check)
+		DECODE_LENGTH_ATLEAST(structs::PlayerPositionUpdateClient_Struct);
+		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);
+
+		IN(spawn_id);
+		IN(sequence);
+		IN(x_pos);
+		IN(y_pos);
+		IN(z_pos);
+		IN(heading);
+		IN(delta_x);
+		IN(delta_y);
+		IN(delta_z);
+		IN(delta_heading);
+		IN(animation);
+		emu->vehicle_id = 0;
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_Consume)
 	{
 		DECODE_LENGTH_EXACT(structs::Consume_Struct);

common/patches/titanium_ops.h

@@ -27,6 +27,7 @@ E(OP_BecomeTrader)
 E(OP_Buff)
 E(OP_ChannelMessage)
 E(OP_CharInventory)
+E(OP_ClientUpdate)
 E(OP_Damage)
 E(OP_DeleteCharge)
 E(OP_DeleteItem)
@@ -82,6 +83,7 @@ D(OP_Bug)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)
+D(OP_ClientUpdate)
 D(OP_Consume)
 D(OP_DeleteItem)
 D(OP_Emote)

common/patches/titanium_structs.h

@@ -1197,20 +1197,20 @@ struct BecomeCorpse_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ int32		delta_heading:10,  // change in heading
-         			x_pos:19,             // x coord
-         			padding0002:3;    // ***Placeholder
-/*0006*/ int32		y_pos:19,             // y coord
-         			animation:10,     // animation
-         			padding0006:3;    // ***Placeholder
-/*0010*/ int32		z_pos:19,             // z coord
-         			delta_y:13;        // change in y
-/*0014*/ int32		delta_x:13,        // change in x
-        			heading:12,       // heading
-         			padding0014:7;    // ***Placeholder
-/*0018*/ int32		delta_z:13,        // change in z
-         			padding0018:19;   // ***Placeholder
+/*0000*/	uint16	spawn_id;
+/*0002*/	int32	delta_heading : 10,	// change in heading
+					x_pos : 19,			// x coord
+					padding0002 : 3;	// ***Placeholder
+/*0006*/	int32	y_pos : 19,			// y coord
+					animation : 10,		// animation
+					padding0006 : 3;	// ***Placeholder
+/*0010*/	int32	z_pos : 19,			// z coord
+					delta_y : 13;		// change in y
+/*0014*/	int32	delta_x : 13,		// change in x
+					heading : 12,		// heading
+					padding0014 : 7;	// ***Placeholder
+/*0018*/	int32	delta_z : 13,		// change in z
+					padding0018 : 19;	// ***Placeholder
 /*0022*/
 };
 
@@ -1222,20 +1222,20 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16	spawn_id;
-/*0022*/ uint16	sequence;	//increments one each packet
-/*0004*/ float y_pos;                 // y coord
-/*0008*/ float delta_z;            // Change in z
-/*0016*/ float delta_x;            // Change in x
-/*0012*/ float delta_y;            // Change in y
-/*0020*/ int32 animation:10,     // animation
-         		delta_heading:10,  // change in heading
-         		padding0020:12;   // ***Placeholder (mostly 1)
-/*0024*/ float x_pos;                 // x coord
-/*0028*/ float z_pos;                 // z coord
-/*0034*/ uint16 heading:12,     // Directional heading
-         		padding0004:4;  // ***Placeholder
-/*0032*/ uint8 unknown0006[2];  // ***Placeholder
+/*0000*/	uint16	spawn_id;
+/*0022*/	uint16	sequence;			// increments one each packet
+/*0004*/	float	y_pos;				// y coord
+/*0008*/	float	delta_z;			// Change in z
+/*0016*/	float	delta_x;			// Change in x
+/*0012*/	float	delta_y;			// Change in y
+/*0020*/	int32	animation : 10,		// animation
+					delta_heading : 10,	// change in heading
+					padding0020 : 12;	// ***Placeholder (mostly 1)
+/*0024*/	float	x_pos;				// x coord
+/*0028*/	float	z_pos;				// z coord
+/*0034*/	uint16	heading : 12,		// Directional heading
+					padding0004 : 4;	// ***Placeholder
+/*0032*/	uint8	unknown0006[2];		// ***Placeholder
 /*0036*/
 };
 

common/patches/uf.cpp

@@ -3252,6 +3252,7 @@ namespace UF
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;
 
 		FINISH_DIRECT_DECODE();
 	}

common/patches/uf_structs.h

@@ -1413,21 +1413,21 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ signed		padding0000:12; // ***Placeholder
-         signed		delta_x:13;      // change in x
-         signed		padding0005:7;  // ***Placeholder
-/*0006*/ signed		delta_heading:10;// change in heading
-         signed		delta_y:13;      // change in y
-         signed		padding0006:9;  // ***Placeholder
-/*0010*/ signed		y_pos:19;           // y coord
-         signed		animation:10;   // animation
-         signed		padding0010:3;  // ***Placeholder
-/*0014*/ unsigned	heading:12;     // heading
-         signed		x_pos:19;           // x coord
-         signed		padding0014:1;  // ***Placeholder
-/*0018*/ signed		z_pos:19;           // z coord
-         signed		delta_z:13;      // change in z
+/*0000*/	uint16		spawn_id;
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		delta_x : 13;		// change in x
+			signed		padding0005 : 7;	// ***Placeholder
+/*0006*/	signed		delta_heading : 10;	// change in heading
+			signed		delta_y : 13;		// change in y
+			signed		padding0006 : 9;	// ***Placeholder
+/*0010*/	signed		y_pos : 19;			// y coord
+			signed		animation : 10;		// animation
+			signed		padding0010 : 3;	// ***Placeholder
+/*0014*/	unsigned	heading : 12;		// heading
+			signed		x_pos : 19;			// x coord
+			signed		padding0014 : 1;	// ***Placeholder
+/*0018*/	signed		z_pos : 19;			// z coord
+			signed		delta_z : 13;		// change in z
 /*0022*/
 };
 
@@ -1440,21 +1440,21 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		spawn_id;			// Player's spawn id
-/*0002*/ uint16		sequence;			// increments one each packet - Verified
-/*0004*/ uint8		unknown0004[4];		// ***Placeholder
-/*0008*/ float		x_pos;				// x coord (2nd loc value)
-/*0012*/ float		y_pos;				// y coord (1st loc value)
-/*0016*/ signed		delta_heading:10;	// change in heading
-         unsigned	padding0036:10;		// animation
-         unsigned	padding0016:12;		// ***Placeholder
-/*0020*/ float		delta_x;			// Change in x
-/*0024*/ float		delta_y;			// Change in y
-/*0028*/ float		z_pos;				// z coord (3rd loc value)
-/*0032*/ float		delta_z;			// Change in z
-/*0036*/ unsigned	animation:10;		// ***Placeholder
-         unsigned	heading:12;			// Directional heading
-         unsigned	padding0037:10;		// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Player's spawn id
+/*0002*/	uint16		sequence;			// increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		x_pos;				// x coord (2nd loc value)
+/*0012*/	float		y_pos;				// y coord (1st loc value)
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0036 : 10;	// animation
+			unsigned	padding0016 : 12;	// ***Placeholder
+/*0020*/	float		delta_x;			// Change in x
+/*0024*/	float		delta_y;			// Change in y
+/*0028*/	float		z_pos;				// z coord (3rd loc value)
+/*0032*/	float		delta_z;			// Change in z
+/*0036*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	heading : 12;		// Directional heading
+			unsigned	padding0037 : 10;	// ***Placeholder
 /*0040*/
 };
 
@@ -3835,7 +3835,7 @@ struct SendAA_Struct {
 /*0092*/	uint32 special_category;
 /*0096*/	uint8 shroud;
 /*0097*/	uint8 unknown97;
-/*0098*/	uint8 layonhands; // 1 for lay on hands -- doesn't seem to matter?
+/*0098*/	uint8 reset_on_death; // timer is reset on death
 /*0099*/	uint8 unknown99;
 /*0100*/	uint32 total_abilities;
 /*0104*/	AA_Ability abilities[0];

common/ptimer.cpp

@@ -190,10 +190,6 @@ bool PersistentTimer::Clear(Database *db) {
 
 /* This function checks if the timer triggered */
 bool PersistentTimer::Expired(Database *db, bool iReset) {
-	if (this == nullptr) {
-		LogError("Null timer during ->Check()!?\n");
-		return(true);
-	}
 	uint32 current_time = get_current_time();
 	if (current_time-start_time >= timer_time) {
 		if (enabled && iReset) {

common/ruletypes.h

@@ -121,6 +121,7 @@ RULE_BOOL(Character, EnableAggroMeter, true, "Enable Aggro Meter, for users with
 RULE_BOOL(Character, KeepLevelOverMax, false, "Don't delevel a character that has somehow gone over the level cap")
 RULE_INT(Character, FoodLossPerUpdate, 32, "How much food/water you lose per stamina update")
 RULE_BOOL(Character, EnableHungerPenalties, false, "being hungry/thirsty has negative effects -- it does appear normal live servers do not have penalties")
+RULE_BOOL(Character, EnableFoodRequirement, true, "if disabled, food is no longer required")
 RULE_INT(Character, BaseInstrumentSoftCap, 36, "Softcap for instrument mods, 36 commonly referred to as \"3.6\" as well")
 RULE_BOOL(Character, UseSpellFileSongCap, true, "When they removed the AA that increased the cap they removed the above and just use the spell field")
 RULE_INT(Character, BaseRunSpeedCap, 158, "Base Run Speed Cap, on live it's 158% which will give you a runspeed of 1.580 hard capped to 225")
@@ -157,6 +158,10 @@ RULE_BOOL(Character, OPClientUpdateVisualDebug, false, "Shows a pulse and forwar
 RULE_BOOL(Character, AllowCrossClassTrainers, false, "")
 RULE_BOOL(Character, PetsUseReagents, true, "Pets use reagent on spells")
 RULE_BOOL(Character, DismountWater, true, "Dismount horses when entering water")
+RULE_BOOL(Character, UseNoJunkFishing, false, "Disregards junk items when fishing")
+RULE_BOOL(Character, SoftDeletes, true, "When characters are deleted in character select, they are only soft deleted")
+RULE_INT(Character, DefaultGuild, 0, "If not 0, new characters placed into the guild # indicated")
+RULE_BOOL(Character, ProcessFearedProximity, false, "Processes proximity checks when feared")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Mercs)
@@ -193,6 +198,7 @@ RULE_INT(Skills, SwimmingStartValue, 100, "")
 RULE_BOOL(Skills, TrainSenseHeading, false, "")
 RULE_INT(Skills, SenseHeadingStartValue, 200, "")
 RULE_BOOL(Skills, SelfLanguageLearning, true, "")
+RULE_BOOL(Skills, RequireTomeHandin, false, "Disable click-to-learn and force turnin to Guild Master")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Pets)
@@ -211,7 +217,7 @@ RULE_CATEGORY_END()
 RULE_CATEGORY(World)
 RULE_INT(World, ZoneAutobootTimeoutMS, 60000, "")
 RULE_INT(World, ClientKeepaliveTimeoutMS, 65000, "")
-RULE_BOOL(World, UseBannedIPsTable, false, "Toggle whether or not to check incoming client connections against the Banned_IPs table. Set this value to false to disable this feature")
+RULE_BOOL(World, UseBannedIPsTable, false, "Toggle whether or not to check incoming client connections against the banned_ips table. Set this value to false to disable this feature")
 RULE_BOOL(World, EnableTutorialButton, true, "")
 RULE_BOOL(World, EnableReturnHomeButton, true, "")
 RULE_INT(World, MaxLevelForTutorial, 10, "")
@@ -264,7 +270,6 @@ RULE_INT(Zone, PEQZoneDebuff1, 4454, "First debuff casted by #peqzone Default is
 RULE_INT(Zone, PEQZoneDebuff2, 2209, "Second debuff casted by #peqzone Default is Tendrils of Apathy")
 RULE_BOOL(Zone, UsePEQZoneDebuffs, true, "Will determine if #peqzone will debuff players or not when used")
 RULE_REAL(Zone, HotZoneBonus, 0.75, "")
-RULE_INT(Zone, ReservedInstances, 30, "Will reserve this many instance ids for globals... probably not a good idea to change this while a server is running")
 RULE_INT(Zone, EbonCrystalItemID, 40902, "")
 RULE_INT(Zone, RadiantCrystalItemID, 40903, "")
 RULE_BOOL(Zone, LevelBasedEXPMods, false, "Allows you to use the level_exp_mods table in consideration to your players EXP hits")
@@ -292,6 +297,7 @@ RULE_BOOL(Pathing, Find, true, "Enable pathing for FindPerson requests from the
 RULE_BOOL(Pathing, Fear, true, "Enable pathing for fear")
 RULE_REAL(Pathing, NavmeshStepSize, 100.0f, "")
 RULE_REAL(Pathing, ShortMovementUpdateRange, 130.0f, "")
+RULE_INT(Pathing, MaxNavmeshNodes, 4092, "Max navmesh nodes in a traversable path")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Watermap)
@@ -490,8 +496,10 @@ RULE_INT(Combat, NPCAssistCapTimer, 6000, "Time in milliseconds a NPC will take
 RULE_BOOL(Combat, UseRevampHandToHand, false, "use h2h revamped dmg/delays I believe this was implemented during SoF")
 RULE_BOOL(Combat, ClassicMasterWu, false, "classic master wu uses a random special, modern doesn't")
 RULE_INT(Combat, LevelToStopDamageCaps, 0, "1 will effectively disable them, 20 should give basically same results as old incorrect system")
+RULE_INT(Combat, LevelToStopACTwinkControl, 50, "1 will effectively disable it, 50 should give basically same results as current system")
 RULE_BOOL(Combat, ClassicNPCBackstab, false, "true disables npc facestab - npcs get normal attack if not behind")
 RULE_BOOL(Combat, UseNPCDamageClassLevelMods, true, "Uses GetClassLevelDamageMod calc in npc_scale_manager")
+RULE_BOOL(Combat, UseExtendedPoisonProcs, false, "Allow old school poisons to last until characrer zones, at a lower proc rate")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(NPC)
@@ -516,10 +524,11 @@ RULE_INT(NPC, NPCToNPCAggroTimerMin, 500, "")
 RULE_INT(NPC, NPCToNPCAggroTimerMax, 6000, "")
 RULE_BOOL(NPC, UseClassAsLastName, true, "Uses class archetype as LastName for npcs with none")
 RULE_BOOL(NPC, NewLevelScaling, true, "Better level scaling, use old if new formulas would break your server")
-RULE_INT(NPC, NPCGatePercent, 5, "% at which the NPC Will attempt to gate at")
+RULE_INT(NPC, NPCGatePercent, 20, "% at which the NPC Will attempt to gate at")
 RULE_BOOL(NPC, NPCGateNearBind, false, "Will NPC attempt to gate when near bind location?")
 RULE_INT(NPC, NPCGateDistanceBind, 75, "Distance from bind before NPC will attempt to gate")
 RULE_BOOL(NPC, NPCHealOnGate, true, "Will the NPC Heal on Gate")
+RULE_BOOL(NPC, UseMeditateBasedManaRegen, false, "Based NPC ooc regen on Meditate skill")
 RULE_REAL(NPC, NPCHealOnGateAmount, 25, "How much the npc will heal on gate if enabled")
 RULE_CATEGORY_END()
 
@@ -565,13 +574,13 @@ RULE_INT(Range, MobPositionUpdates, 600, "")
 RULE_INT(Range, ClientPositionUpdates, 300, "")
 RULE_INT(Range, ClientForceSpawnUpdateRange, 1000, "")
 RULE_INT(Range, CriticalDamage, 80, "")
-RULE_INT(Range, ClientNPCScan, 300, "")
+RULE_INT(Range, MobCloseScanDistance, 600, "")
 RULE_CATEGORY_END()
 
 
 #ifdef BOTS
 RULE_CATEGORY(Bots)
-RULE_INT(Bots, AAExpansion, 8, "Bots get AAs through this expansion")
+RULE_INT(Bots, BotExpansionSettings, 16383, "Sets the expansion settings for bot use. Defaults to all expansions enabled up to TSS")
 RULE_BOOL(Bots, AllowCamelCaseNames, false, "Allows the use of 'MyBot' type names")
 RULE_INT(Bots, CommandSpellRank, 1, "Filters bot command spells by rank (1, 2 and 3 are valid filters - any other number allows all ranks)")
 RULE_INT(Bots, CreationLimit, 150, "Number of bots that each account can create")
@@ -595,8 +604,12 @@ RULE_INT(Bots, CasterStopMeleeLevel, 13, "Level at which caster bots stop melee
 RULE_INT(Bots, AllowedClasses, 0xFFFFFFFF, "Bitmask of allowed bot classes")
 RULE_INT(Bots, AllowedRaces, 0xFFFFFFFF, "Bitmask of allowed bot races")
 RULE_INT(Bots, AllowedGenders, 0x3, "Bitmask of allowed bot genders")
-RULE_BOOL(Bots, AllowOwnerAutoDefend, false, "When active, bots will defend their owner on enemy aggro")
+RULE_BOOL(Bots, AllowOwnerOptionAltCombat, true, "When option is enabled, bots will use an auto-/shared-aggro combat model")
+RULE_BOOL(Bots, AllowOwnerOptionAutoDefend, true, "When option is enabled, bots will defend their owner on enemy aggro")
 RULE_REAL(Bots, LeashDistance, 562500.0f, "Distance a bot is allowed to travel from leash owner before being pulled back (squared value)")
+RULE_BOOL(Bots, AllowApplyPoisonCommand, true, "Allows the use of the bot command 'applypoison'")
+RULE_BOOL(Bots, AllowApplyPotionCommand, true, "Allows the use of the bot command 'applypotion'")
+RULE_BOOL(Bots, RestrictApplyPotionToRogue, true, "Restricts the bot command 'applypotion' to rogue-usable potions (i.e., poisons)")
 RULE_CATEGORY_END()
 #endif
 
@@ -626,6 +639,7 @@ RULE_INT(Merchant, PricePenaltyPct, 4, "Determines maximum price penalty from ha
 RULE_REAL(Merchant, ChaBonusMod, 3.45, "Determines CHA cap, from 104 CHA. 3.45 is 132 CHA at apprehensive. 0.34 is 400 CHA at apprehensive")
 RULE_REAL(Merchant, ChaPenaltyMod, 1.52, "Determines CHA bottom, up to 102 CHA. 1.52 is 37 CHA at apprehensive. 0.98 is 0 CHA at apprehensive")
 RULE_BOOL(Merchant, EnableAltCurrencySell, true, "Enables the ability to resell items to alternate currency merchants")
+RULE_BOOL(Merchant, AllowCorpse, false, "Can merchants generate a corpse")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Bazaar)
@@ -726,7 +740,6 @@ RULE_BOOL(Inventory, EnforceAugmentWear, true, "Forces augment wear slot validat
 RULE_BOOL(Inventory, DeleteTransformationMold, true, "False if you want mold to last forever")
 RULE_BOOL(Inventory, AllowAnyWeaponTransformation, false, "Weapons can use any weapon transformation")
 RULE_BOOL(Inventory, TransformSummonedBags, false, "Transforms summoned bags into disenchanted ones instead of deleting")
-RULE_BOOL(Inventory, BulkSendEnMasse, false, "Sends player 'Enter World' inventory as one massive packet (true = normal behavior)")
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Client)
@@ -755,6 +768,18 @@ RULE_CATEGORY(Logging)
 RULE_BOOL(Logging, PrintFileFunctionAndLine, false, "Ex: [World Server] [net.cpp::main:309] Loading variables...")
 RULE_CATEGORY_END()
 
+RULE_CATEGORY(HotReload)
+RULE_BOOL(HotReload, QuestsRepopWithReload, true, "When a hot reload is triggered, the zone will repop")
+RULE_BOOL(HotReload, QuestsRepopWhenPlayersNotInCombat, true, "When a hot reload is triggered, the zone will repop when no clients are in combat")
+RULE_BOOL(HotReload, QuestsResetTimersWithReload, true, "When a hot reload is triggered, quest timers will be reset")
+RULE_CATEGORY_END()
+
+RULE_CATEGORY(Instances)
+RULE_INT(Instances, ReservedInstances, 30, "Will reserve this many instance ids for globals... probably not a good idea to change this while a server is running")
+RULE_BOOL(Instances, RecycleInstanceIds, true, "Will recycle free instance ids instead of gradually running out at 32k")
+RULE_INT(Instances, GuildHallExpirationDays, 90, "Amount of days before a Guild Hall instance expires")
+RULE_CATEGORY_END()
+
 #undef RULE_CATEGORY
 #undef RULE_INT
 #undef RULE_REAL

common/servertalk.h

@@ -197,7 +197,11 @@
 #define ServerOP_CZSetEntityVariableByClientName 0x4012
 #define ServerOP_UCSServerStatusRequest		0x4013
 #define ServerOP_UCSServerStatusReply		0x4014
-/* Query Server OP Codes */
+#define ServerOP_HotReloadQuests 0x4015
+
+/**
+ * QueryServer
+ */
 #define ServerOP_QSPlayerLogTrades					0x5010
 #define ServerOP_QSPlayerLogHandins					0x5011
 #define ServerOP_QSPlayerLogNPCKills				0x5012
@@ -262,9 +266,6 @@ public:
 	}
 
 	ServerPacket* Copy() {
-		if (this == 0) {
-			return 0;
-		}
 		ServerPacket* ret = new ServerPacket(this->opcode, this->size);
 		if (this->size)
 			memcpy(ret->pBuffer, this->pBuffer, this->size);
@@ -869,10 +870,12 @@ struct SpawnPlayerCorpse_Struct {
 struct ServerOP_Consent_Struct {
 	char grantname[64];
 	char ownername[64];
+	char zonename[32];
 	uint8 permission;
 	uint32 zone_id;
 	uint16 instance_id;
-	uint32 message_string_id;
+	uint8  consent_type; // 0 = normal, 1 = group, 2 = raid, 3 = guild
+	uint32 consent_id;
 };
 
 struct ReloadTasks_Struct {
@@ -1352,12 +1355,16 @@ struct CZSetEntVarByClientName_Struct {
 	char m_var[256];
 };
 
-struct ReloadWorld_Struct{
+struct ReloadWorld_Struct {
 	uint32 Option;
 };
 
+struct HotReloadQuestsStruct {
+	char zone_short_name[200];
+};
+
 struct ServerRequestTellQueue_Struct {
-	char	name[64];
+	char name[64];
 };
 
 struct UCSServerStatus_Struct {

common/shared/shared_memory.h

@@ -0,0 +1,82 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "../expected.h"
+#include "shared_memory_error.h"
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/managed_mapped_file.hpp>
+#include <memory>
+
+namespace eq
+{
+	namespace shared
+	{
+		namespace detail {
+			typedef boost::interprocess::managed_mapped_file::segment_manager segment_manager_t;
+			typedef boost::interprocess::allocator<void, segment_manager_t> allocator;
+		}
+
+		using allocator = detail::allocator;
+
+		class shared_memory
+		{
+		public:
+			shared_memory(const std::string &path, size_t sz) {
+				_path = path;
+				_sz = sz;
+			}
+
+			~shared_memory() = default;
+
+			template<typename Ty>
+			expected<handle<Ty>, shared_memory_error> map(const std::string& key) {
+				if (!_memory) {
+					try {
+						_memory.reset(new boost::interprocess::managed_mapped_file(boost::interprocess::open_or_create, _path.c_str(), _sz));
+					}
+					catch (boost::interprocess::interprocess_exception) {
+						return eq::make_unexpected(shared_memory_error::error_mapping_memory);
+					}
+				}
+
+				handle<Ty> inst;
+				auto ir = inst.initialize(key, _memory.get());
+				if (ir) {
+					return eq::expected<handle<Ty>, shared_memory_error>(inst);
+				}
+				else {
+					return make_unexpected(ir.error());
+				}
+
+				return expected<handle<Ty>, shared_memory_error>(inst);
+			}
+
+			template<typename Ty, typename... Args>
+			Ty construct(Args&&... args) {
+				return Ty(std::forward<Args>(args)..., _memory->get_allocator<void>());
+			}
+		private:
+			std::unique_ptr<boost::interprocess::managed_mapped_file> _memory;
+			std::string _path;
+			size_t _sz;
+		};
+	}
+}

common/shared/shared_memory_error.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -13,36 +13,20 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */
-#ifdef _WINDOWS
-	#include <winsock2.h>
-	#include <windows.h>
-#else
-	#include <sys/socket.h>
-	#include <netinet/in.h>
-	#include <arpa/inet.h>
-	#include <unistd.h>
-	#include <netdb.h>
-#endif
 
-#include "../common/types.h"
-#include "../common/timer.h"
-void CatchSignal(int);
-void UpdateWindowTitle(char* iNewTitle = 0);
+#pragma once
 
-class NetConnection
+namespace eq
 {
-public:
-	~NetConnection();
-	NetConnection();
-
-	uint32	GetIP();
-	uint32	GetIP(char* name);
-	Timer object_timer;
-	Timer door_timer;
-	Timer corpse_timer;
-	Timer group_timer;
-	Timer raid_timer;
-	Timer trap_timer;
-};
+	namespace shared
+	{
+		enum class shared_memory_error
+		{
+			no_error,
+			error_mapping_memory,
+			error_alloc
+		};
+	}
+}

common/shared/shared_memory_handle.h

@@ -0,0 +1,70 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_error.h"
+#include "../expected.h"
+
+#include <boost/interprocess/managed_mapped_file.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <type_traits>
+
+namespace eq
+{
+	namespace shared
+	{
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory {
+				static_assert(std::is_trivially_constructible<Ty>::value, 
+					"Non-specialized types must be trivially constructible, consider creating a type_factory in eq::shared::detail if you want to use this type.");
+				Ty*	create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<Ty>(key.c_str())();
+				}
+			};
+		}
+
+		template<typename Ty>
+		class handle {
+		public:
+			handle() = default;
+			~handle() = default;
+
+			expected<void, shared_memory_error> initialize(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+				try {
+					_mmf = mmf;
+					detail::type_factory<Ty> fac;
+					_ptr = fac.create(key, mmf);
+					return expected<void, shared_memory_error>();
+				}
+				catch (boost::interprocess::interprocess_exception) {
+					return make_unexpected(shared_memory_error::error_mapping_memory);
+				}
+			}
+
+			operator Ty& () {
+				return *_ptr;
+			}
+		private:
+			Ty* _ptr;
+			boost::interprocess::managed_mapped_file* _mmf;
+		};
+	}
+}

common/shared/shared_memory_list.h

@@ -0,0 +1,43 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/list.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using list = boost::interprocess::list<Ty, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<list<Ty>>
+			{
+				list<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<list<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}

common/shared/shared_memory_map.h

@@ -0,0 +1,77 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/map.hpp>
+#include <boost/interprocess/containers/flat_map.hpp>
+#include <boost/unordered_map.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ky, typename Ty>
+		using unordered_map = boost::unordered_map<int,
+			Ty,
+			boost::hash<Ky>,
+			std::equal_to<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		template<typename Ky, typename Ty>
+		using map = boost::interprocess::map<Ky,
+			Ty,
+			std::less<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		template<typename Ky, typename Ty>
+		using flat_map = boost::interprocess::flat_map<Ky,
+			Ty,
+			std::less<Ky>,
+			boost::interprocess::allocator<std::pair<const Ky, Ty>, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ky, typename Ty>
+			struct type_factory<unordered_map<Ky, Ty>>
+			{
+				unordered_map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<unordered_map<Ky, Ty>>(key.c_str())(3, boost::hash<Ky>(), std::equal_to<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+
+			template<typename Ky, typename Ty>
+			struct type_factory<map<Ky, Ty>>
+			{
+				map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<map<Ky, Ty>>(key.c_str())(std::less<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+
+			template<typename Ky, typename Ty>
+			struct type_factory<flat_map<Ky, Ty>>
+			{
+				flat_map<Ky, Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<flat_map<Ky, Ty>>(key.c_str())(std::less<Ky>(), mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}

common/shared/shared_memory_string.h

@@ -0,0 +1,52 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/string.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using basic_string = boost::interprocess::basic_string<Ty, std::char_traits<Ty>, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		using string = basic_string<char>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<basic_string<Ty>>
+			{
+				list<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<list<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+
+		template<typename Ty>
+		std::basic_string<Ty> to_std_string(const eq::shared::basic_string<Ty> &in) {
+			return std::basic_string<Ty>(in.begin(), in.end());
+		}
+	}
+}

common/shared/shared_memory_vector.h

@@ -0,0 +1,43 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#pragma once
+
+#include "shared_memory_handle.h"
+
+#include <boost/interprocess/containers/vector.hpp>
+
+namespace eq
+{
+	namespace shared
+	{
+		template<typename Ty>
+		using vector = boost::interprocess::vector<Ty, boost::interprocess::allocator<Ty, boost::interprocess::managed_mapped_file::segment_manager>>;
+
+		namespace detail
+		{
+			template<typename Ty>
+			struct type_factory<vector<Ty>>
+			{
+				vector<Ty>* create(const std::string& key, boost::interprocess::managed_mapped_file* mmf) {
+					return mmf->find_or_construct<vector<Ty>>(key.c_str())(mmf->get_allocator<void>());
+				}
+			};
+		}
+	}
+}

common/shareddb.cpp

@@ -132,18 +132,36 @@ std::string SharedDatabase::GetMailKey(int CharID, bool key_only)
 {
 	std::string query = StringFormat("SELECT `mailkey` FROM `character_data` WHERE `id`='%i' LIMIT 1", CharID);
 	auto results = QueryDatabase(query);
+
 	if (!results.Success()) {
+
 		Log(Logs::Detail, Logs::MySQLError, "Error retrieving mailkey from database: %s", results.ErrorMessage().c_str());
 		return std::string();
 	}
 
-	auto row = results.begin();
-	std::string mail_key = row[0];
+	if (!results.RowCount()) {
 
-	if (mail_key.length() > 8 && key_only)
-		return mail_key.substr(8);
-	else
-		return mail_key;
+		Log(Logs::General, Logs::ClientLogin, "Error: Mailkey for character id [%i] does not exist or could not be found", CharID);
+		return std::string();
+	}
+
+	auto row = results.begin();
+	if (row != results.end()) {
+
+		std::string mail_key = row[0];
+
+		if (mail_key.length() > 8 && key_only) {
+			return mail_key.substr(8);
+		}
+		else {
+			return mail_key;
+		}
+	}
+	else {
+
+		Log(Logs::General, Logs::MySQLError, "Internal MySQL error in SharedDatabase::GetMailKey(int, bool)");
+		return std::string();
+	}
 }
 
 bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>::const_iterator &start, std::list<EQEmu::ItemInstance*>::const_iterator &end)
@@ -1638,21 +1656,19 @@ uint8 SharedDatabase::GetTrainLevel(uint8 Class_, EQEmu::skills::SkillType Skill
 	return ret;
 }
 
-void SharedDatabase::LoadDamageShieldTypes(SPDat_Spell_Struct* sp, int32 iMaxSpellID) {
+int SharedDatabase::LoadDamageShieldType(int spell_id) {
 
-	std::string query = StringFormat("SELECT `spellid`, `type` FROM `damageshieldtypes` WHERE `spellid` > 0 "
-                                    "AND `spellid` <= %i", iMaxSpellID);
+	std::string query = StringFormat("SELECT `type` FROM `damageshieldtypes` WHERE `spellid` = %i", spell_id);
     auto results = QueryDatabase(query);
     if (!results.Success()) {
-        return;
+        return 0;
     }
 
-    for(auto row = results.begin(); row != results.end(); ++row) {
-        int spellID = atoi(row[0]);
-        if((spellID > 0) && (spellID <= iMaxSpellID))
-            sp[spellID].DamageShieldType = atoi(row[1]);
+    for(auto &row : results) {
+        return atoi(row[0]);
     }
 
+	return 0;
 }
 
 const EvolveInfo* SharedDatabase::GetEvolveInfo(uint32 loregroup) {
@@ -1671,6 +1687,18 @@ int SharedDatabase::GetMaxSpellID() {
 	return atoi(row[0]);
 }
 
+int SharedDatabase::GetSpellCount() {
+	std::string query = "SELECT COUNT(id) FROM spells_new";
+	auto results = QueryDatabase(query);
+	if (!results.Success()) {
+		return -1;
+	}
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
 bool SharedDatabase::LoadSpells(const std::string &prefix, int32 *records, const SPDat_Spell_Struct **sp) {
 	spells_mmf.reset(nullptr);
 
@@ -1692,175 +1720,163 @@ bool SharedDatabase::LoadSpells(const std::string &prefix, int32 *records, const
 	return true;
 }
 
-void SharedDatabase::LoadSpells(void *data, int max_spells) {
-	*(uint32*)data = max_spells;
-	SPDat_Spell_Struct *sp = reinterpret_cast<SPDat_Spell_Struct*>((char*)data + sizeof(uint32));
-
+void SharedDatabase::LoadSpells(std::function<void(const SPDat_Spell_Struct & sp)> on_load) {
 	const std::string query = "SELECT * FROM spells_new ORDER BY id ASC";
     auto results = QueryDatabase(query);
     if (!results.Success()) {
         return;
     }
-
+	
     if(results.ColumnCount() <= SPELL_LOAD_FIELD_COUNT) {
 		LogSpells("Fatal error loading spells: Spell field count < SPELL_LOAD_FIELD_COUNT([{}])", SPELL_LOAD_FIELD_COUNT);
 		return;
     }
 
-    int tempid = 0;
-    int counter = 0;
+    for (auto &row : results) {
+		SPDat_Spell_Struct sp;
 
-    for (auto row = results.begin(); row != results.end(); ++row) {
-        tempid = atoi(row[0]);
-        if(tempid >= max_spells) {
-      LogSpells("Non fatal error: spell.id >= max_spells, ignoring");
-            continue;
-        }
+		sp.id = atoi(row[0]);
+		strn0cpy(sp.name, row[1], sizeof(sp.name));
+		strn0cpy(sp.player_1, row[2], sizeof(sp.player_1));
+		strn0cpy(sp.teleport_zone, row[3], sizeof(sp.teleport_zone));
+		strn0cpy(sp.you_cast, row[4], sizeof(sp.you_cast));
+		strn0cpy(sp.other_casts, row[5], sizeof(sp.other_casts));
+		strn0cpy(sp.cast_on_you, row[6], sizeof(sp.cast_on_you));
+		strn0cpy(sp.cast_on_other, row[7], sizeof(sp.cast_on_other));
+		strn0cpy(sp.spell_fades, row[8], sizeof(sp.spell_fades));
 
-        ++counter;
-        sp[tempid].id = tempid;
-        strn0cpy(sp[tempid].name, row[1], sizeof(sp[tempid].name));
-        strn0cpy(sp[tempid].player_1, row[2], sizeof(sp[tempid].player_1));
-		strn0cpy(sp[tempid].teleport_zone, row[3], sizeof(sp[tempid].teleport_zone));
-		strn0cpy(sp[tempid].you_cast, row[4], sizeof(sp[tempid].you_cast));
-		strn0cpy(sp[tempid].other_casts, row[5], sizeof(sp[tempid].other_casts));
-		strn0cpy(sp[tempid].cast_on_you, row[6], sizeof(sp[tempid].cast_on_you));
-		strn0cpy(sp[tempid].cast_on_other, row[7], sizeof(sp[tempid].cast_on_other));
-		strn0cpy(sp[tempid].spell_fades, row[8], sizeof(sp[tempid].spell_fades));
+		sp.range = static_cast<float>(atof(row[9]));
+		sp.aoerange = static_cast<float>(atof(row[10]));
+		sp.pushback = static_cast<float>(atof(row[11]));
+		sp.pushup = static_cast<float>(atof(row[12]));
+		sp.cast_time = atoi(row[13]);
+		sp.recovery_time = atoi(row[14]);
+		sp.recast_time = atoi(row[15]);
+		sp.buffdurationformula = atoi(row[16]);
+		sp.buffduration = atoi(row[17]);
+		sp.AEDuration = atoi(row[18]);
+		sp.mana = atoi(row[19]);
 
-		sp[tempid].range=static_cast<float>(atof(row[9]));
-		sp[tempid].aoerange=static_cast<float>(atof(row[10]));
-		sp[tempid].pushback=static_cast<float>(atof(row[11]));
-		sp[tempid].pushup=static_cast<float>(atof(row[12]));
-		sp[tempid].cast_time=atoi(row[13]);
-		sp[tempid].recovery_time=atoi(row[14]);
-		sp[tempid].recast_time=atoi(row[15]);
-		sp[tempid].buffdurationformula=atoi(row[16]);
-		sp[tempid].buffduration=atoi(row[17]);
-		sp[tempid].AEDuration=atoi(row[18]);
-		sp[tempid].mana=atoi(row[19]);
+		int y = 0;
+		for (y = 0; y < EFFECT_COUNT; y++)
+			sp.base[y] = atoi(row[20 + y]); // effect_base_value
 
-		int y=0;
-		for(y=0; y< EFFECT_COUNT;y++)
-			sp[tempid].base[y]=atoi(row[20+y]); // effect_base_value
+		for (y = 0; y < EFFECT_COUNT; y++)
+			sp.base2[y] = atoi(row[32 + y]); // effect_limit_value
 
-		for(y=0; y < EFFECT_COUNT; y++)
-			sp[tempid].base2[y]=atoi(row[32+y]); // effect_limit_value
+		for (y = 0; y < EFFECT_COUNT; y++)
+			sp.max[y] = atoi(row[44 + y]);
 
-		for(y=0; y< EFFECT_COUNT;y++)
-			sp[tempid].max[y]=atoi(row[44+y]);
+		for (y = 0; y < 4; y++)
+			sp.components[y] = atoi(row[58 + y]);
 
-		for(y=0; y< 4;y++)
-			sp[tempid].components[y]=atoi(row[58+y]);
+		for (y = 0; y < 4; y++)
+			sp.component_counts[y] = atoi(row[62 + y]);
 
-		for(y=0; y< 4;y++)
-			sp[tempid].component_counts[y]=atoi(row[62+y]);
+		for (y = 0; y < 4; y++)
+			sp.NoexpendReagent[y] = atoi(row[66 + y]);
 
-		for(y=0; y< 4;y++)
-			sp[tempid].NoexpendReagent[y]=atoi(row[66+y]);
+		for (y = 0; y < EFFECT_COUNT; y++)
+			sp.formula[y] = atoi(row[70 + y]);
 
-		for(y=0; y< EFFECT_COUNT;y++)
-			sp[tempid].formula[y]=atoi(row[70+y]);
+		sp.goodEffect = atoi(row[83]);
+		sp.Activated = atoi(row[84]);
+		sp.resisttype = atoi(row[85]);
 
-		sp[tempid].goodEffect=atoi(row[83]);
-		sp[tempid].Activated=atoi(row[84]);
-		sp[tempid].resisttype=atoi(row[85]);
+		for (y = 0; y < EFFECT_COUNT; y++)
+			sp.effectid[y] = atoi(row[86 + y]);
 
-		for(y=0; y< EFFECT_COUNT;y++)
-			sp[tempid].effectid[y]=atoi(row[86+y]);
-
-		sp[tempid].targettype = (SpellTargetType) atoi(row[98]);
-		sp[tempid].basediff=atoi(row[99]);
+		sp.targettype = (SpellTargetType)atoi(row[98]);
+		sp.basediff = atoi(row[99]);
 
 		int tmp_skill = atoi(row[100]);;
 
 		if (tmp_skill < 0 || tmp_skill > EQEmu::skills::HIGHEST_SKILL)
-			sp[tempid].skill = EQEmu::skills::SkillBegging; /* not much better we can do. */ // can probably be changed to client-based 'SkillNone' once activated
-        else
-			sp[tempid].skill = (EQEmu::skills::SkillType) tmp_skill;
+			sp.skill = EQEmu::skills::SkillBegging; /* not much better we can do. */ // can probably be changed to client-based 'SkillNone' once activated
+		else
+			sp.skill = (EQEmu::skills::SkillType) tmp_skill;
 
-		sp[tempid].zonetype=atoi(row[101]);
-		sp[tempid].EnvironmentType=atoi(row[102]);
-		sp[tempid].TimeOfDay=atoi(row[103]);
+		sp.zonetype = atoi(row[101]);
+		sp.EnvironmentType = atoi(row[102]);
+		sp.TimeOfDay = atoi(row[103]);
 
-		for(y=0; y < PLAYER_CLASS_COUNT;y++)
-			sp[tempid].classes[y]=atoi(row[104+y]);
+		for (y = 0; y < PLAYER_CLASS_COUNT; y++)
+			sp.classes[y] = atoi(row[104 + y]);
 
-		sp[tempid].CastingAnim=atoi(row[120]);
-		sp[tempid].SpellAffectIndex=atoi(row[123]);
-		sp[tempid].disallow_sit=atoi(row[124]);
-		sp[tempid].diety_agnostic=atoi(row[125]);
+		sp.CastingAnim = atoi(row[120]);
+		sp.SpellAffectIndex = atoi(row[123]);
+		sp.disallow_sit = atoi(row[124]);
+		sp.diety_agnostic = atoi(row[125]);
 
 		for (y = 0; y < 16; y++)
-			sp[tempid].deities[y]=atoi(row[126+y]);
+			sp.deities[y] = atoi(row[126 + y]);
 
-		sp[tempid].new_icon=atoi(row[144]);
-		sp[tempid].uninterruptable=atoi(row[146]) != 0;
-		sp[tempid].ResistDiff=atoi(row[147]);
-		sp[tempid].dot_stacking_exempt = atoi(row[148]) != 0;
-		sp[tempid].RecourseLink = atoi(row[150]);
-		sp[tempid].no_partial_resist = atoi(row[151]) != 0;
+		sp.new_icon = atoi(row[144]);
+		sp.uninterruptable = atoi(row[146]) != 0;
+		sp.ResistDiff = atoi(row[147]);
+		sp.dot_stacking_exempt = atoi(row[148]) != 0;
+		sp.RecourseLink = atoi(row[150]);
+		sp.no_partial_resist = atoi(row[151]) != 0;
 
-		sp[tempid].short_buff_box = atoi(row[154]);
-		sp[tempid].descnum = atoi(row[155]);
-		sp[tempid].typedescnum = atoi(row[156]);
-		sp[tempid].effectdescnum = atoi(row[157]);
+		sp.short_buff_box = atoi(row[154]);
+		sp.descnum = atoi(row[155]);
+		sp.typedescnum = atoi(row[156]);
+		sp.effectdescnum = atoi(row[157]);
 
-		sp[tempid].npc_no_los = atoi(row[159]) != 0;
-		sp[tempid].reflectable = atoi(row[161]) != 0;
-		sp[tempid].bonushate=atoi(row[162]);
+		sp.npc_no_los = atoi(row[159]) != 0;
+		sp.reflectable = atoi(row[161]) != 0;
+		sp.bonushate = atoi(row[162]);
 
-		sp[tempid].ldon_trap = atoi(row[165]) != 0;
-		sp[tempid].EndurCost=atoi(row[166]);
-		sp[tempid].EndurTimerIndex=atoi(row[167]);
-		sp[tempid].IsDisciplineBuff = atoi(row[168]) != 0;
-		sp[tempid].HateAdded=atoi(row[173]);
-		sp[tempid].EndurUpkeep=atoi(row[174]);
-		sp[tempid].numhitstype = atoi(row[175]);
-		sp[tempid].numhits = atoi(row[176]);
-		sp[tempid].pvpresistbase=atoi(row[177]);
-		sp[tempid].pvpresistcalc=atoi(row[178]);
-		sp[tempid].pvpresistcap=atoi(row[179]);
-		sp[tempid].spell_category=atoi(row[180]);
-		sp[tempid].pcnpc_only_flag=atoi(row[183]);
-		sp[tempid].cast_not_standing = atoi(row[184]) != 0;
-		sp[tempid].can_mgb=atoi(row[185]);
-		sp[tempid].dispel_flag = atoi(row[186]);
-		sp[tempid].MinResist = atoi(row[189]);
-		sp[tempid].MaxResist = atoi(row[190]);
-		sp[tempid].viral_targets = atoi(row[191]);
-		sp[tempid].viral_timer = atoi(row[192]);
-		sp[tempid].NimbusEffect = atoi(row[193]);
-		sp[tempid].directional_start = static_cast<float>(atoi(row[194]));
-		sp[tempid].directional_end = static_cast<float>(atoi(row[195]));
-		sp[tempid].sneak = atoi(row[196]) != 0;
-		sp[tempid].not_focusable = atoi(row[197]) != 0;
-		sp[tempid].no_detrimental_spell_aggro = atoi(row[198]) != 0;
-		sp[tempid].suspendable = atoi(row[200]) != 0;
-		sp[tempid].viral_range = atoi(row[201]);
-		sp[tempid].songcap = atoi(row[202]);
-		sp[tempid].no_block = atoi(row[205]);
-		sp[tempid].spellgroup=atoi(row[207]);
-		sp[tempid].rank = atoi(row[208]);
-		sp[tempid].no_resist=atoi(row[209]);
-		sp[tempid].CastRestriction = atoi(row[211]);
-		sp[tempid].AllowRest = atoi(row[212]) != 0;
-		sp[tempid].InCombat = atoi(row[213]) != 0;
-		sp[tempid].OutofCombat = atoi(row[214]) != 0;
-		sp[tempid].override_crit_chance = atoi(row[217]);
-		sp[tempid].aemaxtargets = atoi(row[218]);
-		sp[tempid].no_heal_damage_item_mod = atoi(row[219]);
-		sp[tempid].persistdeath = atoi(row[224]) != 0;
-		sp[tempid].min_dist = atof(row[227]);
-		sp[tempid].min_dist_mod = atof(row[228]);
-		sp[tempid].max_dist = atof(row[229]);
-		sp[tempid].max_dist_mod = atof(row[230]);
-		sp[tempid].min_range = static_cast<float>(atoi(row[231]));
-		sp[tempid].no_remove = atoi(row[232]) != 0;
-		sp[tempid].DamageShieldType = 0;
+		sp.ldon_trap = atoi(row[165]) != 0;
+		sp.EndurCost = atoi(row[166]);
+		sp.EndurTimerIndex = atoi(row[167]);
+		sp.IsDisciplineBuff = atoi(row[168]) != 0;
+		sp.HateAdded = atoi(row[173]);
+		sp.EndurUpkeep = atoi(row[174]);
+		sp.numhitstype = atoi(row[175]);
+		sp.numhits = atoi(row[176]);
+		sp.pvpresistbase = atoi(row[177]);
+		sp.pvpresistcalc = atoi(row[178]);
+		sp.pvpresistcap = atoi(row[179]);
+		sp.spell_category = atoi(row[180]);
+		sp.pcnpc_only_flag = atoi(row[183]);
+		sp.cast_not_standing = atoi(row[184]) != 0;
+		sp.can_mgb = atoi(row[185]);
+		sp.dispel_flag = atoi(row[186]);
+		sp.MinResist = atoi(row[189]);
+		sp.MaxResist = atoi(row[190]);
+		sp.viral_targets = atoi(row[191]);
+		sp.viral_timer = atoi(row[192]);
+		sp.NimbusEffect = atoi(row[193]);
+		sp.directional_start = static_cast<float>(atoi(row[194]));
+		sp.directional_end = static_cast<float>(atoi(row[195]));
+		sp.sneak = atoi(row[196]) != 0;
+		sp.not_focusable = atoi(row[197]) != 0;
+		sp.no_detrimental_spell_aggro = atoi(row[198]) != 0;
+		sp.suspendable = atoi(row[200]) != 0;
+		sp.viral_range = atoi(row[201]);
+		sp.songcap = atoi(row[202]);
+		sp.no_block = atoi(row[205]);
+		sp.spellgroup = atoi(row[207]);
+		sp.rank = atoi(row[208]);
+		sp.no_resist = atoi(row[209]);
+		sp.CastRestriction = atoi(row[211]);
+		sp.AllowRest = atoi(row[212]) != 0;
+		sp.InCombat = atoi(row[213]) != 0;
+		sp.OutofCombat = atoi(row[214]) != 0;
+		sp.override_crit_chance = atoi(row[217]);
+		sp.aemaxtargets = atoi(row[218]);
+		sp.no_heal_damage_item_mod = atoi(row[219]);
+		sp.persistdeath = atoi(row[224]) != 0;
+		sp.min_dist = atof(row[227]);
+		sp.min_dist_mod = atof(row[228]);
+		sp.max_dist = atof(row[229]);
+		sp.max_dist_mod = atof(row[230]);
+		sp.min_range = static_cast<float>(atoi(row[231]));
+		sp.no_remove = atoi(row[232]) != 0;
+		sp.DamageShieldType = LoadDamageShieldType(sp.id); //ideally we could do this with a simple join but we need to formalize the table first.
+		on_load(sp);
     }
-
-    LoadDamageShieldTypes(sp, max_spells);
 }
 
 int SharedDatabase::GetMaxBaseDataLevel() {

common/shareddb.h

@@ -140,9 +140,10 @@ class SharedDatabase : public Database
 		uint8 GetTrainLevel(uint8 Class_, EQEmu::skills::SkillType Skill, uint8 Level);
 
 		int GetMaxSpellID();
+		int GetSpellCount();
 		bool LoadSpells(const std::string &prefix, int32 *records, const SPDat_Spell_Struct **sp);
-		void LoadSpells(void *data, int max_spells);
-		void LoadDamageShieldTypes(SPDat_Spell_Struct* sp, int32 iMaxSpellID);
+		void LoadSpells(std::function<void(const SPDat_Spell_Struct & sp)> on_load);
+		int LoadDamageShieldType(int spell_id);
 
 		int GetMaxBaseDataLevel();
 		bool LoadBaseData(const std::string &prefix);

common/spdat.cpp

@@ -87,8 +87,9 @@
 
 bool IsTargetableAESpell(uint16 spell_id)
 {
-	if (IsValidSpell(spell_id) && spells[spell_id].targettype == ST_AETarget)
+	if (IsValidSpell(spell_id) && spells[spell_id].targettype == ST_AETarget) {
 		return true;
+	}
 
 	return false;
 }

common/spdat.h

@@ -607,7 +607,7 @@ typedef enum {
 #define SE_LimitSpellGroup				385	// implemented - Limits to spell group(ie type 3 reuse reduction augs that are class specific and thus all share s SG)
 #define SE_CastOnCurer					386 // implemented - Casts a spell on the person curing
 #define SE_CastOnCure					387 // implemented - Casts a spell on the cured person
-//#define SE_SummonCorpseZone			388 // *not implemented - summons a corpse from any zone(nec AA)
+#define SE_SummonCorpseZone				388 // implemented - summons a corpse from any zone(nec AA)
 #define SE_FcTimerRefresh				389 // implemented - Refresh spell icons
 //#define SE_FcTimerLockout				390 // *not implemented - Sets recast timers to specific value, focus limited.
 #define SE_LimitManaMax					391	// implemented

common/string_util.cpp

@@ -222,7 +222,7 @@ bool StringIsNumber(const std::string &s) {
 		auto r = stod(s);
 		return true;
 	}
-	catch (std::exception) {
+	catch (std::exception &) {
 		return false;
 	}
 }

common/string_util.h

@@ -27,6 +27,12 @@
 #include <fmt/format.h>
 #endif
 
+#ifdef _WINDOWS
+#include <ctype.h>
+#include <functional>
+#include <algorithm>
+#endif
+
 #include "types.h"
 
 //std::string based
@@ -38,6 +44,38 @@ const std::string StringFormat(const char* format, ...);
 const std::string vStringFormat(const char* format, va_list args);
 std::string implode(std::string glue, std::vector<std::string> src);
 
+/**
+ * @param str
+ * @param chars
+ * @return
+ */
+inline std::string &ltrim(std::string &str, const std::string &chars = "\t\n\v\f\r ")
+{
+	str.erase(0, str.find_first_not_of(chars));
+	return str;
+}
+
+/**
+ * @param str
+ * @param chars
+ * @return
+ */
+inline std::string &rtrim(std::string &str, const std::string &chars = "\t\n\v\f\r ")
+{
+	str.erase(str.find_last_not_of(chars) + 1);
+	return str;
+}
+
+/**
+ * @param str
+ * @param chars
+ * @return
+ */
+inline std::string &trim(std::string &str, const std::string &chars = "\t\n\v\f\r ")
+{
+	return ltrim(rtrim(str, chars), chars);
+}
+
 template <typename T>
 std::string implode(const std::string &glue, const std::pair<char, char> &encapsulation, const std::vector<T> &src)
 {

common/timer.cpp

@@ -129,13 +129,17 @@ void Timer::SetTimer(uint32 set_timer_time) {
 	}
 }
 
-uint32 Timer::GetRemainingTime() const {
+uint32 Timer::GetRemainingTime() const
+{
 	if (enabled) {
-		if (current_time - start_time > timer_time)
+		if (current_time - start_time > timer_time) {
 			return 0;
-		else
+		}
+		else {
 			return (start_time + timer_time) - current_time;
-	} else {
+		}
+	}
+	else {
 		return 0xFFFFFFFF;
 	}
 }

common/useperl.h

@@ -13,6 +13,10 @@
 #ifndef WIN32
 extern "C" {	//the perl headers dont do this for us...
 #endif
+#if _MSC_VER
+#define __inline__ __inline
+#define __builtin_expect 
+#endif
 #include <perl.h>
 #include <XSUB.h>
 #ifndef WIN32

common/version.h

@@ -1,20 +1,22 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
 
 #ifndef _EQEMU_VERSION_H
 #define _EQEMU_VERSION_H
@@ -22,22 +24,24 @@
 #define LOGIN_VERSION "0.8.0"
 #define EQEMU_PROTOCOL_VERSION "0.3.10"
 
-#define CURRENT_VERSION "1.1.3"
-
-/*
-	Everytime a Database SQL is added to Github,
-		increment CURRENT_BINARY_DATABASE_VERSION number and make sure you update the manifest
-	Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
-*/
+#define CURRENT_VERSION "2.0"
 
 
-#define CURRENT_BINARY_DATABASE_VERSION 9143
+/**
+ * Every time a Database SQL is added to Github increment CURRENT_BINARY_DATABASE_VERSION
+ * number and make sure you update the manifest
+ *
+ * Manifest: https://github.com/EQEmu/Server/blob/master/utils/sql/db_update_manifest.txt
+ */
+
+#define CURRENT_BINARY_DATABASE_VERSION 9152
 
 #ifdef BOTS
-	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9026
+	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9027
 #else
 	#define CURRENT_BINARY_BOTS_DATABASE_VERSION 0 // must be 0
 #endif
+
 #define COMPILE_DATE	__DATE__
 #define COMPILE_TIME	__TIME__
 #ifndef WIN32

eqlaunch/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(eqlaunch_sources
 	eqlaunch.cpp

hc/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(hc_sources
 	eq.cpp
@@ -13,14 +13,10 @@ SET(hc_headers
 	world.h
 )
 
-FIND_PACKAGE(OpenSSL REQUIRED)
-
-INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
-
 ADD_EXECUTABLE(hc ${hc_sources} ${hc_headers})
 
 INSTALL(TARGETS hc RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 
-TARGET_LINK_LIBRARIES(hc ${SERVER_LIBS} ${OPENSSL_LIBRARIES})
+TARGET_LINK_LIBRARIES(hc ${SERVER_LIBS})
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

libs/luabind/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(lb_sources
     src/class.cpp

loginserver/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(eqlogin_sources
 	account_management.cpp
@@ -28,14 +28,10 @@ SET(eqlogin_headers
 	world_server.h
 )
 
-FIND_PACKAGE(OpenSSL REQUIRED)
-
-INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
-
 ADD_EXECUTABLE(loginserver ${eqlogin_sources} ${eqlogin_headers})
 
 INSTALL(TARGETS loginserver RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 
-TARGET_LINK_LIBRARIES(loginserver ${SERVER_LIBS} ${OPENSSL_LIBRARIES})
+TARGET_LINK_LIBRARIES(loginserver ${SERVER_LIBS})
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

loginserver/encryption.cpp

@@ -1,26 +1,17 @@
-/**
- * EQEmulator: Everquest Server Emulator
- * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY except by those people which sell it, which
- * are required to give you total support for your newly bought product;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
+#include "encryption.h"
 
+#ifdef EQEMU_USE_OPENSSL
 #include <openssl/des.h>
 #include <openssl/sha.h>
 #include <openssl/md5.h>
+#endif
+#ifdef EQEMU_USE_MBEDTLS
+#include <mbedtls/des.h>
+#include <mbedtls/md5.h>
+#include <mbedtls/sha1.h>
+#include <mbedtls/sha512.h>
+#endif
+
 #include <cstring>
 #include <string>
 
@@ -30,7 +21,45 @@
 
 #endif
 
-#include "encryption.h"
+/**
+ * @param mode
+ * @return
+ */
+std::string GetEncryptionByModeId(uint32 mode)
+{
+	switch (mode) {
+		case EncryptionModeMD5:
+			return "MD5";
+		case EncryptionModeMD5PassUser:
+			return "MD5PassUser";
+		case EncryptionModeMD5UserPass:
+			return "MD5UserPass";
+		case EncryptionModeMD5Triple:
+			return "MD5Triple";
+		case EncryptionModeSHA:
+			return "SHA";
+		case EncryptionModeSHAPassUser:
+			return "SHAPassUser";
+		case EncryptionModeSHAUserPass:
+			return "SHAUserPass";
+		case EncryptionModeSHATriple:
+			return "SHATriple";
+		case EncryptionModeSHA512:
+			return "SHA512";
+		case EncryptionModeSHA512PassUser:
+			return "SHA512PassUser";
+		case EncryptionModeSHA512UserPass:
+			return "SHA512UserPass";
+		case EncryptionModeSHA512Triple:
+			return "SHA512Triple";
+		case EncryptionModeArgon2:
+			return "Argon2";
+		case EncryptionModeSCrypt:
+			return "SCrypt";
+		default:
+			return "";
+	}
+}
 
 /**
  * @param buffer_in
@@ -41,17 +70,69 @@
  */
 const char *eqcrypt_block(const char *buffer_in, size_t buffer_in_sz, char *buffer_out, bool enc)
 {
-	DES_key_schedule k;
-	DES_cblock       v;
+#ifdef EQEMU_USE_MBEDTLS
+	if (enc) {
+		if (buffer_in_sz % 8 != 0) {
+			auto temp_buffer_sz = ((buffer_in_sz / 8) + 1) * 8;
+			unsigned char *temp_buffer = new unsigned char[temp_buffer_sz];
+			unsigned char *temp_buffer_in = &temp_buffer[0];
+			unsigned char *temp_buffer_out = &temp_buffer[temp_buffer_sz];
 
+			memset(temp_buffer, 0, temp_buffer_sz * 2);
+			memcpy(temp_buffer_in, buffer_in, buffer_in_sz);
+
+			unsigned char key[MBEDTLS_DES_KEY_SIZE];
+			unsigned char iv[8];
+			memset(&key, 0, MBEDTLS_DES_KEY_SIZE);
+			memset(&iv, 0, 8);
+
+			mbedtls_des_context context;
+			mbedtls_des_setkey_enc(&context, key);
+			mbedtls_des_crypt_cbc(&context, MBEDTLS_DES_ENCRYPT, temp_buffer_sz, iv, (const unsigned char*)temp_buffer_in, (unsigned char*)temp_buffer_out);
+
+			memcpy(buffer_out, temp_buffer_out, temp_buffer_sz);
+			delete[] temp_buffer;
+		}
+		else {
+			unsigned char key[MBEDTLS_DES_KEY_SIZE];
+			unsigned char iv[8];
+			memset(&key, 0, MBEDTLS_DES_KEY_SIZE);
+			memset(&iv, 0, 8);
+
+			mbedtls_des_context context;
+			mbedtls_des_setkey_enc(&context, key);
+			mbedtls_des_crypt_cbc(&context, MBEDTLS_DES_ENCRYPT, buffer_in_sz, iv, (const unsigned char*)buffer_in, (unsigned char*)buffer_out);
+		}
+	}
+	else {
+		if (buffer_in_sz && buffer_in_sz % 8 != 0) {
+			return nullptr;
+		}
+
+		unsigned char key[MBEDTLS_DES_KEY_SIZE];
+		unsigned char iv[8];
+		memset(&key, 0, MBEDTLS_DES_KEY_SIZE);
+		memset(&iv, 0, 8);
+	
+		mbedtls_des_context context;
+		mbedtls_des_setkey_dec(&context, key);
+		mbedtls_des_crypt_cbc(&context, MBEDTLS_DES_DECRYPT, buffer_in_sz, iv, (const unsigned char*)buffer_in, (unsigned char*)buffer_out);
+	}
+#endif
+
+#ifdef EQEMU_USE_OPENSSL
+	DES_key_schedule k;
+	DES_cblock v;
+	
 	memset(&k, 0, sizeof(DES_key_schedule));
 	memset(&v, 0, sizeof(DES_cblock));
-
+	
 	if (!enc && buffer_in_sz && buffer_in_sz % 8 != 0) {
 		return nullptr;
 	}
-
-	DES_ncbc_encrypt((const unsigned char *) buffer_in, (unsigned char *) buffer_out, (long) buffer_in_sz, &k, &v, enc);
+	
+	DES_ncbc_encrypt((const unsigned char*)buffer_in, (unsigned char*)buffer_out, (long)buffer_in_sz, &k, &v, enc);
+#endif
 	return buffer_out;
 }
 
@@ -61,17 +142,34 @@ const char *eqcrypt_block(const char *buffer_in, size_t buffer_in_sz, char *buff
  */
 std::string eqcrypt_md5(const std::string &msg)
 {
-	std::string   ret;
-	unsigned char md5_digest[16];
-	char          tmp[4];
+	std::string ret;
+	ret.reserve(32);
 
-	MD5((const unsigned char *) msg.c_str(), msg.length(), md5_digest);
+#ifdef EQEMU_USE_MBEDTLS
+	unsigned char digest[16];
+	char temp[4];
+
+	if (0 == mbedtls_md5_ret((const unsigned char*)msg.c_str(), msg.length(), digest)) {
+		for (int i = 0; i < 16; ++i) {
+			sprintf(&temp[0], "%02x", digest[i]);
+			ret.push_back(temp[0]);
+			ret.push_back(temp[1]);
+		}
+	}
+#endif
+
+#ifdef EQEMU_USE_OPENSSL
+	unsigned char md5_digest[16];
+	char tmp[4];
+
+	MD5((const unsigned char*)msg.c_str(), msg.length(), md5_digest);
 
 	for (int i = 0; i < 16; ++i) {
 		sprintf(&tmp[0], "%02x", md5_digest[i]);
 		ret.push_back(tmp[0]);
 		ret.push_back(tmp[1]);
 	}
+#endif
 
 	return ret;
 }
@@ -82,17 +180,34 @@ std::string eqcrypt_md5(const std::string &msg)
  */
 std::string eqcrypt_sha1(const std::string &msg)
 {
-	std::string   ret;
-	unsigned char sha_digest[20];
-	char          tmp[4];
+	std::string ret;
+	ret.reserve(40);
 
-	SHA1((const unsigned char *) msg.c_str(), msg.length(), sha_digest);
+#ifdef EQEMU_USE_MBEDTLS
+	unsigned char digest[20];
+	char temp[4];
+
+	if (0 == mbedtls_sha1_ret((const unsigned char*)msg.c_str(), msg.length(), digest)) {
+		for (int i = 0; i < 20; ++i) {
+			sprintf(&temp[0], "%02x", digest[i]);
+			ret.push_back(temp[0]);
+			ret.push_back(temp[1]);
+		}
+	}
+#endif
+
+#ifdef EQEMU_USE_OPENSSL
+	unsigned char sha_digest[20];
+	char tmp[4];
+
+	SHA1((const unsigned char*)msg.c_str(), msg.length(), sha_digest);
 
 	for (int i = 0; i < 20; ++i) {
 		sprintf(&tmp[0], "%02x", sha_digest[i]);
 		ret.push_back(tmp[0]);
 		ret.push_back(tmp[1]);
 	}
+#endif
 
 	return ret;
 }
@@ -103,17 +218,34 @@ std::string eqcrypt_sha1(const std::string &msg)
  */
 std::string eqcrypt_sha512(const std::string &msg)
 {
-	std::string   ret;
-	unsigned char sha_digest[64];
-	char          tmp[4];
+	std::string ret;
+	ret.reserve(128);
 
-	SHA512((const unsigned char *) msg.c_str(), msg.length(), sha_digest);
+#ifdef EQEMU_USE_MBEDTLS
+	unsigned char digest[64];
+	char temp[4];
+
+	if (0 == mbedtls_sha512_ret((const unsigned char*)msg.c_str(), msg.length(), digest, 0)) {
+		for (int i = 0; i < 64; ++i) {
+			sprintf(&temp[0], "%02x", digest[i]);
+			ret.push_back(temp[0]);
+			ret.push_back(temp[1]);
+		}
+	}
+#endif
+
+#ifdef EQEMU_USE_OPENSSL
+	unsigned char sha_digest[64];
+	char tmp[4];
+
+	SHA512((const unsigned char*)msg.c_str(), msg.length(), sha_digest);
 
 	for (int i = 0; i < 64; ++i) {
 		sprintf(&tmp[0], "%02x", sha_digest[i]);
 		ret.push_back(tmp[0]);
 		ret.push_back(tmp[1]);
 	}
+#endif
 
 	return ret;
 }
@@ -126,7 +258,8 @@ std::string eqcrypt_sha512(const std::string &msg)
  */
 std::string eqcrypt_argon2(const std::string &msg)
 {
-	char buffer[crypto_pwhash_STRBYTES];
+	char        buffer[crypto_pwhash_STRBYTES] = {0};
+	std::string ret;
 
 	if (crypto_pwhash_str(
 		&buffer[0],
@@ -138,7 +271,8 @@ std::string eqcrypt_argon2(const std::string &msg)
 		return "";
 	}
 
-	return buffer;
+	ret = buffer;
+	return ret;
 }
 
 /**
@@ -147,16 +281,21 @@ std::string eqcrypt_argon2(const std::string &msg)
  */
 std::string eqcrypt_scrypt(const std::string &msg)
 {
-	char buffer[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
+	char        buffer[crypto_pwhash_scryptsalsa208sha256_STRBYTES] = {0};
+	std::string ret;
 
 	if (crypto_pwhash_scryptsalsa208sha256_str(
-		&buffer[0], &msg[0], msg.length(),
-		crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE, crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE
+		&buffer[0],
+		&msg[0],
+		msg.length(),
+		crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE,
+		crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE
 	) != 0) {
 		return "";
 	}
 
-	return buffer;
+	ret = buffer;
+	return ret;
 }
 
 #endif
@@ -231,38 +370,3 @@ bool eqcrypt_verify_hash(const std::string &username, const std::string &passwor
 
 	return false;
 }
-
-std::string GetEncryptionByModeId(uint32 mode) {
-	switch (mode) {
-		case EncryptionModeMD5:
-			return "MD5";
-		case EncryptionModeMD5PassUser:
-			return "MD5PassUser";
-		case EncryptionModeMD5UserPass:
-			return "MD5UserPass";
-		case EncryptionModeMD5Triple:
-			return "MD5Triple";
-		case EncryptionModeSHA:
-			return "SHA";
-		case EncryptionModeSHAPassUser:
-			return "SHAPassUser";
-		case EncryptionModeSHAUserPass:
-			return "SHAUserPass";
-		case EncryptionModeSHATriple:
-			return "SHATriple";
-		case EncryptionModeSHA512:
-			return "SHA512";
-		case EncryptionModeSHA512PassUser:
-			return "SHA512PassUser";
-		case EncryptionModeSHA512UserPass:
-			return "SHA512UserPass";
-		case EncryptionModeSHA512Triple:
-			return "SHA512Triple";
-		case EncryptionModeArgon2:
-			return "Argon2";
-		case EncryptionModeSCrypt:
-			return "SCrypt";
-		default:
-			return "";
-	}
-}

loginserver/login_server.h

@@ -38,6 +38,7 @@
 struct LoginServer
 {
 public:
+
 	LoginServer() : db(nullptr), server_manager(nullptr) {
 
 	}

loginserver/login_util/login.json

@@ -1,39 +1,37 @@
 {
   "database": {
-    "host": "127.0.0.1", // database host
-    "port": "3306", // database port
-    "db": "peq", // database name
-    "user": "root", // database user
-    "password": "eqemu" // database password
+    "host": "127.0.0.1",
+    "port": "3306",
+    "db": "peq",
+    "user": "root",
+    "password": "eqemu"
   },
   "account": {
-    // ideal for local LAN setups, if you want a login attempt to automatically create an account
-    // this will automatically create the account using the username and password if it doesn't exist
     "auto_create_accounts": true
   },
   "worldservers": {
-    "unregistered_allowed": true, // allows worldservers to connect to your loginserver without server admin authentication
-    "reject_duplicate_servers": false // if enabled, rejects duplicate worldservers
+    "unregistered_allowed": true,
+    "reject_duplicate_servers": false
   },
   "web_api": {
-    "enabled": true, // enable/disable embedded webserver api
-    "port": 6000 // the port you want the web api to serve on (recommended not to change)
+    "enabled": true,
+    "port": 6000
   },
   "security": {
-    "mode": 14, // encryption mode (dont touch) (14=scrypt)
-    "allow_password_login": true, // allows users to login via password, most cases, leave this on
-    "allow_token_login": true // allows token based login directly from launching game
+    "mode": 14,
+    "allow_password_login": true,
+    "allow_token_login": true
   },
   "logging": {
-    "trace": false, // For debugging general packet messaging
-    "world_trace": false, // For debugging world to loginserver messaging
-    "dump_packets_in": false, // for debugging inbound packets
-    "dump_packets_out": false // for debugging outbound packets
+    "trace": false,
+    "world_trace": false,
+    "dump_packets_in": false,
+    "dump_packets_out": false
   },
   "client_configuration": {
-    "titanium_port": 5998, // don't change
-    "titanium_opcodes": "login_opcodes.conf", // opcodes for the titanium era clients
-    "sod_port": 5999, // don't change
-    "sod_opcodes": "login_opcodes_sod.conf" // opcodes for sod and higher era clients
+    "titanium_port": 5998,
+    "titanium_opcodes": "login_opcodes.conf",
+    "sod_port": 5999,
+    "sod_opcodes": "login_opcodes_sod.conf"
   }
-}
+}

loginserver/loginserver_command_handler.cpp

@@ -112,6 +112,9 @@ namespace LoginserverCommandHandler {
 			return;
 		}
 
+		server.token_manager = new LoginserverWebserver::TokenManager;
+		server.token_manager->LoadApiTokens();
+
 		for (auto &it : server.token_manager->loaded_api_tokens) {
 			LogInfo(
 				"token [{0}] can_write [{1}] can_read [{2}]",
@@ -133,8 +136,8 @@ namespace LoginserverCommandHandler {
 		description = "Creates Local Loginserver Account";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password"
+			"{username}",
+			"{password}"
 		};
 		std::vector<std::string> options   = {
 			"--email=*"
@@ -147,8 +150,8 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		AccountManagement::CreateLoginServerAccount(
-			cmd("--username").str(),
-			cmd("--password").str(),
+			cmd(2).str(),
+			cmd(3).str(),
 			cmd("--email").str()
 		);
 	}
@@ -164,9 +167,9 @@ namespace LoginserverCommandHandler {
 		description = "Creates Loginserver World Administrator Account";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password",
-			"--email"
+			"{username}",
+			"{password}",
+			"{email}"
 		};
 		std::vector<std::string> options   = {};
 
@@ -177,9 +180,9 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		AccountManagement::CreateLoginserverWorldAdminAccount(
-			cmd("--username").str(),
-			cmd("--password").str(),
-			cmd("--email").str()
+			cmd(2).str(),
+			cmd(3).str(),
+			cmd(4).str()
 		);
 	}
 
@@ -194,8 +197,8 @@ namespace LoginserverCommandHandler {
 		description = "Check user login credentials";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password"
+			"{username}",
+			"{password}"
 		};
 		std::vector<std::string> options   = {};
 
@@ -206,11 +209,11 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		auto res = AccountManagement::CheckLoginserverUserCredentials(
-			cmd("--username").str(),
-			cmd("--password").str()
+			cmd(2).str(),
+			cmd(3).str()
 		);
 
-		LogInfo("Credentials were {0}", res == true ? "accepted" : "not accepted");
+		LogInfo("Credentials were {0}", res != 0 ? "accepted" : "not accepted");
 	}
 
 	/**
@@ -224,8 +227,8 @@ namespace LoginserverCommandHandler {
 		description = "Change user login credentials";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password"
+			"{username}",
+			"{password}"
 		};
 		std::vector<std::string> options   = {};
 
@@ -236,8 +239,8 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		AccountManagement::UpdateLoginserverUserCredentials(
-			cmd("--username").str(),
-			cmd("--password").str()
+			cmd(2).str(),
+			cmd(3).str()
 		);
 	}
 
@@ -252,8 +255,8 @@ namespace LoginserverCommandHandler {
 		description = "Check user external login credentials";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password"
+			"{username}",
+			"{password}"
 		};
 		std::vector<std::string> options   = {};
 
@@ -264,8 +267,8 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		auto res = AccountManagement::CheckExternalLoginserverUserCredentials(
-			cmd("--username").str(),
-			cmd("--password").str()
+			cmd(2).str(),
+			cmd(3).str()
 		);
 
 		LogInfo("Credentials were {0}", res ? "accepted" : "not accepted");
@@ -282,8 +285,8 @@ namespace LoginserverCommandHandler {
 		description = "Update world admin account password";
 
 		std::vector<std::string> arguments = {
-			"--username",
-			"--password"
+			"{username}",
+			"{password}"
 		};
 		std::vector<std::string> options   = {};
 
@@ -294,8 +297,8 @@ namespace LoginserverCommandHandler {
 		EQEmuCommand::ValidateCmdInput(arguments, options, cmd, argc, argv);
 
 		AccountManagement::UpdateLoginserverWorldAdminAccountPasswordByName(
-			cmd("--username").str(),
-			cmd("--password").str()
+			cmd(2).str(),
+			cmd(3).str()
 		);
 	}
 }

loginserver/main.cpp

@@ -43,22 +43,28 @@ void CatchSignal(int sig_num)
 {
 }
 
-int main(int argc, char **argv)
+void LoadDatabaseConnection()
 {
-	RegisterExecutablePlatform(ExePlatformLogin);
-	set_exception_handler();
+	LogInfo("MySQL Database Init");
 
-	LogInfo("Logging System Init");
+	server.db = new Database(
+		server.config.GetVariableString("database", "user", "root"),
+		server.config.GetVariableString("database", "password", ""),
+		server.config.GetVariableString("database", "host", "localhost"),
+		server.config.GetVariableString("database", "port", "3306"),
+		server.config.GetVariableString("database", "db", "peq")
+	);
 
-	if (argc == 1) {
-		LogSys.LoadLogSettingsDefaults();
-	}
+}
 
+void LoadServerConfig()
+{
 	server.config = EQ::JsonConfigFile::Load("login.json");
 	LogInfo("Config System Init");
 
+
 	/**
-	 * options: logging
+	 * Logging
 	 */
 	server.options.Trace(server.config.GetVariableBool("logging", "trace", false));
 	server.options.WorldTrace(server.config.GetVariableBool("logging", "world_trace", false));
@@ -66,7 +72,7 @@ int main(int argc, char **argv)
 	server.options.DumpOutPackets(server.config.GetVariableBool("logging", "dump_packets_out", false));
 
 	/**
-	 * options: worldservers
+	 * Worldservers
 	 */
 	server.options.RejectDuplicateServers(
 		server.config.GetVariableBool(
@@ -77,7 +83,7 @@ int main(int argc, char **argv)
 	server.options.AllowUnregistered(server.config.GetVariableBool("worldservers", "unregistered_allowed", true));
 
 	/**
-	 * options: account
+	 * Account
 	 */
 	server.options.AutoCreateAccounts(server.config.GetVariableBool("account", "auto_create_accounts", true));
 	server.options.AutoLinkAccounts(server.config.GetVariableBool("account", "auto_link_accounts", false));
@@ -92,6 +98,9 @@ int main(int argc, char **argv)
 	);
 #endif
 
+	/**
+	 * Default Loginserver Name (Don't change)
+	 */
 	server.options.DefaultLoginServerName(
 		server.config.GetVariableString(
 			"general",
@@ -100,6 +109,10 @@ int main(int argc, char **argv)
 		)
 	);
 
+	/**
+	 * Security
+	 */
+
 #ifdef ENABLE_SECURITY
 	server.options.EncryptionMode(server.config.GetVariableInt("security", "mode", 13));
 #else
@@ -115,19 +128,41 @@ int main(int argc, char **argv)
 			true
 		)
 	);
+}
+
+int main(int argc, char **argv)
+{
+	RegisterExecutablePlatform(ExePlatformLogin);
+	set_exception_handler();
+
+	LogInfo("Logging System Init");
+
+	if (argc == 1) {
+		LogSys.LoadLogSettingsDefaults();
+	}
+
+	/**
+	 * Command handler
+	 */
+	if (argc > 1) {
+		LogSys.SilenceConsoleLogging();
+
+		LoadServerConfig();
+		LoadDatabaseConnection();
+
+		LogSys.LoadLogSettingsDefaults();
+		LogSys.log_settings[Logs::Debug].log_to_console      = static_cast<uint8>(Logs::General);
+		LogSys.log_settings[Logs::Debug].is_category_enabled = 1;
+
+		LoginserverCommandHandler::CommandHandler(argc, argv);
+	}
+
+	LoadServerConfig();
 
 	/**
 	 * mysql connect
 	 */
-	LogInfo("MySQL Database Init");
-
-	server.db = new Database(
-		server.config.GetVariableString("database", "user", "root"),
-		server.config.GetVariableString("database", "password", ""),
-		server.config.GetVariableString("database", "host", "localhost"),
-		server.config.GetVariableString("database", "port", "3306"),
-		server.config.GetVariableString("database", "db", "peq")
-	);
+	LoadDatabaseConnection();
 
 	if (argc == 1) {
 		server.db->LoadLogSettings(LogSys.log_settings);
@@ -195,14 +230,6 @@ int main(int argc, char **argv)
 		LoginserverWebserver::RegisterRoutes(api);
 	}
 
-	if (argc > 1) {
-		LogSys.LoadLogSettingsDefaults();
-		LogSys.log_settings[Logs::Debug].log_to_console      = static_cast<uint8>(Logs::General);
-		LogSys.log_settings[Logs::Debug].is_category_enabled = 1;
-
-		LoginserverCommandHandler::CommandHandler(argc, argv);
-	}
-
 	LogInfo("[Config] [Logging] IsTraceOn [{0}]", server.options.IsTraceOn());
 	LogInfo("[Config] [Logging] IsWorldTraceOn [{0}]", server.options.IsWorldTraceOn());
 	LogInfo("[Config] [Logging] IsDumpInPacketsOn [{0}]", server.options.IsDumpInPacketsOn());

queryserv/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(qserv_sources
 	database.cpp

shared_memory/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(shared_memory_sources
 	base_data.cpp

shared_memory/spells.cpp

@@ -19,28 +19,35 @@
 #include "spells.h"
 #include "../common/global_define.h"
 #include "../common/shareddb.h"
-#include "../common/ipc_mutex.h"
-#include "../common/memory_mapped_file.h"
-#include "../common/eqemu_exception.h"
 #include "../common/spdat.h"
+#include "../common/shared/shared_memory.h"
+#include "../common/shared/shared_memory_map.h"
+
+namespace eqs = eq::shared;
 
 void LoadSpells(SharedDatabase *database, const std::string &prefix) {
-	EQEmu::IPCMutex mutex("spells");
-	mutex.Lock();
-	int records = database->GetMaxSpellID() + 1;
-	if(records == 0) {
-		EQ_EXCEPT("Shared Memory", "Unable to get any spells from the database.");
+	int records = database->GetSpellCount();
+	int max_spell_id = database->GetMaxSpellID() + 1;
+	auto size = records * sizeof(SPDat_Spell_Struct) * 125 / 100 + (64 * 1024);
+	eqs::shared_memory shared("shared/spells", size);
+
+	auto spells_result = shared.map<eqs::unordered_map<int, SPDat_Spell_Struct>>("spells");
+	if (!spells_result) {
+		//todo: get rid of the exceptions entirely.
+		EQ_EXCEPT("Shared Memory", "Unable to map shared memory");
 	}
 
-	uint32 size = records * sizeof(SPDat_Spell_Struct) + sizeof(uint32);
+	auto max_spell_id_result = shared.map<int>("max_spell_id");
+	if (!max_spell_id_result) {
+		EQ_EXCEPT("Shared Memory", "Unable to map shared memory");
+	}
 
-	auto Config = EQEmuConfig::get();
-	std::string file_name = Config->SharedMemDir + prefix + std::string("spells");
-	EQEmu::MemoryMappedFile mmf(file_name, size);
-	mmf.ZeroFile();
+	eqs::unordered_map<int, SPDat_Spell_Struct>& spells_shm = spells_result.value();
+	int& max_spell_id_shm = max_spell_id_result.value();
+	max_spell_id_shm = max_spell_id;
 
-	void *ptr = mmf.Get();
-	database->LoadSpells(ptr, records);
-	mutex.Unlock();
+	database->LoadSpells([&spells_shm](const SPDat_Spell_Struct &spell) {
+		spells_shm.insert_or_assign(spell.id, spell);
+	});
 }
 

tests/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 ADD_SUBDIRECTORY(cppunit)
 

tests/cppunit/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(cppunit_sources
 	collectoroutput.cpp

ucs/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(ucs_sources
 	chatchannel.cpp

ucs/chatchannel.cpp

@@ -47,8 +47,13 @@ ChatChannel::ChatChannel(std::string inName, std::string inOwner, std::string in
 
 	Moderated = false;
 
-	LogInfo("New ChatChannel created: Name: [[{}]], Owner: [[{}]], Password: [[{}]], MinStatus: [{}]",
-		Name.c_str(), Owner.c_str(), Password.c_str(), MinimumStatus);
+	LogDebug(
+		"New ChatChannel created: Name: [[{}]], Owner: [[{}]], Password: [[{}]], MinStatus: [{}]",
+		Name.c_str(),
+		Owner.c_str(),
+		Password.c_str(),
+		MinimumStatus
+	);
 
 }
 
@@ -154,7 +159,7 @@ void ChatChannelList::SendAllChannels(Client *c) {
 
 void ChatChannelList::RemoveChannel(ChatChannel *Channel) {
 
-	LogInfo("RemoveChannel([{}])", Channel->GetName().c_str());
+	LogDebug("RemoveChannel ([{}])", Channel->GetName().c_str());
 
 	LinkedListIterator<ChatChannel*> iterator(ChatChannels);
 
@@ -175,7 +180,7 @@ void ChatChannelList::RemoveChannel(ChatChannel *Channel) {
 
 void ChatChannelList::RemoveAllChannels() {
 
-	LogInfo("RemoveAllChannels");
+	LogDebug("RemoveAllChannels");
 
 	LinkedListIterator<ChatChannel*> iterator(ChatChannels);
 
@@ -242,7 +247,7 @@ void ChatChannel::AddClient(Client *c) {
 
 	int AccountStatus = c->GetAccountStatus();
 
-	LogInfo("Adding [{}] to channel [{}]", c->GetName().c_str(), Name.c_str());
+	LogDebug("Adding [{}] to channel [{}]", c->GetName().c_str(), Name.c_str());
 
 	LinkedListIterator<Client*> iterator(ClientsInChannel);
 
@@ -267,7 +272,7 @@ bool ChatChannel::RemoveClient(Client *c) {
 
 	if(!c) return false;
 
-	LogInfo("RemoveClient [{}] from channel [{}]", c->GetName().c_str(), GetName().c_str());
+	LogDebug("RemoveClient [{}] from channel [{}]", c->GetName().c_str(), GetName().c_str());
 
 	bool HideMe = c->GetHideMe();
 
@@ -304,7 +309,7 @@ bool ChatChannel::RemoveClient(Client *c) {
 		if((Password.length() == 0) || (RuleI(Channels, DeleteTimer) == 0))
 			return false;
 
-		LogInfo("Starting delete timer for empty password protected channel [{}]", Name.c_str());
+		LogDebug("Starting delete timer for empty password protected channel [{}]", Name.c_str());
 
 		DeleteTimer.Start(RuleI(Channels, DeleteTimer) * 60000);
 	}
@@ -402,7 +407,7 @@ void ChatChannel::SendMessageToChannel(std::string Message, Client* Sender) {
 
 		if(ChannelClient)
 		{
-			LogInfo("Sending message to [{}] from [{}]",
+			LogDebug("Sending message to [{}] from [{}]",
 				ChannelClient->GetName().c_str(), Sender->GetName().c_str());
 
 			if (cv_messages[static_cast<uint32>(ChannelClient->GetClientVersion())].length() == 0) {
@@ -505,7 +510,7 @@ ChatChannel *ChatChannelList::AddClientToChannel(std::string ChannelName, Client
 		return nullptr;
 	}
 
-	LogInfo("AddClient to channel [[{}]] with password [[{}]]", NormalisedName.c_str(), Password.c_str());
+	LogDebug("AddClient to channel [[{}]] with password [[{}]]", NormalisedName.c_str(), Password.c_str());
 
 	ChatChannel *RequiredChannel = FindChannel(NormalisedName);
 
@@ -581,7 +586,7 @@ void ChatChannelList::Process() {
 
 		if(CurrentChannel && CurrentChannel->ReadyToDelete()) {
 
-			LogInfo("Empty temporary password protected channel [{}] being destroyed",
+			LogDebug("Empty temporary password protected channel [{}] being destroyed",
 				CurrentChannel->GetName().c_str());
 
 			RemoveChannel(CurrentChannel);
@@ -597,7 +602,7 @@ void ChatChannel::AddInvitee(const std::string &Invitee)
 	if (!IsInvitee(Invitee)) {
 		Invitees.push_back(Invitee);
 
-		LogInfo("Added [{}] as invitee to channel [{}]", Invitee.c_str(), Name.c_str());
+		LogDebug("Added [{}] as invitee to channel [{}]", Invitee.c_str(), Name.c_str());
 	}
 
 }
@@ -608,7 +613,7 @@ void ChatChannel::RemoveInvitee(std::string Invitee)
 
 	if(it != std::end(Invitees)) {
 		Invitees.erase(it);
-		LogInfo("Removed [{}] as invitee to channel [{}]", Invitee.c_str(), Name.c_str());
+		LogDebug("Removed [{}] as invitee to channel [{}]", Invitee.c_str(), Name.c_str());
 	}
 }