Rename some lua general functions to match the rest of the conventions

[Bugfix] Very edge case Guard awareness latency

.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}"
+	}
+}

.drone.yml

@@ -0,0 +1,16 @@
+---
+kind: pipeline
+type: docker
+name: EQEmulator Server Linux CI
+
+# Limits how many of these builds can run on the drone runner at a time, this isn't about cores
+concurrency:
+  limit: 1
+
+steps:
+  - name: server-build
+    # Source build script https://github.com/Akkadius/akk-stack/blob/master/containers/eqemu-server/Dockerfile#L20
+    image: akkadius/eqemu-server:latest
+    commands:
+      - sudo chown eqemu:eqemu /drone/src/ * -R
+      - git submodule init && git submodule update && mkdir -p build && cd build && cmake -DEQEMU_BUILD_LOGIN=ON -DEQEMU_BUILD_BOTS=ON -DEQEMU_BUILD_LUA=ON -G 'Unix Makefiles' .. && make -j$((`nproc`-4))

.editorconfig

@@ -0,0 +1,23 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# Matches multiple files with brace expansion notation
+# Set default charset
+[*.{js,py}]
+charset = utf-8
+
+[*.cpp]
+indent_style = tab
+[*.h]
+indent_style = tab
+
+# Tab indentation (no size specified)
+[Makefile]
+indent_style = tab

.gitignore

@@ -17,21 +17,40 @@
 *.out
 *.app
 
+.bash_history
+
 # CMake
 CMakeCache.txt
 CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
-Build/
-build/
-Build32/
-build32/
-Build64/
-build64/
-Build_32/
-build_32/
-Build_64/
-build_64/
+[Bb]uild*/
 log/
 logs/
+vcpkg/
+perl/
+
+.idea/*
+*cbp
+
+submodules/*
+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

@@ -0,0 +1,18 @@
+[submodule "submodules/glm"]
+	path = submodules/glm
+	url = https://github.com/g-truc/glm.git
+[submodule "submodules/fmt"]
+	path = submodules/fmt
+	url = https://github.com/fmtlib/fmt.git
+[submodule "submodules/libuv"]
+	path = submodules/libuv
+	url = https://github.com/libuv/libuv.git
+[submodule "submodules/cereal"]
+	path = submodules/cereal
+	url = https://github.com/USCiLab/cereal.git
+[submodule "submodules/websocketpp"]
+	path = submodules/websocketpp
+	url = https://github.com/zaphoyd/websocketpp.git
+[submodule "submodules/recastnavigation"]
+	path = submodules/recastnavigation
+	url = https://github.com/EQEmu/recastnavigation.git

.travis.yml

@@ -1,24 +1,19 @@
 language: cpp
 compiler: gcc
-sudo: false
+dist: bionic
+
 addons:
   apt:
     packages:
-    - libmysqlclient-dev
-    - libperl-dev
-    - libboost-dev
-    - liblua5.1-0-dev
-    - zlib1g-dev
+      - libmysqlclient-dev
+      - libperl-dev
+      - libboost-dev
+      - liblua5.1-0-dev
+      - zlib1g-dev
+      - uuid-dev
+      - libssl-dev
+
 script:
-  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
-  - make -j8
+  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON
+  - make -j2
   - ./bin/tests
-branches:
-  only:
-    - master
-    - stable
-notifications:
-  email: false
-  irc:
-    channels: "irc.eqemulator.net#eqemucoders"
-os: linux

.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,164 @@
+{
+    // 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 bin && make",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "make clean",
+            "type": "shell",
+            "command": "cd bin && make clean",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        },
+        {
+            "label": "cmake",
+            "type": "shell",
+            "command": "mkdir -p bin && cd bin && 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 bin && cd 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 bin && cd 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 bin && cd 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 bin && cd bin && docker run -i --rm --privileged -v ${HOST_PROJECT_PATH}/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}/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}/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}/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}/bin:/src --network=eqemu --name sharedmemory eqemu/server:0.0.3 ./shared_memory && docker run --rm -v ${HOST_PROJECT_PATH}/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}/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 bin && docker network create eqemu | true && docker run --rm -v ${HOST_PROJECT_PATH}/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
+            }
+        },
+        {
+            "label": "ucs",
+            "type": "shell",
+            "command": "docker stop ucs | true && cd bin && docker network create eqemu | true && docker run --rm -v ${HOST_PROJECT_PATH}/bin:/src -p 7778:7778 --name ucs --network=eqemu eqemu/server:0.0.3 gdb -ex run ./ucs",
+            "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,124 +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_STATUS
-#EQEMU_LOG_LEVEL_NORMAL
-#EQEMU_LOG_LEVEL_ERROR
-#EQEMU_LOG_LEVEL_DEBUG
-#EQEMU_LOG_LEVEL_QUEST
-#EQEMU_LOG_LEVEL_COMMANDS
-#EQEMU_LOG_LEVEL_CRASH
-#EQEMU_STREAM_SEND_RATE
-#EQEMU_STREAM_DECAY_RATE
-#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL
-#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX
-#EQEMU_STREAM_AVERAGE_DELTA_MAX
-#EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS
-#EQEMU_DEPOP_INVALIDATES_CACHE
-#EQEMU_ENABLE_BOTS
-#EQEMU_DISABLE_LOGSYS
-#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_MAP_DIR
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
-#We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
-#Can change this if you really want but you should upgrade!
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-
-#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)
 
-#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 14)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
 
 IF(MSVC)
-	#Set our default locations for zlib/mysql based on x86/x64
-	IF(CMAKE_CL_64)
-		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
-		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
-		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x64")
-	ELSE(CMAKE_CL_64)
-		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
-		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
-		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
-	ENDIF(CMAKE_CL_64)
-
-	#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)
-
-	#Disable safe SEH or not?
-	OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
-	IF(EQEMU_DISABLE_SAFESEH)
-		SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-	ENDIF(EQEMU_DISABLE_SAFESEH)
-
-	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)
 
@@ -135,205 +39,327 @@ 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_STATUS 2 CACHE STRING "EQEmu logging level for [Status]:
-	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()
 
-SET(EQEMU_LOG_LEVEL_NORMAL 3 CACHE STRING "EQEmu logging level for [Normal]:
-	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"
-)
+#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)
 
-SET(EQEMU_LOG_LEVEL_ERROR 2 CACHE STRING "EQEmu logging level for [Error]:
-	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"
-)
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Detection                              *")
+MESSAGE(STATUS "**************************************************")
 
-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"
-)
+IF(MYSQL_FOUND)
+	MESSAGE(STATUS "* MySQL:                                   FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MySQL:                                 MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_QUEST 2 CACHE STRING "EQEmu logging level for [Quest]:
-	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"
-)
+IF(MARIADB_FOUND)
+	MESSAGE(STATUS "* MariaDB:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MariaDB:                               MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_COMMANDS 1 CACHE STRING "EQEmu logging level for [Commands]:
-	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"
-)
+IF(ZLIB_FOUND)
+	MESSAGE(STATUS "* ZLIB:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* ZLIB:                                  MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_CRASH 3 CACHE STRING "EQEmu logging level for [Crash]:
-	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"
-)
+IF(Lua51_FOUND)
+	MESSAGE(STATUS "* Lua:                                     FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Lua:                                   MISSING *")
+ENDIF()
 
-MARK_AS_ADVANCED(EQEMU_LOG_LEVEL_STATUS EQEMU_LOG_LEVEL_NORMAL EQEMU_LOG_LEVEL_ERROR EQEMU_LOG_LEVEL_DEBUG EQEMU_LOG_LEVEL_QUEST EQEMU_LOG_LEVEL_COMMANDS EQEMU_LOG_LEVEL_CRASH)
+IF(PerlLibs_FOUND)
+	MESSAGE(STATUS "* Perl:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Perl:                                  MISSING *")
+ENDIF()
 
-SET(EQEMU_STREAM_SEND_RATE 1048576 CACHE STRING "Advanced: Base amount of data stream can send before throttle.")
-SET(EQEMU_STREAM_DECAY_RATE 78642 CACHE STRING "Advanced: Base amount of data stream recovers per tic.")
-SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL 3.0 CACHE STRING "Advanced: Multiplier on retransmit timeout.")
-SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX 5000 CACHE STRING "Advanced: Max in ms for retransmit timeout timer.")
-SET(EQEMU_STREAM_AVERAGE_DELTA_MAX 2500 CACHE STRING "Advanced: The maximum average delta in ms allowed.")
-SET(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS TRUE CACHE BOOL "Advanced: Whether or not acked packets can be retransmitted")
-MARK_AS_ADVANCED(EQEMU_STREAM_SEND_RATE EQEMU_STREAM_DECAY_RATE EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX EQEMU_STREAM_AVERAGE_DELTA_MAX EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
+IF(SODIUM_FOUND)
+	MESSAGE(STATUS "* libsodium:                               FOUND *")
+ELSE()
+	MESSAGE(STATUS "* libsodium:                             MISSING *")
+ENDIF()
 
-#NPC Types Cache Behavior
+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)
-
-#Bots are a compile time option so on/off
 OPTION(EQEMU_ENABLE_BOTS "Enable Bots" OFF)
-
-#Disable entire _mlog system (excludes trade/command logs)
-OPTION(EQEMU_DISABLE_LOGSYS "Disable Logging INI System" ON)
-
-#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_DISABLE_LOGSYS)
-	ADD_DEFINITIONS(-DDISABLE_LOGSYS)
-ENDIF(EQEMU_DISABLE_LOGSYS)
-
 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_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 MariaDB 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()
 
-SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
+IF(SODIUM_FOUND)
+	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()
 
-ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
-ADD_DEFINITIONS(-DINVERSEXY)
-ADD_DEFINITIONS(-DFIELD_ITEMS)
-ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
-ADD_DEFINITIONS(-DRATEBASE=${EQEMU_STREAM_SEND_RATE})
-ADD_DEFINITIONS(-DDECAYBASE=${EQEMU_STREAM_DECAY_RATE})
-ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MULT=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL})
-ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MAX=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX})
-ADD_DEFINITIONS(-DAVERAGE_DELTA_MAX=${EQEMU_STREAM_AVERAGE_DELTA_MAX})
-ADD_DEFINITIONS(-DLOG_LEVEL_STATUS=${EQEMU_LOG_LEVEL_STATUS})
-ADD_DEFINITIONS(-DLOG_LEVEL_NORMAL=${EQEMU_LOG_LEVEL_NORMAL})
-ADD_DEFINITIONS(-DLOG_LEVEL_ERROR=${EQEMU_LOG_LEVEL_ERROR})
-ADD_DEFINITIONS(-DLOG_LEVEL_DEBUG=${EQEMU_LOG_LEVEL_DEBUG})
-ADD_DEFINITIONS(-DLOG_LEVEL_QUEST=${EQEMU_LOG_LEVEL_QUEST})
-ADD_DEFINITIONS(-DLOG_LEVEL_COMMANDS=${EQEMU_LOG_LEVEL_COMMANDS})
-ADD_DEFINITIONS(-DLOG_LEVEL_CRASH=${EQEMU_LOG_LEVEL_CRASH})
-ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
+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(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=true)
-ELSE(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=false)
-ENDIF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
+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()
 
-#Find everything we need
-FIND_PACKAGE(ZLIB REQUIRED)
-FIND_PACKAGE(MySQL REQUIRED)
-IF(EQEMU_BUILD_PERL)
-	FIND_PACKAGE(PerlLibs REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
-ENDIF(EQEMU_BUILD_PERL)
+#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()
 
-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")
+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 "**************************************************")
 
-	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
+#setup server libs and headers
+SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)
 
-	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 "${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/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")
 
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
+OPTION(EQEMU_BUILD_LOGGING "Build Logging (To speed up compilation)" ON)
+IF(EQEMU_BUILD_LOGGING)
+	ADD_DEFINITIONS(-DBUILD_LOGGING)
+ENDIF()
 
-IF(EQEMU_BUILD_LUA)
-    ADD_SUBDIRECTORY(luabind)
-ENDIF(EQEMU_BUILD_LUA)
+IF(TLS_LIBRARY_ENABLED)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${TLS_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${TLS_LIBRARY_INCLUDE}")
+ENDIF()
 
-IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
+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(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()
+ENDIF()
+
+IF(WIN32)
+	SET(SERVER_LIBS ${SERVER_LIBS} "ws2_32" "psapi" "iphlpapi" "userenv")
+ENDIF()
+
+IF(UNIX)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${CMAKE_DL_LIBS} "z" "m" "pthread")
+	IF(NOT DARWIN)
+		SET(SERVER_LIBS ${SERVER_LIBS} "rt")
+	ENDIF()
+	# Freebsd provides uuids in the C library
+	IF(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+		SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
+	ENDIF()
+ENDIF()
+
+IF(EQEMU_BUILD_LOGIN AND NOT TLS_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Login server requires a TLS Library to build.")
+ENDIF()
+
+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)
-ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
+	ADD_SUBDIRECTORY(libs)
+	ADD_SUBDIRECTORY(submodules/fmt)
+	ADD_SUBDIRECTORY(submodules/libuv)
+	
+	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)
@@ -342,10 +368,15 @@ 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)
 
+IF(EQEMU_BUILD_HC)
+	ADD_SUBDIRECTORY(hc)
+ENDIF(EQEMU_BUILD_HC)
+
 IF(EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(tests)
 ENDIF(EQEMU_BUILD_TESTS)

GPL.txt

@@ -1,339 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    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; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU 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.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.

LICENSE

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

LICENSE.md

@@ -1,12 +0,0 @@
-The server code and utilities are released under GPLv3.
-
-We also include some small libraries for convienence that may be under different licensing:
-
-SocketLib - GPL
-LibXML - ZLib License
-StackWalker - New BSD License
-ZLib - ZLib License
-MySQL - GPL
-Perl - GPL / ActiveState (under the assumption that this is a free project).
-CPPUnit - GLP
-StringUtilities - Apache

README.md

@@ -1,53 +1,83 @@
-EQEmu
-===
+# EQEmulator Core Server
+|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/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)   |
 
-[![Build Status](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)
+***
 
-Overview
----
+**EQEmulator is a custom completely from-scratch open source server implementation for EverQuest built mostly on C++**
+ * MySQL/MariaDB is used as the database engine (over 200+ tables)
+ * Perl and LUA are both supported scripting languages for NPC/Player/Quest oriented events
+ * Open source database (Project EQ) has content up to expansion OoW (included in server installs)
+  * Game server environments and databases can be heavily customized to create all new experiences
+ * Hundreds of Quests/events created and maintained by Project EQ
 
-EQEmu is a custom server implementation for EverQuest
+## Server Installs
+| |Windows|Linux|
+|:---:|:---:|:---:|
+|**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 
 
-Dependencies
----
+* [Install Guide](https://eqemu.gitbook.io/server/categories/installation/server-installation-windows)
 
-For Windows: http://eqemu.github.io
+### > Debian/Ubuntu/CentOS/Fedora
 
-Login Server dependencies for Windows/Linux/OSX: http://eqemu.github.io
+* [Install Guide](https://eqemu.gitbook.io/server/categories/installation/server-installation-linux)
 
-For Debian based distros (adjust to your local flavor):
+* You can use curl or wget to kick off the installer (whichever your OS has)
+> curl -O https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh install.sh && chmod 755 install.sh && ./install.sh
 
-- libmysqlclient-dev
-- libperl-dev
-- liblua5.1-0-dev (5.2 should work as well)
-- libboost-dev
+> wget --no-check-certificate https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh -O install.sh && chmod 755 install.sh && ./install.sh
 
-Further instructions on building the source can be found on the
-[wiki](http://wiki.eqemulator.org/i?M=Wiki).
+## Supported Clients
 
-Bug reports
----
+|Titanium Edition|Secrets of Faydwer|Seeds of Destruction|Underfoot|Rain of Fear|
+|:---:|:---:|:---:|:---:|:---:|
+|<img src="http://i.imgur.com/hrwDxoM.jpg" height="150">|<img src="http://i.imgur.com/cRDW5tn.png" height="150">|<img src="http://i.imgur.com/V48kuVn.jpg" height="150">|<img src="http://i.imgur.com/IJQ0XMa.jpg" height="150">|<img src="http://i.imgur.com/OMpHkKa.png" height="100">|
 
-Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
+## Bug Reports <img src="http://i.imgur.com/daf1Vjw.png" height="20">
+* Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
 reports or feature requests.
+* The [EQEmu Forums](http://www.eqemulator.org/forums/) are also a place to submit and get help with bugs.
 
-The [EQEmu Forums](http://www.eqemulator.org/forums/) also have forums to submit
-bugs/get help with bugs.
+## Contributions <img src="http://image.flaticon.com/icons/png/512/25/25231.png" width="20">
 
-Contributions
----
-
-The preferred way to contribute is to fork the repo and submit a pull request on
+* The preferred way to contribute is to fork the repo and submit a pull request on
 GitHub. If you need help with your changes, you can always post on the forums or
-try IRC. You can also post unified diffs (`git diff` should do the trick) on the
+try Discord. You can also post unified diffs (`git diff` should do the trick) on the
 [Server Code Submissions](http://www.eqemulator.org/forums/forumdisplay.php?f=669)
 forum, although pull requests will be much quicker and easier on all parties.
 
-Contact
----
- - **User IRC Channel**: `#eqemu` on `irc.eqemulator.net`
- - **Developer IRC Channel**: `#eqemucoders` on `irc.eqemulator.net`
+## Contact <img src="http://gamerescape.com/wp-content/uploads/2015/06/discord.png" height="20">
 
+ - Discord Channel: https://discord.gg/QHsm7CD
+ - **User Discord Channel**: `#general`
+ - **Developer Discord Channel**: `#eqemucoders`
+
+## Resources
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
-- [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)
+- [EQEmulator Wiki](https://eqemu.gitbook.io/)
+
+## Related Repositories
+* [ProjectEQ Quests](https://github.com/ProjectEQ/projecteqquests)
+* [Maps](https://github.com/Akkadius/EQEmuMaps)
+* [Installer Resources](https://github.com/Akkadius/EQEmuInstall)
+* [Zone Utilities](https://github.com/EQEmu/zone-utilities) - Various utilities and libraries for parsing, rendering and manipulating EQ Zone files.
+
+## Other License Info
+
+* The server code and utilities are released under **GPLv3**
+* We also include some small libraries for convienence that may be under different licensing
+  * SocketLib - GPL LibXML
+  * zlib - zlib license
+  * MariaDB/MySQL - GPL
+  * GPL Perl - GPL / ActiveState (under the assumption that this is a free project)
+  * CPPUnit - GLP StringUtilities - Apache
+  * LUA - MIT
+
+## Contributors
+
+<a href="https://github.com/EQEmu/server/graphs/contributors">
+  <img src="https://contributors-img.firebaseapp.com/image?repo=EQEmu/server" />
+</a>
 

SECURITY.md

@@ -0,0 +1,3 @@
+# Security Policy - Reporting Vulnerabilities
+
+When reporting active hacks, exploits and other vulnerabilities, please describe how to reproduce said report and if you can provide context into a possible solution

appveyor-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=ON -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-bots.zip

appveyor-no-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=OFF -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-no-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-no-bots.zip

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
@@ -9,28 +9,8 @@ SET(export_headers
 
 ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
 
-INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 
-TARGET_LINK_LIBRARIES(export_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
-
-IF(MSVC)
-	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
-	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
-ENDIF(MSVC)
-
-IF(MINGW)
-	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
-ENDIF(MINGW)
-
-IF(UNIX)
-	TARGET_LINK_LIBRARIES(export_client_files "${CMAKE_DL_LIBS}")
-	TARGET_LINK_LIBRARIES(export_client_files "z")
-	TARGET_LINK_LIBRARIES(export_client_files "m")
-	IF(NOT DARWIN)
-		TARGET_LINK_LIBRARIES(export_client_files "rt")
-	ENDIF(NOT DARWIN)
-	TARGET_LINK_LIBRARIES(export_client_files "pthread")
-	ADD_DEFINITIONS(-fPIC)
-ENDIF(UNIX)
+TARGET_LINK_LIBRARIES(export_client_files ${SERVER_LIBS})
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/export/main.cpp

@@ -26,137 +26,198 @@
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
+#include "../../common/content/world_content_service.h"
 
-EQEmuLogSys Log;
+EQEmuLogSys LogSys;
+WorldContentService content_service;
 
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
 void ExportDBStrings(SharedDatabase *db);
 
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
 	RegisterExecutablePlatform(ExePlatformClientExport);
-	Log.LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
-	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+	LogInfo("Client Files Export Utility");
+	if (!EQEmuConfig::LoadConfig()) {
+		LogError("Unable to load configuration file");
 		return 1;
 	}
 
 	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
-			"database connection");
+	SharedDatabase content_db;
+
+	LogInfo("Connecting to database");
+	if (!database.Connect(
+		Config->DatabaseHost.c_str(),
+		Config->DatabaseUsername.c_str(),
+		Config->DatabasePassword.c_str(),
+		Config->DatabaseDB.c_str(),
+		Config->DatabasePort
+	)) {
+		LogError("Unable to connect to the database, cannot continue without a database connection");
 		return 1;
 	}
 
-	/* Register Log System and Settings */
-	database.LoadLogSettings(Log.log_settings);
-	Log.StartFileLogs();
+	/**
+	 * Multi-tenancy: Content database
+	 */
+	if (!Config->ContentDbHost.empty()) {
+		if (!content_db.Connect(
+			Config->ContentDbHost.c_str() ,
+			Config->ContentDbUsername.c_str(),
+			Config->ContentDbPassword.c_str(),
+			Config->ContentDbName.c_str(),
+			Config->ContentDbPort
+		)) {
+			LogError("Cannot continue without a content database connection");
+			return 1;
+		}
+	} else {
+		content_db.SetMysql(database.getMySQL());
+	}
 
-	ExportSpells(&database);
-	ExportSkillCaps(&database);
-	ExportBaseData(&database);
+	database.LoadLogSettings(LogSys.log_settings);
+	LogSys.StartFileLogs();
+
+	std::string arg_1;
+
+	if (argv[1]) {
+		arg_1 = argv[1];
+	}
+
+	if (arg_1 == "spells") {
+		ExportSpells(&content_db);
+		return 0;
+	}
+	if (arg_1 == "skills") {
+		ExportSkillCaps(&content_db);
+		return 0;
+	}
+	if (arg_1 == "basedata") {
+		ExportBaseData(&content_db);
+		return 0;
+	}
+	if (arg_1 == "dbstring") {
+		ExportDBStrings(&database);
+		return 0;
+	}
+
+	ExportSpells(&content_db);
+	ExportSkillCaps(&content_db);
+	ExportBaseData(&content_db);
 	ExportDBStrings(&database);
 
-	Log.CloseFileLogs();
+	LogSys.CloseFileLogs();
 
 	return 0;
 }
 
-void ExportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
+void ExportSpells(SharedDatabase *db)
+{
+	LogInfo("Exporting Spells");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
+	if (!f) {
+		LogError("Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}
 
-	const std::string query = "SELECT * FROM spells_new ORDER BY id";
-	auto results = db->QueryDatabase(query);
+	const std::string query   = "SELECT * FROM spells_new ORDER BY id";
+	auto              results = db->QueryDatabase(query);
 
-	if(results.Success()) {
-        for (auto row = results.begin(); row != results.end(); ++row) {
-			std::string line;
-			unsigned int fields = results.ColumnCount();
-			for(unsigned int i = 0; i < fields; ++i) {
-				if(i != 0) {
+	if (results.Success()) {
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			std::string       line;
+			unsigned int      fields = results.ColumnCount();
+			for (unsigned int i      = 0; i < fields; ++i) {
+				if (i != 0) {
 					line.push_back('^');
 				}
 
-				if(row[i] != nullptr) {
+				if (row[i] != nullptr) {
 					line += row[i];
 				}
 			}
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	} else {
+	}
+	else {
 	}
 
 	fclose(f);
 }
 
-bool SkillUsable(SharedDatabase *db, int skill_id, int class_id) {
+bool SkillUsable(SharedDatabase *db, int skill_id, int class_id)
+{
 
 	bool res = false;
 
-	std::string query = StringFormat("SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
-                                    class_id, skill_id);
-	auto results = db->QueryDatabase(query);
-	if(!results.Success()) {
-        return false;
-    }
+	std::string query   = StringFormat(
+		"SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
+		class_id, skill_id
+	);
+	auto        results = db->QueryDatabase(query);
+	if (!results.Success()) {
+		return false;
+	}
 
-    if (results.RowCount() == 0)
-        return false;
+	if (results.RowCount() == 0) {
+		return false;
+	}
 
-    auto row = results.begin();
-    if(row[0] && atoi(row[0]) > 0)
-        return true;
+	auto row = results.begin();
+	if (row[0] && atoi(row[0]) > 0) {
+		return true;
+	}
 
-    return false;
+	return false;
 }
 
-int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
+int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level)
+{
 
-	std::string query = StringFormat("SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
-                                    class_id, skill_id, level);
-    auto results = db->QueryDatabase(query);
-    if (!results.Success()) {
-        return 0;
-    }
+	std::string query   = StringFormat(
+		"SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
+		class_id, skill_id, level
+	);
+	auto        results = db->QueryDatabase(query);
+	if (!results.Success()) {
+		return 0;
+	}
 
-    if (results.RowCount() == 0)
-        return 0;
+	if (results.RowCount() == 0) {
+		return 0;
+	}
 
-    auto row = results.begin();
+	auto row = results.begin();
 	return atoi(row[0]);
 }
 
-void ExportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
+void ExportSkillCaps(SharedDatabase *db)
+{
+	LogInfo("Exporting Skill Caps");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+	if (!f) {
+		LogError("Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
-	for(int cl = 1; cl <= 16; ++cl) {
-		for(int skill = 0; skill <= 77; ++skill) {
-			if(SkillUsable(db, skill, cl)) {
-				int previous_cap = 0;
-				for(int level = 1; level <= 100; ++level) {
+	for (int cl = 1; cl <= 16; ++cl) {
+		for (int skill = 0; skill <= 77; ++skill) {
+			if (SkillUsable(db, skill, cl)) {
+				int      previous_cap = 0;
+				for (int level        = 1; level <= 100; ++level) {
 					int cap = GetSkill(db, skill, cl, level);
-					if(cap < previous_cap) {
+					if (cap < previous_cap) {
 						cap = previous_cap;
 					}
 
@@ -170,26 +231,28 @@ void ExportSkillCaps(SharedDatabase *db) {
 	fclose(f);
 }
 
-void ExportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
+void ExportBaseData(SharedDatabase *db)
+{
+	LogInfo("Exporting Base Data");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
+	if (!f) {
+		LogError("Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}
 
-	const std::string query = "SELECT * FROM base_data ORDER BY level, class";
-	auto results = db->QueryDatabase(query);
-	if(results.Success()) {
-        for (auto row = results.begin();row != results.end();++row) {
-			std::string line;
-			unsigned int fields = results.ColumnCount();
-			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
-				if(rowIndex != 0)
+	const std::string query   = "SELECT * FROM base_data ORDER BY level, class";
+	auto              results = db->QueryDatabase(query);
+	if (results.Success()) {
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			std::string       line;
+			unsigned int      fields   = results.ColumnCount();
+			for (unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
+				if (rowIndex != 0) {
 					line.push_back('^');
+				}
 
-				if(row[rowIndex] != nullptr) {
+				if (row[rowIndex] != nullptr) {
 					line += row[rowIndex];
 				}
 			}
@@ -201,27 +264,29 @@ void ExportBaseData(SharedDatabase *db) {
 	fclose(f);
 }
 
-void ExportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting DB Strings...");
+void ExportDBStrings(SharedDatabase *db)
+{
+	LogInfo("Exporting DB Strings");
 
 	FILE *f = fopen("export/dbstr_us.txt", "w");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
+	if (!f) {
+		LogError("Unable to open export/dbstr_us.txt to write, skipping.");
 		return;
 	}
 
 	fprintf(f, "Major^Minor^String(New)\n");
-	const std::string query = "SELECT * FROM db_str ORDER BY id, type";
-	auto results = db->QueryDatabase(query);
-	if(results.Success()) {
-		for(auto row = results.begin(); row != results.end(); ++row) {
-			std::string line;
-			unsigned int fields = results.ColumnCount();
-			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
-				if(rowIndex != 0)
+	const std::string query   = "SELECT * FROM db_str ORDER BY id, type";
+	auto              results = db->QueryDatabase(query);
+	if (results.Success()) {
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			std::string       line;
+			unsigned int      fields   = results.ColumnCount();
+			for (unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
+				if (rowIndex != 0) {
 					line.push_back('^');
+				}
 
-				if(row[rowIndex] != nullptr) {
+				if (row[rowIndex] != nullptr) {
 					line += row[rowIndex];
 				}
 			}

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
@@ -9,28 +9,8 @@ SET(import_headers
 
 ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
 
-INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 
-TARGET_LINK_LIBRARIES(import_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
-
-IF(MSVC)
-	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
-	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
-ENDIF(MSVC)
-
-IF(MINGW)
-	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
-ENDIF(MINGW)
-
-IF(UNIX)
-	TARGET_LINK_LIBRARIES(import_client_files "${CMAKE_DL_LIBS}")
-	TARGET_LINK_LIBRARIES(import_client_files "z")
-	TARGET_LINK_LIBRARIES(import_client_files "m")
-	IF(NOT DARWIN)
-		TARGET_LINK_LIBRARIES(import_client_files "rt")
-	ENDIF(NOT DARWIN)
-	TARGET_LINK_LIBRARIES(import_client_files "pthread")
-	ADD_DEFINITIONS(-fPIC)
-ENDIF(UNIX)
+TARGET_LINK_LIBRARIES(import_client_files ${SERVER_LIBS})
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/import/main.cpp

@@ -24,8 +24,10 @@
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
+#include "../../common/content/world_content_service.h"
 
-EQEmuLogSys Log;
+EQEmuLogSys LogSys;
+WorldContentService content_service;
 
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
@@ -34,36 +36,60 @@ void ImportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	Log.LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
+	LogInfo("Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+		LogError("Unable to load configuration file.");
 		return 1;
 	}
 
 	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
-			"database connection");
+	SharedDatabase content_db;
+
+	LogInfo("Connecting to database");
+	if (!database.Connect(
+		Config->DatabaseHost.c_str(),
+		Config->DatabaseUsername.c_str(),
+		Config->DatabasePassword.c_str(),
+		Config->DatabaseDB.c_str(),
+		Config->DatabasePort
+	)) {
+		LogError("Unable to connect to the database, cannot continue without a database connection");
 		return 1;
 	}
 
-	database.LoadLogSettings(Log.log_settings);
-	Log.StartFileLogs();
+	/**
+	 * Multi-tenancy: Content database
+	 */
+	if (!Config->ContentDbHost.empty()) {
+		if (!content_db.Connect(
+			Config->ContentDbHost.c_str() ,
+			Config->ContentDbUsername.c_str(),
+			Config->ContentDbPassword.c_str(),
+			Config->ContentDbName.c_str(),
+			Config->ContentDbPort
+		)) {
+			LogError("Cannot continue without a content database connection");
+			return 1;
+		}
+	} else {
+		content_db.SetMysql(database.getMySQL());
+	}
 
-	ImportSpells(&database);
-	ImportSkillCaps(&database);
-	ImportBaseData(&database);
+	database.LoadLogSettings(LogSys.log_settings);
+	LogSys.StartFileLogs();
+
+	ImportSpells(&content_db);
+	ImportSkillCaps(&content_db);
+	ImportBaseData(&content_db);
 	ImportDBStrings(&database);
 
-	Log.CloseFileLogs();
-	
+	LogSys.CloseFileLogs();
+
 	return 0;
 }
 
@@ -97,10 +123,10 @@ bool IsStringField(int i) {
 }
 
 void ImportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
+	LogInfo("Importing Spells");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		LogError("Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
@@ -173,23 +199,23 @@ void ImportSpells(SharedDatabase *db) {
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+			LogInfo("[{}] spells imported", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+		LogInfo("[{}] spells imported", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
+	LogInfo("Importing Skill Caps");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		LogError("Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
@@ -220,11 +246,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
+	LogInfo("Importing Base Data");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		LogError("Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 
@@ -265,11 +291,11 @@ void ImportBaseData(SharedDatabase *db) {
 }
 
 void ImportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing DB Strings...");
+	LogInfo("Importing DB Strings");
 
 	FILE *f = fopen("import/dbstr_us.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
+		LogError("Unable to open import/dbstr_us.txt to read, skipping.");
 		return;
 	}
 
@@ -300,10 +326,10 @@ void ImportDBStrings(SharedDatabase *db) {
 		std::string sql;
 		int id, type;
 		std::string value;
-		
+
 		id = atoi(split[0].c_str());
 		type = atoi(split[1].c_str());
-		
+
 		if(split.size() >= 3) {
 			value = ::EscapeString(split[2]);
 		}

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/FindSodium.cmake

@@ -0,0 +1,30 @@
+if (NOT MSVC)
+include(FindPkgConfig)
+pkg_check_modules(PC_SODIUM "libsodium")
+if (NOT PC_SODIUM_FOUND)
+    pkg_check_modules(PC_SODIUM "sodium")
+endif (NOT PC_SODIUM_FOUND)
+if (PC_SODIUM_FOUND)
+  set(SODIUM_INCLUDE_HINTS ${PC_SODIUM_INCLUDE_DIRS} ${PC_SODIUM_INCLUDE_DIRS}/*)
+  set(SODIUM_LIBRARY_HINTS ${PC_SODIUM_LIBRARY_DIRS} ${PC_SODIUM_LIBRARY_DIRS}/*)
+endif()
+endif (NOT MSVC)
+
+# some libraries install the headers is a subdirectory of the include dir
+# returned by pkg-config, so use a wildcard match to improve chances of finding
+# headers and libraries.
+find_path(
+    SODIUM_INCLUDE_DIRS
+    NAMES sodium.h
+    HINTS ${SODIUM_INCLUDE_HINTS}
+)
+
+find_library(
+    SODIUM_LIBRARIES
+    NAMES libsodium sodium
+    HINTS ${SODIUM_LIBRARY_HINTS}
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(SODIUM DEFAULT_MSG SODIUM_LIBRARIES SODIUM_INCLUDE_DIRS)
+mark_as_advanced(SODIUM_FOUND SODIUM_LIBRARIES SODIUM_INCLUDE_DIRS)

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,24 +1,25 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
 
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
-	client_version.cpp
+	cli/eqemu_command_handler.cpp
+	compression.cpp
 	condition.cpp
+	content/world_content_service.cpp
 	crash.cpp
 	crc16.cpp
 	crc32.cpp
+	database/database_dump_service.cpp
 	database.cpp
 	database_conversions.cpp
 	database_instances.cpp
 	dbcore.cpp
 	deity.cpp
 	emu_constants.cpp
-	emu_legacy.cpp
 	emu_limits.cpp
 	emu_opcodes.cpp
-	emu_tcp_connection.cpp
-	emu_tcp_server.cpp
+	emu_versions.cpp
 	eqdb.cpp
 	eqdb_res.cpp
 	eqemu_exception.cpp
@@ -26,21 +27,25 @@ SET(common_sources
 	eqemu_logsys.cpp
 	eq_limits.cpp
 	eq_packet.cpp
-	eq_stream.cpp
-	eq_stream_factory.cpp
 	eq_stream_ident.cpp
 	eq_stream_proxy.cpp
 	eqtime.cpp
+	event_sub.cpp
 	extprofile.cpp
 	faction.cpp
+	file_util.cpp
 	guild_base.cpp
 	guilds.cpp
-	inventory_version.cpp
+	inventory_profile.cpp
+	inventory_slot.cpp
 	ipc_mutex.cpp
-	item.cpp
-	item_struct.cpp
+	ip_util.cpp
+	item_data.cpp
+	item_instance.cpp
+	json_config.cpp
 	light_source.cpp
 	md5.cpp
+	memory_buffer.cpp
 	memory_mapped_file.cpp
 	misc.cpp
 	misc_functions.cpp
@@ -55,25 +60,38 @@ SET(common_sources
 	perl_eqdb.cpp
 	perl_eqdb_res.cpp
 	proc_launcher.cpp
+	profanity_manager.cpp
 	ptimer.cpp
 	races.cpp
 	rdtsc.cpp
 	rulesys.cpp
 	say_link.cpp
+	serialize_buffer.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
 	spdat.cpp
 	string_util.cpp
 	struct_strategy.cpp
-	tcp_connection.cpp
-	tcp_server.cpp
-	timeoutmgr.cpp
+	textures.cpp
 	timer.cpp
 	unix.cpp
-	worldconn.cpp
-	xml_parser.cpp
 	platform.cpp
+	json/jsoncpp.cpp
+	net/console_server.cpp
+	net/console_server_connection.cpp
+	net/crc32.cpp
+	net/daybreak_connection.cpp
+	net/eqstream.cpp
+	net/packet.cpp
+	net/servertalk_client_connection.cpp
+	net/servertalk_legacy_client_connection.cpp
+	net/servertalk_server.cpp
+	net/servertalk_server_connection.cpp
+	net/tcp_connection.cpp
+	net/tcp_server.cpp
+	net/websocket_server.cpp
+	net/websocket_server_connection.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sod_limits.cpp
@@ -87,22 +105,333 @@ SET(common_sources
 	patches/titanium_limits.cpp
 	patches/uf.cpp
 	patches/uf_limits.cpp
-	SocketLib/Base64.cpp
-	SocketLib/File.cpp
-	SocketLib/HttpdCookies.cpp
-	SocketLib/HttpdForm.cpp
-	SocketLib/HttpdSocket.cpp
-	SocketLib/HTTPSocket.cpp
-	SocketLib/MemFile.cpp
-	SocketLib/Mime.cpp
-	SocketLib/Parse.cpp
-	SocketLib/socket_include.cpp
-	SocketLib/Utility.cpp
 	StackWalker/StackWalker.cpp
-	tinyxml/tinystr.cpp
-	tinyxml/tinyxml.cpp
-	tinyxml/tinyxmlerror.cpp
-	tinyxml/tinyxmlparser.cpp
+	util/directory.cpp
+	util/uuid.cpp)
+
+SET(repositories
+
+	# Criteria
+	repositories/criteria/content_filter_criteria.h
+
+	# Base Repositories
+	repositories/base/base_aa_ability_repository.h
+	repositories/base/base_aa_ranks_repository.h
+	repositories/base/base_aa_rank_effects_repository.h
+	repositories/base/base_aa_rank_prereqs_repository.h
+	repositories/base/base_account_repository.h
+	repositories/base/base_account_flags_repository.h
+	repositories/base/base_account_ip_repository.h
+	repositories/base/base_account_rewards_repository.h
+	repositories/base/base_adventure_details_repository.h
+	repositories/base/base_adventure_members_repository.h
+	repositories/base/base_adventure_stats_repository.h
+	repositories/base/base_adventure_template_repository.h
+	repositories/base/base_adventure_template_entry_repository.h
+	repositories/base/base_adventure_template_entry_flavor_repository.h
+	repositories/base/base_alternate_currency_repository.h
+	repositories/base/base_auras_repository.h
+	repositories/base/base_base_data_repository.h
+	repositories/base/base_blocked_spells_repository.h
+	repositories/base/base_bugs_repository.h
+	repositories/base/base_bug_reports_repository.h
+	repositories/base/base_buyer_repository.h
+	repositories/base/base_character_activities_repository.h
+	repositories/base/base_character_alternate_abilities_repository.h
+	repositories/base/base_character_alt_currency_repository.h
+	repositories/base/base_character_auras_repository.h
+	repositories/base/base_character_bandolier_repository.h
+	repositories/base/base_character_bind_repository.h
+	repositories/base/base_character_buffs_repository.h
+	repositories/base/base_character_corpses_repository.h
+	repositories/base/base_character_corpse_items_repository.h
+	repositories/base/base_character_currency_repository.h
+	repositories/base/base_character_data_repository.h
+	repositories/base/base_character_disciplines_repository.h
+	repositories/base/base_character_inspect_messages_repository.h
+	repositories/base/base_character_item_recast_repository.h
+	repositories/base/base_character_languages_repository.h
+	repositories/base/base_character_leadership_abilities_repository.h
+	repositories/base/base_character_material_repository.h
+	repositories/base/base_character_memmed_spells_repository.h
+	repositories/base/base_character_pet_buffs_repository.h
+	repositories/base/base_character_pet_info_repository.h
+	repositories/base/base_character_pet_inventory_repository.h
+	repositories/base/base_character_potionbelt_repository.h
+	repositories/base/base_character_skills_repository.h
+	repositories/base/base_character_spells_repository.h
+	repositories/base/base_character_tasks_repository.h
+	repositories/base/base_char_create_combinations_repository.h
+	repositories/base/base_char_create_point_allocations_repository.h
+	repositories/base/base_char_recipe_list_repository.h
+	repositories/base/base_completed_tasks_repository.h
+	repositories/base/base_content_flags_repository.h
+	repositories/base/base_data_buckets_repository.h
+	repositories/base/base_db_str_repository.h
+	repositories/base/base_discovered_items_repository.h
+	repositories/base/base_doors_repository.h
+	repositories/base/base_eventlog_repository.h
+	repositories/base/base_faction_base_data_repository.h
+	repositories/base/base_faction_list_repository.h
+	repositories/base/base_faction_list_mod_repository.h
+	repositories/base/base_faction_values_repository.h
+	repositories/base/base_fishing_repository.h
+	repositories/base/base_forage_repository.h
+	repositories/base/base_friends_repository.h
+	repositories/base/base_global_loot_repository.h
+	repositories/base/base_gm_ips_repository.h
+	repositories/base/base_goallists_repository.h
+	repositories/base/base_graveyard_repository.h
+	repositories/base/base_grid_repository.h
+	repositories/base/base_grid_entries_repository.h
+	repositories/base/base_ground_spawns_repository.h
+	repositories/base/base_group_id_repository.h
+	repositories/base/base_group_leaders_repository.h
+	repositories/base/base_guilds_repository.h
+	repositories/base/base_guild_members_repository.h
+	repositories/base/base_guild_ranks_repository.h
+	repositories/base/base_guild_relations_repository.h
+	repositories/base/base_hackers_repository.h
+	repositories/base/base_instance_list_repository.h
+	repositories/base/base_instance_list_player_repository.h
+	repositories/base/base_inventory_repository.h
+	repositories/base/base_inventory_snapshots_repository.h
+	repositories/base/base_ip_exemptions_repository.h
+	repositories/base/base_items_repository.h
+	repositories/base/base_item_tick_repository.h
+	repositories/base/base_ldon_trap_entries_repository.h
+	repositories/base/base_ldon_trap_templates_repository.h
+	repositories/base/base_level_exp_mods_repository.h
+	repositories/base/base_lfguild_repository.h
+	repositories/base/base_login_accounts_repository.h
+	repositories/base/base_login_api_tokens_repository.h
+	repositories/base/base_login_server_admins_repository.h
+	repositories/base/base_login_server_list_types_repository.h
+	repositories/base/base_login_world_servers_repository.h
+	repositories/base/base_logsys_categories_repository.h
+	repositories/base/base_lootdrop_repository.h
+	repositories/base/base_lootdrop_entries_repository.h
+	repositories/base/base_loottable_repository.h
+	repositories/base/base_loottable_entries_repository.h
+	repositories/base/base_mail_repository.h
+	repositories/base/base_merchantlist_repository.h
+	repositories/base/base_merchantlist_temp_repository.h
+	repositories/base/base_name_filter_repository.h
+	repositories/base/base_npc_emotes_repository.h
+	repositories/base/base_npc_faction_repository.h
+	repositories/base/base_npc_faction_entries_repository.h
+	repositories/base/base_npc_scale_global_base_repository.h
+	repositories/base/base_npc_spells_repository.h
+	repositories/base/base_npc_spells_effects_repository.h
+	repositories/base/base_npc_spells_effects_entries_repository.h
+	repositories/base/base_npc_spells_entries_repository.h
+	repositories/base/base_npc_types_repository.h
+	repositories/base/base_npc_types_tint_repository.h
+	repositories/base/base_object_repository.h
+	repositories/base/base_object_contents_repository.h
+	repositories/base/base_perl_event_export_settings_repository.h
+	repositories/base/base_petitions_repository.h
+	repositories/base/base_pets_repository.h
+	repositories/base/base_pets_equipmentset_repository.h
+	repositories/base/base_pets_equipmentset_entries_repository.h
+	repositories/base/base_player_titlesets_repository.h
+	repositories/base/base_proximities_repository.h
+	repositories/base/base_quest_globals_repository.h
+	repositories/base/base_raid_details_repository.h
+	repositories/base/base_raid_members_repository.h
+	repositories/base/base_reports_repository.h
+	repositories/base/base_respawn_times_repository.h
+	repositories/base/base_rule_sets_repository.h
+	repositories/base/base_rule_values_repository.h
+	repositories/base/base_saylink_repository.h
+	repositories/base/base_skill_caps_repository.h
+	repositories/base/base_spawn2_repository.h
+	repositories/base/base_spawnentry_repository.h
+	repositories/base/base_spawngroup_repository.h
+	repositories/base/base_spawn_conditions_repository.h
+	repositories/base/base_spawn_condition_values_repository.h
+	repositories/base/base_spawn_events_repository.h
+	repositories/base/base_spells_new_repository.h
+	repositories/base/base_spell_buckets_repository.h
+	repositories/base/base_spell_globals_repository.h
+	repositories/base/base_starting_items_repository.h
+	repositories/base/base_start_zones_repository.h
+	repositories/base/base_tasks_repository.h
+	repositories/base/base_tasksets_repository.h
+	repositories/base/base_task_activities_repository.h
+	repositories/base/base_timers_repository.h
+	repositories/base/base_titles_repository.h
+	repositories/base/base_trader_repository.h
+	repositories/base/base_tradeskill_recipe_repository.h
+	repositories/base/base_tradeskill_recipe_entries_repository.h
+	repositories/base/base_traps_repository.h
+	repositories/base/base_tributes_repository.h
+	repositories/base/base_tribute_levels_repository.h
+	repositories/base/base_variables_repository.h
+	repositories/base/base_veteran_reward_templates_repository.h
+	repositories/base/base_zone_repository.h
+	repositories/base/base_zone_points_repository.h
+
+	# Extended Repositories
+	repositories/aa_ability_repository.h
+	repositories/aa_ranks_repository.h
+	repositories/aa_rank_effects_repository.h
+	repositories/aa_rank_prereqs_repository.h
+	repositories/account_repository.h
+	repositories/account_flags_repository.h
+	repositories/account_ip_repository.h
+	repositories/account_rewards_repository.h
+	repositories/adventure_details_repository.h
+	repositories/adventure_members_repository.h
+	repositories/adventure_stats_repository.h
+	repositories/adventure_template_repository.h
+	repositories/adventure_template_entry_repository.h
+	repositories/adventure_template_entry_flavor_repository.h
+	repositories/alternate_currency_repository.h
+	repositories/auras_repository.h
+	repositories/base_data_repository.h
+	repositories/blocked_spells_repository.h
+	repositories/bugs_repository.h
+	repositories/bug_reports_repository.h
+	repositories/buyer_repository.h
+	repositories/character_activities_repository.h
+	repositories/character_alternate_abilities_repository.h
+	repositories/character_alt_currency_repository.h
+	repositories/character_auras_repository.h
+	repositories/character_bandolier_repository.h
+	repositories/character_bind_repository.h
+	repositories/character_buffs_repository.h
+	repositories/character_corpses_repository.h
+	repositories/character_corpse_items_repository.h
+	repositories/character_currency_repository.h
+	repositories/character_data_repository.h
+	repositories/character_disciplines_repository.h
+	repositories/character_inspect_messages_repository.h
+	repositories/character_item_recast_repository.h
+	repositories/character_languages_repository.h
+	repositories/character_leadership_abilities_repository.h
+	repositories/character_material_repository.h
+	repositories/character_memmed_spells_repository.h
+	repositories/character_pet_buffs_repository.h
+	repositories/character_pet_info_repository.h
+	repositories/character_pet_inventory_repository.h
+	repositories/character_potionbelt_repository.h
+	repositories/character_skills_repository.h
+	repositories/character_spells_repository.h
+	repositories/character_tasks_repository.h
+	repositories/char_create_combinations_repository.h
+	repositories/char_create_point_allocations_repository.h
+	repositories/char_recipe_list_repository.h
+	repositories/completed_tasks_repository.h
+	repositories/content_flags_repository.h
+	repositories/data_buckets_repository.h
+	repositories/db_str_repository.h
+	repositories/discovered_items_repository.h
+	repositories/doors_repository.h
+	repositories/eventlog_repository.h
+	repositories/faction_base_data_repository.h
+	repositories/faction_list_repository.h
+	repositories/faction_list_mod_repository.h
+	repositories/faction_values_repository.h
+	repositories/fishing_repository.h
+	repositories/forage_repository.h
+	repositories/friends_repository.h
+	repositories/global_loot_repository.h
+	repositories/gm_ips_repository.h
+	repositories/goallists_repository.h
+	repositories/graveyard_repository.h
+	repositories/grid_repository.h
+	repositories/grid_entries_repository.h
+	repositories/ground_spawns_repository.h
+	repositories/group_id_repository.h
+	repositories/group_leaders_repository.h
+	repositories/guilds_repository.h
+	repositories/guild_members_repository.h
+	repositories/guild_ranks_repository.h
+	repositories/guild_relations_repository.h
+	repositories/hackers_repository.h
+	repositories/instance_list_repository.h
+	repositories/instance_list_player_repository.h
+	repositories/inventory_repository.h
+	repositories/inventory_snapshots_repository.h
+	repositories/ip_exemptions_repository.h
+	repositories/items_repository.h
+	repositories/item_tick_repository.h
+	repositories/ldon_trap_entries_repository.h
+	repositories/ldon_trap_templates_repository.h
+	repositories/level_exp_mods_repository.h
+	repositories/lfguild_repository.h
+	repositories/login_accounts_repository.h
+	repositories/login_api_tokens_repository.h
+	repositories/login_server_admins_repository.h
+	repositories/login_server_list_types_repository.h
+	repositories/login_world_servers_repository.h
+	repositories/logsys_categories_repository.h
+	repositories/lootdrop_repository.h
+	repositories/lootdrop_entries_repository.h
+	repositories/loottable_repository.h
+	repositories/loottable_entries_repository.h
+	repositories/mail_repository.h
+	repositories/merchantlist_repository.h
+	repositories/merchantlist_temp_repository.h
+	repositories/name_filter_repository.h
+	repositories/npc_emotes_repository.h
+	repositories/npc_faction_repository.h
+	repositories/npc_faction_entries_repository.h
+	repositories/npc_scale_global_base_repository.h
+	repositories/npc_spells_repository.h
+	repositories/npc_spells_effects_repository.h
+	repositories/npc_spells_effects_entries_repository.h
+	repositories/npc_spells_entries_repository.h
+	repositories/npc_types_repository.h
+	repositories/npc_types_tint_repository.h
+	repositories/object_repository.h
+	repositories/object_contents_repository.h
+	repositories/perl_event_export_settings_repository.h
+	repositories/petitions_repository.h
+	repositories/pets_repository.h
+	repositories/pets_equipmentset_repository.h
+	repositories/pets_equipmentset_entries_repository.h
+	repositories/player_titlesets_repository.h
+	repositories/proximities_repository.h
+	repositories/quest_globals_repository.h
+	repositories/raid_details_repository.h
+	repositories/raid_members_repository.h
+	repositories/reports_repository.h
+	repositories/respawn_times_repository.h
+	repositories/rule_sets_repository.h
+	repositories/rule_values_repository.h
+	repositories/saylink_repository.h
+	repositories/skill_caps_repository.h
+	repositories/spawn2_repository.h
+	repositories/spawnentry_repository.h
+	repositories/spawngroup_repository.h
+	repositories/spawn_conditions_repository.h
+	repositories/spawn_condition_values_repository.h
+	repositories/spawn_events_repository.h
+	repositories/spells_new_repository.h
+	repositories/spell_buckets_repository.h
+	repositories/spell_globals_repository.h
+	repositories/starting_items_repository.h
+	repositories/start_zones_repository.h
+	repositories/tasks_repository.h
+	repositories/tasksets_repository.h
+	repositories/task_activities_repository.h
+	repositories/timers_repository.h
+	repositories/titles_repository.h
+	repositories/trader_repository.h
+	repositories/tradeskill_recipe_repository.h
+	repositories/tradeskill_recipe_entries_repository.h
+	repositories/traps_repository.h
+	repositories/tributes_repository.h
+	repositories/tribute_levels_repository.h
+	repositories/variables_repository.h
+	repositories/veteran_reward_templates_repository.h
+	repositories/zone_repository.h
+	repositories/zone_points_repository.h
+
+	# Non-Comformative
+	repositories/character_recipe_list_repository.h
 )
 
 SET(common_headers
@@ -111,22 +440,26 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
-	client_version.h
+	compression.h
 	condition.h
+	content/world_content_service.h
 	crash.h
 	crc16.h
 	crc32.h
+	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
-	emu_legacy.h
 	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
-	emu_tcp_connection.h
-	emu_tcp_server.h
+	emu_versions.h
 	eq_constants.h
 	eq_packet_structs.h
 	eqdb.h
@@ -135,36 +468,41 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
+	eqemu_logsys_log_aliases.h
 	eq_limits.h
 	eq_packet.h
-	eq_stream.h
-	eq_stream_factory.h
 	eq_stream_ident.h
 	eq_stream_intf.h
 	eq_stream_locator.h
 	eq_stream_proxy.h
-	eq_stream_type.h
 	eqtime.h
 	errmsg.h
+	event_sub.h
 	extprofile.h
 	faction.h
+	file_util.h
 	features.h
 	fixed_memory_hash_set.h
 	fixed_memory_variable_hash_set.h
 	global_define.h
 	guild_base.h
 	guilds.h
-	inventory_version.h
+	http/httplib.h
+	inventory_profile.h
+	inventory_slot.h
 	ipc_mutex.h
-	item.h
+	ip_util.h
+	item_data.h
 	item_fieldlist.h
-	item_struct.h
+	item_instance.h
+	json_config.h
 	languages.h
 	light_source.h
 	linked_list.h
 	loottable.h
 	mail_oplist.h
 	md5.h
+	memory_buffer.h
 	memory_mapped_file.h
 	misc.h
 	misc_functions.h
@@ -179,6 +517,7 @@ SET(common_headers
 	packet_functions.h
 	platform.h
 	proc_launcher.h
+	profanity_manager.h
 	profiler.h
 	ptimer.h
 	queue.h
@@ -189,6 +528,7 @@ SET(common_headers
 	ruletypes.h
 	say_link.h
 	seperator.h
+	serialize_buffer.h
 	serverinfo.h
 	servertalk.h
 	shareddb.h
@@ -196,105 +536,144 @@ SET(common_headers
 	spdat.h
     string_util.h
 	struct_strategy.h
-	tcp_basic_server.h
-	tcp_connection.h
-	tcp_server.h
-	timeoutmgr.h
+	textures.h
 	timer.h
 	types.h
 	unix.h
 	useperl.h
 	version.h
-	worldconn.h
-	xml_parser.h
 	zone_numbers.h
+	event/event_loop.h
+	event/task.h
+	event/timer.h
+	json/json.h
+	json/json-forwards.h
+	net/console_server.h
+	net/console_server_connection.h
+	net/crc32.h
+	net/daybreak_connection.h
+	net/daybreak_structs.h
+	net/dns.h
+	net/endian.h
+	net/eqstream.h
+	net/packet.h
+	net/servertalk_client_connection.h
+	net/servertalk_legacy_client_connection.h
+	net/servertalk_common.h
+	net/servertalk_server.h
+	net/servertalk_server_connection.h
+	net/tcp_connection.h
+	net/tcp_server.h
+	net/websocket_server.h
+	net/websocket_server_connection.h
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
 	patches/sod_limits.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-#	patches/sof_itemfields.h
 	patches/sof_limits.h
-#	patches/sof_opcode_list.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-#	patches/rof_itemfields.h
 	patches/rof_limits.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
 	patches/rof2_limits.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-#	patches/titanium_itemfields_a.h
-#	patches/titanium_itemfields_b.h
 	patches/titanium_limits.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
-	SocketLib/Base64.h
-	SocketLib/File.h
-	SocketLib/HttpdCookies.h
-	SocketLib/HttpdForm.h
-	SocketLib/HttpdSocket.h
-	SocketLib/HTTPSocket.h
-	SocketLib/IFile.h
-	SocketLib/MemFile.h
-	SocketLib/Mime.h
-	SocketLib/Parse.h
-	SocketLib/socket_include.h
-	SocketLib/Utility.h
 	StackWalker/StackWalker.h
-	tinyxml/tinystr.h
-	tinyxml/tinyxml.h
+	util/memory_stream.h
+	util/directory.h
+	util/uuid.h)
+
+SOURCE_GROUP(Event FILES
+	event/event_loop.h
+	event/timer.h
+	event/task.h
+)
+
+SOURCE_GROUP(Json FILES
+	json/json.h
+	json/jsoncpp.cpp
+	json/json-forwards.h
+)
+
+SOURCE_GROUP(Net FILES
+	net/console_server.cpp
+	net/console_server.h
+	net/console_server_connection.cpp
+	net/console_server_connection.h
+	net/crc32.cpp
+	net/crc32.h
+	net/daybreak_connection.cpp
+	net/daybreak_connection.h
+	net/daybreak_structs.h
+	net/dns.h
+	net/endian.h
+	net/eqmq.cpp
+	net/eqmq.h
+	net/eqstream.cpp
+	net/eqstream.h
+	net/packet.cpp
+	net/packet.h
+	net/servertalk_client_connection.cpp
+	net/servertalk_client_connection.h
+	net/servertalk_legacy_client_connection.cpp
+	net/servertalk_legacy_client_connection.h
+	net/servertalk_common.h
+	net/servertalk_server.cpp
+	net/servertalk_server.h
+	net/servertalk_server_connection.cpp
+	net/servertalk_server_connection.h
+	net/tcp_connection.cpp
+	net/tcp_connection.h
+	net/tcp_server.cpp
+	net/tcp_server.h
+	net/websocket_server.cpp
+	net/websocket_server.h
+	net/websocket_server_connection.cpp
+	net/websocket_server_connection.h
 )
 
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
 	patches/sod_limits.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-#	patches/sof_itemfields.h
 	patches/sof_limits.h
-#	patches/sof_opcode_list.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-#	patches/rof_itemfields.h
 	patches/rof_limits.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
 	patches/rof2_limits.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-#	patches/titanium_itemfields_a.h
-#	patches/titanium_itemfields_b.h
 	patches/titanium_limits.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
@@ -313,52 +692,24 @@ SOURCE_GROUP(Patches FILES
 	patches/uf_limits.cpp
 )
 
-SOURCE_GROUP(SocketLib FILES
-	SocketLib/Base64.h
-	SocketLib/File.h
-	SocketLib/HttpdCookies.h
-	SocketLib/HttpdForm.h
-	SocketLib/HttpdSocket.h
-	SocketLib/HTTPSocket.h
-	SocketLib/IFile.h
-	SocketLib/MemFile.h
-	SocketLib/Mime.h
-	SocketLib/Parse.h
-	SocketLib/socket_include.h
-	SocketLib/Utility.h
-	SocketLib/Base64.cpp
-	SocketLib/File.cpp
-	SocketLib/HttpdCookies.cpp
-	SocketLib/HttpdForm.cpp
-	SocketLib/HttpdSocket.cpp
-	SocketLib/HTTPSocket.cpp
-	SocketLib/MemFile.cpp
-	SocketLib/Mime.cpp
-	SocketLib/Parse.cpp
-	SocketLib/socket_include.cpp
-	SocketLib/Utility.cpp
-)
-
 SOURCE_GROUP(StackWalker FILES
 	StackWalker/StackWalker.h
 	StackWalker/StackWalker.cpp
 )
 
-SOURCE_GROUP(TinyXML FILES
-	tinyxml/tinystr.h
-	tinyxml/tinyxml.h
-	tinyxml/tinystr.cpp
-	tinyxml/tinyxml.cpp
-	tinyxml/tinyxmlerror.cpp
-	tinyxml/tinyxmlparser.cpp
+SOURCE_GROUP(Util FILES
+	util/memory_stream.h
+	util/directory.cpp
+	util/directory.h
+	util/uuid.cpp
+	util/uuid.h
 )
 
-INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
+INCLUDE_DIRECTORIES(Patches SocketLib StackWalker)
 
-ADD_LIBRARY(common ${common_sources} ${common_headers})
+ADD_LIBRARY(common ${common_sources} ${common_headers} ${repositories})
 
 IF(UNIX)
-	ADD_DEFINITIONS(-fPIC)
 	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)
 	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp"  "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)

common/any.h

@@ -24,7 +24,7 @@
  *  DEALINGS IN THE SOFTWARE.
  */
 
-// EQEmu::Any is a modified version of Boost::Any and as such retains the Boost licensing.
+// EQ::Any is a modified version of Boost::Any and as such retains the Boost licensing.
 
 #ifndef EQEMU_COMMON_ANY_H
 #define EQEMU_COMMON_ANY_H
@@ -32,7 +32,7 @@
 #include <algorithm>
 #include <typeinfo>
 
-namespace EQEmu
+namespace EQ
 {
 	class Any
 	{

common/base_data.h

@@ -24,8 +24,8 @@ struct BaseDataStruct
 	double base_hp;
 	double base_mana;
 	double base_end;
-	double unk1;
-	double unk2;
+	double hp_regen;
+	double end_regen;
 	double hp_factor;
 	double mana_factor;
 	double endurance_factor;

common/base_packet.cpp

@@ -39,6 +39,18 @@ BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 	}
 }
 
+BasePacket::BasePacket(SerializeBuffer &buf)
+{
+	pBuffer = buf.m_buffer;
+	buf.m_buffer = nullptr;
+	size = buf.m_pos;
+	buf.m_pos = 0;
+	buf.m_capacity = 0;
+	_wpos = 0;
+	_rpos = 0;
+	timestamp.tv_sec = 0;
+}
+
 BasePacket::~BasePacket()
 {
 	if (pBuffer)

common/base_packet.h

@@ -19,6 +19,7 @@
 #define BASEPACKET_H_
 
 #include "types.h"
+#include "serialize_buffer.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -63,6 +64,8 @@ public:
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }
 	void WriteDouble(double value) { *(double *)(pBuffer + _wpos) = value; _wpos += sizeof(double); }
 	void WriteString(const char * str) { uint32 len = static_cast<uint32>(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; }
+	// this is used in task system a lot, it is NOT null-termed
+	void WriteLengthString(uint32 len, const char *str) { *(uint32 *)(pBuffer + _wpos) = len; _wpos += sizeof(uint32); memcpy(pBuffer + _wpos, str, len); _wpos += len; }
 	void WriteData(const void *ptr, size_t n) { memcpy(pBuffer + _wpos, ptr, n); _wpos += n; }
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
@@ -72,6 +75,7 @@ public:
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }
+	void ReadString(std::string &str) { str = reinterpret_cast<char *>(pBuffer + _rpos); _rpos += str.length() + 1; }
 	void ReadString(char *str, uint32 Offset, uint32 MaxLength) const;
 
 	uint32 GetWritePosition() { return _wpos; }
@@ -83,6 +87,7 @@ protected:
 	virtual ~BasePacket();
 	BasePacket() { pBuffer=nullptr; size=0; _wpos = 0; _rpos = 0; }
 	BasePacket(const unsigned char *buf, const uint32 len);
+	BasePacket(SerializeBuffer &buf);
 };
 
 extern void DumpPacketHex(const BasePacket* app);

common/bodytypes.h

@@ -35,6 +35,7 @@ typedef enum {
 	BT_Greater_Akheva	= 14,
 	BT_Khati_Sha		= 15,
 	BT_Seru				= 16,	//not confirmed....
+	BT_Draz_Nurakk      = 18,
 	BT_Zek				= 19,
 	BT_Luggald			= 20,
 	BT_Animal			= 21,

common/classes.h

@@ -61,6 +61,7 @@
 #define CORPSE_CLASS 62	// only seen on Danvi's Corpse in Akheva so far..
 #define TRIBUTE_MASTER 63
 #define GUILD_TRIBUTE_MASTER 64	// not sure
+#define GUILD_BANKER 66
 #define NORRATHS_KEEPERS_MERCHANT 67
 #define DARK_REIGN_MERCHANT 68
 #define FELLOWSHIP_MASTER 69
@@ -135,6 +136,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/argh.h

@@ -0,0 +1,434 @@
+#pragma once
+
+#include <algorithm>
+#include <sstream>
+#include <limits>
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+#include <cassert>
+
+namespace argh
+{
+	// Terminology:
+	// A command line is composed of 2 types of args:
+	// 1. Positional args, i.e. free standing values
+	// 2. Options: args beginning with '-'. We identify two kinds:
+	//    2.1: Flags: boolean options =>  (exist ? true : false)
+	//    2.2: Parameters: a name followed by a non-option value
+
+#if !defined(__GNUC__) || (__GNUC__ >= 5)
+	using string_stream = std::istringstream;
+#else
+	// Until GCC 5, istringstream did not have a move constructor.
+	// stringstream_proxy is used instead, as a workaround.
+	class stringstream_proxy
+	{
+	public:
+		stringstream_proxy() = default;
+
+		// Construct with a value.
+		stringstream_proxy(std::string const& value) :
+			stream_(value)
+		{}
+
+		// Copy constructor.
+		stringstream_proxy(const stringstream_proxy& other) :
+			stream_(other.stream_.str())
+		{
+			stream_.setstate(other.stream_.rdstate());
+		}
+
+		void setstate(std::ios_base::iostate state) { stream_.setstate(state); }
+
+		// Stream out the value of the parameter.
+		// If the conversion was not possible, the stream will enter the fail state,
+		// and operator bool will return false.
+		template<typename T>
+		stringstream_proxy& operator >> (T& thing)
+		{
+			stream_ >> thing;
+			return *this;
+		}
+
+
+		// Get the string value.
+		std::string str() const { return stream_.str(); }
+
+		std::stringbuf* rdbuf() const { return stream_.rdbuf(); }
+
+		// Check the state of the stream.
+		// False when the most recent stream operation failed
+		operator bool() const { return !!stream_; }
+
+		~stringstream_proxy() = default;
+	private:
+		std::istringstream stream_;
+	};
+	using string_stream = stringstream_proxy;
+#endif
+
+	class parser
+	{
+	public:
+		enum Mode { PREFER_FLAG_FOR_UNREG_OPTION = 1 << 0,
+					PREFER_PARAM_FOR_UNREG_OPTION = 1 << 1,
+					NO_SPLIT_ON_EQUALSIGN = 1 << 2,
+					SINGLE_DASH_IS_MULTIFLAG = 1 << 3,
+		};
+
+		parser() = default;
+
+		parser(std::initializer_list<char const* const> pre_reg_names)
+		{  add_params(pre_reg_names); }
+
+		parser(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
+		{  parse(argv, mode); }
+
+		parser(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
+		{  parse(argc, argv, mode); }
+
+		void add_param(std::string const& name);
+		void add_params(std::initializer_list<char const* const> init_list);
+
+		void parse(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
+		void parse(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
+
+		std::multiset<std::string>          const& flags()    const { return flags_;    }
+		std::map<std::string, std::string>  const& params()   const { return params_;   }
+		std::vector<std::string>            const& pos_args() const { return pos_args_; }
+
+		// begin() and end() for using range-for over positional args.
+		std::vector<std::string>::const_iterator begin() const { return pos_args_.cbegin(); }
+		std::vector<std::string>::const_iterator end()   const { return pos_args_.cend();   }
+		size_t size()                                    const { return pos_args_.size();   }
+
+		//////////////////////////////////////////////////////////////////////////
+		// Accessors
+
+		// flag (boolean) accessors: return true if the flag appeared, otherwise false.
+		bool operator[](std::string const& name) const;
+
+		// multiple flag (boolean) accessors: return true if at least one of the flag appeared, otherwise false.
+		bool operator[](std::initializer_list<char const* const> init_list) const;
+
+		// returns positional arg string by order. Like argv[] but without the options
+		std::string const& operator[](size_t ind) const;
+
+		// returns a std::istream that can be used to convert a positional arg to a typed value.
+		string_stream operator()(size_t ind) const;
+
+		// same as above, but with a default value in case the arg is missing (index out of range).
+		template<typename T>
+		string_stream operator()(size_t ind, T&& def_val) const;
+
+		// parameter accessors, give a name get an std::istream that can be used to convert to a typed value.
+		// call .str() on result to get as string
+		string_stream operator()(std::string const& name) const;
+
+		// accessor for a parameter with multiple names, give a list of names, get an std::istream that can be used to convert to a typed value.
+		// call .str() on result to get as string
+		// returns the first value in the list to be found.
+		string_stream operator()(std::initializer_list<char const* const> init_list) const;
+
+		// same as above, but with a default value in case the param was missing.
+		// Non-string def_val types must have an operator<<() (output stream operator)
+		// If T only has an input stream operator, pass the string version of the type as in "3" instead of 3.
+		template<typename T>
+		string_stream operator()(std::string const& name, T&& def_val) const;
+
+		// same as above but for a list of names. returns the first value to be found.
+		template<typename T>
+		string_stream operator()(std::initializer_list<char const* const> init_list, T&& def_val) const;
+
+	private:
+		string_stream bad_stream() const;
+		std::string trim_leading_dashes(std::string const& name) const;
+		bool is_number(std::string const& arg) const;
+		bool is_option(std::string const& arg) const;
+		bool got_flag(std::string const& name) const;
+		bool is_param(std::string const& name) const;
+
+	private:
+		std::vector<std::string> args_;
+		std::map<std::string, std::string> params_;
+		std::vector<std::string> pos_args_;
+		std::multiset<std::string> flags_;
+		std::set<std::string> registeredParams_;
+		std::string empty_;
+	};
+
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::parse(const char * const argv[], int mode)
+	{
+		int argc = 0;
+		for (auto argvp = argv; *argvp; ++argc, ++argvp);
+		parse(argc, argv, mode);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::parse(int argc, const char* const argv[], int mode /*= PREFER_FLAG_FOR_UNREG_OPTION*/)
+	{
+		// convert to strings
+		args_.resize(argc);
+		std::transform(argv, argv + argc, args_.begin(), [](const char* const arg) { return arg;  });
+
+		// parse line
+		for (auto i = 0u; i < args_.size(); ++i)
+		{
+			if (!is_option(args_[i]))
+			{
+				pos_args_.emplace_back(args_[i]);
+				continue;
+			}
+
+			auto name = trim_leading_dashes(args_[i]);
+
+			if (!(mode & NO_SPLIT_ON_EQUALSIGN))
+			{
+				auto equalPos = name.find('=');
+				if (equalPos != std::string::npos)
+				{
+					params_.insert({ name.substr(0, equalPos), name.substr(equalPos + 1) });
+					continue;
+				}
+			}
+
+			// if the option is unregistered and should be a multi-flag
+			if (1 == (args_[i].size() - name.size()) &&         // single dash
+				argh::parser::SINGLE_DASH_IS_MULTIFLAG & mode && // multi-flag mode
+				!is_param(name))                                  // unregistered
+			{
+				std::string keep_param;
+
+				if (!name.empty() && is_param(std::string(1ul, name.back()))) // last char is param
+				{
+					keep_param += name.back();
+					name.resize(name.size() - 1);
+				}
+
+				for (auto const& c : name)
+				{
+					flags_.emplace(std::string{ c });
+				}
+
+				if (!keep_param.empty())
+				{
+					name = keep_param;
+				}
+				else
+				{
+					continue; // do not consider other options for this arg
+				}
+			}
+
+			// any potential option will get as its value the next arg, unless that arg is an option too
+			// in that case it will be determined a flag.
+			if (i == args_.size() - 1 || is_option(args_[i + 1]))
+			{
+				flags_.emplace(name);
+				continue;
+			}
+
+			// if 'name' is a pre-registered option, then the next arg cannot be a free parameter to it is skipped
+			// otherwise we have 2 modes:
+			// PREFER_FLAG_FOR_UNREG_OPTION: a non-registered 'name' is determined a flag.
+			//                               The following value (the next arg) will be a free parameter.
+			//
+			// PREFER_PARAM_FOR_UNREG_OPTION: a non-registered 'name' is determined a parameter, the next arg
+			//                                will be the value of that option.
+
+			assert(!(mode & argh::parser::PREFER_FLAG_FOR_UNREG_OPTION)
+				   || !(mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION));
+
+			bool preferParam = mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION;
+
+			if (is_param(name) || preferParam)
+			{
+				params_.insert({ name, args_[i + 1] });
+				++i; // skip next value, it is not a free parameter
+				continue;
+			}
+			else
+			{
+				flags_.emplace(name);
+			}
+		};
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::bad_stream() const
+	{
+		string_stream bad;
+		bad.setstate(std::ios_base::failbit);
+		return bad;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::is_number(std::string const& arg) const
+	{
+		// inefficient but simple way to determine if a string is a number (which can start with a '-')
+		std::istringstream istr(arg);
+		double number;
+		istr >> number;
+		return !(istr.fail() || istr.bad());
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::is_option(std::string const& arg) const
+	{
+		assert(0 != arg.size());
+		if (is_number(arg))
+			return false;
+		return '-' == arg[0];
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline std::string parser::trim_leading_dashes(std::string const& name) const
+	{
+		auto pos = name.find_first_not_of('-');
+		return std::string::npos != pos ? name.substr(pos) : name;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool argh::parser::got_flag(std::string const& name) const
+	{
+		return flags_.end() != flags_.find(trim_leading_dashes(name));
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool argh::parser::is_param(std::string const& name) const
+	{
+		return registeredParams_.count(name);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::operator[](std::string const& name) const
+	{
+		return got_flag(name);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::operator[](std::initializer_list<char const* const> init_list) const
+	{
+		return std::any_of(init_list.begin(), init_list.end(), [&](char const* const name) { return got_flag(name); });
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline std::string const& parser::operator[](size_t ind) const
+	{
+		if (ind < pos_args_.size())
+			return pos_args_[ind];
+		return empty_;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(std::string const& name) const
+	{
+		auto optIt = params_.find(trim_leading_dashes(name));
+		if (params_.end() != optIt)
+			return string_stream(optIt->second);
+		return bad_stream();
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(std::initializer_list<char const* const> init_list) const
+	{
+		for (auto& name : init_list)
+		{
+			auto optIt = params_.find(trim_leading_dashes(name));
+			if (params_.end() != optIt)
+				return string_stream(optIt->second);
+		}
+		return bad_stream();
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	template<typename T>
+	string_stream parser::operator()(std::string const& name, T&& def_val) const
+	{
+		auto optIt = params_.find(trim_leading_dashes(name));
+		if (params_.end() != optIt)
+			return string_stream(optIt->second);
+
+		std::ostringstream ostr;
+		ostr.precision(std::numeric_limits<long double>::max_digits10);
+		ostr << def_val;
+		return string_stream(ostr.str()); // use default
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	// same as above but for a list of names. returns the first value to be found.
+	template<typename T>
+	string_stream parser::operator()(std::initializer_list<char const* const> init_list, T&& def_val) const
+	{
+		for (auto& name : init_list)
+		{
+			auto optIt = params_.find(trim_leading_dashes(name));
+			if (params_.end() != optIt)
+				return string_stream(optIt->second);
+		}
+		std::ostringstream ostr;
+		ostr.precision(std::numeric_limits<long double>::max_digits10);
+		ostr << def_val;
+		return string_stream(ostr.str()); // use default
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(size_t ind) const
+	{
+		if (pos_args_.size() <= ind)
+			return bad_stream();
+
+		return string_stream(pos_args_[ind]);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	template<typename T>
+	string_stream parser::operator()(size_t ind, T&& def_val) const
+	{
+		if (pos_args_.size() <= ind)
+		{
+			std::ostringstream ostr;
+			ostr.precision(std::numeric_limits<long double>::max_digits10);
+			ostr << def_val;
+			return string_stream(ostr.str());
+		}
+
+		return string_stream(pos_args_[ind]);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::add_param(std::string const& name)
+	{
+		registeredParams_.insert(trim_leading_dashes(name));
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::add_params(std::initializer_list<char const* const> init_list)
+	{
+		for (auto& name : init_list)
+			registeredParams_.insert(trim_leading_dashes(name));
+	}
+}

common/cli/eqemu_command_handler.cpp

@@ -0,0 +1,199 @@
+/**
+ * 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 <fmt/format.h>
+#include "eqemu_command_handler.h"
+#include "terminal_color.hpp"
+#include "../platform.h"
+
+namespace EQEmuCommand {
+
+	std::map<std::string, void (*)(
+		int argc,
+		char **argv,
+		argh::parser &cmd,
+		std::string &description
+	)> function_map;
+
+	/**
+	 * @param cmd
+	 */
+	void DisplayDebug(argh::parser &cmd)
+	{
+		if (cmd[{"-d", "--debug"}]) {
+			std::cout << "Positional args:\n";
+			for (auto &pos_arg : cmd.pos_args())
+				std::cout << '\t' << pos_arg << std::endl;
+
+			std::cout << "\nFlags:\n";
+			for (auto &flag : cmd.flags())
+				std::cout << '\t' << flag << std::endl;
+
+			std::cout << "\nParameters:\n";
+			for (auto &param : cmd.params())
+				std::cout << '\t' << param.first << " : " << param.second << std::endl;
+		}
+	}
+
+	/**
+	 * @param arguments
+	 * @param options
+	 * @param cmd
+	 * @param argc
+	 * @param argv
+	 */
+	void ValidateCmdInput(
+		std::vector<std::string> &arguments,
+		std::vector<std::string> &options,
+		argh::parser &cmd,
+		int argc,
+		char **argv
+	)
+	{
+		bool arguments_filled = true;
+
+		int index = 2;
+		for (auto &arg : arguments) {
+			if (cmd(arg).str().empty() && cmd(index).str().empty()) {
+				arguments_filled = false;
+			}
+			index++;
+		}
+
+		if (!arguments_filled || argc == 2 || cmd[{"-h", "--help"}]) {
+			std::string arguments_string;
+			for (auto &arg : arguments) {
+				arguments_string += " " + arg;
+			}
+
+			std::string options_string;
+			for (auto   &opt : options) {
+				options_string += "  " + opt + "\n";
+			}
+
+			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(0);
+		}
+	}
+
+	/**
+	 * @param in_function_map
+	 * @param cmd
+	 * @param argc
+	 * @param argv
+	 */
+	void HandleMenu(
+		std::map<std::string, void (*)(
+			int argc,
+			char **argv,
+			argh::parser &cmd,
+			std::string &description
+		)> &in_function_map,
+		argh::parser &cmd,
+		int argc,
+		char **argv
+	)
+	{
+		std::string description;
+		bool        ran_command = false;
+		for (auto   &it: in_function_map) {
+			if (it.first == argv[1]) {
+				(it.second)(argc, argv, cmd, description);
+				ran_command = true;
+			}
+		}
+
+		if (cmd[{"-h", "--help"}]) {
+			std::cout << std::endl;
+			std::cout <<
+					  "> " <<
+					  termcolor::yellow <<
+					  "EQEmulator [" + GetPlatformName() + "] CLI Menu" <<
+					  termcolor::reset
+					  << std::endl
+					  << std::endl;
+
+			/**
+			 * Get max command length for padding length
+			 */
+			int max_command_length = 0;
+
+			for (auto &it: in_function_map) {
+				std::stringstream command;
+				command << termcolor::colorize << termcolor::yellow << it.first << termcolor::reset;
+				if (command.str().length() > max_command_length) {
+					max_command_length = command.str().length() + 1;
+				}
+			}
+
+			/**
+			 * Display command menu
+			 */
+			std::string command_section;
+			for (auto   &it: in_function_map) {
+				description = "";
+
+				(it.second)(argc, argv, cmd, description);
+
+				/**
+				 * Print section header
+				 */
+				std::string command_prefix = it.first.substr(0, it.first.find(":"));
+
+				if (command_prefix.find("test") != std::string::npos) {
+					continue;
+				}
+
+				if (command_section != command_prefix) {
+					command_section = command_prefix;
+					std::cout << termcolor::reset << command_prefix << std::endl;
+				}
+
+				/**
+				 * Print commands
+				 */
+				std::stringstream command;
+				command << termcolor::colorize << termcolor::yellow << it.first << termcolor::reset;
+				printf("  %-*s %s\n", max_command_length, command.str().c_str(), description.c_str());
+			}
+
+			std::cout << std::endl;
+
+			std::exit(0);
+		}
+
+		if (ran_command) {
+			std::exit(0);
+		}
+	}
+
+}

common/cli/eqemu_command_handler.h

@@ -0,0 +1,75 @@
+/**
+ * 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_EQEMU_COMMAND_HANDLER_H
+#define EQEMU_EQEMU_COMMAND_HANDLER_H
+
+#include "argh.h"
+
+namespace EQEmuCommand {
+
+	extern std::map<std::string, void (*)(
+		int argc,
+		char **argv,
+		argh::parser &cmd,
+		std::string &description
+	)> function_map;
+
+	/**
+	 * @param arguments
+	 * @param options
+	 * @param cmd
+	 * @param argc
+	 * @param argv
+	 */
+	void ValidateCmdInput(
+		std::vector<std::string> &arguments,
+		std::vector<std::string> &options,
+		argh::parser &cmd,
+		int argc,
+		char **argv
+	);
+
+	/**
+	 * @param cmd
+	 */
+	void DisplayDebug(argh::parser &cmd);
+
+	/**
+	 * @param in_function_map
+	 * @param cmd
+	 * @param argc
+	 * @param argv
+	 */
+	void HandleMenu(
+		std::map<std::string, void (*)(
+			int argc,
+			char **argv,
+			argh::parser &cmd,
+			std::string &description
+		)> &in_function_map,
+		argh::parser &cmd,
+		int argc,
+		char **argv
+	);
+};
+
+
+#endif //EQEMU_EQEMU_COMMAND_HANDLER_H

common/cli/terminal_color.hpp

@@ -0,0 +1,557 @@
+//!
+//! termcolor
+//! ~~~~~~~~~
+//!
+//! termcolor is a header-only c++ library for printing colored messages
+//! to the terminal. Written just for fun with a help of the Force.
+//!
+//! :copyright: (c) 2013 by Ihor Kalnytskyi
+//! :license: BSD, see LICENSE for details
+//!
+
+#ifndef TERMCOLOR_HPP_
+#define TERMCOLOR_HPP_
+
+// the following snippet of code detects the current OS and
+// defines the appropriate macro that is used to wrap some
+// platform specific things
+#if defined(_WIN32) || defined(_WIN64)
+#   define TERMCOLOR_OS_WINDOWS
+#elif defined(__APPLE__)
+#   define TERMCOLOR_OS_MACOS
+#elif defined(__unix__) || defined(__unix)
+#   define TERMCOLOR_OS_LINUX
+#else
+#   error unsupported platform
+#endif
+
+
+// This headers provides the `isatty()`/`fileno()` functions,
+// which are used for testing whether a standart stream refers
+// to the terminal. As for Windows, we also need WinApi funcs
+// for changing colors attributes of the terminal.
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+#   include <unistd.h>
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#   include <io.h>
+#   include <windows.h>
+#endif
+
+
+#include <iostream>
+#include <cstdio>
+
+
+
+namespace termcolor
+{
+	// Forward declaration of the `_internal` namespace.
+	// All comments are below.
+	namespace _internal
+	{
+		// An index to be used to access a private storage of I/O streams. See
+		// colorize / nocolorize I/O manipulators for details.
+		static int colorize_index = std::ios_base::xalloc();
+
+		inline FILE* get_standard_stream(const std::ostream& stream);
+		inline bool is_colorized(std::ostream& stream);
+		inline bool is_atty(const std::ostream& stream);
+
+#if defined(TERMCOLOR_OS_WINDOWS)
+		inline void win_change_attributes(std::ostream& stream, int foreground, int background=-1);
+#endif
+	}
+
+	inline
+	std::ostream& colorize(std::ostream& stream)
+	{
+		stream.iword(_internal::colorize_index) = 1L;
+		return stream;
+	}
+
+	inline
+	std::ostream& nocolorize(std::ostream& stream)
+	{
+		stream.iword(_internal::colorize_index) = 0L;
+		return stream;
+	}
+
+	inline
+	std::ostream& reset(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;00m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1, -1);
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& bold(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;1m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& dark(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;2m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& underline(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;4m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& blink(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;5m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& reverse(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;7m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& concealed(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;8m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& grey(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;30m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                0   // grey (black)
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& red(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;31m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& green(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;32m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& yellow(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;33m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_GREEN | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& blue(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;34m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& magenta(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;35m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& cyan(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;36m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& white(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;37m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+
+
+	inline
+	std::ostream& on_grey(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;40m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                0   // grey (black)
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_red(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;41m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_green(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;42m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_yellow(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;43m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_blue(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;44m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_magenta(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;45m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE | BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_cyan(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;46m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_white(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;47m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED
+            );
+#endif
+		}
+
+		return stream;
+	}
+
+
+
+	//! Since C++ hasn't a way to hide something in the header from
+	//! the outer access, I have to introduce this namespace which
+	//! is used for internal purpose and should't be access from
+	//! the user code.
+	namespace _internal
+	{
+		//! Since C++ hasn't a true way to extract stream handler
+		//! from the a given `std::ostream` object, I have to write
+		//! this kind of hack.
+		inline
+		FILE* get_standard_stream(const std::ostream& stream)
+		{
+			if (&stream == &std::cout)
+				return stdout;
+			else if ((&stream == &std::cerr) || (&stream == &std::clog))
+				return stderr;
+
+			return 0;
+		}
+
+		// Say whether a given stream should be colorized or not. It's always
+		// true for ATTY streams and may be true for streams marked with
+		// colorize flag.
+		inline
+		bool is_colorized(std::ostream& stream)
+		{
+			return is_atty(stream) || static_cast<bool>(stream.iword(colorize_index));
+		}
+
+		//! Test whether a given `std::ostream` object refers to
+		//! a terminal.
+		inline
+		bool is_atty(const std::ostream& stream)
+		{
+			FILE* std_stream = get_standard_stream(stream);
+
+			// Unfortunately, fileno() ends with segmentation fault
+			// if invalid file descriptor is passed. So we need to
+			// handle this case gracefully and assume it's not a tty
+			// if standard stream is not detected, and 0 is returned.
+			if (!std_stream)
+				return false;
+
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			return ::isatty(fileno(std_stream));
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			return ::_isatty(_fileno(std_stream));
+#endif
+		}
+
+#if defined(TERMCOLOR_OS_WINDOWS)
+		//! Change Windows Terminal colors attribute. If some
+        //! parameter is `-1` then attribute won't changed.
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background)
+        {
+            // yeah, i know.. it's ugly, it's windows.
+            static WORD defaultAttributes = 0;
+
+            // Windows doesn't have ANSI escape sequences and so we use special
+            // API to change Terminal output color. That means we can't
+            // manipulate colors by means of "std::stringstream" and hence
+            // should do nothing in this case.
+            if (!_internal::is_atty(stream))
+                return;
+
+            // get terminal handle
+            HANDLE hTerminal = INVALID_HANDLE_VALUE;
+            if (&stream == &std::cout)
+                hTerminal = GetStdHandle(STD_OUTPUT_HANDLE);
+            else if (&stream == &std::cerr)
+                hTerminal = GetStdHandle(STD_ERROR_HANDLE);
+
+            // save default terminal attributes if it unsaved
+            if (!defaultAttributes)
+            {
+                CONSOLE_SCREEN_BUFFER_INFO info;
+                if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                    return;
+                defaultAttributes = info.wAttributes;
+            }
+
+            // restore all default settings
+            if (foreground == -1 && background == -1)
+            {
+                SetConsoleTextAttribute(hTerminal, defaultAttributes);
+                return;
+            }
+
+            // get current settings
+            CONSOLE_SCREEN_BUFFER_INFO info;
+            if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                return;
+
+            if (foreground != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0x0F);
+                info.wAttributes |= static_cast<WORD>(foreground);
+            }
+
+            if (background != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0xF0);
+                info.wAttributes |= static_cast<WORD>(background);
+            }
+
+            SetConsoleTextAttribute(hTerminal, info.wAttributes);
+        }
+#endif // TERMCOLOR_OS_WINDOWS
+
+	} // namespace _internal
+
+} // namespace termcolor
+
+
+#undef TERMCOLOR_OS_WINDOWS
+#undef TERMCOLOR_OS_MACOS
+#undef TERMCOLOR_OS_LINUX
+
+#endif // TERMCOLOR_HPP_

common/client_version.cpp

@@ -1,128 +0,0 @@
-/*	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
-*/
-
-#include "client_version.h"
-
-
-bool EQEmu::versions::IsValidClientVersion(ClientVersion client_version)
-{
-	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
-		return false;
-
-	return true;
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ValidateClientVersion(ClientVersion client_version)
-{
-	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
-		return ClientVersion::Unknown;
-
-	return client_version;
-}
-
-const char* EQEmu::versions::ClientVersionName(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-		return "Unknown Version";
-	case ClientVersion::Client62:
-		return "Client 6.2";
-	case ClientVersion::Titanium:
-		return "Titanium";
-	case ClientVersion::SoF:
-		return "SoF";
-	case ClientVersion::SoD:
-		return "SoD";
-	case ClientVersion::UF:
-		return "UF";
-	case ClientVersion::RoF:
-		return "RoF";
-	case ClientVersion::RoF2:
-		return "RoF2";
-	default:
-		return "Invalid Version";
-	};
-}
-
-uint32 EQEmu::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-		return bit_Unknown;
-	case ClientVersion::Titanium:
-		return bit_Titanium;
-	case ClientVersion::SoF:
-		return bit_SoF;
-	case ClientVersion::SoD:
-		return bit_SoD;
-	case ClientVersion::UF:
-		return bit_UF;
-	case ClientVersion::RoF:
-		return bit_RoF;
-	case ClientVersion::RoF2:
-		return bit_RoF2;
-	default:
-		return bit_Unknown;
-	}
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
-{
-	switch (client_version_bit) {
-	case (uint32)static_cast<unsigned int>(ClientVersion::Unknown) :
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)) :
-		return ClientVersion::Unknown;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
-		return ClientVersion::Titanium;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)) :
-		return ClientVersion::SoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)) :
-		return ClientVersion::SoD;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)) :
-		return ClientVersion::UF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)) :
-		return ClientVersion::RoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)) :
-		return ClientVersion::RoF2;
-	default:
-		return ClientVersion::Unknown;
-	}
-}
-
-uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-	case ClientVersion::Titanium:
-		return 0x000007FFU;
-	case ClientVersion::SoF:
-		return 0x00007FFFU;
-	case ClientVersion::SoD:
-		return 0x0000FFFFU;
-	case ClientVersion::UF:
-		return 0x0001FFFFU;
-	case ClientVersion::RoF:
-	case ClientVersion::RoF2:
-		return 0x000FFFFFU;
-	default:
-		return 0;
-	}
-}

common/client_version.h

@@ -1,78 +0,0 @@
-/*	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
-*/
-
-#ifndef COMMON_CLIENT_VERSION_H
-#define COMMON_CLIENT_VERSION_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	namespace versions {
-		enum class ClientVersion {
-			Unknown = 0,
-			Client62,	// Build: 'Aug  4 2005 15:40:59'
-			Titanium,	// Build: 'Oct 31 2005 10:33:37'
-			SoF,		// Build: 'Sep  7 2007 09:11:49'
-			SoD,		// Build: 'Dec 19 2008 15:22:49'
-			UF,			// Build: 'Jun  8 2010 16:44:32'
-			RoF,		// Build: 'Dec 10 2012 17:35:44'
-			RoF2		// Build: 'May 10 2013 23:30:08'
-		};
-
-		enum ClientVersionBit : uint32 {
-			bit_Unknown = 0,
-			bit_Client62 = 0x00000001, // unsupported (placeholder for scripts)
-			bit_Titanium = 0x00000002,
-			bit_SoF = 0x00000004,
-			bit_SoD = 0x00000008,
-			bit_UF = 0x00000010,
-			bit_RoF = 0x00000020,
-			bit_RoF2 = 0x00000040,
-			bit_TitaniumAndEarlier = 0x00000003,
-			bit_SoFAndEarlier = 0x00000007,
-			bit_SoDAndEarlier = 0x0000000F,
-			bit_UFAndEarlier = 0x0000001F,
-			bit_RoFAndEarlier = 0x0000003F,
-			bit_SoFAndLater = 0xFFFFFFFC,
-			bit_SoDAndLater = 0xFFFFFFF8,
-			bit_UFAndLater = 0xFFFFFFF0,
-			bit_RoFAndLater = 0xFFFFFFE0,
-			bit_RoF2AndLater = 0xFFFFFFC0,
-			bit_AllClients = 0xFFFFFFFF
-		};
-
-		static const ClientVersion LastClientVersion = ClientVersion::RoF2;
-		static const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
-
-		extern bool IsValidClientVersion(ClientVersion client_version);
-		extern ClientVersion ValidateClientVersion(ClientVersion client_version);
-		extern const char* ClientVersionName(ClientVersion client_version);
-		extern uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
-		extern ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
-		extern uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
-	
-	} /*versions*/
-
-} /*EQEmu*/
-
-#endif /*COMMON_CLIENT_VERSION_H*/

common/compression.cpp

@@ -0,0 +1,82 @@
+#include "global_define.h"
+#include "types.h"
+#include <string.h>
+#include <zlib.h>
+
+namespace EQ
+{
+	uint32 EstimateDeflateBuffer(uint32 len) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		if (deflateInit(&zstream, Z_FINISH) != Z_OK)
+			return 0;
+
+		return deflateBound(&zstream, len);
+	}
+
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+		int zerror;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		deflateInit(&zstream, Z_FINISH);
+
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);
+		zstream.avail_out = out_len_max;
+		zerror = deflate(&zstream, Z_FINISH);
+
+		if (zerror == Z_STREAM_END)
+		{
+			deflateEnd(&zstream);
+			return (uint32)zstream.total_out;
+		}
+		else
+		{
+			zerror = deflateEnd(&zstream);
+			return 0;
+		}
+	}
+
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		int zerror = 0;
+		int i;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);;
+		zstream.avail_out = out_len_max;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+
+		i = inflateInit2(&zstream, 15);
+		if (i != Z_OK) {
+			return 0;
+		}
+
+		zerror = inflate(&zstream, Z_FINISH);
+		if (zerror == Z_STREAM_END) {
+			inflateEnd(&zstream);
+			return zstream.total_out;
+		}
+		else {
+			if (zerror == -4 && zstream.msg == 0)
+			{
+				return 0;
+			}
+
+			zerror = inflateEnd(&zstream);
+			return 0;
+		}
+	}
+}

common/compression.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace EQ
+{
+	uint32 EstimateDeflateBuffer(uint32 len);
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max);
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max);
+}

common/content/world_content_service.cpp

@@ -0,0 +1,101 @@
+/**
+ * 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 "world_content_service.h"
+#include "../database.h"
+#include "../rulesys.h"
+#include "../eqemu_logsys.h"
+
+
+WorldContentService::WorldContentService()
+{
+	SetCurrentExpansion(Expansion::EXPANSION_ALL);
+}
+
+int WorldContentService::GetCurrentExpansion() const
+{
+	return current_expansion;
+}
+
+void WorldContentService::SetExpansionContext()
+{
+	int expansion = RuleI(Expansion, CurrentExpansion);
+	if (expansion >= Expansion::Classic && expansion <= Expansion::MaxId) {
+		content_service.SetCurrentExpansion(expansion);
+	}
+
+	LogInfo(
+		"Current expansion is [{}] ({})",
+		GetCurrentExpansion(),
+		GetCurrentExpansionName()
+	);
+}
+
+std::string WorldContentService::GetCurrentExpansionName()
+{
+	if (content_service.GetCurrentExpansion() == Expansion::EXPANSION_ALL) {
+		return "All Expansions";
+	}
+
+	if (current_expansion >= Expansion::Classic && current_expansion <= Expansion::MaxId) {
+		return Expansion::ExpansionName[content_service.GetCurrentExpansion()];
+	}
+
+	return "Unknown Expansion";
+}
+
+/**
+ * @param current_expansion
+ */
+void WorldContentService::SetCurrentExpansion(int current_expansion)
+{
+	WorldContentService::current_expansion = current_expansion;
+}
+
+/**
+ * @return
+ */
+const std::vector<std::string> &WorldContentService::GetContentFlags() const
+{
+	return content_flags;
+}
+
+/**
+ * @param content_flags
+ */
+void WorldContentService::SetContentFlags(std::vector<std::string> content_flags)
+{
+	WorldContentService::content_flags = content_flags;
+}
+
+/**
+ * @param content_flag
+ * @return
+ */
+bool WorldContentService::IsContentFlagEnabled(const std::string& content_flag)
+{
+	for (auto &flag : GetContentFlags()) {
+		if (flag == content_flag) {
+			return true;
+		}
+	}
+
+	return false;
+}

common/content/world_content_service.h

@@ -0,0 +1,173 @@
+/**
+ * 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_WORLD_CONTENT_SERVICE_H
+#define EQEMU_WORLD_CONTENT_SERVICE_H
+
+#include <string>
+#include <vector>
+
+namespace Expansion {
+	static const int EXPANSION_ALL        = -1;
+	static const int EXPANSION_FILTER_MAX = 99;
+
+	enum ExpansionNumber {
+		Classic = 0,
+		TheRuinsOfKunark,
+		TheScarsOfVelious,
+		TheShadowsOfLuclin,
+		ThePlanesOfPower,
+		TheLegacyOfYkesha,
+		LostDungeonsOfNorrath,
+		GatesOfDiscord,
+		OmensOfWar,
+		DragonsOfNorrath,
+		DepthsOfDarkhollow,
+		ProphecyOfRo,
+		TheSerpentsSpine,
+		TheBuriedSea,
+		SecretsOfFaydwer,
+		SeedsOfDestruction,
+		Underfoot,
+		HouseOfThule,
+		VeilOfAlaris,
+		RainOfFear,
+		CallOfTheForsaken,
+		TheDarkendSea,
+		TheBrokenMirror,
+		EmpiresOfKunark,
+		RingOfScale,
+		TheBurningLands,
+		TormentOfVelious,
+		MaxId
+	};
+
+	/**
+	 * If you add to this, make sure you update LogCategory
+	 */
+	static const char *ExpansionName[ExpansionNumber::MaxId] = {
+		"Classic",
+		"The Ruins of Kunark",
+		"The Scars of Velious",
+		"The Shadows of Luclin",
+		"The Planes of Power",
+		"The Legacy of Ykesha",
+		"Lost Dungeons of Norrath",
+		"Gates of Discord",
+		"Omens of War",
+		"Dragons of Norrath",
+		"Depths of Darkhollow",
+		"Prophecy of Ro",
+		"The Serpent's Spine",
+		"The Buried Sea",
+		"Secrets of Faydwer",
+		"Seeds of Destruction",
+		"Underfoot",
+		"House of Thule",
+		"Veil of Alaris",
+		"Rain of Fear",
+		"Call of the Forsaken",
+		"The Darkened Sea",
+		"The Broken Mirror",
+		"Empires of Kunark",
+		"Ring of Scale",
+		"The Burning Lands",
+		"Torment of Velious",
+	};
+}
+
+class WorldContentService {
+public:
+
+	WorldContentService();
+
+	std::string GetCurrentExpansionName();
+	int GetCurrentExpansion() const;
+	void SetCurrentExpansion(int current_expansion);
+
+	bool IsClassicEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::Classic || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheRuinsOfKunarkEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheRuinsOfKunark || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheScarsOfVeliousEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheScarsOfVelious || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheShadowsOfLuclinEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheShadowsOfLuclin || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsThePlanesOfPowerEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::ThePlanesOfPower || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheLegacyOfYkeshaEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheLegacyOfYkesha || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsLostDungeonsOfNorrathEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::LostDungeonsOfNorrath || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsGatesOfDiscordEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::GatesOfDiscord || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsOmensOfWarEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::OmensOfWar || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsDragonsOfNorrathEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::DragonsOfNorrath || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsDepthsOfDarkhollowEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::DepthsOfDarkhollow || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsProphecyOfRoEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::ProphecyOfRo || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheSerpentsSpineEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheSerpentsSpine || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheBuriedSeaEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheBuriedSea || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsSecretsOfFaydwerEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::SecretsOfFaydwer || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsSeedsOfDestructionEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::SeedsOfDestruction || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsUnderfootEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::Underfoot || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsHouseOfThuleEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::HouseOfThule || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsVeilOfAlarisEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::VeilOfAlaris || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsRainOfFearEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::RainOfFear || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsCallOfTheForsakenEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::CallOfTheForsaken || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheDarkendSeaEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheDarkendSea || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheBrokenMirrorEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheBrokenMirror || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsEmpiresOfKunarkEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::EmpiresOfKunark || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsRingOfScaleEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::RingOfScale || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTheBurningLandsEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TheBurningLands || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+	bool IsTormentOfVeliousEnabled() { return GetCurrentExpansion() >= Expansion::ExpansionNumber::TormentOfVelious || GetCurrentExpansion() == Expansion::EXPANSION_ALL; }
+
+	bool IsCurrentExpansionClassic() { return current_expansion == Expansion::ExpansionNumber::Classic; }
+	bool IsCurrentExpansionTheRuinsOfKunark() { return current_expansion == Expansion::ExpansionNumber::TheRuinsOfKunark; }
+	bool IsCurrentExpansionTheScarsOfVelious() { return current_expansion == Expansion::ExpansionNumber::TheScarsOfVelious; }
+	bool IsCurrentExpansionTheShadowsOfLuclin() { return current_expansion == Expansion::ExpansionNumber::TheShadowsOfLuclin; }
+	bool IsCurrentExpansionThePlanesOfPower() { return current_expansion == Expansion::ExpansionNumber::ThePlanesOfPower; }
+	bool IsCurrentExpansionTheLegacyOfYkesha() { return current_expansion == Expansion::ExpansionNumber::TheLegacyOfYkesha; }
+	bool IsCurrentExpansionLostDungeonsOfNorrath() { return current_expansion == Expansion::ExpansionNumber::LostDungeonsOfNorrath; }
+	bool IsCurrentExpansionGatesOfDiscord() { return current_expansion == Expansion::ExpansionNumber::GatesOfDiscord; }
+	bool IsCurrentExpansionOmensOfWar() { return current_expansion == Expansion::ExpansionNumber::OmensOfWar; }
+	bool IsCurrentExpansionDragonsOfNorrath() { return current_expansion == Expansion::ExpansionNumber::DragonsOfNorrath; }
+	bool IsCurrentExpansionDepthsOfDarkhollow() { return current_expansion == Expansion::ExpansionNumber::DepthsOfDarkhollow; }
+	bool IsCurrentExpansionProphecyOfRo() { return current_expansion == Expansion::ExpansionNumber::ProphecyOfRo; }
+	bool IsCurrentExpansionTheSerpentsSpine() { return current_expansion == Expansion::ExpansionNumber::TheSerpentsSpine; }
+	bool IsCurrentExpansionTheBuriedSea() { return current_expansion == Expansion::ExpansionNumber::TheBuriedSea; }
+	bool IsCurrentExpansionSecretsOfFaydwer() { return current_expansion == Expansion::ExpansionNumber::SecretsOfFaydwer; }
+	bool IsCurrentExpansionSeedsOfDestruction() { return current_expansion == Expansion::ExpansionNumber::SeedsOfDestruction; }
+	bool IsCurrentExpansionUnderfoot() { return current_expansion == Expansion::ExpansionNumber::Underfoot; }
+	bool IsCurrentExpansionHouseOfThule() { return current_expansion == Expansion::ExpansionNumber::HouseOfThule; }
+	bool IsCurrentExpansionVeilOfAlaris() { return current_expansion == Expansion::ExpansionNumber::VeilOfAlaris; }
+	bool IsCurrentExpansionRainOfFear() { return current_expansion == Expansion::ExpansionNumber::RainOfFear; }
+	bool IsCurrentExpansionCallOfTheForsaken() { return current_expansion == Expansion::ExpansionNumber::CallOfTheForsaken; }
+	bool IsCurrentExpansionTheDarkendSea() { return current_expansion == Expansion::ExpansionNumber::TheDarkendSea; }
+	bool IsCurrentExpansionTheBrokenMirror() { return current_expansion == Expansion::ExpansionNumber::TheBrokenMirror; }
+	bool IsCurrentExpansionEmpiresOfKunark() { return current_expansion == Expansion::ExpansionNumber::EmpiresOfKunark; }
+	bool IsCurrentExpansionRingOfScale() { return current_expansion == Expansion::ExpansionNumber::RingOfScale; }
+	bool IsCurrentExpansionTheBurningLands() { return current_expansion == Expansion::ExpansionNumber::TheBurningLands; }
+	bool IsCurrentExpansionTormentOfVelious() { return current_expansion == Expansion::ExpansionNumber::TormentOfVelious; }
+
+private:
+	int current_expansion{};
+	std::vector<std::string> content_flags;
+public:
+	const std::vector<std::string> &GetContentFlags() const;
+	bool IsContentFlagEnabled(const std::string& content_flag);
+	void SetContentFlags(std::vector<std::string> content_flags);
+	void SetExpansionContext();
+};
+
+extern WorldContentService content_service;
+
+#endif //EQEMU_WORLD_CONTENT_SERVICE_H

common/crash.cpp

@@ -25,7 +25,7 @@ public:
 			}
 		}
 
-		Log.Out(Logs::General, Logs::Crash, buffer);
+		Log(Logs::General, Logs::Crash, buffer);
 		StackWalker::OnOutput(szText);
 	}
 };
@@ -35,67 +35,67 @@ LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
 			break;
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
 			break;
 		case EXCEPTION_BREAKPOINT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
 			break;
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
 			break;
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
 			break;
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_FLT_INEXACT_RESULT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
 			break;
 		case EXCEPTION_FLT_INVALID_OPERATION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
 			break;
 		case EXCEPTION_FLT_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
 			break;
 		case EXCEPTION_FLT_STACK_CHECK:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
 			break;
 		case EXCEPTION_FLT_UNDERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
 			break;
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
 			break;
 		case EXCEPTION_IN_PAGE_ERROR:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
 			break;
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_INT_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
 			break;
 		case EXCEPTION_INVALID_DISPOSITION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
 			break;
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
 			break;
 		case EXCEPTION_PRIV_INSTRUCTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
 			break;
 		case EXCEPTION_SINGLE_STEP:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
 			break;
 		case EXCEPTION_STACK_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
 			break;
 		default:
-			Log.Out(Logs::General, Logs::Crash, "Unknown Exception");
+			Log(Logs::General, Logs::Crash, "Unknown Exception");
 			break;
 	}
 
@@ -111,7 +111,65 @@ void set_exception_handler() {
 	SetUnhandledExceptionFilter(windows_exception_handler);
 }
 #else
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/fcntl.h>
+
+#ifdef __FreeBSD__
+#include <signal.h>
+#include <sys/stat.h>
+#endif
+
+void print_trace()
+{
+	auto uid = geteuid();
+
+	std::string temp_output_file = "/tmp/dump-output";
+
+	char pid_buf[30];
+	sprintf(pid_buf, "%d", getpid());
+	char name_buf[512];
+	name_buf[readlink("/proc/self/exe", name_buf, 511)] = 0;
+	int child_pid = fork();
+	if (!child_pid) {
+		int fd = open(temp_output_file.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+
+		dup2(fd, 1); // redirect output to stderr
+		fprintf(stdout, "stack trace for %s pid=%s\n", name_buf, pid_buf);
+		if (uid == 0) {
+			execlp("gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt", name_buf, pid_buf, NULL);
+		}
+		else {
+			execlp("sudo", "gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt", name_buf, pid_buf, NULL);
+		}
+
+		close(fd);
+
+		abort(); /* If gdb failed to start */
+	}
+	else {
+		waitpid(child_pid, NULL, 0);
+	}
+
+	std::ifstream    input(temp_output_file);
+	for (std::string line; getline(input, line);) {
+		LogCrash("{}", line);
+	}
+
+	std::remove(temp_output_file.c_str());
+
+	exit(1);
+}
+
 // crash is off or an unhandled platform
-void set_exception_handler() {
+void set_exception_handler()
+{
+	signal(SIGABRT, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGFPE, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGFPE, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGSEGV, reinterpret_cast<void (*)(int)>(print_trace));
 }
 #endif

common/data_verification.h

@@ -1,48 +1,57 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
+/**
+ * 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
+ *
+ */
 
-	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 COMMON_DATA_VERIFICATION_H
-#define COMMON_DATA_VERIFICATION_H
+#pragma once
 
 #include <algorithm>
+#include <cmath>
 
-namespace EQEmu
-{
+namespace EQ {
+	template<typename T>
+	T Clamp(const T &value, const T &lower, const T &upper)
+	{
+		return std::max(lower, std::min(value, upper));
+	}
 
-template <typename T>
-T Clamp(const T& value, const T& lower, const T& upper) {
-	return std::max(lower, std::min(value, upper));
-}
+	template<typename T>
+	T ClampLower(const T &value, const T &lower)
+	{
+		return std::max(lower, value);
+	}
 
-template <typename T>
-T ClampLower(const T& value, const T& lower) {
-	return std::max(lower, value);
-}
+	template<typename T>
+	T ClampUpper(const T &value, const T &upper)
+	{
+		return std::min(value, upper);
+	}
 
-template <typename T>
-T ClampUpper(const T& value, const T& upper) {
-	return std::min(value, upper);
-}
+	template<typename T>
+	bool ValueWithin(const T &value, const T &lower, const T &upper)
+	{
+		return value >= lower && value <= upper;
+	}
 
-template <typename T>
-bool ValueWithin(const T& value, const T& lower, const T& upper) {
-	return value >= lower && value <= upper;
-}
+	template<typename T1, typename T2, typename T3>
+	bool ValueWithin(const T1 &value, const T2 &lower, const T3 &upper)
+	{
+		return value >= (T1) lower && value <= (T1) upper;
+	}
+} /*EQEmu*/
 
-}
-
-#endif

common/database.h

@@ -37,10 +37,14 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
-class Inventory;
 class MySQLRequestResult;
 class Client;
 
+namespace EQ
+{
+	class InventoryProfile;
+}
+
 struct EventLogDetails_Struct {
 	uint32	id;
 	char	accountname[64];
@@ -90,31 +94,50 @@ class PTimerList;
 #	define _ISNAN_(a) std::isnan(a)
 #endif
 
+#define SQL(...) #__VA_ARGS__
+
 class Database : public DBcore {
 public:
 	Database();
 	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
-	bool Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port);
+	bool Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port, std::string connection_label = "default");
 	~Database();
 
 	/* Character Creation */
 
-	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	MoveCharacterToZone(const char* charname, const char* zonename);
-	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
-	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);
-	bool	ReserveName(uint32 account_id, char* name);
-	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
-	bool	SetHackerFlag(const char* accountname, const char* charactername, const char* hacked);
-	bool	SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone);
-	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
-	bool	UpdateName(const char* oldname, const char* newname);
+	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 *character_name);
+	bool MoveCharacterToZone(const char *charname, uint32 zone_id);
+	bool MoveCharacterToZone(uint32 character_id, uint32 zone_id);
+	bool ReserveName(uint32 account_id, char *name);
+	bool SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct *pp);
+	bool SetHackerFlag(const char *accountname, const char *charactername, const char *hacked);
+	bool SetMQDetectionFlag(const char *accountname, const char *charactername, const char *hacked, const char *zone);
+	bool UpdateName(const char *oldname, const char *newname);
+	bool CopyCharacter(
+		std::string source_character_name,
+		std::string destination_character_name,
+		std::string destination_account_name
+	);
 
 	/* 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);
@@ -123,13 +146,17 @@ public:
 
 	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
 	uint32	GetAccountIDByChar(uint32 char_id);
-	uint32	GetAccountIDByName(const char* accname, int16* status = 0, uint32* lsid = 0);
+	uint32	GetAccountIDByName(const char* accname, const char *loginserver, int16* status = 0, uint32* lsid = 0);
 	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 */
@@ -146,7 +173,6 @@ public:
 	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
 	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
 
-	uint16 GetInstanceID(const char* zone, uint32 charid, int16 version);
 	uint16 GetInstanceID(uint32 zone, uint32 charid, int16 version);
 	uint16 GetInstanceVersion(uint16 instance_id);
 	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
@@ -170,31 +196,35 @@ public:
 
 	/* Account Related */
 
-	bool	DeleteAccount(const char* name);
+	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 lsaccount_id);
+	bool	UpdateLiveChar(char* charname, uint32 account_id);
 
 	int16	CheckStatus(uint32 account_id);
 
-	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
-	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
-	uint32	GetAccountIDFromLSID(uint32 iLSID, char* oAccountName = 0, int16* oStatus = 0);
-	uint32	GetMiniLoginAccount(char* ip);
+	uint32	CheckLogin(const char* name, const char* password, const char *loginserver, int16* oStatus = 0);
+	uint32	CreateAccount(const char* name, const char* password, int16 status, const char* loginserver, uint32 lsaccount_id);
+	uint32	GetAccountIDFromLSID(const std::string& in_loginserver_id, uint32 in_loginserver_account_id, char* in_account_name = 0, int16* in_status = 0);
 	uint8	GetAgreementFlag(uint32 acctid);
 
 	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);
@@ -213,6 +243,8 @@ public:
 	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
 	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
 
+	void    PurgeAllDeletedDataBuckets();
+
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
@@ -228,16 +260,11 @@ public:
 	/* General Queries */
 
 	bool	GetSafePoints(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr);
-	bool	GetSafePoints(uint32 zoneID, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, flag_needed); }
 	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
 	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
 	bool	LoadPTimers(uint32 charid, PTimerList &into);
-	bool	LoadZoneNames();
-
-	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
 
 	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
-	uint32	GetZoneID(const char* zonename);
 
 	uint8	GetPEQZone(uint32 zoneID, uint32 version);
 	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
@@ -254,13 +281,13 @@ public:
 	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
-	void	ClearInvSnapshots(bool use_rule = true);
+	int		CountInvSnapshots();
+	void	ClearInvSnapshots(bool from_now = false);
 
 	/* EQEmuLogSys */
 	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
-	std::map<uint32,std::string>	zonename_array;
 
 	Mutex Mvarcache;
 	VarCache_Struct varcache;

common/database/database_dump_service.cpp

@@ -0,0 +1,580 @@
+/**
+ * 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();
+	if (IsDumpContentTables() && !config->ContentDbHost.empty()) {
+		return fmt::format(
+			"mysqldump -u {} -p{} -h {} --port={} {}",
+			config->ContentDbUsername,
+			config->ContentDbPassword,
+			config->ContentDbHost,
+			config->ContentDbPort,
+			config->ContentDbName
+		);
+	};
+
+	return fmt::format(
+		"mysqldump -u {} -p{} -h {} --port={} {}",
+		config->DatabaseUsername,
+		config->DatabasePassword,
+		config->DatabaseHost,
+		config->DatabasePort,
+		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_conversions.cpp

@@ -41,6 +41,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
 #pragma pack(1)
 
+// all const/macro reference values should really be converted to a magic number for this
+// process to ensure that the struct sizes and offsets match up to the corresponding blob
+
 /* Conversion Structs */
 
 namespace Convert {
@@ -186,7 +189,7 @@ namespace Convert {
 		/*002*/	uint32 HP;
 		/*006*/	uint32 Mana;
 		/*010*/	Convert::SpellBuff_Struct Buffs[BUFF_COUNT];
-		/*510*/	uint32 Items[EQEmu::legacy::MaterialCount];
+		/*510*/	uint32 Items[EQ::textures::materialCount];
 		/*546*/	char Name[64];
 		/*610*/
 	};
@@ -214,7 +217,7 @@ namespace Convert {
 		/*0245*/	uint8							guildbanker;
 		/*0246*/	uint8							unknown0246[6];		//
 		/*0252*/	uint32							intoxication;
-		/*0256*/	uint32							spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
+		/*0256*/	uint32							spellSlotRefresh[9];	//in ms
 		/*0292*/	uint32							abilitySlotRefresh;
 		/*0296*/	uint8							haircolor;			// Player hair color
 		/*0297*/	uint8							beardcolor;			// Player beard color
@@ -227,9 +230,9 @@ namespace Convert {
 		/*0304*/	uint8							ability_time_minutes;
 		/*0305*/	uint8							ability_time_hours;	//place holder
 		/*0306*/	uint8							unknown0306[6];		// @bp Spacer/Flag?
-		/*0312*/	uint32							item_material[EQEmu::legacy::MaterialCount];	// Item texture/material of worn/held items
+		/*0312*/	uint32							item_material[EQ::textures::materialCount];	// Item texture/material of worn/held items
 		/*0348*/	uint8							unknown0348[44];
-		/*0392*/	Convert::Color_Struct			item_tint[EQEmu::legacy::MaterialCount];
+		/*0392*/	Convert::Color_Struct			item_tint[EQ::textures::materialCount];
 		/*0428*/	Convert::AA_Array				aa_array[MAX_PP_AA_ARRAY];
 		/*2348*/	float							unknown2384;		//seen ~128, ~47
 		/*2352*/	char							servername[32];		// length probably not right
@@ -253,9 +256,9 @@ namespace Convert {
 		/*2505*/	uint8							unknown2541[47];	// ?
 		/*2552*/	uint8							languages[MAX_PP_LANGUAGE];
 		/*2580*/	uint8							unknown2616[4];
-		/*2584*/	uint32							spell_book[MAX_PP_REF_SPELLBOOK];
+		/*2584*/	uint32							spell_book[480];
 		/*4504*/	uint8							unknown4540[128];	// Was [428] all 0xff
-		/*4632*/	uint32							mem_spells[MAX_PP_REF_MEMSPELL];
+		/*4632*/	uint32							mem_spells[9];
 		/*4668*/	uint8							unknown4704[32];	//
 		/*4700*/	float							y;					// Player y position
 		/*4704*/	float							x;					// Player x position
@@ -330,7 +333,7 @@ namespace Convert {
 		/*7212*/	uint32							tribute_points;
 		/*7216*/	uint32							unknown7252;
 		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EQEmu::legacy::TRIBUTE_SIZE];
+		/*7224*/	Convert::Tribute_Struct			tributes[5];
 		/*7264*/	Convert::Disciplines_Struct		disciplines;
 		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 		/*7744*/	char							unknown7780[160];
@@ -472,31 +475,8 @@ bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertPPDeblob();
 	CheckDatabaseConvertCorpseDeblob();
 
-	/* Fetch Automatic Upgrade Script */
-	if (!std::ifstream("eqemu_update.pl")){
-		std::cout << "Pulling down automatic database upgrade script..." << std::endl;
-#ifdef _WIN32
-		system("perl -MLWP::UserAgent -e \"require LWP::UserAgent;  my $ua = LWP::UserAgent->new; $ua->timeout(10); $ua->env_proxy; my $response = $ua->get('https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_update.pl'); if ($response->is_success){ open(FILE, '> eqemu_update.pl'); print FILE $response->decoded_content; close(FILE); }\"");
-#else
-		system("wget --no-check-certificate -O eqemu_update.pl https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_update.pl");
-#endif
-	}
-
-	/*
-		Automatic (Database) Upgrade Script
-		Script: eqemu_update.pl V 1 - the number that world passes to the script will
-		force the script to check for a newer version to update itself with
-		eqemu_update.pl ran_from_world - won't bring up a menu if your database versions match
-		eqemu_update.pl - ran standalone will bring up a menu prompt
-	*/
-
-	/* Check for a new version of this script, the arg passed
-	would have to be higher than the copy they have downloaded
-	locally and they will re fetch */
-	system("perl eqemu_update.pl V 14"); 
-
-	/* Run Automatic Database Upgrade Script */
-	system("perl eqemu_update.pl ran_from_world");
+	/* Run EQEmu Server script (Checks for database updates) */
+	if(system("perl eqemu_server.pl ran_from_world"));
 
 	return true;
 }
@@ -1380,7 +1360,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Spell Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < MAX_PP_REF_SPELLBOOK; i++){
+				for (i = 0; i < 480; i++){
 					if (pp->spell_book[i] > 0 && pp->spell_book[i] != 4294967295 && pp->spell_book[i] < 40000 && pp->spell_book[i] != 1){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_spells` (id, slot_id, spell_id) VALUES (%u, %u, %u)", character_id, i, pp->spell_book[i]);
@@ -1392,7 +1372,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Max Memmed Spell Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < MAX_PP_REF_MEMSPELL; i++){
+				for (i = 0; i < 9; i++){
 					if (pp->mem_spells[i] > 0 && pp->mem_spells[i] != 65535 && pp->mem_spells[i] != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_memmed_spells` (id, slot_id, spell_id) VALUES (%u, %u, %u)", character_id, i, pp->mem_spells[i]);
@@ -1416,7 +1396,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Material Color Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EQEmu::legacy::MaterialCount; i++){
+				for (i = EQ::textures::textureBegin; i < EQ::textures::materialCount; i++){
 					if (pp->item_tint[i].color > 0){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_material` (id, slot, blue, green, red, use_tint, color) VALUES (%u, %u, %u, %u, %u, %u, %u)", character_id, i, pp->item_tint[i].rgb.blue, pp->item_tint[i].rgb.green, pp->item_tint[i].rgb.red, pp->item_tint[i].rgb.use_tint, pp->item_tint[i].color);
@@ -1428,7 +1408,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Tribute Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++){
+				for (i = 0; i < 5; i++){
 					if (pp->tributes[i].tribute > 0 && pp->tributes[i].tribute != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_tribute` (id, tier, tribute) VALUES (%u, %u, %u)", character_id, pp->tributes[i].tier, pp->tributes[i].tribute);

common/database_instances.cpp

@@ -34,20 +34,28 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #define strcasecmp	_stricmp
 #else
 #include "unix.h"
+#include "../zone/zonedb.h"
 #include <netinet/in.h>
 #include <sys/time.h>
 #endif
 
+/**
+ * @param instance_id
+ * @param char_id
+ * @return
+ */
 bool Database::AddClientToInstance(uint16 instance_id, uint32 char_id)
 {
 	std::string query = StringFormat(
 		"REPLACE INTO `instance_list_player` (id, charid) "
 		"VALUES "
 		"(%lu, %lu)",
-		(unsigned long)instance_id,
-		(unsigned long)char_id
-		);
+		(unsigned long) instance_id,
+		(unsigned long) char_id
+	);
+
 	auto results = QueryDatabase(query);
+
 	return results.Success();
 }
 
@@ -90,42 +98,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();
@@ -133,66 +152,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;
 }
 
@@ -269,36 +306,6 @@ bool Database::VerifyZoneInstance(uint32 zone_id, uint16 instance_id)
 	return true;
 }
 
-uint16 Database::GetInstanceID(const char* zone, uint32 character_id, int16 version) {
-
-	std::string query = StringFormat(
-		"SELECT "
-		"instance_list.id "
-		"FROM "
-		"instance_list, "
-		"instance_list_player "
-		"WHERE "
-		"instance_list.zone = %u "
-		"AND instance_list.version = %u "
-		"AND instance_list.id = instance_list_player.id "
-		"AND instance_list_player.charid = %u "
-		"LIMIT 1 ",
-		GetZoneID(zone),
-		version,
-		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]);
-}
-
 uint16 Database::GetInstanceID(uint32 zone, uint32 character_id, int16 version)
 {
 	if (!zone)
@@ -465,23 +472,18 @@ void Database::AssignRaidToInstance(uint32 raid_id, uint32 instance_id)
 }
 
 void Database::BuryCorpsesInInstance(uint16 instance_id) {
-	std::string query = StringFormat(
-		"UPDATE `character_corpses` "
-		"SET `is_buried` = 1, "
-		"`instance_id` = 0 "
-		"WHERE "
-		"`instance_id` = %u ",
-		instance_id
-		);
-	auto results = QueryDatabase(query);
+	QueryDatabase(
+		fmt::format(
+			"UPDATE character_corpses SET is_buried = 1, instance_id = 0 WHERE instance_id = {}",
+			instance_id
+		)
+	);
 }
 
 void Database::DeleteInstance(uint16 instance_id)
 {
-
-	std::string query = StringFormat("DELETE FROM instance_list WHERE id=%u", instance_id);
-	QueryDatabase(query);
-
+	std::string query;
+	
 	query = StringFormat("DELETE FROM instance_list_player WHERE id=%u", instance_id);
 	QueryDatabase(query);
 
@@ -491,6 +493,9 @@ void Database::DeleteInstance(uint16 instance_id)
 	query = StringFormat("DELETE FROM spawn_condition_values WHERE instance_id=%u", instance_id);
 	QueryDatabase(query);
 
+	query = fmt::format("DELETE FROM dynamic_zones WHERE instance_id={}", instance_id);
+	QueryDatabase(query);
+
 	BuryCorpsesInInstance(instance_id);
 }
 
@@ -541,17 +546,46 @@ 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)
-		DeleteInstance(atoi(row[0]));
+	std::vector<std::string> instance_ids;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		instance_ids.emplace_back(row[0]);
+	}
+
+	std::string imploded_instance_ids = implode(",", instance_ids);
+
+	QueryDatabase(fmt::format("DELETE FROM instance_list WHERE id IN ({})", imploded_instance_ids));
+	QueryDatabase(fmt::format("DELETE FROM instance_list_player WHERE id IN ({})", imploded_instance_ids));
+	QueryDatabase(fmt::format("DELETE FROM respawn_times WHERE instance_id IN ({})", imploded_instance_ids));
+	QueryDatabase(fmt::format("DELETE FROM spawn_condition_values WHERE instance_id IN ({})", imploded_instance_ids));
+	QueryDatabase(fmt::format("UPDATE character_corpses SET is_buried = 1, instance_id = 0 WHERE instance_id IN ({})", imploded_instance_ids));
+	QueryDatabase(fmt::format("DELETE FROM dynamic_zones WHERE instance_id IN ({})", imploded_instance_ids));
 }
 
 void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
@@ -559,4 +593,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,366 @@
+/**
+ * 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_expedition_lockouts",  "character_id"},
+			{"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_expedition_lockouts",
+			"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_rank_effects",
+			"aa_rank_prereqs",
+			"aa_ranks",
+			"adventure_template",
+			"adventure_template_entry",
+			"adventure_template_entry_flavor",
+			"alternate_currency",
+			"auras",
+			"base_data",
+			"blocked_spells",
+			"books",
+			"char_create_combinations",
+			"char_create_point_allocations",
+			"damageshieldtypes",
+			"doors",
+			"faction_base_data",
+			"faction_list",
+			"faction_list_mod",
+			"fishing",
+			"forage",
+			"global_loot",
+			"goallists",
+			"graveyard",
+			"grid",
+			"grid_entries",
+			"ground_spawns",
+			"horses",
+			"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_tint",
+			"object",
+			"pets",
+			"pets_equipmentset",
+			"pets_equipmentset_entries",
+			"proximities",
+			"skill_caps",
+			"spawn2",
+			"spawn_conditions",
+			"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",
+		};
+	}
+
+	/**
+	 * Gets server tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetServerTables()
+	{
+		return {
+			"chatchannels",
+			"command_settings",
+			"content_flags",
+			"db_str",
+			"eqtime",
+			"launcher",
+			"launcher_zones",
+			"spawn_condition_values",
+			"spawn_events",
+			"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",
+			"dynamic_zones",
+			"eventlog",
+			"expedition_lockouts",
+			"expedition_members",
+			"expeditions",
+			"gm_ips",
+			"group_id",
+			"group_leaders",
+			"hackers",
+			"ip_exemptions",
+			"instance_list",
+			"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

@@ -2,8 +2,9 @@
 #include <winsock2.h>
 #endif
 
-#include "../common/misc_functions.h"
-#include "../common/eqemu_logsys.h"
+#include "misc_functions.h"
+#include "eqemu_logsys.h"
+#include "timer.h"
 
 #include "dbcore.h"
 
@@ -14,33 +15,51 @@
 #include <string.h>
 
 #ifdef _WINDOWS
-	#define snprintf	_snprintf
-	#define strncasecmp	_strnicmp
-	#define strcasecmp	_stricmp
-	#include <process.h>
+#define snprintf	_snprintf
+#define strncasecmp	_strnicmp
+#define strcasecmp	_stricmp
+#include <process.h>
 #else
-	#include "unix.h"
-	#include <pthread.h>
+
+#include "unix.h"
+#include <pthread.h>
+
 #endif
 
 #ifdef _EQDEBUG
-	#define DEBUG_MYSQL_QUERIES 0
+#define DEBUG_MYSQL_QUERIES 0
 #else
-	#define DEBUG_MYSQL_QUERIES 0
+#define DEBUG_MYSQL_QUERIES 0
 #endif
 
-DBcore::DBcore() {
+DBcore::DBcore()
+{
 	mysql_init(&mysql);
-	pHost = 0;
-	pUser = 0;
-	pPassword = 0;
-	pDatabase = 0;
-	pCompress = false;
-	pSSL = false;
-	pStatus = Closed;
+	pHost           = nullptr;
+	pUser           = nullptr;
+	pPassword       = nullptr;
+	pDatabase       = nullptr;
+	pCompress       = false;
+	pSSL            = false;
+	pStatus         = Closed;
 }
 
-DBcore::~DBcore() {
+DBcore::~DBcore()
+{
+	/**
+	 * This prevents us from doing a double free in multi-tenancy setups where we
+	 * are re-using the default database connection pointer when we dont have an
+	 * external configuration setup ex: (content_database)
+	 */
+	std::string mysql_connection_host;
+	if (mysql.host) {
+		mysql_connection_host = mysql.host;
+	}
+
+	if (GetOriginHost() != mysql_connection_host) {
+		return;
+	}
+
 	mysql_close(&mysql);
 	safe_delete_array(pHost);
 	safe_delete_array(pUser);
@@ -49,7 +68,8 @@ DBcore::~DBcore() {
 }
 
 // Sends the MySQL server a keepalive
-void DBcore::ping() {
+void DBcore::ping()
+{
 	if (!MDatabase.trylock()) {
 		// well, if's it's locked, someone's using it. If someone's using it, it doesnt need a keepalive
 		return;
@@ -63,34 +83,44 @@ MySQLRequestResult DBcore::QueryDatabase(std::string query, bool retryOnFailureO
 	return QueryDatabase(query.c_str(), query.length(), retryOnFailureOnce);
 }
 
-MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce)
+bool DBcore::DoesTableExist(std::string table_name)
 {
+	auto results = QueryDatabase(fmt::format("SHOW TABLES LIKE '{}'", table_name));
+
+	return results.RowCount() > 0;
+}
+
+MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, bool retryOnFailureOnce)
+{
+	BenchTimer timer;
+	timer.reset();
+
 	LockMutex lock(&MDatabase);
 
 	// Reconnect if we are not connected before hand.
-	if (pStatus != Connected)
+	if (pStatus != Connected) {
 		Open();
+	}
+
+
 
 	// request query. != 0 indicates some kind of error.
-	if (mysql_real_query(&mysql, query, querylen) != 0)
-	{
+	if (mysql_real_query(&mysql, query, querylen) != 0) {
 		unsigned int errorNumber = mysql_errno(&mysql);
 
-		if (errorNumber == CR_SERVER_GONE_ERROR)
+		if (errorNumber == CR_SERVER_GONE_ERROR) {
 			pStatus = Error;
+		}
 
 		// error appears to be a disconnect error, may need to try again.
-		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR)
-		{
+		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR) {
 
-			if (retryOnFailureOnce)
-			{
-				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
+			if (retryOnFailureOnce) {
+				LogInfo("Database Error: Lost connection, attempting to recover");
 				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);
 
-				if (requestResult.Success())
-				{
-					std::cout << "Reconnection to database successful." << std::endl;
+				if (requestResult.Success()) {
+					LogInfo("Reconnection to database successful");
 					return requestResult;
 				}
 
@@ -102,114 +132,170 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
-			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
+			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32) mysql_errno(&mysql), errorBuffer);
 		}
 
 		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 */
-		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
-				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
+		/**
+		 * Error logging
+		 */
+		if (mysql_errno(&mysql) > 0 && strlen(query) > 0) {
+			LogMySQLError("[{}] [{}]\n[{}]", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
-		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
-
+		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql), errorBuffer);
 	}
 
 	// successful query. get results.
-	MYSQL_RES* res = mysql_store_result(&mysql);
-	uint32 rowCount = 0;
+	MYSQL_RES *res     = mysql_store_result(&mysql);
+	uint32    rowCount = 0;
 
-	if (res != nullptr)
-        rowCount = (uint32)mysql_num_rows(res);
+	if (res != nullptr) {
+		rowCount = (uint32) mysql_num_rows(res);
+	}
 
-	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
-	
-	if (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
-	{
-		if ((strncasecmp(query, "select", 6) == 0))
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
-		else
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+	MySQLRequestResult requestResult(
+		res,
+		(uint32) mysql_affected_rows(&mysql),
+		rowCount,
+		(uint32) mysql_field_count(&mysql),
+		(uint32) mysql_insert_id(&mysql)
+	);
+
+	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
+		if ((strncasecmp(query, "select", 6) == 0)) {
+			LogMySQLQuery(
+				"{0} ({1} row{2} returned) ({3}s)",
+				query,
+				requestResult.RowCount(),
+				requestResult.RowCount() == 1 ? "" : "s",
+				std::to_string(timer.elapsed())
+			);
+		}
+		else {
+			LogMySQLQuery(
+				"{0} ({1} row{2} affected) ({3}s)",
+				query,
+				requestResult.RowsAffected(),
+				requestResult.RowsAffected() == 1 ? "" : "s",
+				std::to_string(timer.elapsed())
+			);
+		}
 	}
 
 	return requestResult;
 }
 
-void DBcore::TransactionBegin() {
+void DBcore::TransactionBegin()
+{
 	QueryDatabase("START TRANSACTION");
 }
 
-void DBcore::TransactionCommit() {
+void DBcore::TransactionCommit()
+{
 	QueryDatabase("COMMIT");
 }
 
-void DBcore::TransactionRollback() {
+void DBcore::TransactionRollback()
+{
 	QueryDatabase("ROLLBACK");
 }
 
-uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {
+uint32 DBcore::DoEscapeString(char *tobuf, const char *frombuf, uint32 fromlen)
+{
 //	No good reason to lock the DB, we only need it in the first place to check char encoding.
 //	LockMutex lock(&MDatabase);
 	return mysql_real_escape_string(&mysql, tobuf, frombuf, fromlen);
 }
 
-bool DBcore::Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase,uint32 iPort, uint32* errnum, char* errbuf, bool iCompress, bool iSSL) {
+bool DBcore::Open(
+	const char *iHost,
+	const char *iUser,
+	const char *iPassword,
+	const char *iDatabase,
+	uint32 iPort,
+	uint32 *errnum,
+	char *errbuf,
+	bool iCompress,
+	bool iSSL
+)
+{
 	LockMutex lock(&MDatabase);
 	safe_delete(pHost);
 	safe_delete(pUser);
 	safe_delete(pPassword);
 	safe_delete(pDatabase);
-	pHost = strcpy(new char[strlen(iHost) + 1], iHost);
-	pUser = strcpy(new char[strlen(iUser) + 1], iUser);
+	pHost     = strcpy(new char[strlen(iHost) + 1], iHost);
+	pUser     = strcpy(new char[strlen(iUser) + 1], iUser);
 	pPassword = strcpy(new char[strlen(iPassword) + 1], iPassword);
 	pDatabase = strcpy(new char[strlen(iDatabase) + 1], iDatabase);
 	pCompress = iCompress;
-	pPort = iPort;
-	pSSL = iSSL;
+	pPort     = iPort;
+	pSSL      = iSSL;
 	return Open(errnum, errbuf);
 }
 
-bool DBcore::Open(uint32* errnum, char* errbuf) {
-	if (errbuf)
+bool DBcore::Open(uint32 *errnum, char *errbuf)
+{
+	if (errbuf) {
 		errbuf[0] = 0;
+	}
 	LockMutex lock(&MDatabase);
-	if (GetStatus() == Connected)
+	if (GetStatus() == Connected) {
 		return true;
+	}
 	if (GetStatus() == Error) {
 		mysql_close(&mysql);
-		mysql_init(&mysql);		// Initialize structure again
+		mysql_init(&mysql);        // Initialize structure again
 	}
-	if (!pHost)
+	if (!pHost) {
 		return false;
+	}
 	/*
 	Added CLIENT_FOUND_ROWS flag to the connect
 	otherwise DB update calls would say 0 rows affected when the value already equalled
 	what the function was tring to set it to, therefore the function would think it failed
 	*/
 	uint32 flags = CLIENT_FOUND_ROWS;
-	if (pCompress)
+	if (pCompress) {
 		flags |= CLIENT_COMPRESS;
-	if (pSSL)
+	}
+	if (pSSL) {
 		flags |= CLIENT_SSL;
+	}
 	if (mysql_real_connect(&mysql, pHost, pUser, pPassword, pDatabase, pPort, 0, flags)) {
 		pStatus = Connected;
+
+		std::string connected_origin_host = pHost;
+		SetOriginHost(connected_origin_host);
+
 		return true;
 	}
 	else {
-		if (errnum)
+		if (errnum) {
 			*errnum = mysql_errno(&mysql);
-		if (errbuf)
+		}
+		if (errbuf) {
 			snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+		}
 		pStatus = Error;
 		return false;
 	}
 }
 
+void DBcore::SetMysql(MYSQL *mysql)
+{
+	DBcore::mysql = *mysql;
+}
 
+const std::string &DBcore::GetOriginHost() const
+{
+	return origin_host;
+}
 
-
-
-
+void DBcore::SetOriginHost(const std::string &origin_host)
+{
+	DBcore::origin_host = origin_host;
+}

common/dbcore.h

@@ -2,8 +2,8 @@
 #define DBCORE_H
 
 #ifdef _WINDOWS
-	#include <winsock2.h>
-	#include <windows.h>
+#include <winsock2.h>
+#include <windows.h>
 #endif
 
 #include "../common/mutex.h"
@@ -15,36 +15,57 @@
 
 class DBcore {
 public:
-	enum eStatus { Closed, Connected, Error };
+	enum eStatus {
+		Closed, Connected, Error
+	};
 
 	DBcore();
 	~DBcore();
-	eStatus	GetStatus() { return pStatus; }
-	MySQLRequestResult	QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce = true);
-	MySQLRequestResult	QueryDatabase(std::string query, bool retryOnFailureOnce = true);
+	eStatus GetStatus() { return pStatus; }
+	MySQLRequestResult QueryDatabase(const char *query, uint32 querylen, bool retryOnFailureOnce = true);
+	MySQLRequestResult QueryDatabase(std::string query, bool retryOnFailureOnce = true);
 	void TransactionBegin();
 	void TransactionCommit();
 	void TransactionRollback();
-	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
-	void	ping();
-	MYSQL*	getMySQL(){ return &mysql; }
+	uint32 DoEscapeString(char *tobuf, const char *frombuf, uint32 fromlen);
+	void ping();
+	MYSQL *getMySQL() { return &mysql; }
+	void SetMysql(MYSQL *mysql);
+
+	const std::string &GetOriginHost() const;
+	void SetOriginHost(const std::string &origin_host);
+
+	bool DoesTableExist(std::string table_name);
 
 protected:
-	bool	Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase, uint32 iPort, uint32* errnum = 0, char* errbuf = 0, bool iCompress = false, bool iSSL = false);
-private:
-	bool	Open(uint32* errnum = 0, char* errbuf = 0);
+	bool Open(
+		const char *iHost,
+		const char *iUser,
+		const char *iPassword,
+		const char *iDatabase,
+		uint32 iPort,
+		uint32 *errnum = 0,
+		char *errbuf = 0,
+		bool iCompress = false,
+		bool iSSL = false
+	);
 
-	MYSQL	mysql;
-	Mutex	MDatabase;
+private:
+	bool Open(uint32 *errnum = nullptr, char *errbuf = nullptr);
+
+	MYSQL   mysql;
+	Mutex   MDatabase;
 	eStatus pStatus;
 
-	char*	pHost;
-	char*	pUser;
-	char*	pPassword;
-	char*	pDatabase;
-	bool	pCompress;
-	uint32	pPort;
-	bool	pSSL;
+	std::string origin_host;
+
+	char   *pHost;
+	char   *pUser;
+	char   *pPassword;
+	char   *pDatabase;
+	bool   pCompress;
+	uint32 pPort;
+	bool   pSSL;
 
 };
 

common/deity.cpp

@@ -20,7 +20,7 @@
 #include "deity.h"
 
 
-EQEmu::deity::DeityTypeBit EQEmu::deity::ConvertDeityTypeToDeityTypeBit(DeityType deity_type)
+EQ::deity::DeityTypeBit EQ::deity::ConvertDeityTypeToDeityTypeBit(DeityType deity_type)
 {
 	switch (deity_type) {
 	case DeityBertoxxulous:
@@ -63,7 +63,7 @@ EQEmu::deity::DeityTypeBit EQEmu::deity::ConvertDeityTypeToDeityTypeBit(DeityTyp
 	};
 }
 
-EQEmu::deity::DeityType EQEmu::deity::ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit)
+EQ::deity::DeityType EQ::deity::ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit)
 {
 	switch (deity_type_bit) {
 	case bit_DeityAgnostic:
@@ -105,7 +105,7 @@ EQEmu::deity::DeityType EQEmu::deity::ConvertDeityTypeBitToDeityType(DeityTypeBi
 	};
 }
 
-const char* EQEmu::deity::DeityName(DeityType deity_type)
+const char* EQ::deity::DeityName(DeityType deity_type)
 {
 	switch (deity_type) {
 	case DeityBertoxxulous:

common/deity.h

@@ -23,7 +23,7 @@
 #include "types.h"
 
 
-namespace EQEmu
+namespace EQ
 {
 	namespace deity {
 		enum DeityType {
@@ -49,7 +49,7 @@ namespace EQEmu
 		};
 
 		enum DeityTypeBit : uint32 {
-			bit_DeityAll = 0x00000000,
+			bit_DeityNone = 0x00000000,
 			bit_DeityAgnostic = 0x00000001,
 			bit_DeityBertoxxulous = 0x00000002,
 			bit_DeityBrellSirilis = 0x00000004,
@@ -66,7 +66,8 @@ namespace EQEmu
 			bit_DeitySolusekRo = 0x00002000,
 			bit_DeityTheTribunal = 0x00004000,
 			bit_DeityTunare = 0x00008000,
-			bit_DeityVeeshan = 0x00010000
+			bit_DeityVeeshan = 0x00010000,
+			bit_DeityAll = 0xFFFFFFFF
 		};
 
 		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);

common/emu_constants.cpp

@@ -18,3 +18,137 @@
 */
 
 #include "emu_constants.h"
+
+
+int16 EQ::invtype::GetInvTypeSize(int16 inv_type) {
+	static const int16 local_array[] = {
+		POSSESSIONS_SIZE,
+		BANK_SIZE,
+		SHARED_BANK_SIZE,
+		TRADE_SIZE,
+		WORLD_SIZE,
+		LIMBO_SIZE,
+		TRIBUTE_SIZE,
+		TROPHY_TRIBUTE_SIZE,
+		GUILD_TRIBUTE_SIZE,
+		MERCHANT_SIZE,
+		DELETED_SIZE,
+		CORPSE_SIZE,
+		BAZAAR_SIZE,
+		INSPECT_SIZE,
+		REAL_ESTATE_SIZE,
+		VIEW_MOD_PC_SIZE,
+		VIEW_MOD_BANK_SIZE,
+		VIEW_MOD_SHARED_BANK_SIZE,
+		VIEW_MOD_LIMBO_SIZE,
+		ALT_STORAGE_SIZE,
+		ARCHIVED_SIZE,
+		MAIL_SIZE,
+		GUILD_TROPHY_TRIBUTE_SIZE,
+		KRONO_SIZE,
+		OTHER_SIZE,
+	};
+
+	if (inv_type < TYPE_BEGIN || inv_type > TYPE_END)
+		return INULL;
+
+	return local_array[inv_type];
+}
+
+const char* EQ::bug::CategoryIDToCategoryName(CategoryID category_id) {
+	switch (category_id) {
+	case catVideo:
+		return "Video";
+	case catAudio:
+		return "Audio";
+	case catPathing:
+		return "Pathing";
+	case catQuest:
+		return "Quest";
+	case catTradeskills:
+		return "Tradeskills";
+	case catSpellStacking:
+		return "Spell stacking";
+	case catDoorsPortals:
+		return "Doors/Portals";
+	case catItems:
+		return "Items";
+	case catNPC:
+		return "NPC";
+	case catDialogs:
+		return "Dialogs";
+	case catLoNTCG:
+		return "LoN - TCG";
+	case catMercenaries:
+		return "Mercenaries";
+	case catOther:
+	default:
+		return "Other";
+	}
+}
+
+EQ::bug::CategoryID EQ::bug::CategoryNameToCategoryID(const char* category_name) {
+	if (!category_name)
+		return catOther;
+
+	if (!strcmp(category_name, "Video"))
+		return catVideo;
+	if (!strcmp(category_name, "Audio"))
+		return catAudio;
+	if (!strcmp(category_name, "Pathing"))
+		return catPathing;
+	if (!strcmp(category_name, "Quest"))
+		return catQuest;
+	if (!strcmp(category_name, "Tradeskills"))
+		return catTradeskills;
+	if (!strcmp(category_name, "Spell stacking"))
+		return catSpellStacking;
+	if (!strcmp(category_name, "Doors/Portals"))
+		return catDoorsPortals;
+	if (!strcmp(category_name, "Items"))
+		return catItems;
+	if (!strcmp(category_name, "NPC"))
+		return catNPC;
+	if (!strcmp(category_name, "Dialogs"))
+		return catDialogs;
+	if (!strcmp(category_name, "LoN - TCG"))
+		return catLoNTCG;
+	if (!strcmp(category_name, "Mercenaries"))
+		return catMercenaries;
+	
+	return catOther;
+}
+
+const char *EQ::constants::GetStanceName(StanceType stance_type) {
+	switch (stance_type) {
+	case stanceUnknown:
+		return "Unknown";
+	case stancePassive:
+		return "Passive";
+	case stanceBalanced:
+		return "Balanced";
+	case stanceEfficient:
+		return "Efficient";
+	case stanceReactive:
+		return "Reactive";
+	case stanceAggressive:
+		return "Aggressive";
+	case stanceAssist:
+		return "Assist";
+	case stanceBurn:
+		return "Burn";
+	case stanceEfficient2:
+		return "Efficient2";
+	case stanceBurnAE:
+		return "BurnAE";
+	default:
+		return "Invalid";
+	}
+}
+
+int EQ::constants::ConvertStanceTypeToIndex(StanceType stance_type) {
+	if (stance_type >= EQ::constants::stancePassive && stance_type <= EQ::constants::stanceBurnAE)
+		return (stance_type - EQ::constants::stancePassive);
+
+	return 0;
+}

common/emu_constants.h

@@ -21,32 +21,317 @@
 #define COMMON_EMU_CONSTANTS_H
 
 #include "eq_limits.h"
-#include "emu_legacy.h"
-#include "inventory_version.h"
-//#include "deity.h"
-//#include "say_link.h"
+#include "emu_versions.h"
 
-#include <string>
+#include <string.h>
 
 
-namespace EQEmu
+// local definitions are the result of using hybrid-client or server-only values and methods
+namespace EQ
 {
+	using RoF2::IINVALID;
+	using RoF2::INULL;
+	
 	namespace inventory {
-		//using namespace RoF2::invtype;
-		//using namespace RoF2::invslot;
-		//using namespace RoF2::invbag;
-		//using namespace RoF2::invaug;
-
+		
 	} /*inventory*/
 
-	namespace constants {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
+	namespace invtype {
+		using namespace RoF2::invtype::enum_;
 
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
+		using RoF2::invtype::POSSESSIONS_SIZE;
+		using RoF2::invtype::BANK_SIZE;
+		using RoF2::invtype::SHARED_BANK_SIZE;
+		using RoF2::invtype::TRADE_SIZE;
+		using RoF2::invtype::WORLD_SIZE;
+		using RoF2::invtype::LIMBO_SIZE;
+		using RoF2::invtype::TRIBUTE_SIZE;
+		using RoF2::invtype::TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::GUILD_TRIBUTE_SIZE;
+		using RoF2::invtype::MERCHANT_SIZE;
+		using RoF2::invtype::DELETED_SIZE;
+		using RoF2::invtype::CORPSE_SIZE;
+		using RoF2::invtype::BAZAAR_SIZE;
+		using RoF2::invtype::INSPECT_SIZE;
+		using RoF2::invtype::REAL_ESTATE_SIZE;
+		using RoF2::invtype::VIEW_MOD_PC_SIZE;
+		using RoF2::invtype::VIEW_MOD_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_LIMBO_SIZE;
+		using RoF2::invtype::ALT_STORAGE_SIZE;
+		using RoF2::invtype::ARCHIVED_SIZE;
+		using RoF2::invtype::MAIL_SIZE;
+		using RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::KRONO_SIZE;
+		using RoF2::invtype::OTHER_SIZE;
+
+		using Titanium::invtype::TRADE_NPC_SIZE;
+
+		using RoF2::invtype::TYPE_INVALID;
+		using RoF2::invtype::TYPE_BEGIN;
+		using RoF2::invtype::TYPE_END;
+		using RoF2::invtype::TYPE_COUNT;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		using RoF2::invtype::GetInvTypeName;
+
+	} // namespace invtype
+
+	namespace DevTools {
+		const int32 GM_ACCOUNT_STATUS_LEVEL = 150;
+	}
+
+	namespace popupresponse {
+		const int32 SERVER_INTERNAL_USE_BASE = 2000000000;
+		const int32 MOB_INFO_DISMISS         = 2000000001;
+	}
+
+	namespace invslot {
+		using namespace RoF2::invslot::enum_;
+
+		using RoF2::invslot::SLOT_INVALID;
+		using RoF2::invslot::SLOT_BEGIN;
+
+		using Titanium::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
+
+		const int16 SLOT_AUGMENT_GENERIC_RETURN = 1001; // clients don't appear to use this method... (internal inventory return value)
+
+		using RoF2::invslot::POSSESSIONS_BEGIN;
+		using RoF2::invslot::POSSESSIONS_END;
+		using RoF2::invslot::POSSESSIONS_COUNT;
+
+		using RoF2::invslot::EQUIPMENT_BEGIN;
+		using RoF2::invslot::EQUIPMENT_END;
+		using RoF2::invslot::EQUIPMENT_COUNT;
+
+		using RoF2::invslot::GENERAL_BEGIN;
+		using RoF2::invslot::GENERAL_END;
+		using RoF2::invslot::GENERAL_COUNT;
+
+		using RoF2::invslot::BONUS_BEGIN;
+		using RoF2::invslot::BONUS_STAT_END;
+		using RoF2::invslot::BONUS_SKILL_END;
+
+		using Titanium::invslot::BANK_BEGIN;
+		using SoF::invslot::BANK_END;
+
+		using Titanium::invslot::SHARED_BANK_BEGIN;
+		using Titanium::invslot::SHARED_BANK_END;
+
+		using Titanium::invslot::TRADE_BEGIN;
+		using Titanium::invslot::TRADE_END;
+
+		using Titanium::invslot::TRADE_NPC_END;
+
+		using Titanium::invslot::WORLD_BEGIN;
+		using Titanium::invslot::WORLD_END;
+
+		using Titanium::invslot::TRIBUTE_BEGIN;
+		using Titanium::invslot::TRIBUTE_END;
+
+		using Titanium::invslot::GUILD_TRIBUTE_BEGIN;
+		using Titanium::invslot::GUILD_TRIBUTE_END;
+
+		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
+		const int16 CORPSE_END = CORPSE_BEGIN + invslot::slotCursor;
+
+		using RoF2::invslot::EQUIPMENT_BITMASK;
+		using RoF2::invslot::GENERAL_BITMASK;
+		using RoF2::invslot::CURSOR_BITMASK;
+		using RoF2::invslot::POSSESSIONS_BITMASK;
+		using RoF2::invslot::CORPSE_BITMASK;
+
+		using RoF2::invslot::GetInvPossessionsSlotName;
+		using RoF2::invslot::GetInvSlotName;
+
+	} // namespace invslot
+
+	namespace invbag {
+		using Titanium::invbag::SLOT_INVALID;
+		using Titanium::invbag::SLOT_BEGIN;
+		using Titanium::invbag::SLOT_END;
+		using Titanium::invbag::SLOT_COUNT;
+
+		using Titanium::invbag::GENERAL_BAGS_BEGIN;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		const int16 GENERAL_BAGS_8_COUNT = 8 * SLOT_COUNT;
+		const int16 GENERAL_BAGS_8_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
+
+		const int16 CURSOR_BAG_BEGIN = 351;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		using Titanium::invbag::BANK_BAGS_BEGIN;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 BANK_BAGS_16_COUNT = 16 * SLOT_COUNT;
+		const int16 BANK_BAGS_16_END = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
+
+		using Titanium::invbag::SHARED_BANK_BAGS_BEGIN;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::TRADE_BAGS_BEGIN;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::GetInvBagIndexName;
+
+	} // namespace invbag
+
+	namespace invaug {
+		using RoF2::invaug::SOCKET_INVALID;
+		using RoF2::invaug::SOCKET_BEGIN;
+		using RoF2::invaug::SOCKET_END;
+		using RoF2::invaug::SOCKET_COUNT;
+
+		using RoF2::invaug::GetInvAugIndexName;
+
+	} // namespace invaug
+
+	namespace constants {
+		const EQ::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQ::versions::ClientVersion::Titanium;
+
+		using RoF2::constants::EXPANSION;
+		using RoF2::constants::EXPANSION_BIT;
+		using RoF2::constants::EXPANSIONS_MASK;
+
+		using RoF2::constants::CHARACTER_CREATION_LIMIT;
+		
+		const size_t SAY_LINK_OPENER_SIZE = 1;
+		using RoF2::constants::SAY_LINK_BODY_SIZE;
+		const size_t SAY_LINK_TEXT_SIZE = 256; // this may be varied until it breaks something (tested:374) - the others are constant
+		const size_t SAY_LINK_CLOSER_SIZE = 1;
+		const size_t SAY_LINK_MAXIMUM_SIZE = (SAY_LINK_OPENER_SIZE + SAY_LINK_BODY_SIZE + SAY_LINK_TEXT_SIZE + SAY_LINK_CLOSER_SIZE);
+
+		enum StanceType : int {
+			stanceUnknown = 0,
+			stancePassive,
+			stanceBalanced,
+			stanceEfficient,
+			stanceReactive,
+			stanceAggressive,
+			stanceAssist,
+			stanceBurn,
+			stanceEfficient2,
+			stanceBurnAE
+		};
+
+		const char *GetStanceName(StanceType stance_type);
+		int ConvertStanceTypeToIndex(StanceType stance_type);
+
+		const int STANCE_TYPE_FIRST = stancePassive;
+		const int STANCE_TYPE_LAST = stanceBurnAE;
+		const int STANCE_TYPE_COUNT = stanceBurnAE;
 
 	} /*constants*/
 
+	namespace profile {
+		using RoF2::profile::BANDOLIERS_SIZE;
+		using RoF2::profile::BANDOLIER_ITEM_COUNT;
+		
+		using RoF2::profile::POTION_BELT_SIZE;
+
+		using RoF2::profile::SKILL_ARRAY_SIZE;
+
+	} // namespace profile
+
+	namespace behavior {
+		using RoF2::behavior::CoinHasWeight;
+
+	} // namespace behavior
+
+	namespace spells {
+		enum class CastingSlot : uint32 { // hybrid declaration
+			Gem1 = 0,
+			Gem2 = 1,
+			Gem3 = 2,
+			Gem4 = 3,
+			Gem5 = 4,
+			Gem6 = 5,
+			Gem7 = 6,
+			Gem8 = 7,
+			Gem9 = 8,
+			Gem10 = 9,
+			Gem11 = 10,
+			Gem12 = 11,
+			MaxGems = 12,
+			Ability = 20, // HT/LoH for Tit
+			PotionBelt = 21, // Tit uses a different slot for PB
+			Item = 22,
+			Discipline = 23,
+			AltAbility = 0xFF
+		};
+
+		using RoF2::spells::SPELL_ID_MAX;
+		using RoF2::spells::SPELLBOOK_SIZE;
+		using UF::spells::SPELL_GEM_COUNT; // RoF+ clients define more than UF client..but, they are not valid beyond UF
+
+		using RoF2::spells::LONG_BUFFS;
+		using RoF2::spells::SHORT_BUFFS;
+		using RoF2::spells::DISC_BUFFS;
+		using RoF2::spells::TOTAL_BUFFS;
+		using RoF2::spells::NPC_BUFFS;
+		using RoF2::spells::PET_BUFFS;
+		using RoF2::spells::MERC_BUFFS;
+
+	} // namespace spells
+
+	namespace bug {
+		enum CategoryID : uint32 {
+			catOther = 0,
+			catVideo,
+			catAudio,
+			catPathing,
+			catQuest,
+			catTradeskills,
+			catSpellStacking,
+			catDoorsPortals,
+			catItems,
+			catNPC,
+			catDialogs,
+			catLoNTCG,
+			catMercenaries
+		};
+
+		enum OptionalInfoFlag : uint32 {
+			infoNoOptionalInfo = 0x0,
+			infoCanDuplicate = 0x1,
+			infoCrashBug = 0x2,
+			infoTargetInfo = 0x4,
+			infoCharacterFlags = 0x8,
+			infoUnknownValue = 0xFFFFFFF0
+		};
+
+		const char* CategoryIDToCategoryName(CategoryID category_id);
+		CategoryID CategoryNameToCategoryID(const char* category_name);
+
+	} // namespace bug
+
+	enum WaypointStatus : int {
+		RoamBoxPauseInProgress = -3,
+		QuestControlNoGrid = -2,
+		QuestControlGrid = -1
+	};
+
+	namespace consent {
+		enum eConsentType : uint8 {
+			Normal = 0,
+			Group,
+			Raid,
+			Guild
+		};
+	}; // namespace consent
+
 } /*EQEmu*/
 
 #endif /*COMMON_EMU_CONSTANTS_H*/
+
+/*	hack list to prevent circular references
+	
+	eq_limits.h:EQ::inventory::LookupEntry::InventoryTypeSize[n];
+
+*/

common/emu_legacy.h

@@ -1,275 +0,0 @@
-/*	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
-*/
-
-#ifndef COMMON_EMU_LEGACY_H
-#define COMMON_EMU_LEGACY_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	// this is for perl and other legacy systems
-	namespace legacy {
-		enum InventorySlot {
-			SLOT_CHARM = 0,
-			SLOT_EAR01 = 1,
-			SLOT_HEAD = 2,
-			SLOT_FACE = 3,
-			SLOT_EAR02 = 4,
-			SLOT_NECK = 5,
-			SLOT_SHOULDER = 6,
-			SLOT_ARMS = 7,
-			SLOT_BACK = 8,
-			SLOT_BRACER01 = 9,
-			SLOT_BRACER02 = 10,
-			SLOT_RANGE = 11,
-			SLOT_HANDS = 12,
-			SLOT_PRIMARY = 13,
-			SLOT_SECONDARY = 14,
-			SLOT_RING01 = 15,
-			SLOT_RING02 = 16,
-			SLOT_CHEST = 17,
-			SLOT_LEGS = 18,
-			SLOT_FEET = 19,
-			SLOT_WAIST = 20,
-			SLOT_POWER_SOURCE = 9999,
-			SLOT_AMMO = 21,
-			SLOT_GENERAL_1 = 22,
-			SLOT_GENERAL_2 = 23,
-			SLOT_GENERAL_3 = 24,
-			SLOT_GENERAL_4 = 25,
-			SLOT_GENERAL_5 = 26,
-			SLOT_GENERAL_6 = 27,
-			SLOT_GENERAL_7 = 28,
-			SLOT_GENERAL_8 = 29,
-			//SLOT_GENERAL_9 = not supported
-			//SLOT_GENERAL_10 = not supported
-			SLOT_CURSOR = 30,
-			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
-			SLOT_TRADESKILL = 1000,
-			SLOT_AUGMENT = 1001,
-			SLOT_INVALID = (int16)0xFFFF,
-			SLOT_POSSESSIONS_BEGIN = 0,
-			SLOT_POSSESSIONS_END = 30,
-			SLOT_EQUIPMENT_BEGIN = 0,
-			SLOT_EQUIPMENT_END = 21,
-			SLOT_PERSONAL_BEGIN = 22,
-			SLOT_PERSONAL_END = 29,
-			SLOT_PERSONAL_BAGS_BEGIN = 251,
-			SLOT_PERSONAL_BAGS_END = 330,
-			SLOT_CURSOR_BAG_BEGIN = 331,
-			SLOT_CURSOR_BAG_END = 340,
-			SLOT_TRIBUTE_BEGIN = 400,
-			SLOT_TRIBUTE_END = 404,
-			SLOT_BANK_BEGIN = 2000,
-			SLOT_BANK_END = 2023,
-			SLOT_BANK_BAGS_BEGIN = 2031,
-			SLOT_BANK_BAGS_END = 2270,
-			SLOT_SHARED_BANK_BEGIN = 2500,
-			SLOT_SHARED_BANK_END = 2501,
-			SLOT_SHARED_BANK_BAGS_BEGIN = 2531,
-			SLOT_SHARED_BANK_BAGS_END = 2550,
-			SLOT_TRADE_BEGIN = 3000,
-			SLOT_TRADE_END = 3007,
-			SLOT_TRADE_BAGS_BEGIN = 3031,
-			SLOT_TRADE_BAGS_END = 3110,
-			SLOT_WORLD_BEGIN = 4000,
-			SLOT_WORLD_END = 4009
-		};
-
-		enum InventoryTypes : int16 {
-			TypePossessions = 0,
-			TypeBank,
-			TypeSharedBank,
-			TypeTrade,
-			TypeWorld,
-			TypeLimbo, // 5
-			TypeTribute,
-			TypeTrophyTribute,
-			TypeGuildTribute,
-			TypeMerchant,
-			TypeDeleted, // 10
-			TypeCorpse,
-			TypeBazaar,
-			TypeInspect,
-			TypeRealEstate,
-			TypeViewMODPC, // 15
-			TypeViewMODBank,
-			TypeViewMODSharedBank,
-			TypeViewMODLimbo,
-			TypeAltStorage,
-			TypeArchived, // 20
-			TypeMail,
-			TypeGuildTrophyTribute,
-			TypeKrono,
-			TypeOther,
-			TypeCount
-		};
-
-		enum PossessionsSlots : int16 {
-			SlotCharm = 0,
-			SlotEar1,
-			SlotHead,
-			SlotFace,
-			SlotEar2,
-			SlotNeck, // 5
-			SlotShoulders,
-			SlotArms,
-			SlotBack,
-			SlotWrist1,
-			SlotWrist2, // 10
-			SlotRange,
-			SlotHands,
-			SlotPrimary,
-			SlotSecondary,
-			SlotFinger1, // 15
-			SlotFinger2,
-			SlotChest,
-			SlotLegs,
-			SlotFeet,
-			SlotWaist, // 20
-			SlotPowerSource = 9999, // temp
-			SlotAmmo = 21, // temp
-			SlotGeneral1,
-			SlotGeneral2,
-			SlotGeneral3,
-			SlotGeneral4, // 25
-			SlotGeneral5,
-			SlotGeneral6,
-			SlotGeneral7,
-			SlotGeneral8,
-			//SlotGeneral9,
-			//SlotGeneral10,
-			SlotCursor, // 30
-			SlotCount
-		};
-
-		enum MaterialSlots : uint8 {
-			MaterialHead = 0,
-			MaterialChest,
-			MaterialArms,
-			MaterialWrist,
-			MaterialHands,
-			MaterialLegs, // 5
-			MaterialFeet,
-			MaterialPrimary,
-			MaterialSecondary,
-			MaterialCount,
-			MaterialInvalid = 255
-		};
-
-		// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
-		static const uint16	TYPE_POSSESSIONS_SIZE = SlotCount;
-		static const uint16 TYPE_BANK_SIZE = 24;
-		static const uint16 TYPE_SHARED_BANK_SIZE = 2;
-		static const uint16 TYPE_TRADE_SIZE = 8;
-		static const uint16 TYPE_WORLD_SIZE = 10;
-		static const uint16 TYPE_LIMBO_SIZE = 36;
-		static const uint16 TYPE_TRIBUTE_SIZE = 5; // (need client values)
-		static const uint16 TYPE_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_GUILD_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_MERCHANT_SIZE = 0;
-		static const uint16 TYPE_DELETED_SIZE = 0;
-		static const uint16 TYPE_CORPSE_SIZE = SlotCount; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
-		static const uint16 TYPE_BAZAAR_SIZE = 80;
-		static const uint16 TYPE_INSPECT_SIZE = 22;
-		static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;//NOT_USED;
-		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;//NOT_USED;
-		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;//NOT_USED;
-		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;//NOT_USED;
-		static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
-		static const uint16 TYPE_ARCHIVED_SIZE = 0;
-		static const uint16 TYPE_MAIL_SIZE = 0;
-		static const uint16 TYPE_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_KRONO_SIZE = 0;
-		static const uint16 TYPE_OTHER_SIZE = 0;
-
-		// most of these definitions will go away with the structure-based system..this maintains compatibility for now
-		// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
-		static const int16 EQUIPMENT_BEGIN = SlotCharm;
-		static const int16 EQUIPMENT_END = SlotAmmo;
-		static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
-
-		static const int16 GENERAL_BEGIN = SlotGeneral1;
-		static const int16 GENERAL_END = SlotGeneral8;
-		static const uint16 GENERAL_SIZE = 8;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 79;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR_BAG_BEGIN = 331;
-		static const int16 CURSOR_BAG_END_OFFSET = 9;
-		static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
-
-		static const int16 BANK_BEGIN = 2000;
-		static const int16 BANK_END = 2023;
-		static const int16 BANK_BAGS_BEGIN = 2031;
-		static const int16 BANK_BAGS_END_OFFSET = 239;
-		static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
-
-		static const int16 SHARED_BANK_BEGIN = 2500;
-		static const int16 SHARED_BANK_END = 2501;
-		static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-		static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-		static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
-
-		static const int16 TRADE_BEGIN = 3000;
-		static const int16 TRADE_END = 3007;
-		static const int16 TRADE_NPC_END = 3003;
-		static const int16 TRADE_BAGS_BEGIN = 3031;
-		static const int16 TRADE_BAGS_END_OFFSET = 79;
-		static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
-
-		static const int16 WORLD_BEGIN = 4000;
-		static const int16 WORLD_END = 4009;
-		static const int16 WORLD_SIZE = TYPE_WORLD_SIZE;
-
-		static const int16 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-		static const int16 TRIBUTE_SIZE = TYPE_TRIBUTE_SIZE;
-
-		static const int16 CORPSE_BEGIN = 22;
-		//static const int16 CORPSE_END = RoF::consts::CORPSE_END; // not ready for use
-
-		static const int16 MATERIAL_BEGIN = MaterialHead;
-		static const int16 MATERIAL_END = MaterialSecondary;
-		static const int16 MATERIAL_TINT_END = MaterialFeet;
-		static const int16 MATERIAL_SIZE = MaterialCount;
-
-		// items
-		// common and container sizes will not increase until the new 'location' struct is implemented
-		static const uint16 ITEM_COMMON_SIZE = 6;//RoF::consts::ITEM_COMMON_SIZE;
-		static const uint16 ITEM_CONTAINER_SIZE = 10;//Titanium::consts::ITEM_CONTAINER_SIZE;
-
-		// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t BANDOLIERS_SIZE = 20;//RoF2::consts::BANDOLIERS_SIZE;			// number of bandolier instances
-		static const size_t BANDOLIER_ITEM_COUNT = 4;//RoF2::consts::BANDOLIER_ITEM_COUNT;	// number of equipment slots in bandolier instance
-
-		// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t POTION_BELT_ITEM_COUNT = 5;//RoF2::consts::POTION_BELT_ITEM_COUNT;
-
-		static const size_t TEXT_LINK_BODY_LENGTH = 56;//RoF2::consts::TEXT_LINK_BODY_LENGTH;
-	}
-}
-
-#endif /* COMMON_EMU_LEGACY_H */

common/emu_limits.cpp

@@ -1,4 +1,4 @@
-/*	EQEMu:  Everquest Server Emulator
+/*	EQEMu: Everquest Server Emulator
 	
 	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
@@ -10,7 +10,7 @@
 	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.
+	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

common/emu_limits.h

@@ -1,4 +1,4 @@
-/*	EQEMu:  Everquest Server Emulator
+/*	EQEMu: Everquest Server Emulator
 	
 	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
@@ -10,7 +10,7 @@
 	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.
+	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
@@ -27,29 +27,101 @@
 
 namespace EntityLimits
 {
-	namespace npc {
-		enum : int { Invalid = -1, Null, Safety };
+	namespace NPC {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
-	}
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-	namespace merc {
-		enum : int { Invalid = -1, Null, Safety };
+		} // namespace invtype
 
-		enum : bool { False = false, True = true };
-	}
+	} /*NPC*/
 
-	namespace bot {
-		enum : int { Invalid = -1, Null, Safety };
+	namespace NPCMerchant {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
-	}
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-	namespace pet {
-		enum : int { Invalid = -1, Null, Safety };
+		} // namespace invtype
 
-		enum : bool { False = false, True = true };
-	}
+	} /*NPCMerchant*/
+
+	namespace Merc {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
+
+		} // namespace invtype
+
+	} /*Merc*/
+
+	namespace Bot {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 8;
+
+		} // namespace invtype
+
+		namespace invslot {
+			const uint64 EQUIPMENT_BITMASK = 0x00000000007FFFFF;
+			const uint64 GENERAL_BITMASK = 0x0000000000000000;
+			const uint64 CURSOR_BITMASK = 0x0000000000000000;
+			const uint64 POSSESSIONS_BITMASK = (EQUIPMENT_BITMASK | GENERAL_BITMASK | CURSOR_BITMASK); // based on 34-slot count (RoF+)
+
+		} // namespace invslot
+
+	} /*Bot*/
+
+	namespace ClientPet {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
+
+		} // namespace invtype
+
+	} /*Pet*/
+
+	namespace NPCPet {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
+
+		} // namespace invtype
+
+	} /*Pet*/
+
+	namespace MercPet {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
+
+		} // namespace invtype
+
+	} /*Pet*/
+
+	namespace BotPet {
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
+
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
+
+		} // namespace invtype
+
+	} /*Pet*/
 
 }; /*EntityLimits*/
 

common/emu_oplist.h

@@ -1,14 +1,13 @@
 // system use
 N(OP_ExploreUnknown),
 // start (please add new opcodes in descending order and re-order any name changes where applicable)
-N(OP_0x0193),
-N(OP_0x0347),
 N(OP_AAAction),
 N(OP_AAExpUpdate),
 N(OP_AcceptNewTask),
 N(OP_AckPacket),
 N(OP_Action),
 N(OP_Action2),
+N(OP_AddNimbusEffect),
 N(OP_AdventureData),
 N(OP_AdventureDetails),
 N(OP_AdventureFinish),
@@ -25,6 +24,9 @@ N(OP_AdventureRequest),
 N(OP_AdventureStatsReply),
 N(OP_AdventureStatsRequest),
 N(OP_AdventureUpdate),
+N(OP_AggroMeterLockTarget),
+N(OP_AggroMeterTargetInfo),
+N(OP_AggroMeterUpdate),
 N(OP_AltCurrency),
 N(OP_AltCurrencyMerchantReply),
 N(OP_AltCurrencyMerchantRequest),
@@ -64,6 +66,7 @@ N(OP_BuffRemoveRequest),
 N(OP_Bug),
 N(OP_CameraEffect),
 N(OP_Camp),
+N(OP_CancelSneakHide),
 N(OP_CancelTask),
 N(OP_CancelTrade),
 N(OP_CastSpell),
@@ -131,20 +134,22 @@ N(OP_Dye),
 N(OP_DynamicWall),
 N(OP_DzAddPlayer),
 N(OP_DzChooseZone),
+N(OP_DzChooseZoneReply),
 N(OP_DzCompass),
 N(OP_DzExpeditionEndsWarning),
 N(OP_DzExpeditionInfo),
-N(OP_DzExpeditionList),
-N(OP_DzJoinExpeditionConfirm),
-N(OP_DzJoinExpeditionReply),
-N(OP_DzLeaderStatus),
+N(OP_DzExpeditionInvite),
+N(OP_DzExpeditionInviteResponse),
+N(OP_DzExpeditionLockoutTimers),
 N(OP_DzListTimers),
 N(OP_DzMakeLeader),
 N(OP_DzMemberList),
-N(OP_DzMemberStatus),
+N(OP_DzMemberListName),
+N(OP_DzMemberListStatus),
 N(OP_DzPlayerList),
 N(OP_DzQuit),
 N(OP_DzRemovePlayer),
+N(OP_DzSetLeaderName),
 N(OP_DzSwapPlayer),
 N(OP_Emote),
 N(OP_EndLootRequest),
@@ -266,6 +271,7 @@ N(OP_ItemVerifyRequest),
 N(OP_ItemViewUnknown),
 N(OP_Jump),
 N(OP_KeyRing),
+N(OP_KickPlayers),
 N(OP_KnowledgeBase),
 N(OP_LDoNButton),
 N(OP_LDoNDisarmTraps),
@@ -288,6 +294,7 @@ N(OP_LFGuild),
 N(OP_LFPCommand),
 N(OP_LFPGetMatchesRequest),
 N(OP_LFPGetMatchesResponse),
+N(OP_LinkedReuse),
 N(OP_LoadSpellSet),
 N(OP_LocInfo),
 N(OP_LockoutTimerInfo),
@@ -334,6 +341,7 @@ N(OP_MOTD),
 N(OP_MoveCoin),
 N(OP_MoveDoor),
 N(OP_MoveItem),
+N(OP_MoveMultipleItems),
 N(OP_MoveLogDisregard),
 N(OP_MoveLogRequest),
 N(OP_MultiLineMsg),
@@ -350,6 +358,7 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
+N(OP_PetCommandState),
 N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
@@ -385,6 +394,7 @@ N(OP_PVPLeaderBoardReply),
 N(OP_PVPLeaderBoardRequest),
 N(OP_PVPStats),
 N(OP_QueryResponseThing),
+N(OP_QueryUCSServerStatus),
 N(OP_RaidInvite),
 N(OP_RaidJoin),
 N(OP_RaidUpdate),
@@ -402,6 +412,7 @@ N(OP_ReloadUI),
 N(OP_RemoveAllDoors),
 N(OP_RemoveBlockedBuffs),
 N(OP_RemoveNimbusEffect),
+N(OP_RemoveTrap),
 N(OP_Report),
 N(OP_ReqClientSpawn),
 N(OP_ReqNewZone),
@@ -517,6 +528,7 @@ N(OP_TributeToggle),
 N(OP_TributeUpdate),
 N(OP_Untargetable),
 N(OP_UpdateAA),
+N(OP_UpdateAura),
 N(OP_UpdateLeadershipAA),
 N(OP_VetClaimReply),
 N(OP_VetClaimRequest),

common/emu_tcp_connection.cpp

@@ -1,818 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 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
-*/
-
-/*
-There are really two or three different objects shoe-hored into this
-connection object. Sombody really needs to factor out the relay link
-crap into its own subclass of this object, it will clean things up
-tremendously.
-*/
-
-#include "../common/global_define.h"
-
-#include <iostream>
-#include <string.h>
-
-#include "emu_tcp_connection.h"
-#include "emu_tcp_server.h"
-#include "../common/servertalk.h"
-
-#ifdef FREEBSD //Timothy Whitman - January 7, 2003
-	#define MSG_NOSIGNAL 0
-#endif
-
-#define TCPN_DEBUG				0
-#define TCPN_DEBUG_Console		0
-#define TCPN_DEBUG_Memory		0
-#define TCPN_LOG_PACKETS		0
-#define TCPN_LOG_RAW_DATA_OUT	0
-#define TCPN_LOG_RAW_DATA_IN	0
-
-
-//server side case
-EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_socket, uint32 irIP, uint16 irPort, bool iOldFormat)
-:	TCPConnection(ID, in_socket, irIP, irPort),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	id = 0;
-	Server = nullptr;
-	pOldFormat = iOldFormat;
-	#ifdef MINILOGIN
-		TCPMode = modePacket;
-		PacketMode = packetModeLogin;
-	#else
-		if (pOldFormat)
-			TCPMode = modePacket;
-		else
-			TCPMode = modeConsole;
-		PacketMode = packetModeZone;
-	#endif
-	RelayLink = 0;
-	RelayServer = false;
-	RelayCount = 0;
-	RemoteID = 0;
-
-}
-
-//client outgoing connection case (and client side relay)
-EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer, eTCPMode iMode)
-:	TCPConnection(),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	Server = iRelayServer;
-	if (Server)
-		RelayServer = true;
-	else
-		RelayServer = false;
-	RelayLink = 0;
-	RelayCount = 0;
-	RemoteID = 0;
-	pOldFormat = iOldFormat;
-	TCPMode = iMode;
-	PacketMode = packetModeZone;
-#if TCPN_DEBUG_Memory >= 7
-	std::cout << "Constructor #1 on outgoing TCP# " << GetID() << std::endl;
-#endif
-}
-
-//server side relay case
-EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort)
-:	TCPConnection(ID, 0, irIP, irPort),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	Server = iServer;
-	RelayLink = iRelayLink;
-	RelayServer = true;
-	RelayCount = 0;
-	RemoteID = iRemoteID;
-	pOldFormat = false;
-	ConnectionType = Incoming;
-	TCPMode = modePacket;
-	PacketMode = packetModeZone;
-#if TCPN_DEBUG_Memory >= 7
-	std::cout << "Constructor #3 on outgoing TCP# " << GetID() << std::endl;
-#endif
-}
-
-EmuTCPConnection::~EmuTCPConnection() {
-	//the queues free their content right now I believe.
-}
-
-EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32 iDestination) {
-	int32 size = sizeof(EmuTCPNetPacket_Struct) + pack->size;
-	if (pack->compressed) {
-		size += 4;
-	}
-	if (iDestination) {
-		size += 4;
-	}
-	EmuTCPNetPacket_Struct* tnps = (EmuTCPNetPacket_Struct*) new uchar[size];
-	tnps->size = size;
-	tnps->opcode = pack->opcode;
-	*((uint8*) &tnps->flags) = 0;
-	uchar* buffer = tnps->buffer;
-	if (pack->compressed) {
-		tnps->flags.compressed = 1;
-		*((int32*) buffer) = pack->InflatedSize;
-		buffer += 4;
-	}
-	if (iDestination) {
-		tnps->flags.destination = 1;
-		*((int32*) buffer) = iDestination;
-		buffer += 4;
-	}
-	memcpy(buffer, pack->pBuffer, pack->size);
-	return tnps;
-}
-
-SPackSendQueue* EmuTCPConnection::MakeOldPacket(ServerPacket* pack) {
-	SPackSendQueue* spsq = (SPackSendQueue*) new uchar[sizeof(SPackSendQueue) + pack->size + 4];
-	if (pack->pBuffer != 0 && pack->size != 0)
-		memcpy((char *) &spsq->buffer[4], (char *) pack->pBuffer, pack->size);
-	memcpy((char *) &spsq->buffer[0], (char *) &pack->opcode, 2);
-	spsq->size = pack->size+4;
-	memcpy((char *) &spsq->buffer[2], (char *) &spsq->size, 2);
-	return spsq;
-}
-
-bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
-	if (!Connected())
-		return false;
-	eTCPMode tmp = GetMode();
-	if (tmp != modePacket && tmp != modeTransition)
-		return false;
-	LockMutex lock(&MState);
-	if (RemoteID)
-		return RelayLink->SendPacket(pack, RemoteID);
-	else if (pOldFormat) {
-		#if TCPN_LOG_PACKETS >= 1
-			if (pack && pack->opcode != 0) {
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				CoutTimestamp(true);
-				std::cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-				#if TCPN_LOG_PACKETS == 2
-					if (pack->size >= 32)
-						DumpPacket(pack->pBuffer, 32);
-					else
-						DumpPacket(pack);
-				#endif
-				#if TCPN_LOG_PACKETS >= 3
-					DumpPacket(pack);
-				#endif
-			}
-		#endif
-		SPackSendQueue* spsq = MakeOldPacket(pack);
-		ServerSendQueuePushEnd(spsq->buffer, spsq->size);
-		safe_delete_array(spsq);
-	}
-	else {
-		EmuTCPNetPacket_Struct* tnps = MakePacket(pack, iDestination);
-		if (tmp == modeTransition) {
-			InModeQueuePush(tnps);
-		}
-		else {
-			#if TCPN_LOG_PACKETS >= 1
-				if (pack && pack->opcode != 0) {
-					struct in_addr	in;
-					in.s_addr = GetrIP();
-					CoutTimestamp(true);
-					std::cout << ": Logging outgoing TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-					#if TCPN_LOG_PACKETS == 2
-						if (pack->size >= 32)
-							DumpPacket(pack->pBuffer, 32);
-						else
-							DumpPacket(pack);
-					#endif
-					#if TCPN_LOG_PACKETS >= 3
-						DumpPacket(pack);
-					#endif
-				}
-			#endif
-			ServerSendQueuePushEnd((uchar**) &tnps, tnps->size);
-		}
-	}
-	return true;
-}
-
-bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
-	if (RemoteID)
-		return false;
-	if (!Connected())
-		return false;
-	if (GetMode() != modePacket)
-		return false;
-
-	LockMutex lock(&MState);
-	eTCPMode tmp = GetMode();
-	if (tmp == modeTransition) {
-		EmuTCPNetPacket_Struct* tnps2 = (EmuTCPNetPacket_Struct*) new uchar[tnps->size];
-		memcpy(tnps2, tnps, tnps->size);
-		InModeQueuePush(tnps2);
-		return true;
-	}
-	#if TCPN_LOG_PACKETS >= 1
-		if (tnps && tnps->opcode != 0) {
-			struct in_addr	in;
-			in.s_addr = GetrIP();
-			CoutTimestamp(true);
-			std::cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << tnps->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort();
-			if (pOldFormat)
-				std::cout << " (OldFormat)";
-			std::cout << std::endl;
-			#if TCPN_LOG_PACKETS == 2
-				if (tnps->size >= 32)
-					DumpPacket((uchar*) tnps, 32);
-				else
-					DumpPacket((uchar*) tnps, tnps->size);
-			#endif
-			#if TCPN_LOG_PACKETS >= 3
-				DumpPacket((uchar*) tnps, tnps->size);
-			#endif
-		}
-	#endif
-	ServerSendQueuePushEnd((const uchar*) tnps, tnps->size);
-	return true;
-}
-
-ServerPacket* EmuTCPConnection::PopPacket() {
-	ServerPacket* ret;
-	if (!MOutQueueLock.trylock())
-		return nullptr;
-	ret = OutQueue.pop();
-	MOutQueueLock.unlock();
-	return ret;
-}
-
-void EmuTCPConnection::InModeQueuePush(EmuTCPNetPacket_Struct* tnps) {
-	MSendQueue.lock();
-	InModeQueue.push(tnps);
-	MSendQueue.unlock();
-}
-
-void EmuTCPConnection::OutQueuePush(ServerPacket* pack) {
-	MOutQueueLock.lock();
-	OutQueue.push(pack);
-	MOutQueueLock.unlock();
-}
-
-
-bool EmuTCPConnection::LineOutQueuePush(char* line) {
-	#if defined(GOTFRAGS) && 0
-		if (strcmp(line, "**CRASHME**") == 0) {
-			int i = 0;
-			std::cout << (5 / i) << std::endl;
-		}
-	#endif
-	if(line[0] == '*') {
-		if (strcmp(line, "**PACKETMODE**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODE**\r", 16);
-			TCPMode = modePacket;
-			PacketMode = packetModeLogin;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEZONE**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEZONE**\r", 20);
-			TCPMode = modePacket;
-			PacketMode = packetModeZone;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODELAUNCHER**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODELAUNCHER**\r", 24);
-			TCPMode = modePacket;
-			PacketMode = packetModeLauncher;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEUCS**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEUCS**\r", 19);
-			TCPMode = modePacket;
-			PacketMode = packetModeUCS;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEQS**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEQS**\r", 18);
-			TCPMode = modePacket;
-			PacketMode = packetModeQueryServ;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-	}
-
-	return(TCPConnection::LineOutQueuePush(line));
-}
-
-void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
-	TCPConnection::Disconnect();
-
-	if (RelayLink) {
-		RelayLink->RemoveRelay(this, iSendRelayDisconnect);
-		RelayLink = 0;
-	}
-}
-
-bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
-	if(!TCPConnection::ConnectIP(irIP, irPort, errbuf))
-		return(false);
-
-	MSendQueue.lock();
-	#ifdef MINILOGIN
-		TCPMode = modePacket;
-	#else
-		if (pOldFormat) {
-			TCPMode = modePacket;
-		}
-		else if (TCPMode == modePacket || TCPMode == modeTransition) {
-			TCPMode = modeTransition;
-			if(PacketMode == packetModeLauncher) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 24;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODELAUNCHER**\r", sendbuf_size);
-			} else if(PacketMode == packetModeLogin) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 16;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODE**\r", sendbuf_size);
-			} else if(PacketMode == packetModeUCS) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 19;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEUCS**\r", sendbuf_size);
-			}
-			else if(PacketMode == packetModeQueryServ) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 18;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEQS**\r", sendbuf_size);
-			} 
-			else {
-				//default: packetModeZone
-				safe_delete_array(sendbuf);
-				sendbuf_size = 20;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEZONE**\r", sendbuf_size);
-			}
-		}
-	#endif
-	MSendQueue.unlock();
-
-	return(true);
-}
-
-void EmuTCPConnection::ClearBuffers() {
-	TCPConnection::ClearBuffers();
-
-	LockMutex lock2(&MOutQueueLock);
-	ServerPacket* pack = 0;
-	while ((pack = OutQueue.pop()))
-		safe_delete(pack);
-
-	EmuTCPNetPacket_Struct* tnps = 0;
-	while ((tnps = InModeQueue.pop()))
-		safe_delete(tnps);
-
-	keepalive_timer.Start();
-	timeout_timer.Start();
-}
-
-void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
-	#if TCPC_DEBUG >= 1
-		struct in_addr	in;
-		in.s_addr = GetrIP();
-		std::cout "NetError: '";
-		if (reason)
-			std::cout << reason;
-		std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-	#endif
-		auto pack = new ServerPacket(0);
-		pack->size = 1;
-		if (reason)
-			pack->size += strlen(reason) + 1;
-		pack->pBuffer = new uchar[pack->size];
-		memset(pack->pBuffer, 0, pack->size);
-		pack->pBuffer[0] = 255;
-		strcpy((char *)&pack->pBuffer[1], reason);
-		SendPacket(pack);
-		safe_delete(pack);
-}
-
-void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect) {
-	if (iSendRelayDisconnect) {
-		auto pack = new ServerPacket(0, 5);
-		pack->pBuffer[0] = 3;
-		*((uint32*) &pack->pBuffer[1]) = relay->GetRemoteID();
-		SendPacket(pack);
-		safe_delete(pack);
-	}
-	RelayCount--;
-}
-
-
-
-bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
-	if (errbuf)
-		errbuf[0] = 0;
-	timeout_timer.Start();
-	if (!recvbuf)
-		return true;
-	if (TCPMode == modePacket) {
-		if (pOldFormat)
-			return ProcessReceivedDataAsOldPackets(errbuf);
-		else
-			return ProcessReceivedDataAsPackets(errbuf);
-	}
-	//else, use the base class's text processing.
-	bool ret = TCPConnection::ProcessReceivedData(errbuf);
-	//see if we made the transition to packet mode...
-	if(ret && TCPMode == modePacket) {
-		return ProcessReceivedDataAsPackets(errbuf);
-	}
-	return(ret);
-}
-
-
-
-bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
-	if (errbuf)
-		errbuf[0] = 0;
-	int32 base = 0;
-	int32 size = 7;
-	uchar* buffer;
-	ServerPacket* pack = 0;
-	while ((recvbuf_used - base) >= size) {
-		EmuTCPNetPacket_Struct* tnps = (EmuTCPNetPacket_Struct*) &recvbuf[base];
-		buffer = tnps->buffer;
-		size = tnps->size;
-		if (size >= MaxTCPReceiveBuffferSize) {
-#if TCPN_DEBUG_Memory >= 1
-			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
-			DumpPacket(&recvbuf[base], 16);
-#endif
-			if (errbuf)
-				snprintf(errbuf, TCPConnection_ErrorBufferSize, "EmuTCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBuffferSize");
-			return false;
-		}
-		if ((recvbuf_used - base) >= size) {
-			// ok, we got enough data to make this packet!
-			pack = new ServerPacket;
-			pack->size = size - sizeof(EmuTCPNetPacket_Struct);
-			// read headers
-			pack->opcode = tnps->opcode;
-			if (tnps->flags.compressed) {
-				pack->compressed = true;
-				pack->InflatedSize = *((int32*)buffer);
-				pack->size -= 4;
-				buffer += 4;
-			}
-			if (tnps->flags.destination) {
-				pack->destination = *((int32*)buffer);
-				pack->size -= 4;
-				buffer += 4;
-			}
-			// end read headers
-			if (pack->size > 0) {
-				if (tnps->flags.compressed) {
-					// Lets decompress the packet here
-					pack->compressed = false;
-					pack->pBuffer = new uchar[pack->InflatedSize];
-					pack->size = InflatePacket(buffer, pack->size, pack->pBuffer, pack->InflatedSize);
-				}
-				else {
-					pack->pBuffer = new uchar[pack->size];
-					memcpy(pack->pBuffer, buffer, pack->size);
-				}
-			}
-			if (pack->opcode == 0) {
-				if (pack->size) {
-					#if TCPN_DEBUG >= 2
-						std::cout << "Received TCP Network layer packet" << std::endl;
-					#endif
-					ProcessNetworkLayerPacket(pack);
-				}
-				#if TCPN_DEBUG >= 5
-					else {
-						std::cout << "Received TCP keepalive packet. (opcode=0)" << std::endl;
-					}
-				#endif
-				// keepalive, no need to process
-				safe_delete(pack);
-			}
-			else {
-				#if TCPN_LOG_PACKETS >= 1
-					if (pack && pack->opcode != 0) {
-						struct in_addr	in;
-						in.s_addr = GetrIP();
-						CoutTimestamp(true);
-						std::cout << ": Logging incoming TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-						#if TCPN_LOG_PACKETS == 2
-							if (pack->size >= 32)
-								DumpPacket(pack->pBuffer, 32);
-							else
-								DumpPacket(pack);
-						#endif
-						#if TCPN_LOG_PACKETS >= 3
-							DumpPacket(pack);
-						#endif
-					}
-				#endif
-				if (RelayServer && Server && pack->destination) {
-					EmuTCPConnection* con = Server->FindConnection(pack->destination);
-					if (!con) {
-						#if TCPN_DEBUG >= 1
-							std::cout << "Error relaying packet: con = 0" << std::endl;
-						#endif
-						safe_delete(pack);
-					}
-					else
-						con->OutQueuePush(pack);
-				}
-				else
-					OutQueuePush(pack);
-			}
-			base += size;
-			size = 7;
-		}
-	}
-	if (base != 0) {
-		if (base >= recvbuf_used) {
-			safe_delete_array(recvbuf);
-		} else {
-			auto tmpbuf = new uchar[recvbuf_size - base];
-			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
-			safe_delete_array(recvbuf);
-			recvbuf = tmpbuf;
-			recvbuf_used -= base;
-			recvbuf_size -= base;
-		}
-	}
-	return true;
-}
-
-bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
-	int32 base = 0;
-	int32 size = 4;
-	uchar* buffer;
-	ServerPacket* pack = 0;
-	while ((recvbuf_used - base) >= size) {
-		buffer = &recvbuf[base];
-		memcpy(&size, &buffer[2], 2);
-		if (size >= MaxTCPReceiveBuffferSize) {
-#if TCPN_DEBUG_Memory >= 1
-			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
-#endif
-			if (errbuf)
-				snprintf(errbuf, TCPConnection_ErrorBufferSize, "EmuTCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBuffferSize");
-			return false;
-		}
-		if ((recvbuf_used - base) >= size) {
-			// ok, we got enough data to make this packet!
-			pack = new ServerPacket;
-			memcpy(&pack->opcode, &buffer[0], 2);
-			pack->size = size - 4;
-/*			if () { // TODO: Checksum or size check or something similar
-				// Datastream corruption, get the hell outta here!
-				delete pack;
-				return false;
-			}*/
-			if (pack->size > 0) {
-				pack->pBuffer = new uchar[pack->size];
-				memcpy(pack->pBuffer, &buffer[4], pack->size);
-			}
-			if (pack->opcode == 0) {
-				// keepalive, no need to process
-				safe_delete(pack);
-			}
-			else {
-				#if TCPN_LOG_PACKETS >= 1
-					if (pack && pack->opcode != 0) {
-						struct in_addr	in;
-						in.s_addr = GetrIP();
-						CoutTimestamp(true);
-						std::cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-						#if TCPN_LOG_PACKETS == 2
-							if (pack->size >= 32)
-								DumpPacket(pack->pBuffer, 32);
-							else
-								DumpPacket(pack);
-						#endif
-						#if TCPN_LOG_PACKETS >= 3
-							DumpPacket(pack);
-						#endif
-					}
-				#endif
-				OutQueuePush(pack);
-			}
-			base += size;
-			size = 4;
-		}
-	}
-	if (base != 0) {
-		if (base >= recvbuf_used) {
-			safe_delete_array(recvbuf);
-		}
-		else {
-			auto tmpbuf = new uchar[recvbuf_size - base];
-			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
-			safe_delete_array(recvbuf);
-			recvbuf = tmpbuf;
-			recvbuf_used -= base;
-			recvbuf_size -= base;
-		}
-	}
-	return true;
-}
-
-void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
-	uint8 opcode = pack->pBuffer[0];
-	uint8* data = &pack->pBuffer[1];
-	switch (opcode) {
-		case 0: {
-			break;
-		}
-		case 1: { // Switch to RelayServer mode
-			if (pack->size != 1) {
-				SendNetErrorPacket("New RelayClient: wrong size, expected 1");
-				break;
-			}
-			if (RelayServer) {
-				SendNetErrorPacket("Switch to RelayServer mode when already in RelayServer mode");
-				break;
-			}
-			if (RemoteID) {
-				SendNetErrorPacket("Switch to RelayServer mode by a Relay Client");
-				break;
-			}
-			if (ConnectionType != Incoming) {
-				SendNetErrorPacket("Switch to RelayServer mode on outgoing connection");
-				break;
-			}
-			#if TCPC_DEBUG >= 3
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				std::cout << "Switching to RelayServer mode: " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-			#endif
-			RelayServer = true;
-			break;
-		}
-		case 2: { // New Relay Client
-			if (!RelayServer) {
-				SendNetErrorPacket("New RelayClient when not in RelayServer mode");
-				break;
-			}
-			if (pack->size != 11) {
-				SendNetErrorPacket("New RelayClient: wrong size, expected 11");
-				break;
-			}
-			if (ConnectionType != Incoming) {
-				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
-				break;
-			}
-			auto con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32 *)data),
-							*((uint32 *)&data[4]), *((uint16 *)&data[8]));
-			Server->AddConnection(con);
-			RelayCount++;
-			break;
-		}
-		case 3: { // Delete Relay Client
-			if (!RelayServer) {
-				SendNetErrorPacket("Delete RelayClient when not in RelayServer mode");
-				break;
-			}
-			if (pack->size != 5) {
-				SendNetErrorPacket("Delete RelayClient: wrong size, expected 5");
-				break;
-			}
-			EmuTCPConnection* con = Server->FindConnection(*((uint32*)data));
-			if (con) {
-				if (ConnectionType == Incoming) {
-					if (con->GetRelayLink() != this) {
-						SendNetErrorPacket("Delete RelayClient: RelayLink != this");
-						break;
-					}
-				}
-				con->Disconnect(false);
-			}
-			break;
-		}
-		case 255: {
-			#if TCPC_DEBUG >= 1
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				std::cout "Received NetError: '";
-				if (pack->size > 1)
-					std::cout << (char*) data;
-				std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-			#endif
-			break;
-		}
-	}
-}
-
-bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
-	sent_something = false;
-	if(!TCPConnection::SendData(sent_something, errbuf))
-		return(false);
-
-	if(sent_something)
-		keepalive_timer.Start();
-	else if (TCPMode == modePacket && keepalive_timer.Check()) {
-		auto pack = new ServerPacket(0, 0);
-		SendPacket(pack);
-		safe_delete(pack);
-		#if TCPN_DEBUG >= 5
-		std::cout << "Sending TCP keepalive packet. (timeout=" << timeout_timer.GetRemainingTime() << " remaining)" << std::endl;
-		#endif
-	}
-
-	return(true);
-}
-
-bool EmuTCPConnection::RecvData(char* errbuf) {
-	if(!TCPConnection::RecvData(errbuf)) {
-		if (OutQueue.count())
-			return(true);
-		else
-			return(false);
-	}
-
-	if ((TCPMode == modePacket || TCPMode == modeTransition) && timeout_timer.Check()) {
-		if (errbuf)
-			snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Connection timeout");
-		return false;
-	}
-
-	return(true);
-}
-

common/emu_tcp_connection.h

@@ -1,104 +0,0 @@
-#ifndef EmuTCPCONNECTION_H_
-#define EmuTCPCONNECTION_H_
-
-#include "tcp_connection.h"
-#include "timer.h"
-
-//moved out of TCPConnection:: to be more exportable
-#pragma pack(1)
-	struct EmuTCPNetPacket_Struct {
-		uint32	size;
-		struct {
-			uint8
-				compressed : 1,
-				destination : 1,
-				flag3 : 1,
-				flag4 : 1,
-				flag5 : 1,
-				flag6 : 1,
-				flag7 : 1,
-				flag8 : 1;
-		} flags;
-		uint16	opcode;
-		uchar	buffer[0];
-	};
-#pragma pack()
-
-struct SPackSendQueue;
-class EmuTCPServer;
-class ServerPacket;
-
-class EmuTCPConnection : public TCPConnection {
-public:
-	enum eTCPMode { modeConsole, modeTransition, modePacket };
-	enum ePacketMode { packetModeZone, packetModeLauncher, packetModeLogin, packetModeUCS, packetModeQueryServ };
-
-	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET iSock, uint32 irIP, uint16 irPort, bool iOldFormat = false);
-	EmuTCPConnection(bool iOldFormat = false, EmuTCPServer* iRelayServer = 0, eTCPMode iMode = modePacket);	// for outgoing connections
-	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort);				// for relay connections
-	virtual ~EmuTCPConnection();
-
-	virtual bool	ConnectIP(uint32 irIP, uint16 irPort, char* errbuf = 0);
-	virtual void	Disconnect(bool iSendRelayDisconnect = true);
-
-	static EmuTCPNetPacket_Struct* MakePacket(ServerPacket* pack, uint32 iDestination = 0);
-	static SPackSendQueue* MakeOldPacket(ServerPacket* pack);
-
-	virtual bool	SendPacket(ServerPacket* pack, uint32 iDestination = 0);
-	virtual bool	SendPacket(EmuTCPNetPacket_Struct* tnps);
-	ServerPacket*	PopPacket(); // OutQueuePop()
-	void SetPacketMode(ePacketMode mode) { PacketMode = mode; }
-
-	eTCPMode		GetMode()	const		{ return TCPMode; }
-	ePacketMode		GetPacketMode() const	{ return(PacketMode); }
-
-	//relay crap:
-	inline bool		IsRelayServer() const { return RelayServer; }
-	inline TCPConnection* GetRelayLink() const	{ return RelayLink; }
-	inline uint32	GetRemoteID() const	{ return RemoteID; }
-
-protected:
-	void	OutQueuePush(ServerPacket* pack);
-	void	RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect);
-
-	void	SendNetErrorPacket(const char* reason = 0);
-
-	virtual bool SendData(bool &sent_something, char* errbuf = 0);
-	virtual bool RecvData(char* errbuf = 0);
-
-	virtual bool ProcessReceivedData(char* errbuf = 0);
-	bool ProcessReceivedDataAsPackets(char* errbuf = 0);
-	bool ProcessReceivedDataAsOldPackets(char* errbuf = 0);
-	void ProcessNetworkLayerPacket(ServerPacket* pack);
-
-	virtual bool LineOutQueuePush(char* line);
-	virtual void ClearBuffers();
-
-	EmuTCPServer*		Server;
-
-	eTCPMode		TCPMode;
-	ePacketMode		PacketMode;
-	bool pOldFormat;
-
-	Timer keepalive_timer;
-	Timer timeout_timer;
-
-	//relay crap:
-	EmuTCPConnection*	RelayLink;
-	int32			RelayCount;
-	bool	RelayServer;
-	uint32			RemoteID;
-
-	//input queue...
-	void	InModeQueuePush(EmuTCPNetPacket_Struct* tnps);
-	MyQueue<EmuTCPNetPacket_Struct> InModeQueue;
-
-	//output queue...
-	MyQueue<ServerPacket> OutQueue;
-	Mutex	MOutQueueLock;
-};
-
-#endif /*EmuTCPCONNECTION_H_*/
-
-
-

common/emu_tcp_server.cpp

@@ -1,81 +0,0 @@
-#include "global_define.h"
-#include "emu_tcp_server.h"
-#include "emu_tcp_connection.h"
-
-EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
-:	TCPServer<EmuTCPConnection>(iPort),
-	pOldFormat(iOldFormat)
-{
-}
-
-EmuTCPServer::~EmuTCPServer() {
-	MInQueue.lock();
-	while(!m_InQueue.empty()) {
-		delete m_InQueue.front();
-		m_InQueue.pop();
-	}
-	MInQueue.unlock();
-}
-
-void EmuTCPServer::Process() {
-	CheckInQueue();
-	TCPServer<EmuTCPConnection>::Process();
-}
-
-void EmuTCPServer::CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
-{
-	auto conn = new EmuTCPConnection(ID, this, in_socket, irIP, irPort, pOldFormat);
-	AddConnection(conn);
-}
-
-
-void EmuTCPServer::SendPacket(ServerPacket* pack) {
-	EmuTCPNetPacket_Struct* tnps = EmuTCPConnection::MakePacket(pack);
-	SendPacket(&tnps);
-}
-
-void EmuTCPServer::SendPacket(EmuTCPNetPacket_Struct** tnps) {
-	MInQueue.lock();
-	m_InQueue.push(*tnps);
-	MInQueue.unlock();
-	tnps = nullptr;
-}
-
-void EmuTCPServer::CheckInQueue() {
-	EmuTCPNetPacket_Struct* tnps = 0;
-
-	while (( tnps = InQueuePop() )) {
-		vitr cur, end;
-		cur = m_list.begin();
-		end = m_list.end();
-		for(; cur != end; cur++) {
-			if ((*cur)->GetMode() != EmuTCPConnection::modeConsole && (*cur)->GetRemoteID() == 0)
-				(*cur)->SendPacket(tnps);
-		}
-		safe_delete(tnps);
-	}
-}
-
-EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
-	EmuTCPNetPacket_Struct* ret = nullptr;
-	MInQueue.lock();
-	if(!m_InQueue.empty()) {
-		ret = m_InQueue.front();
-		m_InQueue.pop();
-	}
-	MInQueue.unlock();
-	return ret;
-}
-
-
-EmuTCPConnection *EmuTCPServer::FindConnection(uint32 iID) {
-	vitr cur, end;
-	cur = m_list.begin();
-	end = m_list.end();
-	for(; cur != end; cur++) {
-		if ((*cur)->GetID() == iID)
-			return *cur;
-	}
-	return(nullptr);
-}
-

common/emu_tcp_server.h

@@ -1,38 +0,0 @@
-#ifndef EmuTCPSERVER_H_
-#define EmuTCPSERVER_H_
-
-#include "tcp_server.h"
-
-class EmuTCPConnection;
-struct EmuTCPNetPacket_Struct;
-class ServerPacket;
-
-class EmuTCPServer : public TCPServer<EmuTCPConnection> {
-public:
-	EmuTCPServer(uint16 iPort = 0, bool iOldFormat = false);
-	virtual ~EmuTCPServer();
-
-	//packet broadcast routines.
-	void	SendPacket(ServerPacket* pack);
-	void	SendPacket(EmuTCPNetPacket_Struct** tnps);
-
-	//special crap for relay management
-	EmuTCPConnection *FindConnection(uint32 iID);
-
-	//exposed for some crap we pull. Do not call from outside this object.
-	using TCPServer<EmuTCPConnection>::AddConnection;
-
-protected:
-	virtual void	Process();
-
-	virtual void CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort);
-
-	bool pOldFormat;
-
-	//broadcast packet queue..
-	void	CheckInQueue();
-	Mutex	MInQueue;
-	EmuTCPNetPacket_Struct*	InQueuePop();	//returns ownership
-	std::queue<EmuTCPNetPacket_Struct *> m_InQueue;
-};
-#endif /*EmuTCPSERVER_H_*/

common/emu_versions.cpp

@@ -0,0 +1,558 @@
+/*	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
+*/
+
+#include "emu_versions.h"
+#include "emu_constants.h"
+
+
+bool EQ::versions::IsValidClientVersion(ClientVersion client_version)
+{
+	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
+		return false;
+
+	return true;
+}
+
+EQ::versions::ClientVersion EQ::versions::ValidateClientVersion(ClientVersion client_version)
+{
+	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
+		return ClientVersion::Unknown;
+
+	return client_version;
+}
+
+const char* EQ::versions::ClientVersionName(ClientVersion client_version)
+{
+	switch (client_version) {
+	case ClientVersion::Unknown:
+		return "Unknown Version";
+	case ClientVersion::Client62:
+		return "Client 6.2";
+	case ClientVersion::Titanium:
+		return "Titanium";
+	case ClientVersion::SoF:
+		return "SoF";
+	case ClientVersion::SoD:
+		return "SoD";
+	case ClientVersion::UF:
+		return "UF";
+	case ClientVersion::RoF:
+		return "RoF";
+	case ClientVersion::RoF2:
+		return "RoF2";
+	default:
+		return "Invalid Version";
+	};
+}
+
+uint32 EQ::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
+{
+	switch (client_version) {
+	case ClientVersion::Titanium:
+		return bitTitanium;
+	case ClientVersion::SoF:
+		return bitSoF;
+	case ClientVersion::SoD:
+		return bitSoD;
+	case ClientVersion::UF:
+		return bitUF;
+	case ClientVersion::RoF:
+		return bitRoF;
+	case ClientVersion::RoF2:
+		return bitRoF2;
+	default:
+		return bitUnknown;
+	}
+}
+
+EQ::versions::ClientVersion EQ::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
+{
+	switch (client_version_bit) {
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
+		return ClientVersion::Titanium;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)) :
+		return ClientVersion::SoF;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)) :
+		return ClientVersion::SoD;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)) :
+		return ClientVersion::UF;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)) :
+		return ClientVersion::RoF;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)) :
+		return ClientVersion::RoF2;
+	default:
+		return ClientVersion::Unknown;
+	}
+}
+
+bool EQ::versions::IsValidMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
+		return false;
+
+	return true;
+}
+
+bool EQ::versions::IsValidPCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
+		return false;
+
+	return true;
+}
+
+bool EQ::versions::IsValidNonPCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
+		return false;
+
+	return true;
+}
+
+bool EQ::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
+		return false;
+
+	return true;
+}
+
+EQ::versions::MobVersion EQ::versions::ValidateMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
+		return MobVersion::Unknown;
+
+	return mob_version;
+}
+
+EQ::versions::MobVersion EQ::versions::ValidatePCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
+		return MobVersion::Unknown;
+
+	return mob_version;
+}
+
+EQ::versions::MobVersion EQ::versions::ValidateNonPCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
+		return MobVersion::Unknown;
+
+	return mob_version;
+}
+
+EQ::versions::MobVersion EQ::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
+{
+	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
+		return MobVersion::Unknown;
+
+	return mob_version;
+}
+
+const char* EQ::versions::MobVersionName(MobVersion mob_version)
+{
+	switch (mob_version) {
+	case MobVersion::Unknown:
+		return "Unknown Version";
+	case MobVersion::Client62:
+		return "Client 6.2";
+	case MobVersion::Titanium:
+		return "Titanium";
+	case MobVersion::SoF:
+		return "SoF";
+	case MobVersion::SoD:
+		return "SoD";
+	case MobVersion::UF:
+		return "UF";
+	case MobVersion::RoF:
+		return "RoF";
+	case MobVersion::RoF2:
+		return "RoF2";
+	case MobVersion::NPC:
+		return "NPC";
+	case MobVersion::NPCMerchant:
+		return "NPC Merchant";
+	case MobVersion::Merc:
+		return "Merc";
+	case MobVersion::Bot:
+		return "Bot";
+	case MobVersion::ClientPet:
+		return "Client Pet";
+	case MobVersion::NPCPet:
+		return "NPC Pet";
+	case MobVersion::MercPet:
+		return "Merc Pet";
+	case MobVersion::BotPet:
+		return "Bot Pet";
+	case MobVersion::OfflineTitanium:
+		return "Offline Titanium";
+	case MobVersion::OfflineSoF:
+		return "Offline SoF";
+	case MobVersion::OfflineSoD:
+		return "Offline SoD";
+	case MobVersion::OfflineUF:
+		return "Offline UF";
+	case MobVersion::OfflineRoF:
+		return "Offline RoF";
+	case MobVersion::OfflineRoF2:
+		return "Offline RoF2";
+	default:
+		return "Invalid Version";
+	};
+}
+
+EQ::versions::ClientVersion EQ::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
+{
+	switch (mob_version) {
+	case MobVersion::Unknown:
+	case MobVersion::Client62:
+		return ClientVersion::Unknown;
+	case MobVersion::Titanium:
+		return ClientVersion::Titanium;
+	case MobVersion::SoF:
+		return ClientVersion::SoF;
+	case MobVersion::SoD:
+		return ClientVersion::SoD;
+	case MobVersion::UF:
+		return ClientVersion::UF;
+	case MobVersion::RoF:
+		return ClientVersion::RoF;
+	case MobVersion::RoF2:
+		return ClientVersion::RoF2;
+	default:
+		return ClientVersion::Unknown;
+	}
+}
+
+EQ::versions::MobVersion EQ::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
+{
+	switch (client_version) {
+	case ClientVersion::Unknown:
+	case ClientVersion::Client62:
+		return MobVersion::Unknown;
+	case ClientVersion::Titanium:
+		return MobVersion::Titanium;
+	case ClientVersion::SoF:
+		return MobVersion::SoF;
+	case ClientVersion::SoD:
+		return MobVersion::SoD;
+	case ClientVersion::UF:
+		return MobVersion::UF;
+	case ClientVersion::RoF:
+		return MobVersion::RoF;
+	case ClientVersion::RoF2:
+		return MobVersion::RoF2;
+	default:
+		return MobVersion::Unknown;
+	}
+}
+
+EQ::versions::MobVersion EQ::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
+{
+	switch (mob_version) {
+	case MobVersion::Titanium:
+		return MobVersion::OfflineTitanium;
+	case MobVersion::SoF:
+		return MobVersion::OfflineSoF;
+	case MobVersion::SoD:
+		return MobVersion::OfflineSoD;
+	case MobVersion::UF:
+		return MobVersion::OfflineUF;
+	case MobVersion::RoF:
+		return MobVersion::OfflineRoF;
+	case MobVersion::RoF2:
+		return MobVersion::OfflineRoF2;
+	default:
+		return MobVersion::Unknown;
+	}
+}
+
+EQ::versions::MobVersion EQ::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
+{
+	switch (mob_version) {
+	case MobVersion::OfflineTitanium:
+		return MobVersion::Titanium;
+	case MobVersion::OfflineSoF:
+		return MobVersion::SoF;
+	case MobVersion::OfflineSoD:
+		return MobVersion::SoD;
+	case MobVersion::OfflineUF:
+		return MobVersion::UF;
+	case MobVersion::OfflineRoF:
+		return MobVersion::RoF;
+	case MobVersion::OfflineRoF2:
+		return MobVersion::RoF2;
+	default:
+		return MobVersion::Unknown;
+	}
+}
+
+EQ::versions::ClientVersion EQ::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
+{
+	switch (mob_version) {
+	case MobVersion::OfflineTitanium:
+		return ClientVersion::Titanium;
+	case MobVersion::OfflineSoF:
+		return ClientVersion::SoF;
+	case MobVersion::OfflineSoD:
+		return ClientVersion::SoD;
+	case MobVersion::OfflineUF:
+		return ClientVersion::UF;
+	case MobVersion::OfflineRoF:
+		return ClientVersion::RoF;
+	case MobVersion::OfflineRoF2:
+		return ClientVersion::RoF2;
+	default:
+		return ClientVersion::Unknown;
+	}
+}
+
+EQ::versions::MobVersion EQ::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
+{
+	switch (client_version) {
+	case ClientVersion::Titanium:
+		return MobVersion::OfflineTitanium;
+	case ClientVersion::SoF:
+		return MobVersion::OfflineSoF;
+	case ClientVersion::SoD:
+		return MobVersion::OfflineSoD;
+	case ClientVersion::UF:
+		return MobVersion::OfflineUF;
+	case ClientVersion::RoF:
+		return MobVersion::OfflineRoF;
+	case ClientVersion::RoF2:
+		return MobVersion::OfflineRoF2;
+	default:
+		return MobVersion::Unknown;
+	}
+}
+
+const char* EQ::expansions::ExpansionName(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::EverQuest:
+		return "EverQuest";
+	case Expansion::RoK:
+		return "The Ruins of Kunark";
+	case Expansion::SoV:
+		return "The Scars of Velious";
+	case Expansion::SoL:
+		return "The Shadows of Luclin";
+	case Expansion::PoP:
+		return "The Planes of Power";
+	case Expansion::LoY:
+		return "The Legacy of Ykesha";
+	case Expansion::LDoN:
+		return "Lost Dungeons of Norrath";
+	case Expansion::GoD:
+		return "Gates of Discord";
+	case Expansion::OoW:
+		return "Omens of War";
+	case Expansion::DoN:
+		return "Dragons of Norrath";
+	case Expansion::DoD:
+		return "Depths of Darkhollow";
+	case Expansion::PoR:
+		return "Prophecy of Ro";
+	case Expansion::TSS:
+		return "The Serpent's Spine";
+	case Expansion::TBS:
+		return "The Buried Sea";
+	case Expansion::SoF:
+		return "Secrets of Faydwer";
+	case Expansion::SoD:
+		return "Seeds of Destruction";
+	case Expansion::UF:
+		return "Underfoot";
+	case Expansion::HoT:
+		return "House of Thule";
+	case Expansion::VoA:
+		return "Veil of Alaris";
+	case Expansion::RoF:
+		return "Rain of Fear";
+	case Expansion::CotF:
+		return "Call of the Forsaken";
+	default:
+		return "Invalid Expansion";
+	}
+}
+
+const char* EQ::expansions::ExpansionName(uint32 expansion_bit)
+{
+	return ExpansionName(ConvertExpansionBitToExpansion(expansion_bit));
+}
+
+uint32 EQ::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::RoK:
+		return bitRoK;
+	case Expansion::SoV:
+		return bitSoV;
+	case Expansion::SoL:
+		return bitSoL;
+	case Expansion::PoP:
+		return bitPoP;
+	case Expansion::LoY:
+		return bitLoY;
+	case Expansion::LDoN:
+		return bitLDoN;
+	case Expansion::GoD:
+		return bitGoD;
+	case Expansion::OoW:
+		return bitOoW;
+	case Expansion::DoN:
+		return bitDoN;
+	case Expansion::DoD:
+		return bitDoD;
+	case Expansion::PoR:
+		return bitPoR;
+	case Expansion::TSS:
+		return bitTSS;
+	case Expansion::TBS:
+		return bitTBS;
+	case Expansion::SoF:
+		return bitSoF;
+	case Expansion::SoD:
+		return bitSoD;
+	case Expansion::UF:
+		return bitUF;
+	case Expansion::HoT:
+		return bitHoT;
+	case Expansion::VoA:
+		return bitVoA;
+	case Expansion::RoF:
+		return bitRoF;
+	case Expansion::CotF:
+		return bitCotF;
+	default:
+		return bitEverQuest;
+	}
+}
+
+EQ::expansions::Expansion EQ::expansions::ConvertExpansionBitToExpansion(uint32 expansion_bit)
+{
+	switch (expansion_bit) {
+	case bitRoK:
+		return Expansion::RoK;
+	case bitSoV:
+		return Expansion::SoV;
+	case bitSoL:
+		return Expansion::SoL;
+	case bitPoP:
+		return Expansion::PoP;
+	case bitLoY:
+		return Expansion::LoY;
+	case bitLDoN:
+		return Expansion::LDoN;
+	case bitGoD:
+		return Expansion::GoD;
+	case bitOoW:
+		return Expansion::OoW;
+	case bitDoN:
+		return Expansion::DoN;
+	case bitDoD:
+		return Expansion::DoD;
+	case bitPoR:
+		return Expansion::PoR;
+	case bitTSS:
+		return Expansion::TSS;
+	case bitTBS:
+		return Expansion::TBS;
+	case bitSoF:
+		return Expansion::SoF;
+	case bitSoD:
+		return Expansion::SoD;
+	case bitUF:
+		return Expansion::UF;
+	case bitHoT:
+		return Expansion::HoT;
+	case bitVoA:
+		return Expansion::VoA;
+	case bitRoF:
+		return Expansion::RoF;
+	case bitCotF:
+		return Expansion::CotF;
+	default:
+		return Expansion::EverQuest;
+	}
+}
+
+uint32 EQ::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::RoK:
+		return maskRoK;
+	case Expansion::SoV:
+		return maskSoV;
+	case Expansion::SoL:
+		return maskSoL;
+	case Expansion::PoP:
+		return maskPoP;
+	case Expansion::LoY:
+		return maskLoY;
+	case Expansion::LDoN:
+		return maskLDoN;
+	case Expansion::GoD:
+		return maskGoD;
+	case Expansion::OoW:
+		return maskOoW;
+	case Expansion::DoN:
+		return maskDoN;
+	case Expansion::DoD:
+		return maskDoD;
+	case Expansion::PoR:
+		return maskPoR;
+	case Expansion::TSS:
+		return maskTSS;
+	case Expansion::TBS:
+		return maskTBS;
+	case Expansion::SoF:
+		return maskSoF;
+	case Expansion::SoD:
+		return maskSoD;
+	case Expansion::UF:
+		return maskUF;
+	case Expansion::HoT:
+		return maskHoT;
+	case Expansion::VoA:
+		return maskVoA;
+	case Expansion::RoF:
+		return maskRoF;
+	case Expansion::CotF:
+		return maskCotF;
+	default:
+		return maskEverQuest;
+	}
+}
+
+EQ::expansions::Expansion EQ::expansions::ConvertClientVersionToExpansion(versions::ClientVersion client_version)
+{
+	return EQ::constants::StaticLookup(client_version)->Expansion;
+}
+
+uint32 EQ::expansions::ConvertClientVersionToExpansionBit(versions::ClientVersion client_version)
+{
+	return EQ::constants::StaticLookup(client_version)->ExpansionBit;
+}
+
+uint32 EQ::expansions::ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version)
+{
+	return EQ::constants::StaticLookup(client_version)->ExpansionsMask;
+}

common/emu_versions.h

@@ -0,0 +1,222 @@
+/*	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
+*/
+
+#ifndef COMMON_EMU_VERSIONS_H
+#define COMMON_EMU_VERSIONS_H
+
+#include "types.h"
+
+#include <stdlib.h>
+
+
+namespace EQ
+{
+	namespace versions {
+		enum class ClientVersion : uint32 {
+			Unknown = 0,
+			Client62,	// Build: 'Aug  4 2005 15:40:59'
+			Titanium,	// Build: 'Oct 31 2005 10:33:37'
+			SoF,		// Build: 'Sep  7 2007 09:11:49'
+			SoD,		// Build: 'Dec 19 2008 15:22:49'
+			UF,			// Build: 'Jun  8 2010 16:44:32'
+			RoF,		// Build: 'Dec 10 2012 17:35:44'
+			RoF2		// Build: 'May 10 2013 23:30:08'
+		};
+
+		enum ClientVersionBitmask : uint32 {
+			bitUnknown = 0x00000000,
+			bitClient62 = 0x00000001, // unsupported (placeholder for scripts)
+			bitTitanium = 0x00000002,
+			bitSoF = 0x00000004,
+			bitSoD = 0x00000008,
+			bitUF = 0x00000010,
+			bitRoF = 0x00000020,
+			bitRoF2 = 0x00000040,
+			maskUnknown = 0x00000000,
+			maskTitaniumAndEarlier = 0x00000003,
+			maskSoFAndEarlier = 0x00000007,
+			maskSoDAndEarlier = 0x0000000F,
+			maskUFAndEarlier = 0x0000001F,
+			maskRoFAndEarlier = 0x0000003F,
+			maskSoFAndLater = 0xFFFFFFFC,
+			maskSoDAndLater = 0xFFFFFFF8,
+			maskUFAndLater = 0xFFFFFFF0,
+			maskRoFAndLater = 0xFFFFFFE0,
+			maskRoF2AndLater = 0xFFFFFFC0,
+			maskAllClients = 0xFFFFFFFF
+		};
+
+		const ClientVersion LastClientVersion = ClientVersion::RoF2;
+		const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
+
+		bool IsValidClientVersion(ClientVersion client_version);
+		ClientVersion ValidateClientVersion(ClientVersion client_version);
+		const char* ClientVersionName(ClientVersion client_version);
+		uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
+		ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
+		
+		enum class MobVersion : uint32 {
+			Unknown = 0,
+			Client62,
+			Titanium,
+			SoF,
+			SoD,
+			UF,
+			RoF,
+			RoF2,
+			NPC,
+			NPCMerchant,
+			Merc,
+			Bot,
+			ClientPet,
+			NPCPet,
+			MercPet,
+			BotPet,
+			OfflineTitanium,
+			OfflineSoF,
+			OfflineSoD,
+			OfflineUF,
+			OfflineRoF,
+			OfflineRoF2
+		};
+
+		const MobVersion LastMobVersion = MobVersion::OfflineRoF2;
+		const MobVersion LastPCMobVersion = MobVersion::RoF2;
+		const MobVersion LastNonPCMobVersion = MobVersion::BotPet;
+		const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineRoF2;
+		const size_t MobVersionCount = (static_cast<size_t>(LastMobVersion) + 1);
+
+		bool IsValidMobVersion(MobVersion mob_version);
+		bool IsValidPCMobVersion(MobVersion mob_version);
+		bool IsValidNonPCMobVersion(MobVersion mob_version);
+		bool IsValidOfflinePCMobVersion(MobVersion mob_version);
+
+		MobVersion ValidateMobVersion(MobVersion mob_version);
+		MobVersion ValidatePCMobVersion(MobVersion mob_version);
+		MobVersion ValidateNonPCMobVersion(MobVersion mob_version);
+		MobVersion ValidateOfflinePCMobVersion(MobVersion mob_version);
+
+		const char* MobVersionName(MobVersion mob_version);
+		ClientVersion ConvertMobVersionToClientVersion(MobVersion mob_version);
+		MobVersion ConvertClientVersionToMobVersion(ClientVersion client_version);
+		MobVersion ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version);
+		MobVersion ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version);
+		ClientVersion ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version);
+		MobVersion ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version);
+
+
+		enum UCSVersion : char {
+			ucsUnknown = '\0',
+			ucsClient62Chat = 'A',
+			ucsClient62Mail = 'a',
+			ucsTitaniumChat = 'B',
+			ucsTitaniumMail = 'b',
+			ucsSoFCombined = 'C',
+			ucsSoDCombined = 'D',
+			ucsUFCombined = 'E',
+			ucsRoFCombined = 'F',
+			ucsRoF2Combined = 'G'
+		};
+
+	} /*versions*/
+
+	namespace expansions {
+		enum class Expansion : uint32 {
+			EverQuest = 0,
+			RoK,
+			SoV,
+			SoL,
+			PoP,
+			LoY,
+			LDoN,
+			GoD,
+			OoW,
+			DoN,
+			DoD,
+			PoR,
+			TSS,
+			TBS,
+			SoF,
+			SoD,
+			UF,
+			HoT,
+			VoA,
+			RoF,
+			CotF
+		};
+
+		enum ExpansionBitmask : uint32 {
+			bitEverQuest = 0x00000000,
+			bitRoK = 0x00000001,
+			bitSoV = 0x00000002,
+			bitSoL = 0x00000004,
+			bitPoP = 0x00000008,
+			bitLoY = 0x00000010,
+			bitLDoN = 0x00000020,
+			bitGoD = 0x00000040,
+			bitOoW = 0x00000080,
+			bitDoN = 0x00000100,
+			bitDoD = 0x00000200,
+			bitPoR = 0x00000400,
+			bitTSS = 0x00000800,
+			bitTBS = 0x00001000,
+			bitSoF = 0x00002000,
+			bitSoD = 0x00004000,
+			bitUF = 0x00008000,
+			bitHoT = 0x00010000,
+			bitVoA = 0x00020000,
+			bitRoF = 0x00040000,
+			bitCotF = 0x00080000,
+			maskEverQuest = 0x00000000,
+			maskRoK = 0x00000001,
+			maskSoV = 0x00000003,
+			maskSoL = 0x00000007,
+			maskPoP = 0x0000000F,
+			maskLoY = 0x0000001F,
+			maskLDoN = 0x0000003F,
+			maskGoD = 0x0000007F,
+			maskOoW = 0x000000FF,
+			maskDoN = 0x000001FF,
+			maskDoD = 0x000003FF,
+			maskPoR = 0x000007FF,
+			maskTSS = 0x00000FFF,
+			maskTBS = 0x00001FFF,
+			maskSoF = 0x00003FFF,
+			maskSoD = 0x00007FFF,
+			maskUF = 0x0000FFFF,
+			maskHoT = 0x0001FFFF,
+			maskVoA = 0x0003FFFF,
+			maskRoF = 0x0007FFFF,
+			maskCotF = 0x000FFFFF
+		};
+
+		const char* ExpansionName(Expansion expansion);
+		const char* ExpansionName(uint32 expansion_bit);
+		uint32 ConvertExpansionToExpansionBit(Expansion expansion);
+		Expansion ConvertExpansionBitToExpansion(uint32 expansion_bit);
+		uint32 ConvertExpansionToExpansionsMask(Expansion expansion);
+		Expansion ConvertClientVersionToExpansion(versions::ClientVersion client_version);
+		uint32 ConvertClientVersionToExpansionBit(versions::ClientVersion client_version);
+		uint32 ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version);
+
+	} /*expansions*/
+
+} /*EQEmu*/
+
+#endif /*COMMON_EMU_VERSIONS_H*/

common/eq_constants.h

@@ -27,7 +27,7 @@
 //SpawnAppearance types: (compared two clients for server-originating types: SoF & RoF2)
 #define AT_Die 0			// this causes the client to keel over and zone to bind point (default action)
 #define AT_WhoLevel 1		// the level that shows up on /who
-//#define AT_2 2			// unknown
+#define AT_HPMax 2			// idk
 #define AT_Invis 3			// 0 = visible, 1 = invisible
 #define AT_PVP 4			// 0 = blue, 1 = pvp (red)
 #define AT_Light 5			// light type emitted by player (lightstone, shiny shield)
@@ -36,38 +36,42 @@
 #define AT_SpawnID 16		// server to client, sets player spawn id
 #define AT_HP 17			// Client->Server, my HP has changed (like regen tic)
 #define AT_Linkdead 18		// 0 = normal, 1 = linkdead
-#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate
+#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate max 5, see GravityBehavior enum
 #define AT_GM 20			// 0 = normal, 1 = GM - all odd numbers seem to make it GM
 #define AT_Anon 21			// 0 = normal, 1 = anon, 2 = roleplay
 #define AT_GuildID 22
 #define AT_GuildRank 23		// 0=member, 1=officer, 2=leader
 #define AT_AFK 24			// 0 = normal, 1 = afk
 #define AT_Pet 25			// Param is EntityID of owner, or 0 for when charm breaks
-//#define AT_27 27			// unknown
+#define AT_Summoned 27		// Unsure
 #define AT_Split 28			// 0 = normal, 1 = autosplit on (not showing in SoF+) (client-to-server only)
 #define AT_Size 29			// spawn's size (present: SoF, absent: RoF2)
-//#define AT_30 30			// unknown
-#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name
-//#define AT_32 32			// unknown
-//#define AT_33 33			// unknown
+#define AT_SetType 30		// 0 = PC, 1 = NPC, 2 <= = corpse
+#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name, Trader on RoF2?
+#define AT_AARank 32		// AA Rank Title ID thingy, does is this the title in /who?
+#define AT_CancelSneakHide 33	// Turns off Hide and Sneak
 //#define AT_34 34			// unknown (present: SoF, absent: RoF2)
-//#define AT_35 35			// unknown
-//#define AT_36 36			// unknown
-//#define AT_37 37			// unknown
-//#define AT_38 38			// unknown
-//#define AT_39 39			// unknown
+#define AT_AreaHPRegen 35	// guild hall regen pool sets to value * 0.001
+#define AT_AreaManaRegen 36	// guild hall regen pool sets to value * 0.001
+#define AT_AreaEndRegen 37	// guild hall regen pool sets to value * 0.001
+#define AT_FreezeBuffs 38	// Freezes beneficial buff timers
+#define AT_NpcTintIndex 39	// not 100% sure
+#define AT_GroupConsent 40	// auto consent group
+#define AT_RaidConsent 41	// auto consent raid
+#define AT_GuildConsent 42	// auto consent guild
 #define AT_ShowHelm 43		// 0 = hide graphic, 1 = show graphic
-#define AT_DamageState 44	// The damage state of a destructible object (0 through 4)
-//#define AT_46 46			// unknown
-//#define AT_48 48			// unknown
-//#define AT_49 49			// unknown
-//#define AT_52 52			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
-//#define AT_53 53			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
+#define AT_DamageState 44	// The damage state of a destructible object (0 through 10) plays soundids most only have 2 or 4 states though
+#define AT_EQPlayers 45		// /eqplayersupdate
+#define AT_FindBits 46		// set FindBits, whatever those are!
+#define AT_TextureType 48	// TextureType
+#define AT_FacePick 49		// Turns off face pick window? maybe ...
+#define AT_GuildShow 52		// this is what MQ2 call sit, not sure
+#define AT_Offline 53		// Offline mode
 
 //#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
 
 // animations for AT_Anim
-#define ANIM_FREEZE	102
+#define ANIM_FREEZE	    102
 #define	ANIM_STAND		0x64
 #define	ANIM_SIT		0x6e
 #define	ANIM_CROUCH		0x6f
@@ -83,199 +87,114 @@ typedef enum {
 	_eaMaxAppearance
 } EmuAppearance;
 
-// msg_type's for custom usercolors
-#define MT_Say					256
-#define MT_Tell					257
-#define MT_Group				258
-#define MT_Guild				259
-#define MT_OOC					260
-#define MT_Auction				261
-#define MT_Shout				262
-#define MT_Emote				263
-#define MT_Spells				264
-#define MT_YouHitOther			265
-#define MT_OtherHitsYou			266
-#define MT_YouMissOther			267
-#define MT_OtherMissesYou		268
-#define MT_Broadcasts			269
-#define MT_Skills				270
-#define MT_Disciplines			271
-#define	MT_Unused1				272
-#define MT_DefaultText			273
-#define MT_Unused2				274
-#define MT_MerchantOffer		275
-#define MT_MerchantBuySell		276
-#define	MT_YourDeath			277
-#define MT_OtherDeath			278
-#define MT_OtherHits			279
-#define MT_OtherMisses			280
-#define	MT_Who					281
-#define MT_YellForHelp			282
-#define MT_NonMelee				283
-#define MT_WornOff				284
-#define MT_MoneySplit			285
-#define MT_LootMessages			286
-#define MT_DiceRoll				287
-#define MT_OtherSpells			288
-#define MT_SpellFailure			289
-#define MT_Chat					290
-#define MT_Channel1				291
-#define MT_Channel2				292
-#define MT_Channel3				293
-#define MT_Channel4				294
-#define MT_Channel5				295
-#define MT_Channel6				296
-#define MT_Channel7				297
-#define MT_Channel8				298
-#define MT_Channel9				299
-#define MT_Channel10			300
-#define MT_CritMelee			301
-#define MT_SpellCrits			302
-#define MT_TooFarAway			303
-#define MT_NPCRampage			304
-#define MT_NPCFlurry			305
-#define MT_NPCEnrage			306
-#define MT_SayEcho				307
-#define MT_TellEcho				308
-#define MT_GroupEcho			309
-#define MT_GuildEcho			310
-#define MT_OOCEcho				311
-#define MT_AuctionEcho			312
-#define MT_ShoutECho			313
-#define MT_EmoteEcho			314
-#define MT_Chat1Echo			315
-#define MT_Chat2Echo			316
-#define MT_Chat3Echo			317
-#define MT_Chat4Echo			318
-#define MT_Chat5Echo			319
-#define MT_Chat6Echo			320
-#define MT_Chat7Echo			321
-#define MT_Chat8Echo			322
-#define MT_Chat9Echo			323
-#define MT_Chat10Echo			324
-#define MT_DoTDamage			325
-#define MT_ItemLink				326
-#define MT_RaidSay				327
-#define MT_MyPet				328
-#define MT_DS					329
-#define MT_Leadership			330
-#define MT_PetFlurry			331
-#define MT_PetCrit				332
-#define MT_FocusEffect			333
-#define MT_Experience			334
-#define MT_System				335
-#define MT_PetSpell				336
-#define MT_PetResponse			337
-#define MT_ItemSpeech			338
-#define MT_StrikeThrough		339
-#define MT_Stun					340
+namespace Chat {
+	const uint16 White       = 0;
+	const uint16 DimGray     = 1;
+	const uint16 Default     = 1;
+	const uint16 Green       = 2;
+	const uint16 BrightBlue  = 3;
+	const uint16 LightBlue   = 4;
+	const uint16 Magenta     = 5;
+	const uint16 Gray        = 6;
+	const uint16 LightGray   = 7;
+	const uint16 NPCQuestSay = 10;
+	const uint16 DarkGray    = 12;
+	const uint16 Red         = 13;
+	const uint16 Lime        = 14;
+	const uint16 Yellow      = 15;
+	const uint16 Blue        = 16;
+	const uint16 LightNavy   = 17;
+	const uint16 Cyan        = 18;
+	const uint16 Black       = 20;
 
-// TODO: Really should combine above and below into one
-
-//from showeq
-enum ChatColor
-{
-	/*
-	CC_Default					= 0,
-	CC_DarkGrey					= 1,
-	CC_DarkGreen				= 2,
-	CC_DarkBlue					= 3,
-	CC_Purple					= 5,
-	CC_LightGrey				= 6,
-	*/
-
-	CC_WhiteSmoke				= 0,	// FF|F0F0F0
-	CC_Green					= 2,	// FF|008000
-	CC_BrightBlue				= 3,	// FF|0040FF
-	CC_Magenta					= 5,	// FF|F000F0
-	CC_Gray						= 6,	// FF|808080
-	CC_LightGray				= 7,	// FF|E0E0E0
-	//CC_WhiteSmoke2				= 10,	// FF|F0F0F0
-	CC_DarkGray					= 12,	// FF|A0A0A0
-	CC_Red						= 13,	// FF|F00000
-	CC_Lime						= 14,	// FF|00F000
-	CC_Yellow					= 15,	// FF|F0F000
-	CC_Blue						= 16,	// FF|0000F0
-	CC_LightNavy				= 17,	// FF|0000AF
-	CC_Cyan						= 18,	// FF|00F0F0
-	CC_Black					= 20,	// FF|000000
-	
-	// any index <= 255 that is not defined above
-	CC_DimGray					= 1,	// FF|606060
-	CC_Default					= 1,
-
-	CC_User_Say					= 256,
-	CC_User_Tell				= 257,
-	CC_User_Group				= 258,
-	CC_User_Guild				= 259,
-	CC_User_OOC					= 260,
-	CC_User_Auction				= 261,
-	CC_User_Shout				= 262,
-	CC_User_Emote				= 263,
-	CC_User_Spells				= 264,
-	CC_User_YouHitOther			= 265,
-	CC_User_OtherHitYou			= 266,
-	CC_User_YouMissOther		= 267,
-	CC_User_OtherMissYou		= 268,
-	CC_User_Duels				= 269,
-	CC_User_Skills				= 270,
-	CC_User_Disciplines			= 271,
-	CC_User_Default				= 273,
-	CC_User_MerchantOffer		= 275,
-	CC_User_MerchantExchange	= 276,
-	CC_User_YourDeath			= 277,
-	CC_User_OtherDeath			= 278,
-	CC_User_OtherHitOther		= 279,
-	CC_User_OtherMissOther		= 280,
-	CC_User_Who					= 281,
-	CC_User_Yell				= 282,
-	CC_User_NonMelee			= 283,
-	CC_User_SpellWornOff		= 284,
-	CC_User_MoneySplit			= 285,
-	CC_User_Loot				= 286,
-	CC_User_Random				= 287,
-	CC_User_OtherSpells			= 288,
-	CC_User_SpellFailure		= 289,
-	CC_User_ChatChannel			= 290,
-	CC_User_Chat1				= 291,
-	CC_User_Chat2				= 292,
-	CC_User_Chat3				= 293,
-	CC_User_Chat4				= 294,
-	CC_User_Chat5				= 295,
-	CC_User_Chat6				= 296,
-	CC_User_Chat7				= 297,
-	CC_User_Chat8				= 298,
-	CC_User_Chat9				= 299,
-	CC_User_Chat10				= 300,
-	CC_User_MeleeCrit			= 301,
-	CC_User_SpellCrit			= 302,
-	CC_User_TooFarAway			= 303,
-	CC_User_NPCRampage			= 304,
-	CC_User_NPCFurry			= 305,
-	CC_User_NPCEnrage			= 306,
-	CC_User_EchoSay				= 307,
-	CC_User_EchoTell			= 308,
-	CC_User_EchoGroup			= 309,
-	CC_User_EchoGuild			= 310,
-	CC_User_EchoOOC				= 311,
-	CC_User_EchoAuction			= 312,
-	CC_User_EchoShout			= 313,
-	CC_User_EchoEmote			= 314,
-	CC_User_EchoChat1			= 315,
-	CC_User_EchoChat2			= 316,
-	CC_User_EchoChat3			= 317,
-	CC_User_EchoChat4			= 318,
-	CC_User_EchoChat5			= 319,
-	CC_User_EchoChat6			= 320,
-	CC_User_EchoChat7			= 321,
-	CC_User_EchoChat8			= 322,
-	CC_User_EchoChat9			= 323,
-	CC_User_EchoChat10			= 324,
-	CC_User_UnusedAtThisTime	= 325,
-	CC_User_ItemTags			= 326,
-	CC_User_RaidSay				= 327,
-	CC_User_MyPet				= 328,
-	CC_User_DamageShield		= 329,
+	/**
+	 * User colors
+	 */
+	const uint16 Say              = 256;
+	const uint16 Tell             = 257;
+	const uint16 Group            = 258;
+	const uint16 Guild            = 259;
+	const uint16 OOC              = 260;
+	const uint16 Auction          = 261;
+	const uint16 Shout            = 262;
+	const uint16 Emote            = 263;
+	const uint16 Spells           = 264;
+	const uint16 YouHitOther      = 265;
+	const uint16 OtherHitYou      = 266;
+	const uint16 YouMissOther     = 267;
+	const uint16 OtherMissYou     = 268;
+	const uint16 Broadcasts       = 269;
+	const uint16 Skills           = 270;
+	const uint16 Disciplines      = 271;
+	const uint16 Unused1          = 272;
+	const uint16 DefaultText      = 273;
+	const uint16 Unused2          = 274;
+	const uint16 MerchantOffer    = 275;
+	const uint16 MerchantExchange = 276;
+	const uint16 YourDeath        = 277;
+	const uint16 OtherDeath       = 278;
+	const uint16 OtherHitOther    = 279;
+	const uint16 OtherMissOther   = 280;
+	const uint16 Who              = 281;
+	const uint16 YellForHelp      = 282;
+	const uint16 NonMelee         = 283;
+	const uint16 SpellWornOff     = 284;
+	const uint16 MoneySplit       = 285;
+	const uint16 Loot             = 286;
+	const uint16 DiceRoll         = 287;
+	const uint16 OtherSpells      = 288;
+	const uint16 SpellFailure     = 289;
+	const uint16 ChatChannel      = 290;
+	const uint16 Chat1            = 291;
+	const uint16 Chat2            = 292;
+	const uint16 Chat3            = 293;
+	const uint16 Chat4            = 294;
+	const uint16 Chat5            = 295;
+	const uint16 Chat6            = 296;
+	const uint16 Chat7            = 297;
+	const uint16 Chat8            = 298;
+	const uint16 Chat9            = 299;
+	const uint16 Chat10           = 300;
+	const uint16 MeleeCrit        = 301;
+	const uint16 SpellCrit        = 302;
+	const uint16 TooFarAway       = 303;
+	const uint16 NPCRampage       = 304;
+	const uint16 NPCFlurry        = 305;
+	const uint16 NPCEnrage        = 306;
+	const uint16 EchoSay          = 307;
+	const uint16 EchoTell         = 308;
+	const uint16 EchoGroup        = 309;
+	const uint16 EchoGuild        = 310;
+	const uint16 EchoOOC          = 311;
+	const uint16 EchoAuction      = 312;
+	const uint16 EchoShout        = 313;
+	const uint16 EchoEmote        = 314;
+	const uint16 EchoChat1        = 315;
+	const uint16 EchoChat2        = 316;
+	const uint16 EchoChat3        = 317;
+	const uint16 EchoChat4        = 318;
+	const uint16 EchoChat5        = 319;
+	const uint16 EchoChat6        = 320;
+	const uint16 EchoChat7        = 321;
+	const uint16 EchoChat8        = 322;
+	const uint16 EchoChat9        = 323;
+	const uint16 EchoChat10       = 324;
+	const uint16 DotDamage        = 325;
+	const uint16 ItemLink         = 326;
+	const uint16 RaidSay          = 327;
+	const uint16 MyPet            = 328;
+	const uint16 DamageShield     = 329;
+	const uint16 LeaderShip       = 330;
+	const uint16 PetFlurry        = 331;
+	const uint16 PetCritical      = 332;
+	const uint16 FocusEffect      = 333;
+	const uint16 Experience       = 334;
+	const uint16 System           = 335;
+	const uint16 PetSpell         = 336;
+	const uint16 PetResponse      = 337;
+	const uint16 ItemSpeech       = 338;
+	const uint16 StrikeThrough    = 339;
+	const uint16 Stun             = 340;
 };
 
 //ZoneChange_Struct->success values
@@ -399,7 +318,7 @@ static const uint8 DamageTypeUnknown	= 0xFF;
 **
 **	(indexed by 'Skill' of SkillUseTypes)
 */
-static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
+static const uint8 SkillDamageTypes[EQ::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
 {
 /*1HBlunt*/					0,
 /*1HSlashing*/				1,
@@ -516,16 +435,33 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 */
 
 #define INVALID_INDEX	-1
-#define NOT_USED		0
-#define NO_ITEM			0
-
-// yes..these are redundant... but, they help to identify and define what is actually being performed
-// plus, since they're pre-op's, they don't affect the actual binary size
-#define TYPE_BEGIN	0
-#define SLOT_BEGIN	0
-#define SUB_INDEX_BEGIN	0
-#define AUG_INDEX_BEGIN	0
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
+enum ChatChannelNames : uint16
+{
+	ChatChannel_Guild = 0,
+	ChatChannel_Group = 2,
+	ChatChannel_Shout = 3,
+	ChatChannel_Auction = 4,
+	ChatChannel_OOC = 5,
+	ChatChannel_Broadcast = 6,
+	ChatChannel_Tell = 7,
+	ChatChannel_Say = 8,
+	ChatChannel_Petition = 10,
+	ChatChannel_GMSAY = 11,
+	ChatChannel_TellEcho = 14,
+	ChatChannel_Raid = 15,
+
+	ChatChannel_UNKNOWN_Guild = 17,
+	ChatChannel_UNKNOWN_GMSAY = 18,
+	ChatChannel_UCSRelay = 20,
+	ChatChannel_Emotes = 22
+};
+
+namespace ZoneBlockedSpellTypes {
+	const uint8 ZoneWide = 1;
+	const uint8 Region   = 2;
+};
+
 #endif /*COMMON_EQ_CONSTANTS_H*/

common/eq_limits.h

@@ -1,4 +1,4 @@
-/*	EQEMu:  Everquest Server Emulator
+/*	EQEMu: Everquest Server Emulator
 	
 	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
@@ -10,7 +10,7 @@
 	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.
+	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
@@ -22,7 +22,7 @@
 
 #include "types.h"
 #include "eq_constants.h"
-#include "inventory_version.h"
+#include "emu_versions.h"
 #include "../common/patches/titanium_limits.h"
 #include "../common/patches/sof_limits.h"
 #include "../common/patches/sod_limits.h"
@@ -31,49 +31,238 @@
 #include "../common/patches/rof2_limits.h"
 
 
-namespace EQEmu
+namespace EQ
 {
+	void InitializeDynamicLookups();
+
 	namespace constants {
-		extern size_t CharacterCreationLimit(versions::ClientVersion client_version);
+		struct LookupEntry {
+			EQ::expansions::Expansion Expansion;
+			uint32 ExpansionBit;
+			uint32 ExpansionsMask;
+			int16 CharacterCreationLimit;
+			size_t SayLinkBodySize;
+			
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				EQ::expansions::Expansion Expansion,
+				uint32 ExpansionBit,
+				uint32 ExpansionsMask,
+				int16 CharacterCreationLimit,
+				size_t SayLinkBodySize
+			) :
+				Expansion(Expansion),
+				ExpansionBit(ExpansionBit),
+				ExpansionsMask(ExpansionsMask),
+				CharacterCreationLimit(CharacterCreationLimit),
+				SayLinkBodySize(SayLinkBodySize)
+			{ }
+		};
+
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::ClientVersion client_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* DynamicGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* StaticLookup(versions::ClientVersion client_version);
 
 	} /*constants*/
 	
 	namespace inventory {
-		extern uint16 InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type);
-		extern uint64 PossessionsBitmask(versions::InventoryVersion inventory_version);
+		struct LookupEntry {
+			// note: 'PossessionsBitmask' needs to be attuned to the client version with the highest number
+			// of possessions slots and 'InventoryTypeSize[typePossessions]' should reflect the same count
+			// with translators adjusting for valid slot indices. Server-side validations will be performed
+			// against 'PossessionsBitmask' (note: the same applies to CorpseBitmask..size is not dependent)
 
-		extern bool AllowEmptyBagInBag(versions::InventoryVersion inventory_version);
-		extern bool AllowClickCastFromBag(versions::InventoryVersion inventory_version);
+			struct InventoryTypeSize_Struct { // should reflect count and naming conventions referenced in emu_constants.h
+				int16 Possessions,	Bank,				SharedBank;
+				int16 Trade,		World,				Limbo;
+				int16 Tribute,		TrophyTribute,		GuildTribute;
+				int16 Merchant,		Deleted,			Corpse;
+				int16 Bazaar,		Inspect,			RealEstate;
+				int16 ViewMODPC,	ViewMODBank,		ViewMODSharedBank;
+				int16 ViewMODLimbo,	AltStorage,			Archived;
+				int16 Mail,			GuildTrophyTribute,	Krono;
+				int16 Other;
 
-		extern uint16 ItemAugSize(versions::InventoryVersion inventory_version);
-		extern uint16 ItemBagSize(versions::InventoryVersion inventory_version);
+				InventoryTypeSize_Struct(
+					int16 Possessions,	int16 Bank,					int16 SharedBank,
+					int16 Trade,		int16 World,				int16 Limbo,
+					int16 Tribute,		int16 TrophyTribute,		int16 GuildTribute,
+					int16 Merchant,		int16 Deleted,				int16 Corpse,
+					int16 Bazaar,		int16 Inspect,				int16 RealEstate,
+					int16 ViewMODPC,	int16 ViewMODBank,			int16 ViewMODSharedBank,
+					int16 ViewMODLimbo,	int16 AltStorage,			int16 Archived,
+					int16 Mail,			int16 GuildTrophyTribute,	int16 Krono,
+					int16 Other
+				) :
+					Possessions(Possessions),	Bank(Bank),								SharedBank(SharedBank),
+					Trade(Trade),				World(World),							Limbo(Limbo),
+					Tribute(Tribute),			TrophyTribute(TrophyTribute),			GuildTribute(GuildTribute),
+					Merchant(Merchant),			Deleted(Deleted),						Corpse(Corpse),
+					Bazaar(Bazaar),				Inspect(Inspect),						RealEstate(RealEstate),
+					ViewMODPC(ViewMODPC),		ViewMODBank(ViewMODBank),				ViewMODSharedBank(ViewMODSharedBank),
+					ViewMODLimbo(ViewMODLimbo),	AltStorage(AltStorage),					Archived(Archived),
+					Mail(Mail),					GuildTrophyTribute(GuildTrophyTribute),	Krono(Krono),
+					Other(Other)
+				{ }
+			};
 
-		extern bool ConcatenateInvTypeLimbo(versions::InventoryVersion inventory_version);
+			union {
+				InventoryTypeSize_Struct InventoryTypeSize;
+				int16 InventoryTypeSizeArray[25]; // should reflect EQ::invtype::TYPE_COUNT referenced in emu_constants.h
+			};
 
-		extern bool AllowOverLevelEquipment(versions::InventoryVersion inventory_version);
+			uint64 EquipmentBitmask;
+			uint64 GeneralBitmask;
+			uint64 CursorBitmask;
+			uint64 PossessionsBitmask;
+			uint64 CorpseBitmask;
+			int16 BagSlotCount;
+			int16 AugSocketCount;
+
+			bool AllowEmptyBagInBag;
+			bool AllowClickCastFromBag;
+			bool ConcatenateInvTypeLimbo;
+			bool AllowOverLevelEquipment;
+
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				InventoryTypeSize_Struct InventoryTypeSize,
+				uint64 EquipmentBitmask,
+				uint64 GeneralBitmask,
+				uint64 CursorBitmask,
+				uint64 PossessionsBitmask,
+				uint64 CorpseBitmask,
+				int16 BagSlotCount,
+				int16 AugSocketCount,
+				bool AllowEmptyBagInBag,
+				bool AllowClickCastFromBag,
+				bool ConcatenateInvTypeLimbo,
+				bool AllowOverLevelEquipment
+			) :
+				InventoryTypeSize(InventoryTypeSize),
+				EquipmentBitmask(EquipmentBitmask),
+				GeneralBitmask(GeneralBitmask),
+				CursorBitmask(CursorBitmask),
+				PossessionsBitmask(PossessionsBitmask),
+				CorpseBitmask(CorpseBitmask),
+				BagSlotCount(BagSlotCount),
+				AugSocketCount(AugSocketCount),
+				AllowEmptyBagInBag(AllowEmptyBagInBag),
+				AllowClickCastFromBag(AllowClickCastFromBag),
+				ConcatenateInvTypeLimbo(ConcatenateInvTypeLimbo),
+				AllowOverLevelEquipment(AllowOverLevelEquipment)
+			{ }
+		};
+
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::MobVersion mob_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* DynamicGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* StaticLookup(versions::MobVersion mob_version);
 
 	} /*inventory*/
 	
-	namespace profile {
-		extern bool CoinHasWeight(versions::InventoryVersion inventory_version);
+	namespace behavior {
+		struct LookupEntry {
+			bool CoinHasWeight;
 
-	} /*profile*/
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				bool CoinHasWeight
+			) :
+				CoinHasWeight(CoinHasWeight)
+			{ }
+		};
+
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::MobVersion mob_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* DynamicGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* StaticLookup(versions::MobVersion mob_version);
+
+	} /*behavior*/
+
+	namespace spells {
+		struct LookupEntry {
+			int SpellIdMax;
+			int SpellbookSize;
+			int SpellGemCount;
+
+			int LongBuffs;
+			int ShortBuffs;
+			int DiscBuffs;
+			int TotalBuffs;
+			int NPCBuffs;
+			int PetBuffs;
+			int MercBuffs;
+			
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				int SpellIdMax,
+				int SpellbookSize,
+				int SpellGemCount,
+				int LongBuffs,
+				int ShortBuffs,
+				int DiscBuffs,
+				int TotalBuffs,
+				int NPCBuffs,
+				int PetBuffs,
+				int MercBuffs
+			) :
+				SpellIdMax(SpellIdMax),
+				SpellbookSize(SpellbookSize),
+				SpellGemCount(SpellGemCount),
+				LongBuffs(LongBuffs),
+				ShortBuffs(ShortBuffs),
+				DiscBuffs(DiscBuffs),
+				TotalBuffs(TotalBuffs),
+				NPCBuffs(NPCBuffs),
+				PetBuffs(PetBuffs),
+				MercBuffs(MercBuffs)
+			{ }
+		};
+		
+		void InitializeDynamicLookups();
+		
+		const LookupEntry* DynamicLookup(versions::ClientVersion client_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* DynamicGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* StaticLookup(versions::ClientVersion client_version);
+
+	} /*spells*/
 
 } /*EQEmu*/
 
 namespace ClientUnknown
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
+	namespace constants {
+		const EQ::expansions::Expansion EXPANSION = EQ::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQ::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQ::expansions::maskEverQuest;
+
+	} // namespace constants
 
 } /*ClientUnknown*/
 
 namespace Client62
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
+	namespace constants {
+		const EQ::expansions::Expansion EXPANSION = EQ::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQ::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQ::expansions::maskEverQuest;
+
+	} // namespace constants
 
 } /*Client62*/
 

common/eq_packet.cpp

@@ -132,7 +132,7 @@ void EQApplicationPacket::build_header_dump(char *buffer) const
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x Size=%u]\n", emu_opcode,size);
 #else
-	sprintf(buffer, "[OpCode %s Size=%u]",OpcodeManager::EmuToName(emu_opcode),size);
+	sprintf(buffer, "[OpCode %s(0x%04x) Size=%u]",OpcodeManager::EmuToName(emu_opcode), GetProtocolOpcode(), size);
 #endif
 }
 

common/eq_packet.h

@@ -51,6 +51,7 @@ protected:
 	EmuOpcode emu_opcode;
 
 	EQPacket(EmuOpcode opcode, const unsigned char *buf, const uint32 len);
+	EQPacket(EmuOpcode opcode, SerializeBuffer &buf) : BasePacket(buf), emu_opcode(opcode) { };
 //	EQPacket(const EQPacket &p) { }
 	EQPacket() { emu_opcode=OP_Unknown; pBuffer=nullptr; size=0; }
 
@@ -104,6 +105,8 @@ public:
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op, buf, len), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+	EQApplicationPacket(const EmuOpcode op, SerializeBuffer &buf) : EQPacket(op, buf), opcode_bypass(0)
+		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
 	uint32 Size() const { return size+app_opcode_size; }
@@ -115,11 +118,14 @@ public:
 	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
 	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;
 
-	uint16 GetOpcodeBypass() { return opcode_bypass; }
+	uint16 GetOpcodeBypass() const { return opcode_bypass; }
 	void SetOpcodeBypass(uint16 v) { opcode_bypass = v; }
 
+	uint16 GetProtocolOpcode() const { return protocol_opcode; }
+	void SetProtocolOpcode(uint16 v) { protocol_opcode = v; }
 protected:
 
+	uint16 protocol_opcode;
 	uint8 app_opcode_size;
 	uint16 opcode_bypass;
 private:

common/eq_stream.cpp

@@ -84,14 +84,14 @@ void EQStream::init(bool resetSession) {
 
 	OpMgr = nullptr;
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+		LogNetcode(_L "init Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 }
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
+	LogNetcode(_L "Creating new application packet, length [{}]" __L, p->size);
 	// _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
 	ap = p->MakeAppPacket();
 	return ap;
@@ -100,7 +100,7 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
+	LogNetcode(_L "Creating new application packet, length [{}]" __L, len);
 	ap = new EQRawApplicationPacket(buf, len);
 	return ap;
 }
@@ -130,7 +130,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 	}
 
 	if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Session not initialized, packet ignored" __L);
+		LogNetcode(_L "Session not initialized, packet ignored" __L);
 		// _raw(NET__DEBUG, 0xFFFF, p);
 		return;
 	}
@@ -141,7 +141,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed < p->size) {
 				subpacket_length=*(p->pBuffer+processed);
 				EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
+				LogNetcode(_L "Extracting combined packet of length [{}]" __L, subpacket_length);
 				// _raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
 				subp->copyInfo(p);
 				ProcessPacket(subp);
@@ -156,12 +156,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed<p->size) {
 				EQRawApplicationPacket *ap=nullptr;
 				if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length);
 					processed+=subpacket_length+1;
 				} else {
 					subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1));
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length);
 					processed+=subpacket_length+3;
 				}
@@ -176,29 +176,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Packet: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Packet that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Packet that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+					LogNetcode(_L "Future OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 					// _raw(NET__DEBUG, seq, p);
 
 					PacketQueue[seq]=p->Copy();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+					LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Duplicate OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq); //we already got this packet but it was out of order
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
+					LogNetcode("[NET_TRACE] OP_Packet: Removing older queued packet with sequence [{}]", seq);
 					delete qp;
 				}
 
@@ -207,7 +207,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				// Check for an embedded OP_AppCombinded (protocol level 0x19)
 				if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 					EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2);
-					Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
+					LogNetcode(_L "seq [{}], Extracting combined packet of length [{}]" __L, seq, subp->size);
 					// _raw(NET__NET_CREATE_HEX, seq, subp);
 					subp->copyInfo(p);
 					ProcessPacket(subp);
@@ -226,29 +226,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Fragment: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Fragment that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Fragment that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Future OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 
 				PacketQueue[seq]=p->Copy();
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
+				LogNetcode(_L "OP_Fragment Queue size=[{}]" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Duplicate OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq);
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
+					LogNetcode("[NET_TRACE] OP_Fragment: Removing older queued packet with sequence [{}]", seq);
 					delete qp;
 				}
 				SetNextAckToSend(seq);
@@ -256,18 +256,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				if (oversize_buffer) {
 					memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2);
 					oversize_offset+=p->size-2;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
+					LogNetcode(_L "Fragment of oversized of length [{}], seq [{}]: now at [{}]/[{}]" __L, p->size-2, seq, oversize_offset, oversize_length);
 					if (oversize_offset==oversize_length) {
 						if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 							EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
-							Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
+							LogNetcode(_L "seq [{}], Extracting combined oversize packet of length [{}]" __L, seq, subp->size);
 							//// _raw(NET__NET_CREATE_HEX, subp);
 							subp->copyInfo(p);
 							ProcessPacket(subp);
 							delete subp;
 						} else {
 							EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
-							Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
+							LogNetcode(_L "seq [{}], completed combined oversize packet of length [{}]" __L, seq, ap->size);
 							if (ap) {
 								ap->copyInfo(p);
 								InboundQueuePush(ap);
@@ -282,20 +282,20 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					oversize_buffer=new unsigned char[oversize_length];
 					memcpy(oversize_buffer,p->pBuffer+6,p->size-6);
 					oversize_offset=p->size-6;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
+					LogNetcode(_L "First fragment of oversized of seq [{}]: now at [{}]/[{}]" __L, seq, oversize_offset, oversize_length);
 				}
 			}
 		}
 		break;
 		case OP_KeepAlive: {
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
+			LogNetcode(_L "Received and queued reply to keep alive" __L);
 		}
 		break;
 		case OP_Ack: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
@@ -309,11 +309,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionRequest: {
 			if(p->Size() < sizeof(SessionRequest))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
 			if (GetState()==ESTABLISHED) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
+				LogNetcode(_L "Received OP_SessionRequest in ESTABLISHED state ([{}]) streamactive ([{}]) attempt ([{}])" __L, GetState(),streamactive,sessionAttempts);
 
 				// client seems to try a max of 30 times (initial+3 retries) then gives up, giving it a few more attempts just in case
 				// streamactive means we identified the opcode for the stream, we cannot re-establish this connection
@@ -331,7 +331,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SessionRequest *Request=(SessionRequest *)p->pBuffer;
 			Session=ntohl(Request->Session);
 			SetMaxLen(ntohl(Request->MaxLength));
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
+			LogNetcode(_L "Received OP_SessionRequest: session [{}], maxlen [{}]" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
 			Key=0x11223344;
 			SendSessionResponse();
@@ -340,7 +340,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionResponse: {
 			if(p->Size() < sizeof(SessionResponse))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionResponse that was of malformed size" __L);
 				break;
 			}
 
@@ -356,7 +356,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			compressed=(Response->Format&FLAG_COMPRESSED);
 			encoded=(Response->Format&FLAG_ENCODED);
 
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
+			LogNetcode(_L "Received OP_SessionResponse: session [{}], maxlen [{}], key [{}], compressed? [{}], encoded? [{}]" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
 
 			// Kinda kludgy, but trie for now
 			if (StreamType==UnknownStream) {
@@ -379,17 +379,17 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			EQStreamState state = GetState();
 			if(state == ESTABLISHED) {
 				//client initiated disconnect?
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
+				LogNetcode(_L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect" __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else if(state == CLOSING) {
 				//we were waiting for this anyways, ignore pending messages, send the reply and be closed.
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
+				LogNetcode(_L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though" __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else {
 				//we are expecting this (or have already gotten it, but dont care either way)
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
+				LogNetcode(_L "Received expected OP_SessionDisconnect. Moving to closed state" __L);
 				SetState(CLOSED);
 			}
 		}
@@ -397,24 +397,24 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_OutOfOrderAck: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
+				LogNetcode(_L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Pre-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
 			if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
 					seq, SequencedBase, SequencedBase+SequencedQueue.size());
 
 				uint16 sqsize = SequencedQueue.size();
 				uint16 index = seq - SequencedBase;
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+				LogNetcode(_L "OP_OutOfOrderAck marking packet acked in queue (queue index = [{}], queue size = [{}])" __L, index, sqsize);
 				if (index < sqsize) {
 					SequencedQueue[index]->acked = true;
 					// flag packets for a resend
@@ -423,7 +423,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
 						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
 							(*sitr)->sent_time = 0;
-							Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
+							LogNetcode(_L "OP_OutOfOrderAck Flagging packet [{}] for retransmission" __L, SequencedBase + count);
 						}
 					}
 				}
@@ -432,11 +432,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimer = Timer::GetCurrentTime();
 				}
 			} else {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
+				LogNetcode(_L "Received OP_OutOfOrderAck for out-of-window [{}]. Window ([{}]->[{}])" __L, seq, SequencedBase, NextOutSeq);
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Post-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 
 			MOutboundQueue.unlock();
@@ -445,11 +445,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionStatRequest: {
 			if(p->Size() < sizeof(ClientSessionStats))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
 			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
+			Log(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
 				(unsigned long)ntohl(ClientStats->packets_received), (unsigned long)ntohl(ClientStats->packets_sent), (unsigned long)ntohl(ClientStats->last_local_delta),
 				(unsigned long)ntohl(ClientStats->low_delta), (unsigned long)ntohl(ClientStats->average_delta),
 				(unsigned long)ntohl(ClientStats->high_delta), (unsigned long)ntohl(ClientStats->last_remote_delta));
@@ -468,7 +468,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
+					LogNetcode(_L "Retransmit timeout recalculated to [{}]ms" __L, retransmittimeout);
 				}
 			}
 
@@ -485,11 +485,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_SessionStatResponse: {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
+			LogNetcode(_L "Received OP_SessionStatResponse. Ignoring" __L);
 		}
 		break;
 		case OP_OutOfSession: {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
+			LogNetcode(_L "Received OP_OutOfSession. Ignoring" __L);
 		}
 		break;
 		default:
@@ -520,7 +520,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 		return;
 
 	if(OpMgr == nullptr || *OpMgr == nullptr) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
+		LogNetcode(_L "Packet enqueued into a stream with no opcode manager, dropping" __L);
 		delete pack;
 		return;
 	}
@@ -529,7 +529,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 	if(pack->GetOpcodeBypass() != 0) {
 		opcode = pack->GetOpcodeBypass();
 	} else {
-		opcode = (*OpMgr)->EmuToEQ(pack->emu_opcode);
+		opcode = (*OpMgr)->EmuToEQ(pack->GetOpcode());
 	}
 
 	if (!ack_req) {
@@ -545,32 +545,32 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 	uint32 chunksize, used;
 	uint32 length;
 
-	if (Log.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
-			Log.Out(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+			Log(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
 		}
 	}
 
-	if (Log.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
-			Log.Out(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
+			Log(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
 		}
 	}
 
 	// Convert the EQApplicationPacket to 1 or more EQProtocolPackets
 	if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
+		LogNetcode(_L "Making oversized packet, len [{}]" __L, p->Size());
 
 		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
 		if (length != p->Size())
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
+			LogNetcode(_L "Packet adjustment, len [{}] to [{}]" __L, p->Size(), length);
 
 		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
 		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
+		LogNetcode(_L "First fragment: used [{}]/[{}]. Payload size [{}] in the packet" __L, used, length, p->size);
 		SequencedPush(out);
 
 
@@ -581,7 +581,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
+			LogNetcode(_L "Subsequent fragment: len [{}], used [{}]/[{}]" __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
@@ -602,18 +602,18 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
 	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+		Log(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
 			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
+	Log(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
 		NextOutSeq, p->size, SequencedBase);
 	*(uint16 *)(p->pBuffer) = htons(NextOutSeq);
 	SequencedQueue.push_back(p);
 	NextOutSeq++;
 
 	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+		Log(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
 			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 
@@ -623,7 +623,7 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
+	LogNetcode(_L "Pushing non-sequenced packet of length [{}]" __L, p->size);
 	NonSequencedQueue.push(p);
 	MOutboundQueue.unlock();
 }
@@ -631,14 +631,14 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
 void EQStream::SendAck(uint16 seq)
 {
 uint16 Seq=htons(seq);
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
+	LogNetcode(_L "Sending ack with sequence [{}]" __L, seq);
 	SetLastAckSent(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
 }
 
 void EQStream::SendOutOfOrderAck(uint16 seq)
 {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
+	LogNetcode(_L "Sending out of order ack with sequence [{}]" __L, seq);
 uint16 Seq=htons(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16)));
 }
@@ -688,24 +688,24 @@ void EQStream::Write(int eq_fd)
 				// If we don't have a packet to try to combine into, use this one as the base
 				// And remove it form the queue
 				p = NonSequencedQueue.front();
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
+				LogNetcode(_L "Starting combined packet with non-seq packet of len [{}]" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
 				// Trying to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
+				LogNetcode(_L "Combined packet full at len [{}], next non-seq packet is len [{}]" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
 				BytesWritten+=p->size;
 				p=nullptr;
 
 				if (BytesWritten > threshold) {
 					// Sent enough this round, lets stop to be fair
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
+					LogNetcode(_L "Exceeded write threshold in nonseq ([{}] > [{}])" __L, BytesWritten, threshold);
 					break;
 				}
 			} else {
 				// Combine worked, so just remove this packet and it's spot in the queue
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
+				LogNetcode(_L "Combined non-seq packet of len [{}], yeilding [{}] combined" __L, (NonSequencedQueue.front())->size, p->size);
 				delete NonSequencedQueue.front();
 				NonSequencedQueue.pop();
 			}
@@ -718,7 +718,7 @@ void EQStream::Write(int eq_fd)
 			uint16 seq_send = SequencedBase + count;	//just for logging...
 
 			if(SequencedQueue.empty()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
+				LogNetcode(_L "Tried to write a packet with an empty queue ([{}] is past next out [{}])" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
 				continue;
 			}
@@ -728,35 +728,35 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
 					}
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
+					LogNetcode(_L "Not retransmitting seq packet [{}] because already marked as acked" __L, seq_send);
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
+					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send + 1, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					LogNetcode(_L "Combined seq packet [{}] of len [{}], yeilding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -766,7 +766,7 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
@@ -776,25 +776,25 @@ void EQStream::Write(int eq_fd)
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					(*sitr)->sent_time = Timer::GetCurrentTime();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 
 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					LogNetcode(_L "Combined seq packet [{}] of len [{}], yielding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -802,7 +802,7 @@ void EQStream::Write(int eq_fd)
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Post send Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 		} else {
 			// No more sequenced packets
@@ -814,7 +814,7 @@ void EQStream::Write(int eq_fd)
 
 	// We have a packet still, must have run out of both seq and non-seq, so send it
 	if (p) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+		LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 		ReadyToSend.push(p);
 		BytesWritten+=p->size;
 	}
@@ -831,7 +831,7 @@ void EQStream::Write(int eq_fd)
 	if(SeqEmpty && NonSeqEmpty) {
 		//no more data to send
 		if(CheckState(CLOSING)) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "All outgoing data flushed, closing stream." __L );
+			LogNetcode(_L "All outgoing data flushed, closing stream" __L );
 			//we are waiting for the queues to empty, now we can do our disconnect.
 			//this packet will not actually go out until the next call to Write().
 			_SendDisconnect();
@@ -896,7 +896,7 @@ void EQStream::SendSessionResponse()
 
 	out->size=sizeof(SessionResponse);
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
 		(unsigned long)Session, MaxLen, Key, compressed?"yes":"no", encoded?"yes":"no");
 
 	NonSequencedPush(out);
@@ -910,7 +910,7 @@ void EQStream::SendSessionRequest()
 	Request->Session=htonl(time(nullptr));
 	Request->MaxLength=htonl(512);
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
+	LogNetcode(_L "Sending OP_SessionRequest: session [{}], maxlen=[{}]" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
 
 	NonSequencedPush(out);
 }
@@ -924,7 +924,7 @@ void EQStream::_SendDisconnect()
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
+	LogNetcode(_L "Sending OP_SessionDisconnect: session [{}]" __L, (unsigned long)Session);
 }
 
 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@@ -950,7 +950,7 @@ EQRawApplicationPacket *p=nullptr;
 		if (OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if (emu_op == OP_Unknown) {
-				// Log.Out(Logs::General, Logs::Client_Server_Packet_Unhandled, "Unknown :: [%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->opcode, p->Size(), DumpPacketToString(p).c_str());
+				// Log(Logs::General, Logs::Client_Server_Packet_Unhandled, "Unknown :: [%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->opcode, p->Size(), DumpPacketToString(p).c_str());
 			} 
 			p->SetOpcode(emu_op);
 		}
@@ -976,7 +976,7 @@ EQRawApplicationPacket *p=nullptr;
 		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if(emu_op == OP_Unknown) {
-				Log.Out(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
+				LogNetcode("Unable to convert EQ opcode {:#04x} to an Application opcode", p->opcode);
 			}
 
 			p->SetOpcode(emu_op);
@@ -1004,7 +1004,7 @@ void EQStream::InboundQueueClear()
 {
 EQApplicationPacket *p=nullptr;
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
+	LogNetcode(_L "Clearing inbound queue" __L);
 
 	MInboundQueue.lock();
 	if (!InboundQueue.empty()) {
@@ -1047,7 +1047,7 @@ void EQStream::OutboundQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
+	LogNetcode(_L "Clearing outbound queue" __L);
 
 	MOutboundQueue.lock();
 	while(!NonSequencedQueue.empty()) {
@@ -1069,7 +1069,7 @@ void EQStream::PacketQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
+	LogNetcode(_L "Clearing future packet queue" __L);
 
 	if(!PacketQueue.empty()) {
 		std::map<unsigned short,EQProtocolPacket *>::iterator itr;
@@ -1101,7 +1101,7 @@ void EQStream::Process(const unsigned char *buffer, const uint32 length)
 		delete p;
 		ProcessQueue();
 	} else {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
+		LogNetcode(_L "Incoming packet failed checksum" __L);
 	}
 }
 
@@ -1132,23 +1132,23 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 	SeqOrder ord = CompareSequence(SequencedBase, seq);
 	if(ord == SeqInOrder) {
 		//they are not acking anything new...
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
+		LogNetcode(_L "Received an ack with no window advancement (seq [{}])" __L, seq);
 	} else if(ord == SeqPast) {
 		//they are nacking blocks going back before our buffer, wtf?
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
+		LogNetcode(_L "Received an ack with backward window advancement (they gave [{}], our window starts at [{}]). This is bad" __L, seq, SequencedBase);
 	} else {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);
+		LogNetcode(_L "Received an ack up through sequence [{}]. Our base is [{}]" __L, seq, SequencedBase);
 
 
 		//this is a good ack, we get to ack some blocks.
 		seq++;	//we stop at the block right after their ack, counting on the wrap of both numbers.
 		while(SequencedBase != seq) {
 			if(SequencedQueue.empty()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, SequencedQueue.size());
+				LogNetcode(_L "OUT OF PACKETS acked packet with sequence [{}]. Next send is [{}] before this" __L, (unsigned long)SequencedBase, SequencedQueue.size());
 				SequencedBase = NextOutSeq;
 				break;
 			}
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
+			LogNetcode(_L "Removing acked packet with sequence [{}]" __L, (unsigned long)SequencedBase);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
@@ -1156,7 +1156,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 			SequencedBase++;
 		}
 		if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
+			LogNetcode(_L "Post-Ack on [{}] Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
 		}
 	}
 
@@ -1166,7 +1166,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 void EQStream::SetNextAckToSend(uint32 seq)
 {
 	MAcks.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
+	LogNetcode(_L "Set Next Ack To Send to [{}]" __L, (unsigned long)seq);
 	NextAckToSend=seq;
 	MAcks.unlock();
 }
@@ -1174,7 +1174,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
 void EQStream::SetLastAckSent(uint32 seq)
 {
 	MAcks.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
+	LogNetcode(_L "Set Last Ack Sent to [{}]" __L, (unsigned long)seq);
 	LastAckSent=seq;
 	MAcks.unlock();
 }
@@ -1187,10 +1187,10 @@ void EQStream::ProcessQueue()
 
 	EQProtocolPacket *qp=nullptr;
 	while((qp=RemoveQueue(NextInSeq))!=nullptr) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
+		LogNetcode(_L "Processing Queued Packet: Seq=[{}]" __L, NextInSeq);
 		ProcessPacket(qp);
 		delete qp;
-		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
 	}
 }
 
@@ -1201,21 +1201,21 @@ EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
 	}
 	return qp;
 }
 
 void EQStream::SetStreamType(EQStreamType type)
 {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
+	LogNetcode(_L "Changing stream type from [{}] to [{}]" __L, StreamTypeString(StreamType), StreamTypeString(type));
 	StreamType=type;
 	switch (StreamType) {
 		case LoginStream:
 			app_opcode_size=1;
 			compressed=false;
 			encoded=false;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
+			LogNetcode(_L "Login stream has app opcode size [{}], is not compressed or encoded" __L, app_opcode_size);
 			break;
 		case ChatOrMailStream:
 		case ChatStream:
@@ -1223,7 +1223,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=1;
 			compressed=false;
 			encoded=true;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
+			LogNetcode(_L "Chat/Mail stream has app opcode size [{}], is not compressed, and is encoded" __L, app_opcode_size);
 			break;
 		case ZoneStream:
 		case WorldStream:
@@ -1231,7 +1231,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=2;
 			compressed=true;
 			encoded=false;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
+			LogNetcode(_L "World/Zone stream has app opcode size [{}], is compressed, and is not encoded" __L, app_opcode_size);
 			break;
 	}
 }
@@ -1281,7 +1281,7 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)
 
 void EQStream::SetState(EQStreamState state) {
 	MState.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
+	LogNetcode(_L "Changing state from [{}] to [{}]" __L, State, state);
 	State=state;
 	MState.unlock();
 }
@@ -1293,29 +1293,29 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
 
 	EQStreamState orig_state = GetState();
 	if (orig_state == CLOSING && !outgoing_data) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Out of data in closing state, disconnecting." __L);
+		LogNetcode(_L "Out of data in closing state, disconnecting" __L);
 		_SendDisconnect();
 		SetState(DISCONNECTING);
 	} else if (LastPacket && (now-LastPacket) > timeout) {
 		switch(orig_state) {
 		case CLOSING:
 			//if we time out in the closing state, they are not acking us, just give up
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L);
+			LogNetcode(_L "Timeout expired in closing state. Moving to closed state" __L);
 			_SendDisconnect();
 			SetState(CLOSED);
 			break;
 		case DISCONNECTING:
 			//we timed out waiting for them to send us the disconnect reply, just give up.
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
+			LogNetcode(_L "Timeout expired in disconnecting state. Moving to closed state" __L);
 			SetState(CLOSED);
 			break;
 		case CLOSED:
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in closed state??" __L);
+			LogNetcode(_L "Timeout expired in closed state??" __L);
 			break;
 		case ESTABLISHED:
 			//we timed out during normal operation. Try to be nice about it.
 			//we will almost certainly time out again waiting for the disconnect reply, but oh well.
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in established state. Closing connection." __L);
+			LogNetcode(_L "Timeout expired in established state. Closing connection" __L);
 			_SendDisconnect();
 			SetState(DISCONNECTING);
 			break;
@@ -1342,7 +1342,7 @@ void EQStream::Decay()
 		for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end(); ++sitr, count++) {
 			if (!(*sitr)->acked && (*sitr)->sent_time > 0 && ((*sitr)->sent_time + retransmittimeout) < Timer::GetCurrentTime()) {
 				(*sitr)->sent_time = 0;
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
+				LogNetcode(_L "Timeout exceeded for seq [{}].  Flagging packet for retransmission" __L, SequencedBase + count);
 			}
 		}
 		MOutboundQueue.unlock();
@@ -1359,11 +1359,11 @@ void EQStream::AdjustRates(uint32 average_delta)
 			DecayRate=DECAYBASE/average_delta;
 			if (BytesWritten > RateThreshold)
 				BytesWritten = RateThreshold + DecayRate;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
 				RateThreshold, DecayRate, average_delta);
 			MRate.unlock();
 		} else {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
 				average_delta, AVERAGE_DELTA_MAX);
 			AverageDelta = AVERAGE_DELTA_MAX;
 		}
@@ -1374,7 +1374,7 @@ void EQStream::AdjustRates(uint32 average_delta)
 			BytesWritten = 0;
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
 				RateThreshold, DecayRate, average_delta);
 			MRate.unlock();
 		}
@@ -1384,12 +1384,12 @@ void EQStream::AdjustRates(uint32 average_delta)
 void EQStream::Close() {
 	if(HasOutgoingData()) {
 		//there is pending data, wait for it to go out.
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
+		LogNetcode(_L "Stream requested to Close(), but there is pending data, waiting for it" __L);
 		SetState(CLOSING);
 	} else {
 		//otherwise, we are done, we can drop immediately.
 		_SendDisconnect();
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream closing immediate due to Close()" __L);
+		LogNetcode(_L "Stream closing immediate due to Close()" __L);
 		SetState(DISCONNECTING);
 	}
 }
@@ -1417,19 +1417,19 @@ EQStream::MatchState EQStream::CheckSignature(const Signature *sig) {
 		} else if(p->opcode == sig->first_eq_opcode) {
 			//opcode matches, check length..
 			if(p->size == sig->first_length) {
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length matched [{}]", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else if(sig->first_length == 0) {
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length ([{}]) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else {
 				//opcode matched but length did not.
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x}, but length [{}] did not match expected [{}]", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
 				res = MatchFailed;
 			}
 		} else {
 			//first opcode did not match..
-			Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
+			LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode {:#04x} did not match expected {:#04x}", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
 			res = MatchFailed;
 		}
 	}

common/eq_stream.h

@@ -241,7 +241,7 @@ class EQStream : public EQStreamInterface {
 		virtual bool CheckState(EQStreamState state) { return GetState() == state; }
 		virtual std::string Describe() const { return("Direct EQStream"); }
 
-		void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
+		virtual void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
 
 		void CheckTimeout(uint32 now, uint32 timeout=30);
 		bool HasOutgoingData();
@@ -250,13 +250,13 @@ class EQStream : public EQStreamInterface {
 		void Write(int eq_fd);
 
 		// whether or not the stream has been assigned (we passed our stream match)
-		void SetActive(bool val) { streamactive = val; }
+		virtual void SetActive(bool val) { streamactive = val; }
 
 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }
 
-		inline EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
+		virtual EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
 
 		static SeqOrder CompareSequence(uint16 expected_seq , uint16 seq);
 
@@ -306,19 +306,7 @@ class EQStream : public EQStreamInterface {
 		const uint64 GetPacketsReceived() { return received_packet_count; }
 
 		//used for dynamic stream identification
-		class Signature {
-		public:
-			//this object could get more complicated if needed...
-			uint16 ignore_eq_opcode;		//0=dont ignore
-			uint16 first_eq_opcode;
-			uint32 first_length;			//0=dont check length
-		};
-		typedef enum {
-			MatchNotReady,
-			MatchSuccessful,
-			MatchFailed
-		} MatchState;
-		MatchState CheckSignature(const Signature *sig);
+		virtual MatchState CheckSignature(const Signature *sig);
 
 };
 

common/eq_stream_factory.cpp

@@ -23,18 +23,10 @@
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-EQStreamFactory *fs=(EQStreamFactory *)eqfs;
-
-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
-#endif
+	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 	fs->ReaderLoop();
 
-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
-#endif
-
 	THREAD_RETURN(nullptr);
 }
 
@@ -42,16 +34,8 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
 	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
-#endif
-
 	fs->WriterLoop();
 
-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
-#endif
-
 	THREAD_RETURN(nullptr);
 }
 

common/eq_stream_ident.cpp

@@ -4,7 +4,7 @@
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
 #include "eq_stream_proxy.h"
-
+#include "misc.h"
 
 EQStreamIdentifier::~EQStreamIdentifier() {
 	while(!m_identified.empty()) {
@@ -26,7 +26,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 	}
 }
 
-void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
+void EQStreamIdentifier::RegisterPatch(const EQStreamInterface::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
 	auto p = new Patch;
 	p->signature = sig;
 	p->name = name;
@@ -46,9 +46,9 @@ void EQStreamIdentifier::Process() {
 
 		//first see if this stream has expired
 		if(r.expire.Check(false)) {
-			//this stream has failed to match any pattern in our timeframe.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
-			r.stream->ReleaseFromUse();
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before timeout", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
+			r.stream->Close();
+
 			cur = m_streams.erase(cur);
 			continue;
 		}
@@ -62,23 +62,23 @@ void EQStreamIdentifier::Process() {
 		}
 		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before it closed", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
+				LogNetcode("[StreamIdentify] Stream state was Established");
 				break;
 			case CLOSING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
+				LogNetcode("[StreamIdentify] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
+				LogNetcode("[StreamIdentify] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
+				LogNetcode("[StreamIdentify] Stream state was Closed");
 				break;
 			default:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
+				LogNetcode("[StreamIdentify] Stream state was Unestablished or unknown");
 				break;
 			}
 			r.stream->ReleaseFromUse();
@@ -98,17 +98,17 @@ void EQStreamIdentifier::Process() {
 			Patch *p = *curp;
 
 			//ask the stream to see if it matches the supplied signature
-			EQStream::MatchState res = r.stream->CheckSignature(&p->signature);
+			EQStreamInterface::MatchState res = r.stream->CheckSignature(&p->signature);
 			switch(res) {
-			case EQStream::MatchNotReady:
+			case EQStreamInterface::MatchNotReady:
 				//the stream has not received enough packets to compare with this signature
-//				Log.LogDebugType(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+//				Log.LogDebugType(Logs::General, Logs::Netcode, "[StreamIdentify] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				all_ready = false;
 				break;
-			case EQStream::MatchSuccessful: {
+			case EQStreamInterface::MatchSuccessful: {
 				//yay, a match.
 
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				LogNetcode("[StreamIdentify] Identified stream [{}:{}] with signature [{}]", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 
 				// before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further
 				r.stream->SetActive(true);
@@ -120,9 +120,9 @@ void EQStreamIdentifier::Process() {
 				found_one = true;
 				break;
 			}
-			case EQStream::MatchFailed:
+			case EQStreamInterface::MatchFailed:
 				//do nothing...
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				LogNetcode("[StreamIdentify] [{}:{}] Tried patch [{}] and it did not match", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				break;
 			}
 		}
@@ -130,7 +130,7 @@ void EQStreamIdentifier::Process() {
 		//if we checked all patches and did not find a match.
 		if(all_ready && !found_one) {
 			//the stream cannot be identified.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}], no match found", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			r.stream->ReleaseFromUse();
 		}
 
@@ -144,7 +144,7 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }
 
-void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
+void EQStreamIdentifier::AddStream(std::shared_ptr<EQStreamInterface> eqs) {
 	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
@@ -157,7 +157,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }
 
-EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
+EQStreamIdentifier::Record::Record(std::shared_ptr<EQStreamInterface> s)
 :	stream(std::move(s)),
 	expire(STREAM_IDENT_WAIT_MS)
 {

common/eq_stream_ident.h

@@ -1,13 +1,13 @@
 #ifndef EQSTREAMIDENT_H_
 #define EQSTREAMIDENT_H_
 
-#include "eq_stream.h"
+#include "eq_stream_intf.h"
 #include "timer.h"
 #include <vector>
 #include <queue>
 #include <memory>
 
-#define STREAM_IDENT_WAIT_MS 10000
+#define STREAM_IDENT_WAIT_MS 30000
 
 class OpcodeManager;
 class StructStrategy;
@@ -18,11 +18,11 @@ public:
 	~EQStreamIdentifier();
 
 	//registration interface.
-	void RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs);
+	void RegisterPatch(const EQStreamInterface::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs);
 
 	//main processing interface
 	void Process();
-	void AddStream(std::shared_ptr<EQStream> &eqs);
+	void AddStream(std::shared_ptr<EQStreamInterface> eqs);
 	EQStreamInterface *PopIdentified();
 
 protected:
@@ -31,7 +31,7 @@ protected:
 	class Patch {
 	public:
 		std::string				name;
-		EQStream::Signature		signature;
+		EQStreamInterface::Signature		signature;
 		OpcodeManager **		opcodes;
 		const StructStrategy *structs;
 	};
@@ -40,8 +40,8 @@ protected:
 	//pending streams..
 	class Record {
 	public:
-		Record(std::shared_ptr<EQStream> s);
-		std::shared_ptr<EQStream> stream;		//we own this
+		Record(std::shared_ptr<EQStreamInterface> s);
+		std::shared_ptr<EQStreamInterface> stream;		//we own this
 		Timer expire;
 	};
 	std::vector<Record> m_streams;	//we own these objects, and the streams contained in them.

common/eq_stream_intf.h

@@ -4,7 +4,9 @@
 //this is the only part of an EQStream that is seen by the application.
 
 #include <string>
-#include "client_version.h" // inv2 watch
+#include "emu_versions.h"
+#include "eq_packet.h"
+#include "net/daybreak_connection.h"
 
 typedef enum {
 	ESTABLISHED,
@@ -15,27 +17,93 @@ typedef enum {
 } EQStreamState;
 
 class EQApplicationPacket;
+class OpcodeManager;
+
+struct EQStreamManagerInterfaceOptions
+{
+	EQStreamManagerInterfaceOptions() {
+		opcode_size = 2;
+	}
+
+	EQStreamManagerInterfaceOptions(int port, bool encoded, bool compressed) {
+		opcode_size = 2;
+
+		//World seems to support both compression and xor zone supports one or the others.
+		//Enforce one or the other in the convienence construct
+		//Login I had trouble getting to recognize compression at all 
+		//but that might be because it was still a bit buggy when i was testing that.
+		if (compressed) {
+			daybreak_options.encode_passes[0] = EQ::Net::EncodeCompression;
+		}
+		else if (encoded) {
+			daybreak_options.encode_passes[0] = EQ::Net::EncodeXOR;
+		}
+
+		daybreak_options.port = port;
+	}
+
+	int opcode_size;
+	bool track_opcode_stats;
+	EQ::Net::DaybreakConnectionManagerOptions daybreak_options;
+};
+
+class EQStreamManagerInterface
+{
+public:
+	EQStreamManagerInterface(const EQStreamManagerInterfaceOptions &options) { m_options = options; }
+	virtual ~EQStreamManagerInterface() { };
+
+	EQStreamManagerInterfaceOptions GetOptions() { return m_options; }
+	const EQStreamManagerInterfaceOptions& GetOptions() const { return m_options; }
+	virtual void SetOptions(const EQStreamManagerInterfaceOptions& options) = 0;
+protected:
+	EQStreamManagerInterfaceOptions m_options;
+};
 
 class EQStreamInterface {
 public:
 	virtual ~EQStreamInterface() {}
 
+	class Signature {
+	public:
+		//this object could get more complicated if needed...
+		uint16 ignore_eq_opcode;		//0=dont ignore
+		uint16 first_eq_opcode;
+		uint32 first_length;			//0=dont check length
+	};
+
+	typedef enum {
+		MatchNotReady,
+		MatchSuccessful,
+		MatchFailed
+	} MatchState;
+
+	struct Stats
+	{
+		EQ::Net::DaybreakConnectionStats DaybreakStats;
+		int RecvCount[_maxEmuOpcode];
+		int SentCount[_maxEmuOpcode];
+	};
+
 	virtual void QueuePacket(const EQApplicationPacket *p, bool ack_req=true) = 0;
 	virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true) = 0;
 	virtual EQApplicationPacket *PopPacket() = 0;
 	virtual void Close() = 0;
 	virtual void ReleaseFromUse() = 0;
 	virtual void RemoveData() = 0;
+	virtual std::string GetRemoteAddr() const = 0;
 	virtual uint32 GetRemoteIP() const = 0;
 	virtual uint16 GetRemotePort() const = 0;
 	virtual bool CheckState(EQStreamState state) = 0;
 	virtual std::string Describe() const = 0;
-
-	virtual const uint32 GetBytesSent() const { return 0; }
-	virtual const uint32 GetBytesRecieved() const { return 0; }
-	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
-	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
-	virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
+	virtual void SetActive(bool val) { }
+	virtual MatchState CheckSignature(const Signature *sig) { return MatchFailed; }
+	virtual EQStreamState GetState() = 0;
+	virtual void SetOpcodeManager(OpcodeManager **opm) = 0;
+	virtual const EQ::versions::ClientVersion ClientVersion() const { return EQ::versions::ClientVersion::Unknown; }
+	virtual Stats GetStats() const = 0;
+	virtual void ResetStats() = 0;
+	virtual EQStreamManagerInterface* GetManager() const = 0;
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -1,11 +1,12 @@
 
 #include "global_define.h"
 #include "eq_stream_proxy.h"
-#include "eq_stream.h"
 #include "struct_strategy.h"
+#include "eqemu_logsys.h"
+#include "opcodemgr.h"
 
 
-EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -21,15 +22,30 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
+const EQ::versions::ClientVersion EQStreamProxy::ClientVersion() const
 {
 	return m_structs->ClientVersion();
 }
 
+EQStreamState EQStreamProxy::GetState()
+{
+	return m_stream->GetState();
+}
+
+void EQStreamProxy::SetOpcodeManager(OpcodeManager **opm)
+{
+	return m_stream->SetOpcodeManager(opm);
+}
+
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 	if(p == nullptr)
 		return;
 
+	if (p->GetOpcode() != OP_SpecialMesg) {
+		Log(Logs::General, Logs::PacketServerClient, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+		Log(Logs::General, Logs::PacketServerClientWithDump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
+	}
+
 	EQApplicationPacket *newp = p->Copy();
 	FastQueuePacket(&newp, ack_req);
 }
@@ -54,6 +70,10 @@ void EQStreamProxy::Close() {
 	m_stream->Close();
 }
 
+std::string EQStreamProxy::GetRemoteAddr() const {
+	return(m_stream->GetRemoteAddr());
+}
+
 uint32 EQStreamProxy::GetRemoteIP() const {
 	return(m_stream->GetRemoteIP());
 }
@@ -62,26 +82,6 @@ uint16 EQStreamProxy::GetRemotePort() const {
 	return(m_stream->GetRemotePort());
 }
 
-const uint32 EQStreamProxy::GetBytesSent() const
-{
-	return(m_stream->GetBytesSent());
-}
-
-const uint32 EQStreamProxy::GetBytesRecieved() const
-{
-	return(m_stream->GetBytesRecieved());
-}
-
-const uint32 EQStreamProxy::GetBytesSentPerSecond() const
-{
-	return(m_stream->GetBytesSentPerSecond());
-}
-
-const uint32 EQStreamProxy::GetBytesRecvPerSecond() const
-{
-	return(m_stream->GetBytesRecvPerSecond());
-}
-
 void EQStreamProxy::ReleaseFromUse() {
 	m_stream->ReleaseFromUse();
 }
@@ -90,6 +90,21 @@ void EQStreamProxy::RemoveData() {
 	m_stream->RemoveData();
 }
 
+EQStreamInterface::Stats EQStreamProxy::GetStats() const
+{
+	return m_stream->GetStats();
+}
+
+void EQStreamProxy::ResetStats()
+{
+	m_stream->ResetStats();
+}
+
+EQStreamManagerInterface *EQStreamProxy::GetManager() const
+{
+	return m_stream->GetManager();
+}
+
 bool EQStreamProxy::CheckState(EQStreamState state) {
 	if(m_stream)
 		return(m_stream->CheckState(state));

common/eq_stream_proxy.h

@@ -4,7 +4,6 @@
 
 #include "types.h"
 #include "eq_stream_intf.h"
-#include "eq_stream.h"
 #include <memory>
 
 class StructStrategy;
@@ -14,7 +13,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();
 
 	//EQStreamInterface:
@@ -22,22 +21,23 @@ public:
 	virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true);
 	virtual EQApplicationPacket *PopPacket();
 	virtual void Close();
+	virtual std::string GetRemoteAddr() const;
 	virtual uint32 GetRemoteIP() const;
 	virtual uint16 GetRemotePort() const;
 	virtual void ReleaseFromUse();
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const EQEmu::versions::ClientVersion ClientVersion() const;
-
-	virtual const uint32 GetBytesSent() const;
-	virtual const uint32 GetBytesRecieved() const;
-	virtual const uint32 GetBytesSentPerSecond() const;
-	virtual const uint32 GetBytesRecvPerSecond() const;
+	virtual const EQ::versions::ClientVersion ClientVersion() const;
+	virtual EQStreamState GetState();
+	virtual void SetOpcodeManager(OpcodeManager **opm);
+	virtual Stats GetStats() const;
+	virtual void ResetStats();
+	virtual EQStreamManagerInterface* GetManager() const;
 
 protected:
-	std::shared_ptr<EQStream> const					m_stream;	//we own this stream object.
-	const StructStrategy *const		m_structs;	//we do not own this object.
+	std::shared_ptr<EQStreamInterface> const m_stream;	//we own this stream object.
+	const StructStrategy *const	m_structs;	//we do not own this object.
 	//this is a pointer to a pointer to make it less likely that a packet will
 	//reference an invalid opcode manager when they are being reloaded.
 	OpcodeManager **const			m_opcodes;	//we do not own this object.

common/eqemu_config.cpp

@@ -23,330 +23,151 @@
 #include <iostream>
 #include <sstream>
 
-std::string EQEmuConfig::ConfigFile = "eqemu_config.xml";
+std::string EQEmuConfig::ConfigFile = "eqemu_config.json";
 EQEmuConfig *EQEmuConfig::_config = nullptr;
 
-void EQEmuConfig::do_world(TiXmlElement *ele)
+void EQEmuConfig::parse_config()
 {
-	const char *text;
-	TiXmlElement * sub_ele;;
-	text = ParseTextBlock(ele, "shortname");
-	if (text) {
-		ShortName = text;
+
+	ShortName    = _root["server"]["world"].get("shortname", "").asString();
+	LongName     = _root["server"]["world"].get("longname", "").asString();
+	WorldAddress = _root["server"]["world"].get("address", "").asString();
+	LocalAddress = _root["server"]["world"].get("localaddress", "").asString();
+	MaxClients   = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
+	SharedKey    = _root["server"]["world"].get("key", "").asString();
+	LoginCount   = 0;
+
+	if (_root["server"]["world"]["loginserver"].isObject()) {
+		LoginHost   = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
+		LoginPort   = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
+		LoginLegacy = false;
+		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") { LoginLegacy = true; }
+		LoginAccount  = _root["server"]["world"]["loginserver"].get("account", "").asString();
+		LoginPassword = _root["server"]["world"]["loginserver"].get("password", "").asString();
 	}
-	text = ParseTextBlock(ele, "longname");
-	if (text) {
-		LongName = text;
-	}
-	text = ParseTextBlock(ele, "address", true);
-	if (text) {
-		WorldAddress = text;
-	}
-	text = ParseTextBlock(ele, "localaddress", true);
-	if (text) {
-		LocalAddress = text;
-	}
-	text = ParseTextBlock(ele, "maxclients", true);
-	if (text) {
-		MaxClients = atoi(text);
-	}
-	// Get the <key> element
-	text = ParseTextBlock(ele, "key", true);
-	if (text) {
-		SharedKey = text;
-	}
-	// Get the <loginserver> element
-	sub_ele = ele->FirstChildElement("loginserver");
-	if (sub_ele) {
-		text = ParseTextBlock(sub_ele, "host", true);
-		if (text) {
-			LoginHost = text;
-		}
-		text = ParseTextBlock(sub_ele, "port", true);
-		if (text) {
-			LoginPort = atoi(text);
-		}
-		text = ParseTextBlock(sub_ele, "account", true);
-		if (text) {
-			LoginAccount = text;
-		}
-		text = ParseTextBlock(sub_ele, "password", true);
-		if (text) {
-			LoginPassword = text;
-		}
-	} else {
-		char	str[32];
+	else {
+		char str[32];
+		loginlist.Clear();
 		do {
 			sprintf(str, "loginserver%i", ++LoginCount);
-			sub_ele = ele->FirstChildElement(str);
-			if (sub_ele) {
-				auto loginconfig = new LoginConfig;
-				text = ParseTextBlock(sub_ele, "host", true);
-				if (text) {
-					loginconfig->LoginHost = text;
-				}
-				text = ParseTextBlock(sub_ele, "port", true);
-				if (text) {
-					loginconfig->LoginPort = atoi(text);
-				}
-				text = ParseTextBlock(sub_ele, "account", true);
-				if (text) {
-					loginconfig->LoginAccount = text;
-				}
-				text = ParseTextBlock(sub_ele, "password", true);
-				if (text) {
-					loginconfig->LoginPassword = text;
-				}
-				loginlist.Insert(loginconfig);
+			if (!_root["server"]["world"][str].isObject()) {
+				break;
 			}
-		} while (sub_ele);
+
+			auto loginconfig = new LoginConfig;
+			loginconfig->LoginHost     = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
+			loginconfig->LoginPort     = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
+			loginconfig->LoginAccount  = _root["server"]["world"][str].get("account", "").asString();
+			loginconfig->LoginPassword = _root["server"]["world"][str].get("password", "").asString();
+
+			loginconfig->LoginLegacy = false;
+			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") { loginconfig->LoginLegacy = true; }
+			loginlist.Insert(loginconfig);
+		} while (LoginCount < 100);
 	}
-	// Check for locked
-	sub_ele = ele->FirstChildElement("locked");
-	if (sub_ele != nullptr) {
-		Locked = true;
-	}
-	// Get the <tcp> element
-	sub_ele = ele->FirstChildElement("tcp");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("ip");
-		if (text) {
-			WorldIP = text;
-		}
-		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldTCPPort = atoi(text);
-		}
-		text = sub_ele->Attribute("telnet");
-		if (text && !strcasecmp(text, "enabled")) {
-			TelnetEnabled = true;
-		}
-	}
-	// Get the <http> element
-	sub_ele = ele->FirstChildElement("http");
-	if (sub_ele != nullptr) {
-//		text = sub_ele->Attribute("ip");
-//		if (text)
-//			WorldIP=text;
-		text = sub_ele->Attribute("mimefile");
-		if (text) {
-			WorldHTTPMimeFile = text;
-		}
-		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldHTTPPort = atoi(text);
-		}
-		text = sub_ele->Attribute("enabled");
-		if (text && !strcasecmp(text, "true")) {
-			WorldHTTPEnabled = true;
-		}
+
+
+	//<locked> from xml converts to json as locked: "", so i default to "false". 
+	//The only way to enable locked is by switching to true, meaning this value is always false until manually set true
+	Locked = false;
+	if (_root["server"]["world"].get("locked", "false").asString() == "true") { Locked = true; }
+	WorldIP      = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
+	WorldTCPPort = atoi(_root["server"]["world"]["tcp"].get("port", "9000").asString().c_str());
+
+	TelnetIP      = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
+	TelnetTCPPort = atoi(_root["server"]["world"]["telnet"].get("port", "9001").asString().c_str());
+	TelnetEnabled = false;
+	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") { TelnetEnabled = true; }
+
+	WorldHTTPMimeFile = _root["server"]["world"]["http"].get("mimefile", "mime.types").asString();
+	WorldHTTPPort     = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
+	WorldHTTPEnabled  = false;
+
+	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") {
+		WorldHTTPEnabled = true;
 	}
+
+	/**
+	 * UCS
+	 */
+	ChatHost = _root["server"]["chatserver"].get("host", "eqchat.eqemulator.net").asString();
+	ChatPort = atoi(_root["server"]["chatserver"].get("port", "7778").asString().c_str());
+	MailHost = _root["server"]["mailserver"].get("host", "eqmail.eqemulator.net").asString();
+	MailPort = atoi(_root["server"]["mailserver"].get("port", "7778").asString().c_str());
+
+	/**
+	 * Database
+	 */
+	DatabaseUsername = _root["server"]["database"].get("username", "eq").asString();
+	DatabasePassword = _root["server"]["database"].get("password", "eq").asString();
+	DatabaseHost     = _root["server"]["database"].get("host", "localhost").asString();
+	DatabasePort     = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
+	DatabaseDB       = _root["server"]["database"].get("db", "eq").asString();
+
+	/**
+	 * Content Database
+	 */
+	ContentDbUsername = _root["server"]["content_database"].get("username", "").asString();
+	ContentDbPassword = _root["server"]["content_database"].get("password", "").asString();
+	ContentDbHost     = _root["server"]["content_database"].get("host", "").asString();
+	ContentDbPort     = atoi(_root["server"]["content_database"].get("port", 0).asString().c_str());
+	ContentDbName     = _root["server"]["content_database"].get("db", "").asString();
+
+	/**
+	 * QS
+	 */
+	QSDatabaseHost     = _root["server"]["qsdatabase"].get("host", "localhost").asString();
+	QSDatabasePort     = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
+	QSDatabaseUsername = _root["server"]["qsdatabase"].get("username", "eq").asString();
+	QSDatabasePassword = _root["server"]["qsdatabase"].get("password", "eq").asString();
+	QSDatabaseDB       = _root["server"]["qsdatabase"].get("db", "eq").asString();
+
+	/**
+	 * Zones
+	 */
+	DefaultStatus = atoi(_root["server"]["zones"].get("defaultstatus", 0).asString().c_str());
+	ZonePortLow   = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
+	ZonePortHigh  = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());
+
+	/**
+	 * Files
+	 */
+	SpellsFile      = _root["server"]["files"].get("spells", "spells_us.txt").asString();
+	OpCodesFile     = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
+	MailOpCodesFile = _root["server"]["files"].get("mail_opcodes", "mail_opcodes.conf").asString();
+	PluginPlFile    = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();
+
+	/**
+	 * Directories
+	 */
+	MapDir       = _root["server"]["directories"].get("maps", "Maps/").asString();
+	QuestDir     = _root["server"]["directories"].get("quests", "quests/").asString();
+	PluginDir    = _root["server"]["directories"].get("plugins", "plugins/").asString();
+	LuaModuleDir = _root["server"]["directories"].get("lua_modules", "lua_modules/").asString();
+	PatchDir     = _root["server"]["directories"].get("patches", "./").asString();
+	SharedMemDir = _root["server"]["directories"].get("shared_memory", "shared/").asString();
+	LogDir       = _root["server"]["directories"].get("logs", "logs/").asString();
+
+	/**
+	 * Logs
+	 */
+	LogPrefix = _root["server"]["launcher"].get("logprefix", "logs/zone-").asString();
+	LogSuffix = _root["server"]["launcher"].get("logsuffix", ".log").asString();
+
+	/**
+	 * Launcher
+	 */
+	RestartWait      = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
+	TerminateWait    = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
+	InitialBootWait  = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
+	ZoneBootInterval = atoi(_root["server"]["launcher"]["timers"].get("interval", "2000").asString().c_str());
+#ifdef WIN32
+	ZoneExe = _root["server"]["launcher"].get("exe", "zone.exe").asString();
+#else
+	ZoneExe = _root["server"]["launcher"].get("exe", "./zone").asString();
+#endif
+
 }
-
-void EQEmuConfig::do_chatserver(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		ChatHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		ChatPort = atoi(text);
-	}
-}
-
-void EQEmuConfig::do_mailserver(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		MailHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		MailPort = atoi(text);
-	}
-}
-
-void EQEmuConfig::do_database(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		DatabaseHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		DatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		DatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		DatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		DatabaseDB = text;
-	}
-}
-
-
-void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		QSDatabaseHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		QSDatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		QSDatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		QSDatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		QSDatabaseDB = text;
-	}
-}
-
-void EQEmuConfig::do_zones(TiXmlElement *ele)
-{
-	const char *text;
-	TiXmlElement *sub_ele;
-//	TiXmlNode *node,*sub_node;
-	text = ParseTextBlock(ele, "defaultstatus", true);
-	if (text) {
-		DefaultStatus = atoi(text);
-	}
-	// Get the <ports> element
-	sub_ele = ele->FirstChildElement("ports");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("low");
-		if (text) {
-			ZonePortLow = atoi(text);
-		};
-		text = sub_ele->Attribute("high");
-		if (text) {
-			ZonePortHigh = atoi(text);
-		}
-	}
-}
-
-void EQEmuConfig::do_files(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "spells", true);
-	if (text) {
-		SpellsFile = text;
-	}
-	text = ParseTextBlock(ele, "opcodes", true);
-	if (text) {
-		OpCodesFile = text;
-	}
-	text = ParseTextBlock(ele, "plugin.pl", true);
-	if (text) {
-		PluginPlFile = text;
-	}
-}
-
-void EQEmuConfig::do_directories(TiXmlElement *ele)
-{
-	const char *text;
-	text = ParseTextBlock(ele, "maps", true);
-	if (text) {
-		MapDir = text;
-		if ( MapDir.back() != '/' )
-			MapDir += '/';
-	}
-	text = ParseTextBlock(ele, "quests", true);
-	if (text) {
-		QuestDir = text;
-		if ( QuestDir.back() != '/' )
-			QuestDir += '/';
-	}
-	text = ParseTextBlock(ele, "plugins", true);
-	if (text) {
-		PluginDir = text;
-		if ( PluginDir.back() != '/' )
-			PluginDir += '/';
-	}
-	text = ParseTextBlock(ele, "lua_modules", true);
-	if (text) {
-		LuaModuleDir = text;
-		if ( LuaModuleDir.back() != '/' )
-			LuaModuleDir += '/';
-	}
-	text = ParseTextBlock(ele, "patches", true);
-	if (text) {
-		PatchDir = text;
-		if ( PatchDir.back() != '/' )
-			PatchDir += '/';
-	}
-	text = ParseTextBlock(ele, "shared_memory", true);
-	if (text) {
-		SharedMemDir = text;
-		if ( SharedMemDir.back() != '/' )
-			SharedMemDir += '/';
-	}
-	//Not Fully Implemented yet LogDir
-	text = ParseTextBlock(ele, "logs", true);
-	if (text) {
-		LogDir = text;
-		if ( LogDir.back() != '/' )
-			LogDir += '/';
-	}
-}
-
-void EQEmuConfig::do_launcher(TiXmlElement *ele)
-{
-	const char *text;
-	TiXmlElement *sub_ele;
-	text = ParseTextBlock(ele, "logprefix", true);
-	if (text) {
-		LogPrefix = text;
-	}
-	text = ParseTextBlock(ele, "logsuffix", true);
-	if (text) {
-		LogSuffix = text;
-	}
-	// Get the <exe> element
-	text = ParseTextBlock(ele, "exe", true);
-	if (text) {
-		ZoneExe = text;
-	}
-	// Get the <timers> element
-	sub_ele = ele->FirstChildElement("timers");
-	if (sub_ele != nullptr) {
-		text = sub_ele->Attribute("restart");
-		if (text) {
-			RestartWait = atoi(text);
-		}
-		text = sub_ele->Attribute("reterminate");
-		if (text) {
-			TerminateWait = atoi(text);
-		}
-		text = sub_ele->Attribute("initial");
-		if (text) {
-			InitialBootWait = atoi(text);
-		}
-		text = sub_ele->Attribute("interval");
-		if (text) {
-			ZoneBootInterval = atoi(text);
-		}
-	}
-}
-
 std::string EQEmuConfig::GetByName(const std::string &var_name) const
 {
 	if (var_name == "ShortName") {
@@ -370,6 +191,9 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "LoginPort") {
 		return (itoa(LoginPort));
 	}
+	if (var_name == "LoginLegacy") {
+		return (itoa(LoginLegacy ? 1 : 0));
+	}
 	if (var_name == "Locked") {
 		return (Locked ? "true" : "false");
 	}
@@ -379,6 +203,12 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "WorldIP") {
 		return (WorldIP);
 	}
+	if (var_name == "TelnetTCPPort") {
+		return (itoa(TelnetTCPPort));
+	}
+	if (var_name == "TelnetIP") {
+		return (TelnetIP);
+	}
 	if (var_name == "TelnetEnabled") {
 		return (TelnetEnabled ? "true" : "false");
 	}
@@ -439,6 +269,9 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "OpCodesFile") {
 		return (OpCodesFile);
 	}
+	if (var_name == "MailOpCodesFile") {
+		return (MailOpCodesFile);
+	}
 	if (var_name == "PluginPlFile") {
 		return (PluginPlFile);
 	}
@@ -495,9 +328,12 @@ void EQEmuConfig::Dump() const
 	std::cout << "LoginAccount = " << LoginAccount << std::endl;
 	std::cout << "LoginPassword = " << LoginPassword << std::endl;
 	std::cout << "LoginPort = " << LoginPort << std::endl;
+	std::cout << "LoginLegacy = " << LoginLegacy << std::endl;
 	std::cout << "Locked = " << Locked << std::endl;
 	std::cout << "WorldTCPPort = " << WorldTCPPort << std::endl;
 	std::cout << "WorldIP = " << WorldIP << std::endl;
+	std::cout << "TelnetTCPPort = " << TelnetTCPPort << std::endl;
+	std::cout << "TelnetIP = " << TelnetIP << std::endl;
 	std::cout << "TelnetEnabled = " << TelnetEnabled << std::endl;
 	std::cout << "WorldHTTPPort = " << WorldHTTPPort << std::endl;
 	std::cout << "WorldHTTPMimeFile = " << WorldHTTPMimeFile << std::endl;
@@ -518,6 +354,7 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
+	std::cout << "MailOpcodesFile = " << MailOpCodesFile << std::endl;
 	std::cout << "PluginPlFile = " << PluginPlFile << std::endl;
 	std::cout << "MapDir = " << MapDir << std::endl;
 	std::cout << "QuestDir = " << QuestDir << std::endl;
@@ -528,7 +365,6 @@ void EQEmuConfig::Dump() const
 	std::cout << "LogDir = " << LogDir << std::endl;
 	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
 	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
-	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
+	std::cout << "DefaultStatus = " << (int) DefaultStatus << std::endl;
 //	std::cout << "DynamicCount = " << DynamicCount << std::endl;
 }
-

common/eqemu_config.h

@@ -18,17 +18,19 @@
 #ifndef __EQEmuConfig_H
 #define __EQEmuConfig_H
 
-#include "xml_parser.h"
+#include "json/json.h"
 #include "linked_list.h"
+#include <fstream>
 
 struct LoginConfig {
 	std::string LoginHost;
 	std::string LoginAccount;
 	std::string LoginPassword;
 	uint16 LoginPort;
+	bool LoginLegacy;
 };
 
-class EQEmuConfig : public XMLParser
+class EQEmuConfig
 {
 	public:
 		virtual std::string GetByName(const std::string &var_name) const;
@@ -42,11 +44,14 @@ class EQEmuConfig : public XMLParser
 		std::string LoginAccount;
 		std::string LoginPassword;
 		uint16 LoginPort;
+		bool LoginLegacy;
 		uint32 LoginCount;
 		LinkedList<LoginConfig*> loginlist;
 		bool Locked;
 		uint16 WorldTCPPort;
 		std::string WorldIP;
+		uint16 TelnetTCPPort;
+		std::string TelnetIP;
 		bool TelnetEnabled;
 		int32 MaxClients;
 		bool WorldHTTPEnabled;
@@ -69,6 +74,13 @@ class EQEmuConfig : public XMLParser
 		std::string DatabaseDB;
 		uint16 DatabasePort;
 
+		// From <content_database/>
+		std::string ContentDbHost;
+		std::string ContentDbUsername;
+		std::string ContentDbPassword;
+		std::string ContentDbName;
+		uint16      ContentDbPort;
+
 		// From <qsdatabase> // QueryServ
 		std::string QSDatabaseHost;
 		std::string QSDatabaseUsername;
@@ -79,6 +91,7 @@ class EQEmuConfig : public XMLParser
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;
+		std::string MailOpCodesFile;
 		std::string PluginPlFile;
 
 		// From <directories/>
@@ -111,85 +124,14 @@ class EQEmuConfig : public XMLParser
 	protected:
 
 		static EQEmuConfig *_config;
-
+		Json::Value _root;
 		static std::string ConfigFile;
 
-#define ELEMENT(name) \
-	void do_##name(TiXmlElement *ele);
-#include "eqemu_config_elements.h"
-
+		void parse_config();
 
 		EQEmuConfig()
-		{
-			// import the needed handler prototypes
-#define ELEMENT(name) \
-	Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
-#include "eqemu_config_elements.h"
-			// Set sane defaults
-			// Login server
-			LoginHost = "eqemulator.net";
-			LoginPort = 5998;
-			// World
-			Locked = false;
-			WorldTCPPort = 9000;
-			TelnetEnabled = false;
-			WorldHTTPEnabled = false;
-			WorldHTTPPort = 9080;
-			WorldHTTPMimeFile = "mime.types";
-			SharedKey = "";	//blank disables authentication
-			// Mail
-			ChatHost = "eqchat.eqemulator.net";
-			ChatPort = 7778;
-			// Mail
-			MailHost = "eqmail.eqemulator.net";
-			MailPort = 7779;
-			// Mysql
-			DatabaseHost = "localhost";
-			DatabasePort = 3306;
-			DatabaseUsername = "eq";
-			DatabasePassword = "eq";
-			DatabaseDB = "eq";
-			// QueryServ Database
-			QSDatabaseHost = "localhost";
-			QSDatabasePort = 3306;
-			QSDatabaseUsername = "eq";
-			QSDatabasePassword = "eq";
-			QSDatabaseDB = "eq";
-			// Files
-			SpellsFile = "spells_us.txt";
-			OpCodesFile = "opcodes.conf";
-			PluginPlFile = "plugin.pl";
-			// Dirs
-			MapDir = "Maps/";
-			QuestDir = "quests/";
-			PluginDir = "plugins/";
-			LuaModuleDir = "lua_modules/";
-			PatchDir = "./";
-			SharedMemDir = "shared/";
-			LogDir = "logs/";
+		{			
 
-			// Launcher
-			LogPrefix = "logs/zone-";
-			LogSuffix = ".log";
-			RestartWait = 10000;		//milliseconds
-			TerminateWait = 10000;		//milliseconds
-			InitialBootWait = 20000;	//milliseconds
-			ZoneBootInterval = 2000;	//milliseconds
-			#ifdef WIN32
-			ZoneExe = "zone.exe";
-			#else
-			ZoneExe = "./zone";
-			#endif
-			// Zones
-			ZonePortLow = 7000;
-			ZonePortHigh = 7999;
-			DefaultStatus = 0;
-			// For where zones need to connect to.
-			WorldIP = "127.0.0.1";
-			// Dynamics to start
-			//DynamicCount=5;
-			MaxClients = -1;
-			LoginCount = 0;
 		}
 		virtual ~EQEmuConfig() {}
 
@@ -198,9 +140,7 @@ class EQEmuConfig : public XMLParser
 		// Produce a const singleton
 		static const EQEmuConfig *get()
 		{
-			if (_config == nullptr) {
-				LoadConfig();
-			}
+			LoadConfig();
 			return (_config);
 		}
 
@@ -214,10 +154,28 @@ class EQEmuConfig : public XMLParser
 		static bool LoadConfig()
 		{
 			if (_config != nullptr) {
-				delete _config;
+				return true;
 			}
 			_config = new EQEmuConfig;
-			return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(), "server");
+
+			return parseFile();
+		}
+
+		// Load config file and parse data
+		static bool parseFile() {
+			if (_config == nullptr) {
+				return LoadConfig();
+			}
+
+			std::ifstream fconfig(EQEmuConfig::ConfigFile, std::ifstream::binary);
+			try {
+				fconfig >> _config->_root;
+				_config->parse_config();
+			}
+			catch (std::exception &) {
+				return false;
+			}			
+			return true;
 		}
 
 		void Dump() const;

common/eqemu_exception.cpp

@@ -18,7 +18,7 @@
 
 #include "eqemu_exception.h"
 
-namespace EQEmu
+namespace EQ
 {
 	Exception::Exception(const char* name, const std::string& description, const char* file, long line)
 		: line_(line),

common/eqemu_exception.h

@@ -22,7 +22,7 @@
 #include <sstream>
 #include <exception>
 
-namespace EQEmu
+namespace EQ
 {
 	//! EQEmu Exception Class
 	/*!
@@ -104,7 +104,7 @@ namespace EQEmu
 } // EQEmu
 
 #ifndef EQ_EXCEPT
-#define EQ_EXCEPT(n, d) throw EQEmu::Exception(n, d, __FILE__, __LINE__)
+#define EQ_EXCEPT(n, d) throw EQ::Exception(n, d, __FILE__, __LINE__)
 #endif
 
 #endif

common/eqemu_logsys.cpp

@@ -1,23 +1,25 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 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-2018 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 "eqemu_logsys.h"
+#include "rulesys.h"
 #include "platform.h"
 #include "string_util.h"
 #include "database.h"
@@ -33,149 +35,250 @@
 std::ofstream process_log;
 
 #ifdef _WINDOWS
-	#include <direct.h>
-	#include <conio.h>
-	#include <iostream>
-	#include <dos.h>
-	#include <windows.h>
-	#include <process.h>
+#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>
+
+#include <unistd.h>
+#include <sys/stat.h>
+
 #endif
 
-/* Linux ANSI console color defines */
+/**
+ * Linux ANSI console color defines
+ */
 #define LC_RESET   "\033[0m"
-#define LC_BLACK   "\033[30m"      /* Black */
-#define LC_RED     "\033[31m"      /* Red */
-#define LC_GREEN   "\033[32m"      /* Green */
-#define LC_YELLOW  "\033[33m"      /* Yellow */
-#define LC_BLUE    "\033[34m"      /* Blue */
-#define LC_MAGENTA "\033[35m"      /* Magenta */
-#define LC_CYAN    "\033[36m"      /* Cyan */
-#define LC_WHITE   "\033[37m"      /* White */
+#define LC_BLACK   "\033[30m" /* Black */
+#define LC_RED     "\033[31m" /* Red */
+#define LC_GREEN   "\033[32m" /* Green */
+#define LC_YELLOW  "\033[33m" /* Yellow */
+#define LC_BLUE    "\033[34m" /* Blue */
+#define LC_MAGENTA "\033[35m" /* Magenta */
+#define LC_CYAN    "\033[36m" /* Cyan */
+#define LC_WHITE   "\033[37m" /* White */
 
 namespace Console {
 	enum Color {
-		Black = 0,
-		Blue = 1,
-		Green = 2,
-		Cyan = 3,
-		Red = 4,
-		Magenta = 5,
-		Brown = 6,
-		LightGray = 7,
-		DarkGray = 8,
-		LightBlue = 9,
-		LightGreen = 10,
-		LightCyan = 11,
-		LightRed = 12,
+		Black        = 0,
+		Blue         = 1,
+		Green        = 2,
+		Cyan         = 3,
+		Red          = 4,
+		Magenta      = 5,
+		Brown        = 6,
+		LightGray    = 7,
+		DarkGray     = 8,
+		LightBlue    = 9,
+		LightGreen   = 10,
+		LightCyan    = 11,
+		LightRed     = 12,
 		LightMagenta = 13,
-		Yellow = 14,
-		White = 15
+		Yellow       = 14,
+		White        = 15
 	};
 }
 
+/**
+ * EQEmuLogSys Constructor
+ */
 EQEmuLogSys::EQEmuLogSys()
 {
-	on_log_gmsay_hook = [](uint16 log_type, const std::string&) {};
-	bool file_logs_enabled = false;
-	int log_platform = 0;
+	on_log_gmsay_hook   = [](uint16 log_type, const std::string &) {};
+	on_log_console_hook = [](uint16 debug_level, uint16 log_type, const std::string &) {};
 }
 
-EQEmuLogSys::~EQEmuLogSys()
-{
-}
+/**
+ * EQEmuLogSys Deconstructor
+ */
+EQEmuLogSys::~EQEmuLogSys() = default;
 
 void EQEmuLogSys::LoadLogSettingsDefaults()
 {
-	/* Get Executable platform currently running this code (Zone/World/etc) */
+	/**
+	 * Get Executable platform currently running this code (Zone/World/etc)
+	 */
 	log_platform = GetExecutablePlatformInt();
 
-	/* Zero out Array */
-	memset(log_settings, 0, sizeof(LogSettings) * Logs::LogCategory::MaxCategoryID);
+	for (int log_category_id = Logs::AA; log_category_id != Logs::MaxCategoryID; log_category_id++) {
+		log_settings[log_category_id].log_to_console      = 0;
+		log_settings[log_category_id].log_to_file         = 0;
+		log_settings[log_category_id].log_to_gmsay        = 0;
+		log_settings[log_category_id].is_category_enabled = 0;
+	}
 
-	/* Set Defaults */
-	log_settings[Logs::World_Server].log_to_console = Logs::General;
-	log_settings[Logs::Zone_Server].log_to_console = Logs::General;
-	log_settings[Logs::QS_Server].log_to_console = Logs::General;
-	log_settings[Logs::UCS_Server].log_to_console = Logs::General;
-	log_settings[Logs::Crash].log_to_console = Logs::General;
-	log_settings[Logs::MySQLError].log_to_console = Logs::General;
-	log_settings[Logs::Login_Server].log_to_console = Logs::General;
+	file_logs_enabled = false;
 
-	/*	Declare process file names for log writing
-		If there is no process_file_name declared, no log file will be written, simply
-	*/
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld)
+	/**
+	 * Set Defaults
+	 */
+	log_settings[Logs::WorldServer].log_to_console    = static_cast<uint8>(Logs::General);
+	log_settings[Logs::ZoneServer].log_to_console     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::QSServer].log_to_console       = static_cast<uint8>(Logs::General);
+	log_settings[Logs::UCSServer].log_to_console      = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Crash].log_to_console          = static_cast<uint8>(Logs::General);
+	log_settings[Logs::MySQLError].log_to_console     = static_cast<uint8>(Logs::General);
+	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);
+	log_settings[Logs::Loot].log_to_gmsay             = static_cast<uint8>(Logs::General);
+
+	/**
+	 * RFC 5424
+	 */
+	log_settings[Logs::Emergency].log_to_console = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Alert].log_to_console     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Critical].log_to_console  = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Error].log_to_console     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Warning].log_to_console   = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Notice].log_to_console    = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Info].log_to_console      = static_cast<uint8>(Logs::General);
+
+	/**
+	 * Set Category enabled status on defaults
+	 */
+	for (int log_category_id = Logs::AA; log_category_id != Logs::MaxCategoryID; log_category_id++) {
+		const bool log_to_console      = log_settings[log_category_id].log_to_console > 0;
+		const bool log_to_file         = log_settings[log_category_id].log_to_file > 0;
+		const bool log_to_gmsay        = log_settings[log_category_id].log_to_gmsay > 0;
+		const bool is_category_enabled = log_to_console || log_to_file || log_to_gmsay;
+		if (is_category_enabled) {
+			log_settings[log_category_id].is_category_enabled = 1;
+		}
+	}
+
+	/**
+	 * Declare process file names for log writing=
+	 */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld) {
 		platform_file_name = "world";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ) {
 		platform_file_name = "query_server";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
 		platform_file_name = "zone";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS) {
 		platform_file_name = "ucs";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin) {
 		platform_file_name = "login";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch) {
 		platform_file_name = "launcher";
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC) {
+		platform_file_name = "hc";
+	}
 }
 
-std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
+/**
+ * @param log_category
+ * @return
+ */
+bool EQEmuLogSys::IsRfc5424LogCategory(uint16 log_category)
 {
-	std::string category_string;
-	if (log_category > 0 && Logs::LogCategoryName[log_category])
-		category_string = StringFormat("[%s] ", Logs::LogCategoryName[log_category]);
-	return StringFormat("%s%s", category_string.c_str(), in_message.c_str());
+	return (
+		log_category == Logs::Emergency ||
+		log_category == Logs::Alert ||
+		log_category == Logs::Critical ||
+		log_category == Logs::Error ||
+		log_category == Logs::Warning ||
+		log_category == Logs::Notice ||
+		log_category == Logs::Info ||
+		log_category == Logs::Debug
+	);
 }
 
-void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
+/**
+ * @param log_category
+ * @param in_message
+ * @return
+ */
+std::string EQEmuLogSys::FormatOutMessageString(
+	uint16 log_category,
+	const std::string &in_message
+)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_gmsay == 0)
-		return;
+	std::string return_string;
 
-	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
-	if (log_category == Logs::LogCategory::Netcode)
-		return;
+	if (IsRfc5424LogCategory(log_category)) {
+		return_string = "[" + GetPlatformName() + "] ";
+	}
 
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_gmsay < debug_level)
-		return;
+	return return_string + "[" + Logs::LogCategoryName[log_category] + "] " + in_message;
+}
 
-	/* Check to see if the process that actually ran this is zone */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
+void EQEmuLogSys::ProcessGMSay(
+	uint16 debug_level,
+	uint16 log_category,
+	const std::string &message
+)
+{
+	/**
+	 * Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash
+	 */
+	if (log_category == Logs::LogCategory::Netcode) {
+		return;
+	}
+
+	/**
+	 * Check to see if the process that actually ran this is zone
+	 */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
 		on_log_gmsay_hook(log_category, message);
+	}
 }
 
-void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message)
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
+void EQEmuLogSys::ProcessLogWrite(
+	uint16 debug_level,
+	uint16 log_category,
+	const std::string &message
+)
 {
 	if (log_category == Logs::Crash) {
 		char time_stamp[80];
 		EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 		std::ofstream crash_log;
 		EQEmuLogSys::MakeDirectory("logs/crashes");
-		crash_log.open(StringFormat("logs/crashes/crash_%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+		crash_log.open(
+			StringFormat("logs/crashes/crash_%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
 		crash_log << time_stamp << " " << message << "\n";
 		crash_log.close();
 	}
 
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_file == 0)
-		return;
-
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_file < debug_level)
-		return;
-
 	char time_stamp[80];
 	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 
-	if (process_log)
+	if (process_log) {
 		process_log << time_stamp << " " << message << std::endl;
+	}
 }
 
-uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
@@ -198,12 +301,19 @@ uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category) {
 	}
 }
 
-std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
 			return LC_YELLOW;
 		case Logs::MySQLError:
+		case Logs::Warning:
+		case Logs::Critical:
 		case Logs::Error:
 			return LC_RED;
 		case Logs::MySQLQuery:
@@ -221,86 +331,173 @@ std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category) {
 	}
 }
 
-uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
-			return 15; /* Yellow */
+			return Chat::Yellow;
 		case Logs::MySQLError:
 		case Logs::Error:
-			return 13; /* Red */
+			return Chat::Red;
 		case Logs::MySQLQuery:
 		case Logs::Debug:
-			return 14; /* Light Green */
+			return Chat::Lime;
 		case Logs::Quests:
-			return 258; /* Light Cyan */
+			return Chat::Group;
 		case Logs::Commands:
 		case Logs::Mercenaries:
-			return 5; /* Light Purple */
+			return Chat::Magenta;
 		case Logs::Crash:
-			return 13; /* Red */
+			return Chat::Red;
 		default:
-			return 15; /* Yellow */
+			return Chat::Yellow;
 	}
 }
 
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_console == 0)
-		return;
+#ifdef _WINDOWS
+	HANDLE  console_handle;
+	console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_FONT_INFOEX info = { 0 };
+	info.cbSize = sizeof(info);
+	info.dwFontSize.Y = 12; // leave X as zero
+	info.FontWeight = FW_NORMAL;
+	wcscpy(info.FaceName, L"Lucida Console");
+	SetCurrentConsoleFontEx(console_handle, NULL, &info);
+	SetConsoleTextAttribute(console_handle, EQEmuLogSys::GetWindowsConsoleColorFromCategory(log_category));
+	std::cout << message << "\n";
+	SetConsoleTextAttribute(console_handle, Console::Color::White);
+#else
+	std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
+#endif
 
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_console < debug_level)
-		return;
-
-	#ifdef _WINDOWS
-		HANDLE  console_handle;
-		console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-		CONSOLE_FONT_INFOEX info = { 0 };
-		info.cbSize = sizeof(info);
-		info.dwFontSize.Y = 12; // leave X as zero
-		info.FontWeight = FW_NORMAL;
-		wcscpy(info.FaceName, L"Lucida Console");
-		SetCurrentConsoleFontEx(console_handle, NULL, &info);
-		SetConsoleTextAttribute(console_handle, EQEmuLogSys::GetWindowsConsoleColorFromCategory(log_category));
-		std::cout << message << "\n";
-		SetConsoleTextAttribute(console_handle, Console::Color::White);
-	#else
-		std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
-	#endif
+	on_log_console_hook(debug_level, log_category, message);
 }
 
-void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
+/**
+ * @param str
+ * @return
+ */
+constexpr const char *str_end(const char *str)
 {
-	const bool log_to_console = log_settings[log_category].log_to_console > 0;
-	const bool log_to_file = log_settings[log_category].log_to_file > 0;
-	const bool log_to_gmsay = log_settings[log_category].log_to_gmsay > 0;
-	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
+	return *str ? str_end(str + 1) : str;
+}
 
-	if (nothing_to_log) return;
+/**
+ * @param str
+ * @return
+ */
+constexpr bool str_slant(const char *str)
+{
+	return *str == '/' ? true : (*str ? str_slant(str + 1) : false);
+}
+
+/**
+ * @param str
+ * @return
+ */
+constexpr const char *r_slant(const char *str)
+{
+	return *str == '/' ? (str + 1) : r_slant(str - 1);
+}
+
+/**
+ * @param str
+ * @return
+ */
+constexpr const char *base_file_name(const char *str)
+{
+	return str_slant(str) ? r_slant(str_end(str)) : str;
+}
+
+/**
+ * Core logging function
+ *
+ * @param debug_level
+ * @param log_category
+ * @param message
+ * @param ...
+ */
+void EQEmuLogSys::Out(
+	Logs::DebugLevel debug_level,
+	uint16 log_category,
+	const char *file,
+	const char *func,
+	int line,
+	const char *message,
+	...
+)
+{
+	bool log_to_console = true;
+	if (log_settings[log_category].log_to_console < debug_level) {
+		log_to_console = false;
+	}
+
+	bool log_to_file = true;
+	if (log_settings[log_category].log_to_file < debug_level) {
+		log_to_file = false;
+	}
+
+	bool log_to_gmsay = true;
+	if (log_settings[log_category].log_to_gmsay < debug_level) {
+		log_to_gmsay = false;
+	}
+
+	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
+	if (nothing_to_log) {
+		return;
+	}
+
+	std::string prefix;
+
+	if (RuleB(Logging, PrintFileFunctionAndLine)) {
+		prefix = fmt::format("[{0}::{1}:{2}] ", base_file_name(file), func, line);
+	}
 
 	va_list args;
 	va_start(args, message);
-	std::string output_message = vStringFormat(message.c_str(), args);
+	std::string output_message = vStringFormat(message, args);
 	va_end(args);
 
-	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, output_message);
+	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, prefix + output_message);
 
-	if (log_to_console) EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
-	if (log_to_gmsay) EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
-	if (log_to_file) EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
+	if (log_to_console) {
+		EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
+	}
+	if (log_to_gmsay) {
+		EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
+	}
+	if (log_to_file) {
+		EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
+	}
 }
 
-void EQEmuLogSys::SetCurrentTimeStamp(char* time_stamp)
+/**
+ * @param time_stamp
+ */
+void EQEmuLogSys::SetCurrentTimeStamp(char *time_stamp)
 {
-	time_t raw_time;
-	struct tm * time_info;
+	time_t    raw_time;
+	struct tm *time_info;
 	time(&raw_time);
 	time_info = localtime(&raw_time);
 	strftime(time_stamp, 80, "[%m-%d-%Y :: %H:%M:%S]", time_info);
 }
 
+/**
+ * @param directory_name
+ */
 void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
 {
 #ifdef _WINDOWS
@@ -309,9 +506,10 @@ void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
 		return;
 	_mkdir(directory_name.c_str());
 #else
-	struct stat st;
-	if (stat(directory_name.c_str(), &st) == 0) // exists
+	struct stat st{};
+	if (stat(directory_name.c_str(), &st) == 0) { // exists
 		return;
+	}
 	mkdir(directory_name.c_str(), 0755);
 #endif
 }
@@ -323,29 +521,86 @@ void EQEmuLogSys::CloseFileLogs()
 	}
 }
 
+/**
+ * @param log_name
+ */
 void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 {
 	EQEmuLogSys::CloseFileLogs();
 
-	/* When loading settings, we must have been given a reason in category based logging to output to a file in order to even create or open one... */
-	if (file_logs_enabled == false)
+	/**
+	 * When loading settings, we must have been given a reason in category based logging to output to a file in order to even create or open one...
+	 */
+	if (!file_logs_enabled) {
 		return;
+	}
 
+	/**
+	 * Zone
+	 */
 	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
-		if (!log_name.empty())
+		if (!log_name.empty()) {
 			platform_file_name = log_name;
+		}
 
-		if (platform_file_name.empty())
+		if (platform_file_name.empty()) {
 			return;
+		}
 
-		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
+		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());
+
+		/**
+		 * Make directory if not exists
+		 */
 		EQEmuLogSys::MakeDirectory("logs/zone");
-		process_log.open(StringFormat("logs/zone/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
-	} else {
-		if (platform_file_name.empty())
-			return;
 
-		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
-		process_log.open(StringFormat("logs/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+		/**
+		 * Open file pointer
+		 */
+		process_log.open(
+			StringFormat("logs/zone/%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
+	}
+	else {
+
+		/**
+		 * All other processes
+		 */
+		if (platform_file_name.empty()) {
+			return;
+		}
+
+		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());
+
+		/**
+		 * Open file pointer
+		 */
+		process_log.open(
+			StringFormat("logs/%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
+	}
+}
+
+/**
+ * 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

@@ -1,19 +1,21 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 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-2018 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_LOGSYS_H
@@ -24,6 +26,13 @@
 #include <stdio.h>
 #include <functional>
 
+#ifdef _WIN32
+#ifdef utf16_to_utf8
+#undef utf16_to_utf8
+#endif
+#endif
+
+#include <fmt/format.h>
 #include "types.h"
 
 namespace Logs {
@@ -33,18 +42,18 @@ namespace Logs {
 		Detail			/* 3 - Use this for extreme detail in logging, usually in extreme debugging in the stack or interprocess communication */
 	};
 
-	/*
-		If you add to this, make sure you update LogCategoryName
-		NOTE: Only add to the bottom of the enum because that is the type ID assignment
-	*/
-
+	/**
+	 * If you add to this, make sure you update LogCategoryName
+	 *
+	 * NOTE: Only add to the bottom of the enum because that is the type ID assignment
+	 */
 	enum LogCategory {
 		None = 0,
 		AA,
 		AI,
 		Aggro,
 		Attack,
-		Client_Server_Packet,
+		PacketClientServer,
 		Combat,
 		Commands,
 		Crash,
@@ -58,35 +67,66 @@ namespace Logs {
 		Normal,
 		Object,
 		Pathing,
-		QS_Server,
+		QSServer,
 		Quests,
 		Rules,
 		Skills,
 		Spawns,
 		Spells,
 		Status,
-		TCP_Connection,
+		TCPConnection,
 		Tasks,
 		Tradeskills,
 		Trading,
 		Tribute,
-		UCS_Server,
-		WebInterface_Server,
-		World_Server,
-		Zone_Server,
+		UCSServer,
+		WebInterfaceServer,
+		WorldServer,
+		ZoneServer,
 		MySQLError,
 		MySQLQuery,
 		Mercenaries,
 		QuestDebug,
-		Server_Client_Packet,
-		Client_Server_Packet_Unhandled,
-		Server_Client_Packet_With_Dump,
-		Client_Server_Packet_With_Dump,
-		Login_Server,
-		MaxCategoryID	/* Don't Remove this*/
+		PacketServerClient,
+		PacketClientServerUnhandled,
+		PacketServerClientWithDump,
+		PacketClientServerWithDump,
+		Loginserver,
+		ClientLogin,
+		HeadlessClient,
+		HPUpdate,
+		FixZ,
+		Food,
+		Traps,
+		NPCRoamBox,
+		NPCScaling,
+		MobAppearance,
+		Info,
+		Warning,
+		Critical,
+		Emergency,
+		Alert,
+		Notice,
+		AIScanClose,
+		AIYellForHelp,
+		AICastBeneficialClose,
+		AoeCast,
+		EntityManagement,
+		Flee,
+		Aura,
+		HotReload,
+		Merchants,
+		ZonePoints,
+		Loot,
+		Expeditions,
+		DynamicZones,
+		Group,
+		MaxCategoryID /* Don't Remove this */
 	};
 
-	/* If you add to this, make sure you update LogCategory */
+	/**
+	 * If you add to this, make sure you update LogCategory
+	 */
 	static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
 		"",
 		"AA",
@@ -131,41 +171,98 @@ namespace Logs {
 		"Packet :: Client -> Server Unhandled",
 		"Packet :: Server -> Client (Dump)",
 		"Packet :: Client -> Server (Dump)",
-		"Login Server"
+		"Login Server",
+		"Client Login",
+		"Headless Client",
+		"HP Update",
+		"FixZ",
+		"Food",
+		"Traps",
+		"NPC Roam Box",
+		"NPC Scaling",
+		"Mob Appearance",
+		"Info",
+		"Warning",
+		"Critical",
+		"Emergency",
+		"Alert",
+		"Notice",
+		"AI Scan Close",
+		"AI Yell For Help",
+		"AI Cast Beneficial Close",
+		"AOE Cast",
+		"Entity Management",
+		"Flee",
+		"Aura",
+		"HotReload",
+		"Merchants",
+		"ZonePoints",
+		"Loot",
+		"Expeditions",
+		"DynamicZones",
+		"Group",
 	};
 }
 
+#include "eqemu_logsys_log_aliases.h"
+
 class EQEmuLogSys {
 public:
 	EQEmuLogSys();
 	~EQEmuLogSys();
 
-	void CloseFileLogs(); /* Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else. This should be handled on deconstructor but to be safe we use it anyways. */
-	void LoadLogSettingsDefaults(); /* Initializes log_settings and sets some defaults if DB is not present */
-	void MakeDirectory(const std::string &directory_name); /* Platform independent way of performing a MakeDirectory based on name */
-	/*
-		The one and only Logging function that uses a debug level as a parameter, as well as a log_category
-		log_category - defined in Logs::LogCategory::[]
-		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+	/**
+	 * Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else.
+	 * This should be handled on deconstructor but to be safe we use it anyways.
+	 */
+	void CloseFileLogs();
+	void LoadLogSettingsDefaults();
 
-		Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
-			- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
-				be checked against to see if that piped output is set to actually process it for the category and debug level
+	/**
+	 * @param directory_name
+	 */
+	void MakeDirectory(const std::string &directory_name);
+
+	/**
+	 *	The one and only Logging function that uses a debug level as a parameter, as well as a log_category
+	 *		log_category - defined in Logs::LogCategory::[]
+	 *		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+	 *
+	 *	Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
+	 *		- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
+	 *			be checked against to see if that piped output is set to actually process it for the category and debug level
 	*/
-	void Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...);
-	void SetCurrentTimeStamp(char* time_stamp); /* Used in file logs to prepend a timestamp entry for logs */ 
-	void StartFileLogs(const std::string &log_name = ""); /* Used to declare the processes file log and to keep it open for later use */
+	void Out(
+		Logs::DebugLevel debug_level,
+		uint16 log_category,
+		const char *file,
+		const char *func,
+		int line,
+		const char *message,
+		...
+	);
 
-	/*
-		LogSettings Struct
+	/**
+	 * Used in file logs to prepend a timestamp entry for logs
+	 * @param time_stamp
+	 */
+	void SetCurrentTimeStamp(char* time_stamp);
 
-		This struct is the master reference for all settings for each category, and for each output
+	/**
+	 * @param log_name
+	 */
+	void StartFileLogs(const std::string &log_name = "");
 
-		log_to_file[category_id] = [1-3] - Sets debug level for category to output to file
-		log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
-		log_to_gmsay[category_id] = [1-3] - Sets debug level for category to output to gmsay
+	/**
+     * LogSettings Struct
+     *
+     * This struct is the master reference for all settings for each category, and for each output
+     *
+     * log_to_file[category_id]    = [1-3] - Sets debug level for category to output to file
+     * log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
+     * log_to_gmsay[category_id]   = [1-3] - Sets debug level for category to output to gmsay
+     *
 	*/
-
 	struct LogSettings {
 		uint8 log_to_file;
 		uint8 log_to_console;
@@ -173,34 +270,130 @@ public:
 		uint8 is_category_enabled; /* When any log output in a category > 0, set this to 1 as (Enabled) */
 	};
 
-	/* Internally used memory reference for all log settings per category.
-		These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults.
-		Database loaded via Database::LoadLogSettings(log_settings)
+	/**
+	 * Internally used memory reference for all log settings per category
+	 * These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults
+	 * Database loaded via Database::LoadLogSettings(log_settings)
 	*/
-	LogSettings log_settings[Logs::LogCategory::MaxCategoryID];
+	LogSettings log_settings[Logs::LogCategory::MaxCategoryID]{};
 
-	bool file_logs_enabled; /* Set when log settings are loaded to determine if keeping a file open is necessary */
+	bool file_logs_enabled = false;
 
-	int log_platform; /* Sets Executable platform (Zone/World/UCS) etc. */
+	/**
+	 * Sets Executable platform (Zone/World/UCS) etc.
+	 */
+	int log_platform = 0;
 
-	std::string platform_file_name; /* File name used in writing logs */
+	/**
+	 * File name used in writing logs
+	 */
+	std::string platform_file_name;
 
-	uint16 GetGMSayColorFromCategory(uint16 log_category); /* GMSay Client Message colors mapped by category */
+	/**
+	 * GMSay Client Message colors mapped by category
+	 *
+	 * @param log_category
+	 * @return
+	 */
+	uint16 GetGMSayColorFromCategory(uint16 log_category);
 
-	void OnLogHookCallBackZone(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+	/**
+	 * @param f
+	 */
+	void SetGMSayHandler(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+
+	/**
+	 * @param f
+	 */
+	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:
-	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook; /* Callback pointer to zone process for hooking logs to zone using GMSay */
-	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message); /* Formats log messages like '[Category] This is a log message' */
-	std::string GetLinuxConsoleColorFromCategory(uint16 log_category); /* Linux console color messages mapped by category */
 
-	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */
+	/**
+	 * Callback pointer to zone process for hooking logs to zone using GMSay
+	 */
+	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook;
+	std::function<void(uint16 debug_level, uint16 log_category, const std::string&)> on_log_console_hook;
 
-	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log.Out */
-	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log.Out */
-	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log.Out */
+	/**
+	 * Formats log messages like '[Category] This is a log message'
+	 */
+	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message);
+
+	/**
+	 * Linux console color messages mapped by category
+	 *
+	 * @param log_category
+	 * @return
+	 */
+	std::string GetLinuxConsoleColorFromCategory(uint16 log_category);
+
+	/**
+	 * Windows console color messages mapped by category
+	 */
+	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category);
+
+	/**
+	 * @param debug_level
+	 * @param log_category
+	 * @param message
+	 */
+	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message);
+
+	/**
+	 * @param debug_level
+	 * @param log_category
+	 * @param message
+	 */
+	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message);
+
+	/**
+	 * @param debug_level
+	 * @param log_category
+	 * @param message
+	 */
+	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message);
+
+	/**
+	 * @param log_category
+	 * @return
+	 */
+	bool IsRfc5424LogCategory(uint16 log_category);
 };
 
-extern EQEmuLogSys Log;
+extern EQEmuLogSys LogSys;
+
+/**
+template<typename... Args>
+void OutF(
+	EQEmuLogSys &ls,
+	Logs::DebugLevel debug_level,
+	uint16 log_category,
+	const char *file,
+	const char *func,
+	int line,
+	const char *fmt,
+	const Args &... args
+)
+{
+	std::string log_str = fmt::format(fmt, args...);
+	ls.Out(debug_level, log_category, file, func, line, log_str.c_str());
+}
+ **/
+
+#define OutF(ls, debug_level, log_category, file, func, line, formatStr, ...) \
+do { \
+    ls.Out(debug_level, log_category, file, func, line, fmt::format(formatStr, ##__VA_ARGS__).c_str()); \
+} while(0)
 
 #endif

common/event/event_loop.h

@@ -0,0 +1,45 @@
+#pragma once
+#include <functional>
+#include <uv.h>
+#include <cstring>
+
+namespace EQ
+{
+	class EventLoop
+	{
+	public:
+		static EventLoop &Get() {
+			static thread_local EventLoop inst;
+			return inst;
+		}
+
+		~EventLoop() {
+			uv_loop_close(&m_loop);
+		}
+
+		void Process() {
+			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:
+		EventLoop() {
+			memset(&m_loop, 0, sizeof(uv_loop_t));
+			uv_loop_init(&m_loop);
+		}
+		
+		EventLoop(const EventLoop&);
+		EventLoop& operator=(const EventLoop&);
+	
+		uv_loop_t m_loop;
+	};
+}

common/event/task.h

@@ -0,0 +1,100 @@
+#pragma once
+#include <functional>
+#include <exception>
+#include "event_loop.h"
+#include "../any.h"
+
+namespace EQ {
+	class Task
+	{
+	public:
+		typedef std::function<void(const EQ::Any&)> ResolveFn;
+		typedef std::function<void(const std::exception&)> RejectFn;
+		typedef std::function<void()> FinallyFn;
+		typedef std::function<void(ResolveFn, RejectFn)> TaskFn;
+		struct TaskBaton
+		{
+			TaskFn fn;
+			ResolveFn on_then;
+			RejectFn on_catch;
+			FinallyFn on_finally;
+			bool has_result;
+			EQ::Any result;
+			bool has_error;
+			std::exception error;
+		};
+
+		Task(TaskFn fn) {
+			m_fn = fn;
+		}
+
+		~Task() {
+
+		}
+
+		Task& Then(ResolveFn fn) {
+			m_then = fn;
+			return *this;
+		}
+
+		Task& Catch(RejectFn fn) {
+			m_catch = fn;
+			return *this;
+		}
+
+		Task& Finally(FinallyFn fn) {
+			m_finally = fn;
+			return *this;
+		}
+
+		void Run() {
+			uv_work_t *m_work = new uv_work_t;
+			memset(m_work, 0, sizeof(uv_work_t));
+			TaskBaton *baton = new TaskBaton();
+			baton->fn = m_fn;
+			baton->on_then = m_then;
+			baton->on_catch = m_catch;
+			baton->on_finally = m_finally;
+			baton->has_result = false;
+			baton->has_error = false;
+
+			m_work->data = baton;
+
+			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
+				TaskBaton *baton = (TaskBaton*)req->data;
+
+				baton->fn([baton](const EQ::Any& result) {
+					baton->has_error = false;
+					baton->has_result = true;
+					baton->result = result;
+				}, [baton](const std::exception &err) {
+					baton->has_error = true;
+					baton->has_result = false;
+					baton->error = err;
+				});
+			}, [](uv_work_t* req, int status) {
+				TaskBaton *baton = (TaskBaton*)req->data;
+
+				if (baton->has_error && baton->on_catch) {
+					baton->on_catch(baton->error);
+				}
+				else if (baton->has_result && baton->on_then) {
+					baton->on_then(baton->result);
+				}
+
+				if (baton->on_finally) {
+					baton->on_finally();
+				}
+
+				delete baton;
+				delete req;
+			});
+		}
+
+	private:
+		TaskFn m_fn;
+		ResolveFn m_then;
+		RejectFn m_catch;
+		FinallyFn m_finally;
+	};
+}

common/event/task_scheduler.h

@@ -0,0 +1,114 @@
+#pragma once
+#include <vector>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <functional>
+#include <queue>
+#include <future>
+
+namespace EQ
+{
+	namespace Event
+	{
+		class TaskScheduler
+		{
+		public:
+			static const int DefaultThreadCount = 4;
+		
+			TaskScheduler() : _running(false)
+			{
+				Start(DefaultThreadCount);
+			}
+
+			TaskScheduler(size_t threads) : _running(false)
+			{
+				Start(threads);
+			}
+			
+			~TaskScheduler() {
+				Stop();
+			}
+
+			void Start(size_t threads) {
+				if (true == _running) {
+					return;
+				}
+
+				_running = true;
+
+				for (size_t i = 0; i < threads; ++i) {
+					_threads.push_back(std::thread(std::bind(&TaskScheduler::ProcessWork, this)));
+				}
+			}
+			
+			void Stop() {
+				if (false == _running) {
+					return;
+				}
+
+				{
+					std::unique_lock<std::mutex> lock(_lock);
+					_running = false;
+				}
+
+				_cv.notify_all();
+
+				for (auto &t : _threads) {
+					t.join();
+				}
+			}
+			
+			template<typename Fn, typename... Args>
+			auto Enqueue(Fn&& fn, Args&&... args) -> std::future<typename std::result_of<Fn(Args...)>::type> {
+				using return_type = typename std::result_of<Fn(Args...)>::type;
+			
+				auto task = std::make_shared<std::packaged_task<return_type()>>(
+					std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...)
+					);
+			
+				std::future<return_type> res = task->get_future();
+				{
+					std::unique_lock<std::mutex> lock(_lock);
+			
+					if (false == _running) {
+						throw std::runtime_error("Enqueue on stopped scheduler.");
+					}
+			
+					_tasks.emplace([task]() { (*task)(); });
+				}
+			
+				_cv.notify_one();
+				return res;
+			}
+			
+			private:
+			void ProcessWork() {
+				for (;;) {
+					std::function<void()> work;
+
+					{
+						std::unique_lock<std::mutex> lock(_lock);
+						_cv.wait(lock, [this] { return !_running || !_tasks.empty(); });
+
+						if (false == _running) {
+							return;
+						}
+
+						work = std::move(_tasks.front());
+						_tasks.pop();
+					}
+
+					work();
+				}
+				
+			}
+
+			bool _running = true;
+			std::vector<std::thread> _threads;
+			std::mutex _lock;
+			std::condition_variable _cv;
+			std::queue<std::function<void()>> _tasks;
+		};
+	}
+}

common/event/timer.h

@@ -0,0 +1,67 @@
+#pragma once
+#include <functional>
+#include "event_loop.h"
+
+namespace EQ {
+	class Timer
+	{
+	public:
+		Timer(std::function<void(Timer *)> cb)
+		{
+			m_timer = nullptr;
+			m_cb = cb;
+		}
+
+		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
+		{
+			m_timer = nullptr;
+			m_cb = cb;
+			Start(duration_ms, repeats);
+		}
+	
+		~Timer()
+		{
+			Stop();
+		}
+
+		void Start(uint64_t duration_ms, bool repeats) {
+			auto loop = EventLoop::Get().Handle();
+			if (!m_timer) {
+				m_timer = new uv_timer_t;
+				memset(m_timer, 0, sizeof(uv_timer_t));
+				uv_timer_init(loop, m_timer);
+				m_timer->data = this;
+
+				if (repeats) {
+					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Execute();
+					}, duration_ms, duration_ms);
+				}
+				else {
+					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Stop();
+						t->Execute();
+					}, duration_ms, 0);
+				}
+			}
+		}
+
+		void Stop() {
+			if (m_timer) {
+				uv_close((uv_handle_t*)m_timer, [](uv_handle_t* handle) {
+					delete handle;
+				});
+				m_timer = nullptr;
+			}
+		}
+	private:
+		void Execute() {
+			m_cb(this);
+		}
+	
+		uv_timer_t *m_timer;
+		std::function<void(Timer*)> m_cb;
+	};
+}

common/event_sub.cpp

@@ -0,0 +1,21 @@
+#include "event_sub.h"
+
+void EventSubscriptionWatcher::Subscribe(const std::string &event_name)
+{
+	m_subs[event_name] = 1;
+}
+
+void EventSubscriptionWatcher::Unsubscribe(const std::string &event_name)
+{
+	m_subs[event_name] = 0;
+}
+
+bool EventSubscriptionWatcher::IsSubscribed(const std::string &event_name) const
+{
+	auto iter = m_subs.find(event_name);
+	if (iter != m_subs.end()) {
+		return iter->second;
+	}
+
+	return false;
+}

common/event_sub.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <unordered_map>
+#include <string>
+
+class EventSubscriptionWatcher
+{
+public:
+	~EventSubscriptionWatcher();
+	
+	void Subscribe(const std::string &event_name);
+	void Unsubscribe(const std::string &event_name);
+	bool IsSubscribed(const std::string &event_name) const;
+
+	static EventSubscriptionWatcher *Get() {
+		static EventSubscriptionWatcher* inst = nullptr;
+		if(!inst) {
+			inst = new EventSubscriptionWatcher();
+		}
+		
+		return inst;
+	}
+private:
+	EventSubscriptionWatcher() { }
+	EventSubscriptionWatcher(const EventSubscriptionWatcher&);
+	EventSubscriptionWatcher& operator=(const EventSubscriptionWatcher&);
+	
+	std::unordered_map<std::string, bool> m_subs;
+};

common/extprofile.h

@@ -19,7 +19,7 @@
 #define EXTENDED_PROFILE_H
 
 #include "eq_packet_structs.h"
-#include "item.h"
+#include "inventory_profile.h"
 
 #pragma pack(1)
 
@@ -40,7 +40,7 @@ struct ExtendedProfile_Struct {
 	uint16				old_pet_hp; /* Not Used */
 	uint16				old_pet_mana; /* Not Used */
 	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
-	uint32				pet_items[EQEmu::legacy::MaterialCount]; /* Not Used */
+	EQ::TextureMaterialProfile	pet_items; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */