Merge branch 'master' of https://github.com/EQEmu/Server into peq-expansions

.devcontainer/devcontainer.json

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

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

.gitignore

@@ -17,8 +17,6 @@
 *.out
 *.app
 
-.bash_history
-
 # CMake
 CMakeCache.txt
 CMakeFiles
@@ -29,28 +27,6 @@ install_manifest.txt
 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/
+*cbp

.travis.yml

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

.vscode/c_cpp_properties.json

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

.vscode/tasks.json

@@ -1,164 +0,0 @@
-{
-    // 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

@@ -1,64 +0,0 @@
-# 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,28 +1,122 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
-
-SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
+#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_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_USE_MAP_MMFS
+#EQEMU_MAP_DIR
 
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 IF(POLICY CMP0074)
-	CMAKE_POLICY(SET CMP0074 NEW)
+	cmake_policy(SET CMP0074 NEW)
 ENDIF()
 
+#FindMySQL is located here so lets make it so CMake can find it
+SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
+
+#Our project name is EQEmu
 PROJECT(EQEmu)
 
+#Default build type is set to RelWithDebInfo for generators that honor that like makefiles
 IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
 ENDIF(NOT CMAKE_BUILD_TYPE)
 
-SET(CMAKE_CXX_STANDARD 14)
-SET(CMAKE_CXX_STANDARD_REQUIRED ON)
-SET(CMAKE_CXX_EXTENSIONS OFF)
+SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
+
+#Add our various windows definitions
+IF(MSVC OR MINGW)
+	ADD_DEFINITIONS(-D_WINDOWS)
+	IF(CMAKE_CL_64)
+		ADD_DEFINITIONS(-DWIN64)
+	ELSE(CMAKE_CL_64)
+		ADD_DEFINITIONS(-DWIN32)
+	ENDIF(CMAKE_CL_64)
+ENDIF(MSVC OR MINGW)
 
 IF(MSVC)
-	ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
+	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")
+		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x64")
+		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
+		IF(MSVC_VERSION GREATER 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v140/dynamic")
+		ELSEIF(MSVC_VERSION EQUAL 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v120/dynamic")
+		ELSE()
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v110/dynamic")
+		ENDIF()
+	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")
+		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
+		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86")
+		IF(MSVC_VERSION GREATER 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic")
+		ELSEIF(MSVC_VERSION EQUAL 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v120/dynamic")
+		ELSE()
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v110/dynamic")
+		ENDIF()
+	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)
+
+	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(-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)
 
@@ -39,284 +133,195 @@ IF(UNIX)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
 ENDIF(UNIX)
 
-ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
-ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
-ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
+#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"
+)
 
-#MSVC can fetch dependencies automatically.
-IF(MSVC)
-	INCLUDE("${CMAKE_SOURCE_DIR}/cmake/DependencyHelperMSVC.cmake")
-ENDIF()
+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"
+)
 
-#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_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"
+)
 
-MESSAGE(STATUS "**************************************************")
-MESSAGE(STATUS "* Library Detection                              *")
-MESSAGE(STATUS "**************************************************")
+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"
+)
 
-IF(MYSQL_FOUND)
-	MESSAGE(STATUS "* MySQL:                                   FOUND *")
-ELSE()
-	MESSAGE(STATUS "* MySQL:                                 MISSING *")
-ENDIF()
+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(MARIADB_FOUND)
-	MESSAGE(STATUS "* MariaDB:                                 FOUND *")
-ELSE()
-	MESSAGE(STATUS "* MariaDB:                               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(ZLIB_FOUND)
-	MESSAGE(STATUS "* ZLIB:                                    FOUND *")
-ELSE()
-	MESSAGE(STATUS "* ZLIB:                                  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(Lua51_FOUND)
-	MESSAGE(STATUS "* Lua:                                     FOUND *")
-ELSE()
-	MESSAGE(STATUS "* Lua:                                   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(PerlLibs_FOUND)
-	MESSAGE(STATUS "* Perl:                                    FOUND *")
-ELSE()
-	MESSAGE(STATUS "* Perl:                                  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(SODIUM_FOUND)
-	MESSAGE(STATUS "* libsodium:                               FOUND *")
-ELSE()
-	MESSAGE(STATUS "* libsodium:                             MISSING *")
-ENDIF()
-
-IF(OpenSSL_FOUND)
-	MESSAGE(STATUS "* OpenSSL:                                 FOUND *")
-ELSE()
-	MESSAGE(STATUS "* OpenSSL:                               MISSING *")
-ENDIF()
-
-IF(MBEDTLS_FOUND)
-	MESSAGE(STATUS "* mbedTLS:                                 FOUND *")
-ELSE()
-	MESSAGE(STATUS "* mbedTLS:                               MISSING *")
-ENDIF()
-
-MESSAGE(STATUS "**************************************************")
-
-#options
+#NPC Types Cache Behavior
 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)
 
-#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()
-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()
+#What to build
+OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
+OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
+OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
+OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
+OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
+OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
+OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
 
-#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")
+#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")
 	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()
+ENDIF(NOT MSVC)
 
+#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)
+
+#Disabled until reevaluation performed
+#OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
+#IF(EQEMU_USE_MAP_MMFS)
+#	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
+#ENDIF(EQEMU_USE_MAP_MMFS)
+
+SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
+
+ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
+ADD_DEFINITIONS(-DINVERSEXY)
+ADD_DEFINITIONS(-DFIELD_ITEMS)
+ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
+ADD_DEFINITIONS(-DLOG_LEVEL_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)
+ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
+ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
+
+#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)
+
+SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} uv_a fmt RecastNavigation::Detour)
+
+FIND_PACKAGE(Sodium REQUIRED)
 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)
+	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
+	IF(EQEMU_ENABLE_SECURITY)
+		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
+		ADD_DEFINITIONS(-DENABLE_SECURITY)
+		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
+	ENDIF()
 ENDIF()
 
-IF(Lua51_FOUND)
-	SET(LUA_LIBRARY_TYPE " Lua 5.1")
-	SET(LUA_LIBRARY_ENABLED ON)
-	SET(LUA_LIBRARY_LIBS ${LUA_LIBRARY} luabind)
-	SET(LUA_LIBRARY_INCLUDE ${LUA_INCLUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
-ELSE()
-	SET(LUA_LIBRARY_TYPE "Disabled")
-	SET(LUA_LIBRARY_ENABLED OFF)
-ENDIF()
-
-IF(PerlLibs_FOUND)
-	SET(PERL_LIBRARY_TYPE "    Perl")
-	SET(PERL_LIBRARY_ENABLED ON)
-	SET(PERL_LIBRARY_LIBS ${PERL_LIBRARY})
-	SET(PERL_LIBRARY_INCLUDE ${PERL_INCLUDE_PATH})
-ELSE()
-	SET(PERL_LIBRARY_TYPE "Disabled")
-	SET(PERL_LIBRARY_ENABLED OFF)
-ENDIF()
-
-#use zlib if exists
 IF(ZLIB_FOUND)
-	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." ON)
+	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." OFF)
+	
 	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")
+		INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+		SET(SERVER_LIBS ${SERVER_LIBS} "zlibstatic")
 	ELSE()
-		SET(ZLIB_LIBRARY_TYPE "   zlib")
-		SET(ZLIB_LIBRARY_LIBS ${ZLIB_LIBRARY})
-		SET(ZLIB_LIBRARY_INCLUDE ${ZLIB_INCLUDE_DIRS})
+		INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
+		SET(SERVER_LIBS ${SERVER_LIBS} ${ZLIB_LIBRARY})
 	ENDIF()
 ELSE()
-	SET(ZLIB_LIBRARY_TYPE "zlib-ng")
-	SET(ZLIB_LIBRARY_LIBS "zlibstatic")
-	SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
-ENDIF()
-
-MESSAGE(STATUS "")
-MESSAGE(STATUS "**************************************************")
-MESSAGE(STATUS "* Library Usage                                  *")
-MESSAGE(STATUS "**************************************************")
-MESSAGE(STATUS "* Database:                              ${DATABASE_LIBRARY_TYPE} *")
-MESSAGE(STATUS "* TLS:                                  ${TLS_LIBRARY_TYPE} *")
-MESSAGE(STATUS "* Sodium:                              ${SODIUM_LIBRARY_TYPE} *")
-MESSAGE(STATUS "* Lua:                                  ${LUA_LIBRARY_TYPE} *")
-MESSAGE(STATUS "* Perl:                                 ${PERL_LIBRARY_TYPE} *")
-MESSAGE(STATUS "* zlib:                                  ${ZLIB_LIBRARY_TYPE} *")
-MESSAGE(STATUS "**************************************************")
-
-#setup server libs and headers
-SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)
-
-INCLUDE_DIRECTORIES(SYSTEM "${DATABASE_LIBRARY_INCLUDE}")
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_LIBRARY_INCLUDE}")
-INCLUDE_DIRECTORIES(SYSTEM "${Boost_INCLUDE_DIRS}")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/fmt/include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/libuv/include" )
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DebugUtils/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Detour/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourCrowd/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourTileCache/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Recast/Include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/websocketpp")
-
-OPTION(EQEMU_BUILD_LOGGING "Build Logging (To speed up compilation)" ON)
-IF(EQEMU_BUILD_LOGGING)
-	ADD_DEFINITIONS(-DBUILD_LOGGING)
-ENDIF()
-
-IF(TLS_LIBRARY_ENABLED)
-	SET(SERVER_LIBS ${SERVER_LIBS} ${TLS_LIBRARY_LIBS})
-	INCLUDE_DIRECTORIES(SYSTEM "${TLS_LIBRARY_INCLUDE}")
-ENDIF()
-
-IF(SODIUM_LIBRARY_ENABLED)
-	SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARY_LIBS})
-	INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_LIBRARY_INCLUDE}")
-ENDIF()
-
-IF(LUA_LIBRARY_ENABLED)
-	OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
-	
-	IF(EQEMU_BUILD_LUA)
-		ADD_DEFINITIONS(-DLUA_EQEMU)
-		SET(SERVER_LIBS ${SERVER_LIBS} ${LUA_LIBRARY_LIBS})
-		INCLUDE_DIRECTORIES(SYSTEM "${LUA_LIBRARY_INCLUDE}")
-		
-		OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
-		IF(EQEMU_SANITIZE_LUA_LIBS)
-			ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
-		ENDIF()
-	ENDIF()
-ENDIF()
-
-IF(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()
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+	SET(SERVER_LIBS ${SERVER_LIBS} "zlibstatic")
 ENDIF()
 
 IF(WIN32)
@@ -328,38 +333,55 @@ IF(UNIX)
 	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()
+	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
 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_LUA)
+	FIND_PACKAGE(EQLua51 REQUIRED)
+	SET(Boost_USE_STATIC_LIBS OFF)
+	SET(Boost_USE_MULTITHREADED ON)
+	SET(Boost_USE_STATIC_RUNTIME OFF)
+	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
 
-IF(EQEMU_BUILD_HC AND NOT TLS_LIBRARY_ENABLED)
-	MESSAGE(FATAL_ERROR "Headless client requires a TLS Library to build.")
-ENDIF()
+	FIND_PACKAGE(Boost REQUIRED)
+	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+
+	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
+	IF(EQEMU_SANITIZE_LUA_LIBS)
+		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
+	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
+ENDIF(EQEMU_BUILD_LUA)
+
+INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/fmt/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/libuv/include" )
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DebugUtils/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Detour/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourCrowd/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourTileCache/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Recast/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/websocketpp")
 
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)
 	ADD_SUBDIRECTORY(libs)
 	ADD_SUBDIRECTORY(submodules/fmt)
 	ADD_SUBDIRECTORY(submodules/libuv)
+
+	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
+	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
+	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
+	ADD_SUBDIRECTORY(submodules/recastnavigation)
 	
 	IF(EQEMU_BUILD_ZLIB)
 		SET(ZLIB_COMPAT ON CACHE BOOL "Compile with zlib compatible API")
 		SET(ZLIB_ENABLE_TESTS OFF CACHE BOOL "Build test binaries")
 		ADD_SUBDIRECTORY(libs/zlibng)
 	ENDIF()
-	
-	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
-	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
-	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
-	ADD_SUBDIRECTORY(submodules/recastnavigation)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
-
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -368,7 +390,6 @@ IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(queryserv)
 	ADD_SUBDIRECTORY(eqlaunch)
 ENDIF(EQEMU_BUILD_SERVER)
-
 IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)

README.md

@@ -1,7 +1,7 @@
 # EQEmulator Core Server
-|Travis CI (Linux)|Appveyor (Windows x86)   |Appveyor (Windows x64)   |
+|Travis CI (Linux)|Appveyor w/ Bots (Windows)   |Appveyor w/o Bots (Windows)   |
 |:---:|:---:|:---:| 
-|[![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)   |
+|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Build status](https://ci.appveyor.com/api/projects/status/scr25kmntx36c1ub/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-87crp/branch/master)   |[![Build status](https://ci.appveyor.com/api/projects/status/mdwbr4o9l6mxqofj/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-w0pq2/branch/master)   |
 
 ***
 
@@ -17,13 +17,9 @@
 |:---:|:---:|:---:|
 |**Install Count**|![Windows Install Count](http://analytics.akkadius.com/?install_count&windows_count)|![Linux Install Count](http://analytics.akkadius.com/?install_count&linux_count)| 
 ### > Windows 
-
-* [Install Guide](https://eqemu.gitbook.io/server/categories/installation/server-installation-windows)
+* [Install](https://github.com/EQEmu/Server/wiki/Windows-Server)
 
 ### > Debian/Ubuntu/CentOS/Fedora
-
-* [Install Guide](https://eqemu.gitbook.io/server/categories/installation/server-installation-linux)
-
 * 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
 
@@ -56,7 +52,7 @@ forum, although pull requests will be much quicker and easier on all parties.
 
 ## Resources
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
-- [EQEmulator Wiki](https://eqemu.gitbook.io/)
+- [EQEmulator Wiki](https://github.com/EQEmu/Server/wiki)
 
 ## Related Repositories
 * [ProjectEQ Quests](https://github.com/ProjectEQ/projecteqquests)
@@ -74,10 +70,3 @@ forum, although pull requests will be much quicker and easier on all parties.
   * 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

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

client_files/CMakeLists.txt

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

client_files/export/CMakeLists.txt

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

client_files/export/main.cpp

@@ -26,63 +26,37 @@
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
-#include "../../common/content/world_content_service.h"
 
 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);
 	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	LogInfo("Client Files Export Utility");
-	if (!EQEmuConfig::LoadConfig()) {
-		LogError("Unable to load configuration file");
+	Log(Logs::General, Logs::Status, "Client Files Export Utility");
+	if(!EQEmuConfig::LoadConfig()) {
+		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	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");
+	Log(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(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+			"database connection");
 		return 1;
 	}
 
-	/**
-	 * 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());
-	}
-
+	/* Register Log System and Settings */
 	database.LoadLogSettings(LogSys.log_settings);
 	LogSys.StartFileLogs();
 
@@ -93,15 +67,15 @@ int main(int argc, char **argv)
 	}
 
 	if (arg_1 == "spells") {
-		ExportSpells(&content_db);
+		ExportSpells(&database);
 		return 0;
 	}
 	if (arg_1 == "skills") {
-		ExportSkillCaps(&content_db);
+		ExportSkillCaps(&database);
 		return 0;
 	}
 	if (arg_1 == "basedata") {
-		ExportBaseData(&content_db);
+		ExportBaseData(&database);
 		return 0;
 	}
 	if (arg_1 == "dbstring") {
@@ -109,9 +83,9 @@ int main(int argc, char **argv)
 		return 0;
 	}
 
-	ExportSpells(&content_db);
-	ExportSkillCaps(&content_db);
-	ExportBaseData(&content_db);
+	ExportSpells(&database);
+	ExportSkillCaps(&database);
+	ExportBaseData(&database);
 	ExportDBStrings(&database);
 
 	LogSys.CloseFileLogs();
@@ -119,105 +93,93 @@ int main(int argc, char **argv)
 	return 0;
 }
 
-void ExportSpells(SharedDatabase *db)
-{
-	LogInfo("Exporting Spells");
+void ExportSpells(SharedDatabase *db) {
+	Log(Logs::General, Logs::Status, "Exporting Spells...");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
-	if (!f) {
-		LogError("Unable to open export/spells_us.txt to write, skipping.");
+	if(!f) {
+		Log(Logs::General, Logs::Error, "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)
-{
-	LogInfo("Exporting Skill Caps");
+void ExportSkillCaps(SharedDatabase *db) {
+	Log(Logs::General, Logs::Status, "Exporting Skill Caps...");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
-	if (!f) {
-		LogError("Unable to open export/SkillCaps.txt to write, skipping.");
+	if(!f) {
+		Log(Logs::General, Logs::Error, "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;
 					}
 
@@ -231,28 +193,26 @@ void ExportSkillCaps(SharedDatabase *db)
 	fclose(f);
 }
 
-void ExportBaseData(SharedDatabase *db)
-{
-	LogInfo("Exporting Base Data");
+void ExportBaseData(SharedDatabase *db) {
+	Log(Logs::General, Logs::Status, "Exporting Base Data...");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
-	if (!f) {
-		LogError("Unable to open export/BaseData.txt to write, skipping.");
+	if(!f) {
+		Log(Logs::General, Logs::Error, "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];
 				}
 			}
@@ -264,29 +224,27 @@ void ExportBaseData(SharedDatabase *db)
 	fclose(f);
 }
 
-void ExportDBStrings(SharedDatabase *db)
-{
-	LogInfo("Exporting DB Strings");
+void ExportDBStrings(SharedDatabase *db) {
+	Log(Logs::General, Logs::Status, "Exporting DB Strings...");
 
 	FILE *f = fopen("export/dbstr_us.txt", "w");
-	if (!f) {
-		LogError("Unable to open export/dbstr_us.txt to write, skipping.");
+	if(!f) {
+		Log(Logs::General, Logs::Error, "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 3.2)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 
 SET(import_sources
 	main.cpp

client_files/import/main.cpp

@@ -24,10 +24,8 @@
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
-#include "../../common/content/world_content_service.h"
 
 EQEmuLogSys LogSys;
-WorldContentService content_service;
 
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
@@ -39,57 +37,33 @@ int main(int argc, char **argv) {
 	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	LogInfo("Client Files Import Utility");
+	Log(Logs::General, Logs::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		LogError("Unable to load configuration file.");
+		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	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");
+	Log(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(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+			"database connection");
 		return 1;
 	}
 
-	/**
-	 * 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());
-	}
-
 	database.LoadLogSettings(LogSys.log_settings);
 	LogSys.StartFileLogs();
 
-	ImportSpells(&content_db);
-	ImportSkillCaps(&content_db);
-	ImportBaseData(&content_db);
+	ImportSpells(&database);
+	ImportSkillCaps(&database);
+	ImportBaseData(&database);
 	ImportDBStrings(&database);
 
 	LogSys.CloseFileLogs();
-
+	
 	return 0;
 }
 
@@ -123,10 +97,10 @@ bool IsStringField(int i) {
 }
 
 void ImportSpells(SharedDatabase *db) {
-	LogInfo("Importing Spells");
+	Log(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		LogError("Unable to open import/spells_us.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
@@ -199,23 +173,23 @@ void ImportSpells(SharedDatabase *db) {
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			LogInfo("[{}] spells imported", spells_imported);
+			Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		LogInfo("[{}] spells imported", spells_imported);
+		Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	LogInfo("Importing Skill Caps");
+	Log(Logs::General, Logs::Status, "Importing Skill Caps...");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		LogError("Unable to open import/SkillCaps.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
@@ -246,11 +220,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	LogInfo("Importing Base Data");
+	Log(Logs::General, Logs::Status, "Importing Base Data...");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		LogError("Unable to open import/BaseData.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 
@@ -291,11 +265,11 @@ void ImportBaseData(SharedDatabase *db) {
 }
 
 void ImportDBStrings(SharedDatabase *db) {
-	LogInfo("Importing DB Strings");
+	Log(Logs::General, Logs::Status, "Importing DB Strings...");
 
 	FILE *f = fopen("import/dbstr_us.txt", "r");
 	if(!f) {
-		LogError("Unable to open import/dbstr_us.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
 		return;
 	}
 
@@ -326,10 +300,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

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

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

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

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

cmake/FindmbedTLS.cmake

@@ -1,93 +0,0 @@
-# - 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,16 +1,13 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.2)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 
 SET(common_sources
 	base_packet.cpp
 	classes.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
@@ -33,13 +30,11 @@ SET(common_sources
 	event_sub.cpp
 	extprofile.cpp
 	faction.cpp
-	file_util.cpp
 	guild_base.cpp
 	guilds.cpp
 	inventory_profile.cpp
 	inventory_slot.cpp
 	ipc_mutex.cpp
-	ip_util.cpp
 	item_data.cpp
 	item_instance.cpp
 	json_config.cpp
@@ -76,6 +71,7 @@ SET(common_sources
 	textures.cpp
 	timer.cpp
 	unix.cpp
+	xml_parser.cpp
 	platform.cpp
 	json/jsoncpp.cpp
 	net/console_server.cpp
@@ -106,332 +102,12 @@ SET(common_sources
 	patches/uf.cpp
 	patches/uf_limits.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
+	util/uuid.cpp
 )
 
 SET(common_headers
@@ -442,17 +118,11 @@ SET(common_headers
 	classes.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
@@ -468,7 +138,7 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
-	eqemu_logsys_log_aliases.h
+	eqemu_logsys_fmt.h
 	eq_limits.h
 	eq_packet.h
 	eq_stream_ident.h
@@ -480,18 +150,15 @@ SET(common_headers
 	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
-	http/httplib.h
 	inventory_profile.h
 	inventory_slot.h
 	ipc_mutex.h
-	ip_util.h
 	item_data.h
 	item_fieldlist.h
 	item_instance.h
@@ -542,6 +209,7 @@ SET(common_headers
 	unix.h
 	useperl.h
 	version.h
+	xml_parser.h
 	zone_numbers.h
 	event/event_loop.h
 	event/task.h
@@ -595,9 +263,12 @@ SET(common_headers
 	patches/uf_ops.h
 	patches/uf_structs.h
 	StackWalker/StackWalker.h
+	tinyxml/tinystr.h
+	tinyxml/tinyxml.h
 	util/memory_stream.h
 	util/directory.h
-	util/uuid.h)
+	util/uuid.h
+)
 
 SOURCE_GROUP(Event FILES
 	event/event_loop.h
@@ -697,6 +368,15 @@ SOURCE_GROUP(StackWalker FILES
 	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
@@ -705,9 +385,9 @@ SOURCE_GROUP(Util FILES
 	util/uuid.h
 )
 
-INCLUDE_DIRECTORIES(Patches SocketLib StackWalker)
+INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
 
-ADD_LIBRARY(common ${common_sources} ${common_headers} ${repositories})
+ADD_LIBRARY(common ${common_sources} ${common_headers})
 
 IF(UNIX)
 	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)

common/any.h

@@ -24,7 +24,7 @@
  *  DEALINGS IN THE SOFTWARE.
  */
 
-// EQ::Any is a modified version of Boost::Any and as such retains the Boost licensing.
+// EQEmu::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 EQ
+namespace EQEmu
 {
 	class Any
 	{

common/base_packet.h

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

common/classes.cpp

@@ -378,8 +378,6 @@ const char *GetClassIDName(uint8 class_id, uint8 level)
 			return "Berserker Guildmaster";
 		case MERCHANT:
 			return "Merchant";
-		case DISCORD_MERCHANT:
-			return "Discord Merchant";
 		case ADVENTURERECRUITER:
 			return "Adventure Recruiter";
 		case ADVENTUREMERCHANT:
@@ -390,18 +388,6 @@ const char *GetClassIDName(uint8 class_id, uint8 level)
 			return "Tribute Master";
 		case GUILD_TRIBUTE_MASTER:
 			return "Guild Tribute Master";
-		case GUILD_BANKER:
-			return "Guild Banker";
-		case NORRATHS_KEEPERS_MERCHANT:
-			return "Radiant Crystal Merchant";
-		case DARK_REIGN_MERCHANT:
-			return "Ebon Crystal Merchant";
-		case FELLOWSHIP_MASTER:
-			return "Fellowship Master";
-		case ALT_CURRENCY_MERCHANT:
-			return "Alternate Currency Merchant";
-		case MERCERNARY_MASTER:
-			return "Mercenary Liaison";
 		default:
 			return "Unknown";
 	}
@@ -587,20 +573,6 @@ bool IsNonSpellFighterClass(uint8 class_id)
 	}
 }
 
-bool IsHybridClass(uint8 class_id)
-{
-	switch (class_id) {
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case BARD:
-	case BEASTLORD:
-		return true;
-	default:
-		return false;
-	}
-}
-
 bool IsCasterClass(uint8 class_id)
 {
 	switch (class_id) {

common/classes.h

@@ -61,7 +61,6 @@
 #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
@@ -136,7 +135,6 @@ 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

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

@@ -1,199 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-/**
- * 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

@@ -1,557 +0,0 @@
-//!
-//! 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/compression.cpp

@@ -3,7 +3,7 @@
 #include <string.h>
 #include <zlib.h>
 
-namespace EQ
+namespace EQEmu
 {
 	uint32 EstimateDeflateBuffer(uint32 len) {
 		z_stream zstream;

common/compression.h

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

common/content/world_content_service.cpp

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,173 +0,0 @@
-/**
- * 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

@@ -111,65 +111,7 @@ 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()
-{
-	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));
+void set_exception_handler() {
 }
 #endif

common/data_verification.h

@@ -1,57 +1,53 @@
-/**
- * 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
- *
- */
+/*	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
+*/
 
 #pragma once
 
 #include <algorithm>
 #include <cmath>
 
-namespace EQ {
-	template<typename T>
-	T Clamp(const T &value, const T &lower, const T &upper)
-	{
+namespace EQEmu
+{
+	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)
-	{
+	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)
-	{
+	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)
-	{
+	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;
+	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*/
 

common/database.h

@@ -40,7 +40,7 @@
 class MySQLRequestResult;
 class Client;
 
-namespace EQ
+namespace EQEmu
 {
 	class InventoryProfile;
 }
@@ -94,50 +94,31 @@ 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, std::string connection_label = "default");
+	bool Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port);
 	~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 *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
-	);
+	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, EQEmu::InventoryProfile* inv);
+	bool	UpdateName(const char* oldname, const char* newname);
 
 	/* 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);
@@ -146,17 +127,13 @@ public:
 
 	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
 	uint32	GetAccountIDByChar(uint32 char_id);
-	uint32	GetAccountIDByName(const char* accname, const char *loginserver, int16* status = 0, uint32* lsid = 0);
+	uint32	GetAccountIDByName(const char* accname, 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 */
@@ -173,6 +150,7 @@ 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);
@@ -196,35 +174,35 @@ public:
 
 	/* Account Related */
 
-	bool	DeleteAccount(const char *name, const char* loginserver);
+	bool	DeleteAccount(const char* name);
 	bool	GetLiveChar(uint32 account_id, char* cname);
 	bool	SetAccountStatus(const char* name, int16 status);
-	bool	SetAccountStatus(const std::string& account_name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
-	bool	UpdateLiveChar(char* charname, uint32 account_id);
+	bool	UpdateLiveChar(char* charname, uint32 lsaccount_id);
 
 	int16	CheckStatus(uint32 account_id);
 
-	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);
+	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);
 	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);
@@ -259,12 +237,17 @@ 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(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, uint32* minexpansion = 0, uint32* maxexpansion = 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, uint32* minexpansion = 0, uint32* maxexpansion = 0, char *flag_needed = nullptr) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, minexpansion, maxexpansion, 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);
@@ -288,6 +271,7 @@ public:
 	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

@@ -1,580 +0,0 @@
-/**
- * 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

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

@@ -189,7 +189,7 @@ namespace Convert {
 		/*002*/	uint32 HP;
 		/*006*/	uint32 Mana;
 		/*010*/	Convert::SpellBuff_Struct Buffs[BUFF_COUNT];
-		/*510*/	uint32 Items[EQ::textures::materialCount];
+		/*510*/	uint32 Items[EQEmu::textures::materialCount];
 		/*546*/	char Name[64];
 		/*610*/
 	};
@@ -230,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[EQ::textures::materialCount];	// Item texture/material of worn/held items
+		/*0312*/	uint32							item_material[EQEmu::textures::materialCount];	// Item texture/material of worn/held items
 		/*0348*/	uint8							unknown0348[44];
-		/*0392*/	Convert::Color_Struct			item_tint[EQ::textures::materialCount];
+		/*0392*/	Convert::Color_Struct			item_tint[EQEmu::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
@@ -476,7 +476,7 @@ bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertCorpseDeblob();
 
 	/* Run EQEmu Server script (Checks for database updates) */
-	if(system("perl eqemu_server.pl ran_from_world"));
+	system("perl eqemu_server.pl ran_from_world");
 
 	return true;
 }
@@ -1396,7 +1396,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Material Color Convert */
 				first_entry = 0; rquery = "";
-				for (i = EQ::textures::textureBegin; i < EQ::textures::materialCount; i++){
+				for (i = EQEmu::textures::textureBegin; i < EQEmu::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);

common/database_instances.cpp

@@ -34,7 +34,6 @@ 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
@@ -98,53 +97,42 @@ 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);
 
-	return (start_time + duration) <= tv.tv_sec;
+	if ((start_time + duration) <= tv.tv_sec)
+		return true;
 
+	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 (%u, %u, %u, UNIX_TIMESTAMP(), %u)",
-		instance_id,
-		zone_id,
-		version,
-		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);
 	auto results = QueryDatabase(query);
 
 	return results.Success();
@@ -152,84 +140,66 @@ bool Database::CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version
 
 bool Database::GetUnusedInstanceID(uint16 &instance_id)
 {
-	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;
-
-			)
-		);
-	}
+	uint32 count = RuleI(Zone, ReservedInstances);
+	uint32 max = 65535;
 
+	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 = max_reserved_instance_id;
-		return true;
+	if (results.RowCount() == 0)
+	{
+		instance_id = 0;
+		return false;
 	}
 
 	auto row = results.begin();
 
-	if (atoi(row[0]) <= max) {
+	if (atoi(row[0]) <= max)
+	{
 		instance_id = atoi(row[0]);
-
 		return true;
 	}
 
-	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);
+	query = StringFormat("SELECT id FROM instance_list where id > %u ORDER BY id", count);
 	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;
 	}
 
-	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;
+	count++;
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		if (count < atoi(row[0]))
+		{
+			instance_id = count;
 			return true;
 		}
 
-		if (max_reserved_instance_id > max) {
+		if (count > max)
+		{
 			instance_id = 0;
 			return false;
 		}
 
-		max_reserved_instance_id++;
+		count++;
 	}
 
-	instance_id = max_reserved_instance_id;
-
+	instance_id = count;
 	return true;
 }
 
@@ -306,6 +276,36 @@ 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)
@@ -472,18 +472,23 @@ void Database::AssignRaidToInstance(uint32 raid_id, uint32 instance_id)
 }
 
 void Database::BuryCorpsesInInstance(uint16 instance_id) {
-	QueryDatabase(
-		fmt::format(
-			"UPDATE character_corpses SET is_buried = 1, instance_id = 0 WHERE instance_id = {}",
-			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);
 }
 
 void Database::DeleteInstance(uint16 instance_id)
 {
-	std::string query;
-	
+
+	std::string query = StringFormat("DELETE FROM instance_list WHERE id=%u", instance_id);
+	QueryDatabase(query);
+
 	query = StringFormat("DELETE FROM instance_list_player WHERE id=%u", instance_id);
 	QueryDatabase(query);
 
@@ -493,9 +498,6 @@ 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);
 }
 
@@ -546,46 +548,17 @@ void Database::GetCharactersInInstance(uint16 instance_id, std::list<uint32> &ch
 
 void Database::PurgeExpiredInstances()
 {
-
-	/**
-	 * 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
-		);
-
+	std::string query("SELECT id FROM instance_list where (start_time+duration) <= UNIX_TIMESTAMP() and never_expires = 0");
 	auto results = QueryDatabase(query);
 
-	if (!results.Success()) {
+	if (!results.Success())
 		return;
-	}
 
-	if (results.RowCount() == 0) {
+	if (results.RowCount() == 0)
 		return;
-	}
 
-	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));
+	for (auto row = results.begin(); row != results.end(); ++row)
+		DeleteInstance(atoi(row[0]));
 }
 
 void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
@@ -593,4 +566,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

@@ -1,366 +0,0 @@
-/**
- * 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,9 +2,8 @@
 #include <winsock2.h>
 #endif
 
-#include "misc_functions.h"
-#include "eqemu_logsys.h"
-#include "timer.h"
+#include "../common/misc_functions.h"
+#include "../common/eqemu_logsys.h"
 
 #include "dbcore.h"
 
@@ -15,51 +14,33 @@
 #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           = nullptr;
-	pUser           = nullptr;
-	pPassword       = nullptr;
-	pDatabase       = nullptr;
-	pCompress       = false;
-	pSSL            = false;
-	pStatus         = Closed;
+	pHost = 0;
+	pUser = 0;
+	pPassword = 0;
+	pDatabase = 0;
+	pCompress = false;
+	pSSL = false;
+	pStatus = Closed;
 }
 
-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;
-	}
-
+DBcore::~DBcore() {
 	mysql_close(&mysql);
 	safe_delete_array(pHost);
 	safe_delete_array(pUser);
@@ -68,8 +49,7 @@ 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;
@@ -83,44 +63,34 @@ MySQLRequestResult DBcore::QueryDatabase(std::string query, bool retryOnFailureO
 	return QueryDatabase(query.c_str(), query.length(), retryOnFailureOnce);
 }
 
-bool DBcore::DoesTableExist(std::string table_name)
+MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce)
 {
-	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) {
-				LogInfo("Database Error: Lost connection, attempting to recover");
+			if (retryOnFailureOnce)
+			{
+				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
 				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);
 
-				if (requestResult.Success()) {
-					LogInfo("Reconnection to database successful");
+				if (requestResult.Success())
+				{
+					std::cout << "Reconnection to database successful." << std::endl;
 					return requestResult;
 				}
 
@@ -132,170 +102,116 @@ 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));
 
-		/**
-		 * Error logging
-		 */
-		if (mysql_errno(&mysql) > 0 && strlen(query) > 0) {
-			LogMySQLError("[{}] [{}]\n[{}]", mysql_errno(&mysql), mysql_error(&mysql), query);
+		/* Implement Logging at the Root */
+		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
+			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
+				Log(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
-		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 (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
+	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())
-			);
+			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
 		}
 		else {
-			LogMySQLQuery(
-				"{0} ({1} row{2} affected) ({3}s)",
-				query,
-				requestResult.RowsAffected(),
-				requestResult.RowsAffected() == 1 ? "" : "s",
-				std::to_string(timer.elapsed())
-			);
+			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
 		}
 	}
 
 	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,57 +15,36 @@
 
 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; }
-	void SetMysql(MYSQL *mysql);
-
-	const std::string &GetOriginHost() const;
-	void SetOriginHost(const std::string &origin_host);
-
-	bool DoesTableExist(std::string table_name);
+	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
+	void	ping();
+	MYSQL*	getMySQL(){ return &mysql; }
 
 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
-	);
-
+	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 = nullptr, char *errbuf = nullptr);
+	bool	Open(uint32* errnum = 0, char* errbuf = 0);
 
-	MYSQL   mysql;
-	Mutex   MDatabase;
+	MYSQL	mysql;
+	Mutex	MDatabase;
 	eStatus pStatus;
 
-	std::string origin_host;
-
-	char   *pHost;
-	char   *pUser;
-	char   *pPassword;
-	char   *pDatabase;
-	bool   pCompress;
-	uint32 pPort;
-	bool   pSSL;
+	char*	pHost;
+	char*	pUser;
+	char*	pPassword;
+	char*	pDatabase;
+	bool	pCompress;
+	uint32	pPort;
+	bool	pSSL;
 
 };
 

common/deity.cpp

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

common/deity.h

@@ -23,7 +23,7 @@
 #include "types.h"
 
 
-namespace EQ
+namespace EQEmu
 {
 	namespace deity {
 		enum DeityType {

common/emu_constants.cpp

@@ -20,7 +20,7 @@
 #include "emu_constants.h"
 
 
-int16 EQ::invtype::GetInvTypeSize(int16 inv_type) {
+int16 EQEmu::invtype::GetInvTypeSize(int16 inv_type) {
 	static const int16 local_array[] = {
 		POSSESSIONS_SIZE,
 		BANK_SIZE,
@@ -55,7 +55,7 @@ int16 EQ::invtype::GetInvTypeSize(int16 inv_type) {
 	return local_array[inv_type];
 }
 
-const char* EQ::bug::CategoryIDToCategoryName(CategoryID category_id) {
+const char* EQEmu::bug::CategoryIDToCategoryName(CategoryID category_id) {
 	switch (category_id) {
 	case catVideo:
 		return "Video";
@@ -87,7 +87,7 @@ const char* EQ::bug::CategoryIDToCategoryName(CategoryID category_id) {
 	}
 }
 
-EQ::bug::CategoryID EQ::bug::CategoryNameToCategoryID(const char* category_name) {
+EQEmu::bug::CategoryID EQEmu::bug::CategoryNameToCategoryID(const char* category_name) {
 	if (!category_name)
 		return catOther;
 
@@ -119,7 +119,7 @@ EQ::bug::CategoryID EQ::bug::CategoryNameToCategoryID(const char* category_name)
 	return catOther;
 }
 
-const char *EQ::constants::GetStanceName(StanceType stance_type) {
+const char *EQEmu::constants::GetStanceName(StanceType stance_type) {
 	switch (stance_type) {
 	case stanceUnknown:
 		return "Unknown";
@@ -146,9 +146,9 @@ const char *EQ::constants::GetStanceName(StanceType stance_type) {
 	}
 }
 
-int EQ::constants::ConvertStanceTypeToIndex(StanceType stance_type) {
-	if (stance_type >= EQ::constants::stancePassive && stance_type <= EQ::constants::stanceBurnAE)
-		return (stance_type - EQ::constants::stancePassive);
+int EQEmu::constants::ConvertStanceTypeToIndex(StanceType stance_type) {
+	if (stance_type >= EQEmu::constants::stancePassive && stance_type <= EQEmu::constants::stanceBurnAE)
+		return (stance_type - EQEmu::constants::stancePassive);
 
 	return 0;
 }

common/emu_constants.h

@@ -27,7 +27,7 @@
 
 
 // local definitions are the result of using hybrid-client or server-only values and methods
-namespace EQ
+namespace EQEmu
 {
 	using RoF2::IINVALID;
 	using RoF2::INULL;
@@ -77,10 +77,6 @@ namespace EQ
 
 	} // 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;
@@ -193,7 +189,7 @@ namespace EQ
 	} // namespace invaug
 
 	namespace constants {
-		const EQ::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQ::versions::ClientVersion::Titanium;
+		const EQEmu::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQEmu::versions::ClientVersion::Titanium;
 
 		using RoF2::constants::EXPANSION;
 		using RoF2::constants::EXPANSION_BIT;
@@ -317,21 +313,12 @@ namespace EQ
 		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];
+	eq_limits.h:EQEmu::inventory::LookupEntry::InventoryTypeSize[n];
 
 */

common/emu_oplist.h

@@ -136,22 +136,20 @@ 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_DzExpeditionInvite),
-N(OP_DzExpeditionInviteResponse),
-N(OP_DzExpeditionLockoutTimers),
+N(OP_DzExpeditionList),
+N(OP_DzJoinExpeditionConfirm),
+N(OP_DzJoinExpeditionReply),
+N(OP_DzLeaderStatus),
 N(OP_DzListTimers),
 N(OP_DzMakeLeader),
 N(OP_DzMemberList),
-N(OP_DzMemberListName),
-N(OP_DzMemberListStatus),
+N(OP_DzMemberStatus),
 N(OP_DzPlayerList),
 N(OP_DzQuit),
 N(OP_DzRemovePlayer),
-N(OP_DzSetLeaderName),
 N(OP_DzSwapPlayer),
 N(OP_Emote),
 N(OP_EndLootRequest),
@@ -273,7 +271,6 @@ N(OP_ItemVerifyRequest),
 N(OP_ItemViewUnknown),
 N(OP_Jump),
 N(OP_KeyRing),
-N(OP_KickPlayers),
 N(OP_KnowledgeBase),
 N(OP_LDoNButton),
 N(OP_LDoNDisarmTraps),

common/emu_versions.cpp

@@ -21,7 +21,7 @@
 #include "emu_constants.h"
 
 
-bool EQ::versions::IsValidClientVersion(ClientVersion client_version)
+bool EQEmu::versions::IsValidClientVersion(ClientVersion client_version)
 {
 	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
 		return false;
@@ -29,7 +29,7 @@ bool EQ::versions::IsValidClientVersion(ClientVersion client_version)
 	return true;
 }
 
-EQ::versions::ClientVersion EQ::versions::ValidateClientVersion(ClientVersion client_version)
+EQEmu::versions::ClientVersion EQEmu::versions::ValidateClientVersion(ClientVersion client_version)
 {
 	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
 		return ClientVersion::Unknown;
@@ -37,7 +37,7 @@ EQ::versions::ClientVersion EQ::versions::ValidateClientVersion(ClientVersion cl
 	return client_version;
 }
 
-const char* EQ::versions::ClientVersionName(ClientVersion client_version)
+const char* EQEmu::versions::ClientVersionName(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Unknown:
@@ -61,7 +61,7 @@ const char* EQ::versions::ClientVersionName(ClientVersion client_version)
 	};
 }
 
-uint32 EQ::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
+uint32 EQEmu::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Titanium:
@@ -81,7 +81,7 @@ uint32 EQ::versions::ConvertClientVersionToClientVersionBit(ClientVersion client
 	}
 }
 
-EQ::versions::ClientVersion EQ::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
 {
 	switch (client_version_bit) {
 	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
@@ -101,7 +101,7 @@ EQ::versions::ClientVersion EQ::versions::ConvertClientVersionBitToClientVersion
 	}
 }
 
-bool EQ::versions::IsValidMobVersion(MobVersion mob_version)
+bool EQEmu::versions::IsValidMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
 		return false;
@@ -109,7 +109,7 @@ bool EQ::versions::IsValidMobVersion(MobVersion mob_version)
 	return true;
 }
 
-bool EQ::versions::IsValidPCMobVersion(MobVersion mob_version)
+bool EQEmu::versions::IsValidPCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
 		return false;
@@ -117,7 +117,7 @@ bool EQ::versions::IsValidPCMobVersion(MobVersion mob_version)
 	return true;
 }
 
-bool EQ::versions::IsValidNonPCMobVersion(MobVersion mob_version)
+bool EQEmu::versions::IsValidNonPCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
 		return false;
@@ -125,7 +125,7 @@ bool EQ::versions::IsValidNonPCMobVersion(MobVersion mob_version)
 	return true;
 }
 
-bool EQ::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
+bool EQEmu::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
 		return false;
@@ -133,7 +133,7 @@ bool EQ::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
 	return true;
 }
 
-EQ::versions::MobVersion EQ::versions::ValidateMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
 		return MobVersion::Unknown;
@@ -141,7 +141,7 @@ EQ::versions::MobVersion EQ::versions::ValidateMobVersion(MobVersion mob_version
 	return mob_version;
 }
 
-EQ::versions::MobVersion EQ::versions::ValidatePCMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidatePCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
 		return MobVersion::Unknown;
@@ -149,7 +149,7 @@ EQ::versions::MobVersion EQ::versions::ValidatePCMobVersion(MobVersion mob_versi
 	return mob_version;
 }
 
-EQ::versions::MobVersion EQ::versions::ValidateNonPCMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateNonPCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
 		return MobVersion::Unknown;
@@ -157,7 +157,7 @@ EQ::versions::MobVersion EQ::versions::ValidateNonPCMobVersion(MobVersion mob_ve
 	return mob_version;
 }
 
-EQ::versions::MobVersion EQ::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
 		return MobVersion::Unknown;
@@ -165,7 +165,7 @@ EQ::versions::MobVersion EQ::versions::ValidateOfflinePCMobVersion(MobVersion mo
 	return mob_version;
 }
 
-const char* EQ::versions::MobVersionName(MobVersion mob_version)
+const char* EQEmu::versions::MobVersionName(MobVersion mob_version)
 {
 	switch (mob_version) {
 	case MobVersion::Unknown:
@@ -217,7 +217,7 @@ const char* EQ::versions::MobVersionName(MobVersion mob_version)
 	};
 }
 
-EQ::versions::ClientVersion EQ::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
 {
 	switch (mob_version) {
 	case MobVersion::Unknown:
@@ -240,7 +240,7 @@ EQ::versions::ClientVersion EQ::versions::ConvertMobVersionToClientVersion(MobVe
 	}
 }
 
-EQ::versions::MobVersion EQ::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Unknown:
@@ -263,7 +263,7 @@ EQ::versions::MobVersion EQ::versions::ConvertClientVersionToMobVersion(ClientVe
 	}
 }
 
-EQ::versions::MobVersion EQ::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
 {
 	switch (mob_version) {
 	case MobVersion::Titanium:
@@ -283,7 +283,7 @@ EQ::versions::MobVersion EQ::versions::ConvertPCMobVersionToOfflinePCMobVersion(
 	}
 }
 
-EQ::versions::MobVersion EQ::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
 {
 	switch (mob_version) {
 	case MobVersion::OfflineTitanium:
@@ -303,7 +303,7 @@ EQ::versions::MobVersion EQ::versions::ConvertOfflinePCMobVersionToPCMobVersion(
 	}
 }
 
-EQ::versions::ClientVersion EQ::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
 {
 	switch (mob_version) {
 	case MobVersion::OfflineTitanium:
@@ -323,7 +323,7 @@ EQ::versions::ClientVersion EQ::versions::ConvertOfflinePCMobVersionToClientVers
 	}
 }
 
-EQ::versions::MobVersion EQ::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Titanium:
@@ -343,7 +343,7 @@ EQ::versions::MobVersion EQ::versions::ConvertClientVersionToOfflinePCMobVersion
 	}
 }
 
-const char* EQ::expansions::ExpansionName(Expansion expansion)
+const char* EQEmu::expansions::ExpansionName(Expansion expansion)
 {
 	switch (expansion) {
 	case Expansion::EverQuest:
@@ -393,12 +393,12 @@ const char* EQ::expansions::ExpansionName(Expansion expansion)
 	}
 }
 
-const char* EQ::expansions::ExpansionName(uint32 expansion_bit)
+const char* EQEmu::expansions::ExpansionName(uint32 expansion_bit)
 {
 	return ExpansionName(ConvertExpansionBitToExpansion(expansion_bit));
 }
 
-uint32 EQ::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
+uint32 EQEmu::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
 {
 	switch (expansion) {
 	case Expansion::RoK:
@@ -446,7 +446,7 @@ uint32 EQ::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
 	}
 }
 
-EQ::expansions::Expansion EQ::expansions::ConvertExpansionBitToExpansion(uint32 expansion_bit)
+EQEmu::expansions::Expansion EQEmu::expansions::ConvertExpansionBitToExpansion(uint32 expansion_bit)
 {
 	switch (expansion_bit) {
 	case bitRoK:
@@ -494,7 +494,7 @@ EQ::expansions::Expansion EQ::expansions::ConvertExpansionBitToExpansion(uint32
 	}
 }
 
-uint32 EQ::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
+uint32 EQEmu::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
 {
 	switch (expansion) {
 	case Expansion::RoK:
@@ -542,17 +542,42 @@ uint32 EQ::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
 	}
 }
 
-EQ::expansions::Expansion EQ::expansions::ConvertClientVersionToExpansion(versions::ClientVersion client_version)
+EQEmu::expansions::Expansion EQEmu::expansions::ConvertClientVersionToExpansion(versions::ClientVersion client_version)
 {
-	return EQ::constants::StaticLookup(client_version)->Expansion;
+	return EQEmu::constants::StaticLookup(client_version)->Expansion;
 }
 
-uint32 EQ::expansions::ConvertClientVersionToExpansionBit(versions::ClientVersion client_version)
+uint32 EQEmu::expansions::ConvertClientVersionToExpansionBit(versions::ClientVersion client_version)
 {
-	return EQ::constants::StaticLookup(client_version)->ExpansionBit;
+	return EQEmu::constants::StaticLookup(client_version)->ExpansionBit;
 }
 
-uint32 EQ::expansions::ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version)
+uint32 EQEmu::expansions::ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version)
 {
-	return EQ::constants::StaticLookup(client_version)->ExpansionsMask;
+	return EQEmu::constants::StaticLookup(client_version)->ExpansionsMask;
+}
+
+uint32 EQEmu::expansions::ConvertExpansionMaskToLatestExpansion(uint32 expansion_mask)
+{
+	if ((expansion_mask & bitRoK) == bitRoK) return static_cast<uint32>(Expansion::RoK);
+	if ((expansion_mask & bitSoV) == bitSoV) return static_cast<uint32>(Expansion::SoV);
+	if ((expansion_mask & bitSoL) == bitSoL) return static_cast<uint32>(Expansion::SoL);
+	if ((expansion_mask & bitPoP) == bitPoP) return static_cast<uint32>(Expansion::PoP);
+	if ((expansion_mask & bitLoY) == bitLoY) return static_cast<uint32>(Expansion::LoY);
+	if ((expansion_mask & bitLDoN) == bitLDoN) return static_cast<uint32>(Expansion::LDoN);
+	if ((expansion_mask & bitGoD) == bitGoD) return static_cast<uint32>(Expansion::GoD);
+	if ((expansion_mask & bitOoW) == bitOoW) return static_cast<uint32>(Expansion::OoW);
+	if ((expansion_mask & bitDoN) == bitDoN) return static_cast<uint32>(Expansion::DoN);
+	if ((expansion_mask & bitDoD) == bitDoD) return static_cast<uint32>(Expansion::DoD);
+	if ((expansion_mask & bitPoR) == bitPoR) return static_cast<uint32>(Expansion::PoR);
+	if ((expansion_mask & bitTSS) == bitTSS) return static_cast<uint32>(Expansion::TSS);
+	if ((expansion_mask & bitTBS) == bitTBS) return static_cast<uint32>(Expansion::TBS);
+	if ((expansion_mask & bitSoF) == bitSoF) return static_cast<uint32>(Expansion::SoF);
+	if ((expansion_mask & bitSoD) == bitSoD) return static_cast<uint32>(Expansion::SoD);
+	if ((expansion_mask & bitUF) == bitUF) return static_cast<uint32>(Expansion::UF);
+	if ((expansion_mask & bitHoT) == bitHoT) return static_cast<uint32>(Expansion::HoT);
+	if ((expansion_mask & bitVoA) == bitVoA) return static_cast<uint32>(Expansion::VoA);
+	if ((expansion_mask & bitRoF) == bitRoF) return static_cast<uint32>(Expansion::RoF);
+	if ((expansion_mask & bitCotF) == bitCotF) return static_cast<uint32>(Expansion::CotF);
+	return static_cast<uint32>(Expansion::EverQuest);
 }

common/emu_versions.h

@@ -25,7 +25,7 @@
 #include <stdlib.h>
 
 
-namespace EQ
+namespace EQEmu
 {
 	namespace versions {
 		enum class ClientVersion : uint32 {
@@ -214,7 +214,7 @@ namespace EQ
 		Expansion ConvertClientVersionToExpansion(versions::ClientVersion client_version);
 		uint32 ConvertClientVersionToExpansionBit(versions::ClientVersion client_version);
 		uint32 ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version);
-
+		uint32 ConvertExpansionMaskToLatestExpansion(uint32 expansion_mask);
 	} /*expansions*/
 
 } /*EQEmu*/

common/eq_constants.h

@@ -71,7 +71,7 @@
 //#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
@@ -87,114 +87,199 @@ typedef enum {
 	_eaMaxAppearance
 } EmuAppearance;
 
-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;
+// 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
 
-	/**
-	 * 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;
+// 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,
 };
 
 //ZoneChange_Struct->success values
@@ -318,7 +403,7 @@ static const uint8 DamageTypeUnknown	= 0xFF;
 **
 **	(indexed by 'Skill' of SkillUseTypes)
 */
-static const uint8 SkillDamageTypes[EQ::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
+static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
 {
 /*1HBlunt*/					0,
 /*1HSlashing*/				1,
@@ -438,30 +523,4 @@ static const uint8 SkillDamageTypes[EQ::skills::HIGHEST_SKILL + 1] = // change t
 
 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.cpp

@@ -25,7 +25,7 @@
 
 
 static bool global_dictionary_init = false;
-void EQ::InitializeDynamicLookups() {
+void EQEmu::InitializeDynamicLookups() {
 	if (global_dictionary_init == true)
 		return;
 
@@ -37,12 +37,12 @@ void EQ::InitializeDynamicLookups() {
 	global_dictionary_init = true;
 }
 
-static std::unique_ptr<EQ::constants::LookupEntry> constants_dynamic_nongm_lookup_entries[EQ::versions::ClientVersionCount];
-static std::unique_ptr<EQ::constants::LookupEntry> constants_dynamic_gm_lookup_entries[EQ::versions::ClientVersionCount];
-static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::versions::ClientVersionCount] =
+static std::unique_ptr<EQEmu::constants::LookupEntry> constants_dynamic_nongm_lookup_entries[EQEmu::versions::ClientVersionCount];
+static std::unique_ptr<EQEmu::constants::LookupEntry> constants_dynamic_gm_lookup_entries[EQEmu::versions::ClientVersionCount];
+static const EQEmu::constants::LookupEntry constants_static_lookup_entries[EQEmu::versions::ClientVersionCount] =
 {
 	/*[ClientVersion::Unknown] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		ClientUnknown::constants::EXPANSION,
 		ClientUnknown::constants::EXPANSION_BIT,
 		ClientUnknown::constants::EXPANSIONS_MASK,
@@ -50,7 +50,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		ClientUnknown::INULL
 	),
 	/*[ClientVersion::Client62] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		Client62::constants::EXPANSION,
 		Client62::constants::EXPANSION_BIT,
 		Client62::constants::EXPANSIONS_MASK,
@@ -58,7 +58,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		Client62::INULL
 	),
 	/*[ClientVersion::Titanium] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		Titanium::constants::EXPANSION,
 		Titanium::constants::EXPANSION_BIT,
 		Titanium::constants::EXPANSIONS_MASK,
@@ -66,7 +66,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		Titanium::constants::SAY_LINK_BODY_SIZE
 	),
 	/*[ClientVersion::SoF] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		SoF::constants::EXPANSION,
 		SoF::constants::EXPANSION_BIT,
 		SoF::constants::EXPANSIONS_MASK,
@@ -74,7 +74,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		SoF::constants::SAY_LINK_BODY_SIZE
 	),
 	/*[ClientVersion::SoD] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		SoD::constants::EXPANSION,
 		SoD::constants::EXPANSION_BIT,
 		SoD::constants::EXPANSIONS_MASK,
@@ -82,7 +82,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		SoD::constants::SAY_LINK_BODY_SIZE
 	),
 	/*[ClientVersion::UF] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		UF::constants::EXPANSION,
 		UF::constants::EXPANSION_BIT,
 		UF::constants::EXPANSIONS_MASK,
@@ -90,7 +90,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		UF::constants::SAY_LINK_BODY_SIZE
 	),
 	/*[ClientVersion::RoF] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		RoF::constants::EXPANSION,
 		RoF::constants::EXPANSION_BIT,
 		RoF::constants::EXPANSIONS_MASK,
@@ -98,7 +98,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 		RoF::constants::SAY_LINK_BODY_SIZE
 	),
 	/*[ClientVersion::RoF2] =*/
-	EQ::constants::LookupEntry(
+	EQEmu::constants::LookupEntry(
 		RoF2::constants::EXPANSION,
 		RoF2::constants::EXPANSION_BIT,
 		RoF2::constants::EXPANSIONS_MASK,
@@ -108,7 +108,7 @@ static const EQ::constants::LookupEntry constants_static_lookup_entries[EQ::vers
 };
 
 static bool constants_dictionary_init = false;
-void EQ::constants::InitializeDynamicLookups() {
+void EQEmu::constants::InitializeDynamicLookups() {
 	if (constants_dictionary_init == true)
 		return;
 	constants_dictionary_init = true;
@@ -119,7 +119,7 @@ void EQ::constants::InitializeDynamicLookups() {
 	// use static references for now
 }
 
-const EQ::constants::LookupEntry* EQ::constants::DynamicLookup(versions::ClientVersion client_version, bool gm_flag)
+const EQEmu::constants::LookupEntry* EQEmu::constants::DynamicLookup(versions::ClientVersion client_version, bool gm_flag)
 {
 	if (gm_flag)
 		return DynamicGMLookup(client_version);
@@ -127,7 +127,7 @@ const EQ::constants::LookupEntry* EQ::constants::DynamicLookup(versions::ClientV
 		return DynamicNonGMLookup(client_version);
 }
 
-const EQ::constants::LookupEntry* EQ::constants::DynamicNonGMLookup(versions::ClientVersion client_version)
+const EQEmu::constants::LookupEntry* EQEmu::constants::DynamicNonGMLookup(versions::ClientVersion client_version)
 {
 	client_version = versions::ValidateClientVersion(client_version);
 	if (constants_dynamic_nongm_lookup_entries[static_cast<int>(client_version)])
@@ -136,7 +136,7 @@ const EQ::constants::LookupEntry* EQ::constants::DynamicNonGMLookup(versions::Cl
 	return &constants_static_lookup_entries[static_cast<int>(client_version)];
 }
 
-const EQ::constants::LookupEntry* EQ::constants::DynamicGMLookup(versions::ClientVersion client_version)
+const EQEmu::constants::LookupEntry* EQEmu::constants::DynamicGMLookup(versions::ClientVersion client_version)
 {
 	client_version = versions::ValidateClientVersion(client_version);
 	if (constants_dynamic_gm_lookup_entries[static_cast<int>(client_version)])
@@ -145,18 +145,18 @@ const EQ::constants::LookupEntry* EQ::constants::DynamicGMLookup(versions::Clien
 	return &constants_static_lookup_entries[static_cast<int>(client_version)];
 }
 
-const EQ::constants::LookupEntry* EQ::constants::StaticLookup(versions::ClientVersion client_version)
+const EQEmu::constants::LookupEntry* EQEmu::constants::StaticLookup(versions::ClientVersion client_version)
 {
 	return &constants_static_lookup_entries[static_cast<int>(versions::ValidateClientVersion(client_version))];
 }
 
-static std::unique_ptr<EQ::inventory::LookupEntry> inventory_dynamic_nongm_lookup_entries[EQ::versions::MobVersionCount];
-static std::unique_ptr<EQ::inventory::LookupEntry> inventory_dynamic_gm_lookup_entries[EQ::versions::MobVersionCount];
-static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::versions::MobVersionCount] =
+static std::unique_ptr<EQEmu::inventory::LookupEntry> inventory_dynamic_nongm_lookup_entries[EQEmu::versions::MobVersionCount];
+static std::unique_ptr<EQEmu::inventory::LookupEntry> inventory_dynamic_gm_lookup_entries[EQEmu::versions::MobVersionCount];
+static const EQEmu::inventory::LookupEntry inventory_static_lookup_entries[EQEmu::versions::MobVersionCount] =
 {
 	/*[MobVersion::Unknown] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
 			ClientUnknown::INULL, ClientUnknown::INULL, ClientUnknown::INULL,
@@ -182,8 +182,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::Client62] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			Client62::INULL, Client62::INULL, Client62::INULL,
 			Client62::INULL, Client62::INULL, Client62::INULL,
 			Client62::INULL, Client62::INULL, Client62::INULL,
@@ -209,9 +209,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::Titanium] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,		Titanium::invtype::BANK_SIZE,			Titanium::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,		Titanium::invtype::BANK_SIZE,			Titanium::invtype::SHARED_BANK_SIZE,
 			Titanium::invtype::TRADE_SIZE,			Titanium::invtype::WORLD_SIZE,			Titanium::invtype::LIMBO_SIZE,
 			Titanium::invtype::TRIBUTE_SIZE,		Titanium::INULL,						Titanium::invtype::GUILD_TRIBUTE_SIZE,
 			Titanium::invtype::MERCHANT_SIZE,		Titanium::INULL,						Titanium::invtype::CORPSE_SIZE,
@@ -236,9 +236,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		Titanium::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::SoF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,	SoF::invtype::BANK_SIZE,			SoF::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,	SoF::invtype::BANK_SIZE,			SoF::invtype::SHARED_BANK_SIZE,
 			SoF::invtype::TRADE_SIZE,			SoF::invtype::WORLD_SIZE,			SoF::invtype::LIMBO_SIZE,
 			SoF::invtype::TRIBUTE_SIZE,			SoF::INULL,							SoF::invtype::GUILD_TRIBUTE_SIZE,
 			SoF::invtype::MERCHANT_SIZE,		SoF::INULL,							SoF::invtype::CORPSE_SIZE,
@@ -263,9 +263,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		SoF::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::SoD] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,	SoD::invtype::BANK_SIZE,			SoD::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,	SoD::invtype::BANK_SIZE,			SoD::invtype::SHARED_BANK_SIZE,
 			SoD::invtype::TRADE_SIZE,			SoD::invtype::WORLD_SIZE,			SoD::invtype::LIMBO_SIZE,
 			SoD::invtype::TRIBUTE_SIZE,			SoD::INULL,							SoD::invtype::GUILD_TRIBUTE_SIZE,
 			SoD::invtype::MERCHANT_SIZE,		SoD::INULL,							SoD::invtype::CORPSE_SIZE,
@@ -290,9 +290,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		SoD::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::UF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,	UF::invtype::BANK_SIZE,				UF::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,	UF::invtype::BANK_SIZE,				UF::invtype::SHARED_BANK_SIZE,
 			UF::invtype::TRADE_SIZE,			UF::invtype::WORLD_SIZE,			UF::invtype::LIMBO_SIZE,
 			UF::invtype::TRIBUTE_SIZE,			UF::INULL,							UF::invtype::GUILD_TRIBUTE_SIZE,
 			UF::invtype::MERCHANT_SIZE,			UF::INULL,							UF::invtype::CORPSE_SIZE,
@@ -317,9 +317,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		UF::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::RoF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,	RoF::invtype::BANK_SIZE,					RoF::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,	RoF::invtype::BANK_SIZE,					RoF::invtype::SHARED_BANK_SIZE,
 			RoF::invtype::TRADE_SIZE,			RoF::invtype::WORLD_SIZE,					RoF::invtype::LIMBO_SIZE,
 			RoF::invtype::TRIBUTE_SIZE,			RoF::invtype::TROPHY_TRIBUTE_SIZE,			RoF::invtype::GUILD_TRIBUTE_SIZE,
 			RoF::invtype::MERCHANT_SIZE,		RoF::invtype::DELETED_SIZE,					RoF::invtype::CORPSE_SIZE,
@@ -344,9 +344,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		RoF::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::RoF2] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,	RoF2::invtype::BANK_SIZE,					RoF2::invtype::SHARED_BANK_SIZE,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,	RoF2::invtype::BANK_SIZE,					RoF2::invtype::SHARED_BANK_SIZE,
 			RoF2::invtype::TRADE_SIZE,			RoF2::invtype::WORLD_SIZE,					RoF2::invtype::LIMBO_SIZE,
 			RoF2::invtype::TRIBUTE_SIZE,		RoF2::invtype::TROPHY_TRIBUTE_SIZE,			RoF2::invtype::GUILD_TRIBUTE_SIZE,
 			RoF2::invtype::MERCHANT_SIZE,		RoF2::invtype::DELETED_SIZE,				RoF2::invtype::CORPSE_SIZE,
@@ -371,9 +371,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		RoF2::inventory::AllowOverLevelEquipment
 	),
 	/*[MobVersion::NPC] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE,		EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE,		EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
 			EntityLimits::NPC::invtype::TRADE_SIZE,	EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
 			EntityLimits::NPC::INULL,				EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL,
 			EntityLimits::NPC::INULL,				EntityLimits::NPC::INULL,	EntityLimits::NPC::INULL, /*InvTypeCorpseSize,*/
@@ -389,8 +389,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::NPC::INULL,
 		EntityLimits::NPC::INULL,
 		EntityLimits::NPC::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -398,9 +398,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::NPCMerchant] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
 			EntityLimits::NPCMerchant::invtype::TRADE_SIZE,					EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
 			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL,
 			EntityLimits::NPCMerchant::INULL,								EntityLimits::NPCMerchant::INULL,	EntityLimits::NPCMerchant::INULL, /*InvTypeCorpseSize,*/
@@ -416,8 +416,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::NPCMerchant::INULL,
 		EntityLimits::NPCMerchant::INULL,
 		EntityLimits::NPCMerchant::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -425,9 +425,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::Merc] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
 			EntityLimits::Merc::invtype::TRADE_SIZE,						EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
 			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL,
 			EntityLimits::Merc::INULL,										EntityLimits::Merc::INULL,	EntityLimits::Merc::INULL, /*InvTypeCorpseSize,*/
@@ -443,8 +443,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::Merc::INULL,
 		EntityLimits::Merc::INULL,
 		EntityLimits::Merc::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -452,9 +452,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::Bot] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
 			EntityLimits::Bot::invtype::TRADE_SIZE,							EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
 			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL,
 			EntityLimits::Bot::INULL,										EntityLimits::Bot::INULL,	EntityLimits::Bot::INULL, /*InvTypeCorpseSize,*/
@@ -470,8 +470,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::Bot::invslot::CURSOR_BITMASK,
 		EntityLimits::Bot::invslot::POSSESSIONS_BITMASK,
 		EntityLimits::Bot::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		EQ::invaug::SOCKET_COUNT, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		EQEmu::invaug::SOCKET_COUNT, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -479,9 +479,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::ClientPet] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
 			EntityLimits::ClientPet::invtype::TRADE_SIZE,					EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
 			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL,
 			EntityLimits::ClientPet::INULL,									EntityLimits::ClientPet::INULL,	EntityLimits::ClientPet::INULL, /*InvTypeCorpseSize,*/
@@ -497,8 +497,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::ClientPet::INULL,
 		EntityLimits::ClientPet::INULL,
 		EntityLimits::ClientPet::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -506,9 +506,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::NPCPet] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
 			EntityLimits::NPCPet::invtype::TRADE_SIZE,						EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
 			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL,
 			EntityLimits::NPCPet::INULL,									EntityLimits::NPCPet::INULL,	EntityLimits::NPCPet::INULL, /*InvTypeCorpseSize,*/
@@ -524,8 +524,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::NPCPet::INULL,
 		EntityLimits::NPCPet::INULL,
 		EntityLimits::NPCPet::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -533,9 +533,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::MercPet] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
 			EntityLimits::MercPet::invtype::TRADE_SIZE,						EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
 			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL,
 			EntityLimits::MercPet::INULL,									EntityLimits::MercPet::INULL,	EntityLimits::MercPet::INULL, /*InvTypeCorpseSize,*/
@@ -551,8 +551,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::MercPet::INULL,
 		EntityLimits::MercPet::INULL,
 		EntityLimits::MercPet::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -560,9 +560,9 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::BotPet] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
-			EQ::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
+			EQEmu::invtype::POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/	EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
 			EntityLimits::BotPet::invtype::TRADE_SIZE,						EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
 			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL,
 			EntityLimits::BotPet::INULL,									EntityLimits::BotPet::INULL,	EntityLimits::BotPet::INULL, /*InvTypeCorpseSize,*/
@@ -578,8 +578,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		EntityLimits::BotPet::INULL,
 		EntityLimits::BotPet::INULL,
 		EntityLimits::BotPet::INULL,
-		0, //EQ::inventory::ContainerCount, /*ItemBagSize,*/
-		0, //EQ::inventory::SocketCount, /*ItemAugSize,*/
+		0, //EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
+		0, //EQEmu::inventory::SocketCount, /*ItemAugSize,*/
 
 		false,
 		false,
@@ -587,8 +587,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineTitanium] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			Titanium::INULL,						Titanium::INULL,						Titanium::INULL,
 			Titanium::invtype::TRADE_SIZE,			Titanium::INULL,						Titanium::INULL,
 			Titanium::INULL,						Titanium::INULL,						Titanium::INULL,
@@ -614,8 +614,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineSoF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			SoF::INULL,							SoF::INULL,							SoF::INULL,
 			SoF::invtype::TRADE_SIZE,			SoF::INULL,							SoF::INULL,
 			SoF::INULL,							SoF::INULL,							SoF::INULL,
@@ -641,8 +641,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineSoD] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			SoD::INULL,							SoD::INULL,							SoD::INULL,
 			SoD::invtype::TRADE_SIZE,			SoD::INULL,							SoD::INULL,
 			SoD::INULL,							SoD::INULL,							SoD::INULL,
@@ -668,8 +668,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineUF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			UF::INULL,							UF::INULL,							UF::INULL,
 			UF::invtype::TRADE_SIZE,			UF::INULL,							UF::INULL,
 			UF::INULL,							UF::INULL,							UF::INULL,
@@ -695,8 +695,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineRoF] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			RoF::INULL,							RoF::INULL,							RoF::INULL,
 			RoF::invtype::TRADE_SIZE,			RoF::INULL,							RoF::INULL,
 			RoF::INULL,							RoF::INULL,							RoF::INULL,
@@ -722,8 +722,8 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 		false
 	),
 	/*[MobVersion::OfflineRoF2] =*/
-	EQ::inventory::LookupEntry(
-		EQ::inventory::LookupEntry::InventoryTypeSize_Struct(
+	EQEmu::inventory::LookupEntry(
+		EQEmu::inventory::LookupEntry::InventoryTypeSize_Struct(
 			RoF2::INULL,						RoF2::INULL,						RoF2::INULL,
 			RoF2::invtype::TRADE_SIZE,			RoF2::INULL,						RoF2::INULL,
 			RoF2::INULL,						RoF2::INULL,						RoF2::INULL,
@@ -751,7 +751,7 @@ static const EQ::inventory::LookupEntry inventory_static_lookup_entries[EQ::vers
 };
 
 static bool inventory_dictionary_init = false;
-void EQ::inventory::InitializeDynamicLookups() {
+void EQEmu::inventory::InitializeDynamicLookups() {
 	if (inventory_dictionary_init == true)
 		return;
 	inventory_dictionary_init = true;
@@ -774,9 +774,9 @@ void EQ::inventory::InitializeDynamicLookups() {
 
 	const uint32 dynamic_check_mask = 
 		(
-			EQ::expansions::bitPoR |
-			EQ::expansions::bitTBS |
-			EQ::expansions::bitHoT
+			EQEmu::expansions::bitPoR |
+			EQEmu::expansions::bitTBS |
+			EQEmu::expansions::bitHoT
 		);
 
 	// if all of the above expansion bits are present, then static references will suffice
@@ -784,7 +784,7 @@ void EQ::inventory::InitializeDynamicLookups() {
 		return;
 
 	// Dynamic Lookups (promotive methodology) (all mob versions allowed)
-	for (uint32 iter = static_cast<uint32>(EQ::versions::MobVersion::Unknown); iter <= static_cast<uint32>(EQ::versions::LastPCMobVersion); ++iter) {
+	for (uint32 iter = static_cast<uint32>(EQEmu::versions::MobVersion::Unknown); iter <= static_cast<uint32>(EQEmu::versions::LastPCMobVersion); ++iter) {
 		// no need to dynamic this condition since it is the lowest compatibility standard
 		if ((dynamic_check_mask & ~constants_static_lookup_entries[iter].ExpansionsMask) == dynamic_check_mask)
 			continue;
@@ -803,21 +803,21 @@ void EQ::inventory::InitializeDynamicLookups() {
 		inventory_dynamic_nongm_lookup_entries[iter]->PossessionsBitmask = 0; // we'll fix later
 		inventory_dynamic_nongm_lookup_entries[iter]->CorpseBitmask = 0; // we'll fix later
 
-		if (RuleI(World, ExpansionSettings) & EQ::expansions::bitPoR) {
+		if (RuleI(World, ExpansionSettings) & EQEmu::expansions::bitPoR) {
 			// update bank size
-			if (constants_static_lookup_entries[iter].ExpansionsMask & EQ::expansions::bitPoR)
+			if (constants_static_lookup_entries[iter].ExpansionsMask & EQEmu::expansions::bitPoR)
 				inventory_dynamic_nongm_lookup_entries[iter]->InventoryTypeSize.Bank = SoF::invtype::BANK_SIZE;
 		}
 
-		if (RuleI(World, ExpansionSettings) & EQ::expansions::bitTBS) {
+		if (RuleI(World, ExpansionSettings) & EQEmu::expansions::bitTBS) {
 			// update power source
-			if (constants_static_lookup_entries[iter].ExpansionsMask & EQ::expansions::bitTBS)
+			if (constants_static_lookup_entries[iter].ExpansionsMask & EQEmu::expansions::bitTBS)
 				inventory_dynamic_nongm_lookup_entries[iter]->EquipmentBitmask = SoF::invslot::EQUIPMENT_BITMASK;
 		}
 
-		if (RuleI(World, ExpansionSettings) & EQ::expansions::bitHoT) {
+		if (RuleI(World, ExpansionSettings) & EQEmu::expansions::bitHoT) {
 			// update general size
-			if (constants_static_lookup_entries[iter].ExpansionsMask & EQ::expansions::bitHoT)
+			if (constants_static_lookup_entries[iter].ExpansionsMask & EQEmu::expansions::bitHoT)
 				inventory_dynamic_nongm_lookup_entries[iter]->GeneralBitmask = RoF::invslot::GENERAL_BITMASK;
 		}
 
@@ -841,7 +841,7 @@ void EQ::inventory::InitializeDynamicLookups() {
 	}
 
 	// Dynamic GM Lookups (demotive methodology) (client-linked mob versions only)
-	for (uint32 iter = static_cast<uint32>(EQ::versions::MobVersion::Unknown); iter <= static_cast<uint32>(EQ::versions::LastPCMobVersion); ++iter) {
+	for (uint32 iter = static_cast<uint32>(EQEmu::versions::MobVersion::Unknown); iter <= static_cast<uint32>(EQEmu::versions::LastPCMobVersion); ++iter) {
 		// no need to dynamic this condition since it is the lowest compatibility standard
 		if ((dynamic_check_mask & ~constants_static_lookup_entries[iter].ExpansionsMask) == dynamic_check_mask)
 			continue;
@@ -869,13 +869,13 @@ void EQ::inventory::InitializeDynamicLookups() {
 		inventory_dynamic_gm_lookup_entries[iter]->PossessionsBitmask = 0; // we'll fix later
 		inventory_dynamic_gm_lookup_entries[iter]->CorpseBitmask = 0; // we'll fix later
 
-		if (~RuleI(World, ExpansionSettings) & EQ::expansions::bitPoR) {
+		if (~RuleI(World, ExpansionSettings) & EQEmu::expansions::bitPoR) {
 			// update bank size
-			if (constants_static_lookup_entries[iter].ExpansionsMask & EQ::expansions::bitPoR)
+			if (constants_static_lookup_entries[iter].ExpansionsMask & EQEmu::expansions::bitPoR)
 				inventory_dynamic_gm_lookup_entries[iter]->InventoryTypeSize.Bank = Titanium::invtype::BANK_SIZE;
 		}
 
-		if (~RuleI(World, ExpansionSettings) & EQ::expansions::bitTBS) {
+		if (~RuleI(World, ExpansionSettings) & EQEmu::expansions::bitTBS) {
 			// update power source
 			switch (iter) {
 			case versions::bitUF:
@@ -890,7 +890,7 @@ void EQ::inventory::InitializeDynamicLookups() {
 			}
 		}
 
-		if (~RuleI(World, ExpansionSettings) & EQ::expansions::bitHoT) {
+		if (~RuleI(World, ExpansionSettings) & EQEmu::expansions::bitHoT) {
 			// update general size
 			switch (iter) {
 			case versions::bitUF:
@@ -927,7 +927,7 @@ void EQ::inventory::InitializeDynamicLookups() {
 	// only client versions that require a change from their static definitions have been given a dynamic (gm) lookup entry
 }
 
-const EQ::inventory::LookupEntry* EQ::inventory::DynamicLookup(versions::MobVersion mob_version, bool gm_flag)
+const EQEmu::inventory::LookupEntry* EQEmu::inventory::DynamicLookup(versions::MobVersion mob_version, bool gm_flag)
 {
 	if (gm_flag)
 		return DynamicGMLookup(mob_version);
@@ -935,7 +935,7 @@ const EQ::inventory::LookupEntry* EQ::inventory::DynamicLookup(versions::MobVers
 		return DynamicNonGMLookup(mob_version);
 }
 
-const EQ::inventory::LookupEntry* EQ::inventory::DynamicNonGMLookup(versions::MobVersion mob_version)
+const EQEmu::inventory::LookupEntry* EQEmu::inventory::DynamicNonGMLookup(versions::MobVersion mob_version)
 {
 	mob_version = versions::ValidateMobVersion(mob_version);
 	if (inventory_dynamic_nongm_lookup_entries[static_cast<int>(mob_version)])
@@ -944,7 +944,7 @@ const EQ::inventory::LookupEntry* EQ::inventory::DynamicNonGMLookup(versions::Mo
 	return &inventory_static_lookup_entries[static_cast<int>(mob_version)];
 }
 
-const EQ::inventory::LookupEntry* EQ::inventory::DynamicGMLookup(versions::MobVersion mob_version)
+const EQEmu::inventory::LookupEntry* EQEmu::inventory::DynamicGMLookup(versions::MobVersion mob_version)
 {
 	mob_version = versions::ValidateMobVersion(mob_version);
 	if (inventory_dynamic_gm_lookup_entries[static_cast<int>(mob_version)])
@@ -953,107 +953,107 @@ const EQ::inventory::LookupEntry* EQ::inventory::DynamicGMLookup(versions::MobVe
 	return &inventory_static_lookup_entries[static_cast<int>(mob_version)];
 }
 
-const EQ::inventory::LookupEntry* EQ::inventory::StaticLookup(versions::MobVersion mob_version)
+const EQEmu::inventory::LookupEntry* EQEmu::inventory::StaticLookup(versions::MobVersion mob_version)
 {
 	return &inventory_static_lookup_entries[static_cast<int>(versions::ValidateMobVersion(mob_version))];
 }
 
-static std::unique_ptr<EQ::behavior::LookupEntry> behavior_dynamic_nongm_lookup_entries[EQ::versions::MobVersionCount];
-static std::unique_ptr<EQ::behavior::LookupEntry> behavior_dynamic_gm_lookup_entries[EQ::versions::MobVersionCount];
-static const EQ::behavior::LookupEntry behavior_static_lookup_entries[EQ::versions::MobVersionCount] =
+static std::unique_ptr<EQEmu::behavior::LookupEntry> behavior_dynamic_nongm_lookup_entries[EQEmu::versions::MobVersionCount];
+static std::unique_ptr<EQEmu::behavior::LookupEntry> behavior_dynamic_gm_lookup_entries[EQEmu::versions::MobVersionCount];
+static const EQEmu::behavior::LookupEntry behavior_static_lookup_entries[EQEmu::versions::MobVersionCount] =
 {
 	/*[MobVersion::Unknown] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		true
 	),
 	/*[MobVersion::Client62] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		true
 	),
 	/*[MobVersion::Titanium] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		Titanium::behavior::CoinHasWeight
 	),
 	/*[MobVersion::SoF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		SoF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::SoD] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		SoD::behavior::CoinHasWeight
 	),
 	/*[MobVersion::UF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		UF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::RoF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		RoF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::RoF2] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		RoF2::behavior::CoinHasWeight
 	),
 	/*[MobVersion::NPC] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::NPCMerchant] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::Merc] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::Bot] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::ClientPet] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::NPCPet] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::MercPet] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::BotPet] =*/
-	EQ::behavior::LookupEntry(
-		EQ::behavior::CoinHasWeight
+	EQEmu::behavior::LookupEntry(
+		EQEmu::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineTitanium] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		Titanium::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineSoF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		SoF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineSoD] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		SoD::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineUF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		UF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineRoF] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		RoF::behavior::CoinHasWeight
 	),
 	/*[MobVersion::OfflineRoF2] =*/
-	EQ::behavior::LookupEntry(
+	EQEmu::behavior::LookupEntry(
 		RoF2::behavior::CoinHasWeight
 	)
 };
 
 static bool behavior_dictionary_init = false;
-void EQ::behavior::InitializeDynamicLookups() {
+void EQEmu::behavior::InitializeDynamicLookups() {
 	if (behavior_dictionary_init == true)
 		return;
 	behavior_dictionary_init = true;
@@ -1064,7 +1064,7 @@ void EQ::behavior::InitializeDynamicLookups() {
 	// use static references for now
 }
 
-const EQ::behavior::LookupEntry* EQ::behavior::DynamicLookup(versions::MobVersion mob_version, bool gm_flag)
+const EQEmu::behavior::LookupEntry* EQEmu::behavior::DynamicLookup(versions::MobVersion mob_version, bool gm_flag)
 {
 	if (gm_flag)
 		return DynamicGMLookup(mob_version);
@@ -1072,7 +1072,7 @@ const EQ::behavior::LookupEntry* EQ::behavior::DynamicLookup(versions::MobVersio
 		return DynamicNonGMLookup(mob_version);
 }
 
-const EQ::behavior::LookupEntry* EQ::behavior::DynamicNonGMLookup(versions::MobVersion mob_version)
+const EQEmu::behavior::LookupEntry* EQEmu::behavior::DynamicNonGMLookup(versions::MobVersion mob_version)
 {
 	mob_version = versions::ValidateMobVersion(mob_version);
 	if (behavior_dynamic_nongm_lookup_entries[static_cast<int>(mob_version)])
@@ -1081,7 +1081,7 @@ const EQ::behavior::LookupEntry* EQ::behavior::DynamicNonGMLookup(versions::MobV
 	return &behavior_static_lookup_entries[static_cast<int>(mob_version)];
 }
 
-const EQ::behavior::LookupEntry* EQ::behavior::DynamicGMLookup(versions::MobVersion mob_version)
+const EQEmu::behavior::LookupEntry* EQEmu::behavior::DynamicGMLookup(versions::MobVersion mob_version)
 {
 	mob_version = versions::ValidateMobVersion(mob_version);
 	if (behavior_dynamic_gm_lookup_entries[static_cast<int>(mob_version)])
@@ -1090,17 +1090,17 @@ const EQ::behavior::LookupEntry* EQ::behavior::DynamicGMLookup(versions::MobVers
 	return &behavior_static_lookup_entries[static_cast<int>(mob_version)];
 }
 
-const EQ::behavior::LookupEntry* EQ::behavior::StaticLookup(versions::MobVersion mob_version)
+const EQEmu::behavior::LookupEntry* EQEmu::behavior::StaticLookup(versions::MobVersion mob_version)
 {
 	return &behavior_static_lookup_entries[static_cast<int>(versions::ValidateMobVersion(mob_version))];
 }
 
-static std::unique_ptr<EQ::spells::LookupEntry> spells_dynamic_nongm_lookup_entries[EQ::versions::ClientVersionCount];
-static std::unique_ptr<EQ::spells::LookupEntry> spells_dynamic_gm_lookup_entries[EQ::versions::ClientVersionCount];
-static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::ClientVersionCount] =
+static std::unique_ptr<EQEmu::spells::LookupEntry> spells_dynamic_nongm_lookup_entries[EQEmu::versions::ClientVersionCount];
+static std::unique_ptr<EQEmu::spells::LookupEntry> spells_dynamic_gm_lookup_entries[EQEmu::versions::ClientVersionCount];
+static const EQEmu::spells::LookupEntry spells_static_lookup_entries[EQEmu::versions::ClientVersionCount] =
 {
 	/*[ClientVersion::Unknown] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		ClientUnknown::INULL,
 		ClientUnknown::INULL,
 		ClientUnknown::INULL,
@@ -1113,7 +1113,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		ClientUnknown::INULL
 	),
 	/*[ClientVersion::Client62] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		Client62::INULL,
 		Client62::INULL,
 		Client62::INULL,
@@ -1126,7 +1126,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		Client62::INULL
 	),
 	/*[ClientVersion::Titanium] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		Titanium::spells::SPELL_ID_MAX,
 		Titanium::spells::SPELLBOOK_SIZE,
 		Titanium::spells::SPELL_GEM_COUNT,
@@ -1139,7 +1139,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		Titanium::spells::MERC_BUFFS
 	),
 	/*[ClientVersion::SoF] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		SoF::spells::SPELL_ID_MAX,
 		SoF::spells::SPELLBOOK_SIZE,
 		SoF::spells::SPELL_GEM_COUNT,
@@ -1152,7 +1152,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		SoF::spells::MERC_BUFFS
 	),
 	/*[ClientVersion::SoD] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		SoD::spells::SPELL_ID_MAX,
 		SoD::spells::SPELLBOOK_SIZE,
 		SoD::spells::SPELL_GEM_COUNT,
@@ -1165,7 +1165,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		SoD::spells::MERC_BUFFS
 	),
 	/*[ClientVersion::UF] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		UF::spells::SPELL_ID_MAX,
 		UF::spells::SPELLBOOK_SIZE,
 		UF::spells::SPELL_GEM_COUNT,
@@ -1178,7 +1178,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		UF::spells::MERC_BUFFS
 	),
 	/*[ClientVersion::RoF] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		RoF::spells::SPELL_ID_MAX,
 		RoF::spells::SPELLBOOK_SIZE,
 		UF::spells::SPELL_GEM_COUNT, // client translators are setup to allow the max value a client supports..however, the top 4 indices are not valid in this case
@@ -1191,7 +1191,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 		RoF::spells::MERC_BUFFS
 	),
 	/*[ClientVersion::RoF2] =*/
-	EQ::spells::LookupEntry(
+	EQEmu::spells::LookupEntry(
 		RoF2::spells::SPELL_ID_MAX,
 		RoF2::spells::SPELLBOOK_SIZE,
 		UF::spells::SPELL_GEM_COUNT, // client translators are setup to allow the max value a client supports..however, the top 4 indices are not valid in this case
@@ -1206,7 +1206,7 @@ static const EQ::spells::LookupEntry spells_static_lookup_entries[EQ::versions::
 };
 
 static bool spells_dictionary_init = false;
-void EQ::spells::InitializeDynamicLookups() {
+void EQEmu::spells::InitializeDynamicLookups() {
 	if (spells_dictionary_init == true)
 		return;
 	spells_dictionary_init = true;
@@ -1217,7 +1217,7 @@ void EQ::spells::InitializeDynamicLookups() {
 	// use static references for now
 }
 
-const EQ::spells::LookupEntry* EQ::spells::DynamicLookup(versions::ClientVersion client_version, bool gm_flag)
+const EQEmu::spells::LookupEntry* EQEmu::spells::DynamicLookup(versions::ClientVersion client_version, bool gm_flag)
 {
 	if (gm_flag)
 		return DynamicGMLookup(client_version);
@@ -1225,7 +1225,7 @@ const EQ::spells::LookupEntry* EQ::spells::DynamicLookup(versions::ClientVersion
 		return DynamicNonGMLookup(client_version);
 }
 
-const EQ::spells::LookupEntry* EQ::spells::DynamicNonGMLookup(versions::ClientVersion client_version)
+const EQEmu::spells::LookupEntry* EQEmu::spells::DynamicNonGMLookup(versions::ClientVersion client_version)
 {
 	client_version = versions::ValidateClientVersion(client_version);
 	if (spells_dynamic_nongm_lookup_entries[static_cast<int>(client_version)])
@@ -1234,7 +1234,7 @@ const EQ::spells::LookupEntry* EQ::spells::DynamicNonGMLookup(versions::ClientVe
 	return &spells_static_lookup_entries[static_cast<int>(client_version)];
 }
 
-const EQ::spells::LookupEntry* EQ::spells::DynamicGMLookup(versions::ClientVersion client_version)
+const EQEmu::spells::LookupEntry* EQEmu::spells::DynamicGMLookup(versions::ClientVersion client_version)
 {
 	client_version = versions::ValidateClientVersion(client_version);
 	if (spells_dynamic_gm_lookup_entries[static_cast<int>(client_version)])
@@ -1243,7 +1243,7 @@ const EQ::spells::LookupEntry* EQ::spells::DynamicGMLookup(versions::ClientVersi
 	return &spells_static_lookup_entries[static_cast<int>(client_version)];
 }
 
-const EQ::spells::LookupEntry* EQ::spells::StaticLookup(versions::ClientVersion client_version)
+const EQEmu::spells::LookupEntry* EQEmu::spells::StaticLookup(versions::ClientVersion client_version)
 {
 	return &spells_static_lookup_entries[static_cast<int>(versions::ValidateClientVersion(client_version))];
 }

common/eq_limits.h

@@ -31,13 +31,13 @@
 #include "../common/patches/rof2_limits.h"
 
 
-namespace EQ
+namespace EQEmu
 {
 	void InitializeDynamicLookups();
 
 	namespace constants {
 		struct LookupEntry {
-			EQ::expansions::Expansion Expansion;
+			EQEmu::expansions::Expansion Expansion;
 			uint32 ExpansionBit;
 			uint32 ExpansionsMask;
 			int16 CharacterCreationLimit;
@@ -45,7 +45,7 @@ namespace EQ
 			
 			LookupEntry(const LookupEntry *lookup_entry) { }
 			LookupEntry(
-				EQ::expansions::Expansion Expansion,
+				EQEmu::expansions::Expansion Expansion,
 				uint32 ExpansionBit,
 				uint32 ExpansionsMask,
 				int16 CharacterCreationLimit,
@@ -111,7 +111,7 @@ namespace EQ
 
 			union {
 				InventoryTypeSize_Struct InventoryTypeSize;
-				int16 InventoryTypeSizeArray[25]; // should reflect EQ::invtype::TYPE_COUNT referenced in emu_constants.h
+				int16 InventoryTypeSizeArray[25]; // should reflect EQEmu::invtype::TYPE_COUNT referenced in emu_constants.h
 			};
 
 			uint64 EquipmentBitmask;
@@ -244,9 +244,9 @@ namespace ClientUnknown
 	const int16 INULL = 0;
 
 	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;
+		const EQEmu::expansions::Expansion EXPANSION = EQEmu::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQEmu::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQEmu::expansions::maskEverQuest;
 
 	} // namespace constants
 
@@ -258,9 +258,9 @@ namespace Client62
 	const int16 INULL = 0;
 
 	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;
+		const EQEmu::expansions::Expansion EXPANSION = EQEmu::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQEmu::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQEmu::expansions::maskEverQuest;
 
 	} // namespace constants
 

common/eq_packet_structs.h

@@ -35,8 +35,6 @@ static const uint32 MAX_MERC = 100;
 static const uint32 MAX_MERC_GRADES = 10;
 static const uint32 MAX_MERC_STANCES = 10;
 static const uint32 BLOCKED_BUFF_COUNT = 20;
-static const uint32 QUESTREWARD_COUNT = 8;
-static const uint32 ADVANCED_LORE_LENGTH = 8192;
 
 
 /*
@@ -129,7 +127,7 @@ struct LDoNTrapTemplate
 
 // All clients translate the character select information to some degree
 
-struct CharSelectEquip : EQ::textures::Texture_Struct, EQ::textures::Tint_Struct {};
+struct CharSelectEquip : EQEmu::textures::Texture_Struct, EQEmu::textures::Tint_Struct {};
 
 // RoF2-based hybrid struct
 struct CharacterSelectEntry_Struct
@@ -144,7 +142,7 @@ struct CharacterSelectEntry_Struct
 	uint16 Instance;
 	uint8 Gender;
 	uint8 Face;
-	CharSelectEquip	Equip[EQ::textures::materialCount];
+	CharSelectEquip	Equip[EQEmu::textures::materialCount];
 	uint8 Unknown15;			// Seen FF
 	uint8 Unknown19;			// Seen FF
 	uint32 DrakkinTattoo;
@@ -253,7 +251,7 @@ struct Spawn_Struct {
 /*0189*/ uint32	petOwnerId;			// If this is a pet, the spawn id of owner
 /*0193*/ uint8	guildrank;			// 0=normal, 1=officer, 2=leader
 /*0194*/ uint8	unknown0194[3];
-/*0197*/ EQ::TextureProfile equipment;
+/*0197*/ EQEmu::TextureProfile equipment;
 /*0233*/ float	runspeed;		// Speed when running
 /*0036*/ uint8	afk;			// 0=no, 1=afk
 /*0238*/ uint32	guildID;		// Current guild
@@ -284,7 +282,7 @@ union
 /*0340*/ uint32 spawnId;		// Spawn Id
 /*0344*/ float bounding_radius; // used in melee, overrides calc
 /*0347*/ uint8 IsMercenary;
-/*0348*/ EQ::TintProfile equipment_tint;
+/*0348*/ EQEmu::TintProfile equipment_tint;
 /*0384*/ uint8	lfg;			// 0=off, 1=lfg on
 /*0385*/
 
@@ -375,16 +373,13 @@ struct NewZone_Struct {
 /*0686*/	uint16	zone_instance;
 /*0688*/	uint32	unknown688;
 /*0692*/	uint8	unknown692[8];
-// Titanium doesn't have a translator, but we can still safely add stuff under here without issues since client memcpy's only what it knows
-// Just wastes some bandwidth sending to tit clients /shrug
 /*0700*/	float	fog_density;
 /*0704*/	uint32	SuspendBuffs;
 /*0708*/	uint32	FastRegenHP;
 /*0712*/	uint32	FastRegenMana;
 /*0716*/	uint32	FastRegenEndurance;
 /*0720*/	uint32	NPCAggroMaxDist;
-/*0724*/	uint32	underworld_teleport_index; // > 0 teleports w/ zone point index, invalid succors, if this value is 0, it prevents you from running off edges that would end up underworld
-/*0728*/
+/*0724*/
 };
 
 /*
@@ -739,7 +734,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[EQ::profile::BANDOLIER_ITEM_COUNT];
+	BandolierItem_Struct Items[EQEmu::profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -753,7 +748,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[EQ::profile::POTION_BELT_SIZE];
+	PotionBeltItem_Struct Items[EQEmu::profile::POTION_BELT_SIZE];
 };
 
 struct MovePotionToBelt_Struct
@@ -844,7 +839,7 @@ struct SuspendedMinion_Struct
 	/*002*/	uint32 HP;
 	/*006*/	uint32 Mana;
 	/*010*/	SpellBuff_Struct Buffs[BUFF_COUNT];
-	/*510*/	EQ::TextureMaterialProfile Items;
+	/*510*/	EQEmu::TextureMaterialProfile Items;
 	/*546*/	char Name[64];
 	/*610*/
 };
@@ -936,7 +931,7 @@ struct PlayerProfile_Struct
 /*0245*/	uint8				guildbanker;
 /*0246*/	uint8				unknown0246[6];		//
 /*0252*/	uint32				intoxication;
-/*0256*/	uint32				spellSlotRefresh[EQ::spells::SPELL_GEM_COUNT];	//in ms
+/*0256*/	uint32				spellSlotRefresh[EQEmu::spells::SPELL_GEM_COUNT];	//in ms
 /*0292*/	uint32				abilitySlotRefresh;
 /*0296*/	uint8				haircolor;			// Player hair color
 /*0297*/	uint8				beardcolor;			// Player beard color
@@ -949,9 +944,9 @@ struct PlayerProfile_Struct
 /*0304*/	uint8				ability_time_minutes;
 /*0305*/	uint8				ability_time_hours;	//place holder
 /*0306*/	uint8				unknown0306[6];		// @bp Spacer/Flag?
-/*0312*/	EQ::TextureMaterialProfile	item_material;	// Item texture/material of worn/held items
+/*0312*/	EQEmu::TextureMaterialProfile	item_material;	// Item texture/material of worn/held items
 /*0348*/	uint8				unknown0348[44];
-/*0392*/	EQ::TintProfile	item_tint;
+/*0392*/	EQEmu::TintProfile	item_tint;
 /*0428*/	AA_Array			aa_array[MAX_PP_AA_ARRAY];
 /*2348*/	float				unknown2384;		//seen ~128, ~47
 /*2352*/	char				servername[32];		// length probably not right
@@ -975,9 +970,9 @@ struct PlayerProfile_Struct
 /*2505*/	uint8				unknown2541[47];	// ?
 /*2552*/	uint8				languages[MAX_PP_LANGUAGE];
 /*2580*/	uint8				unknown2616[4];
-/*2584*/	uint32				spell_book[EQ::spells::SPELLBOOK_SIZE];
+/*2584*/	uint32				spell_book[EQEmu::spells::SPELLBOOK_SIZE];
 /*4504*/	uint8				unknown4540[128];	// Was [428] all 0xff
-/*4632*/	uint32				mem_spells[EQ::spells::SPELL_GEM_COUNT];
+/*4632*/	uint32				mem_spells[EQEmu::spells::SPELL_GEM_COUNT];
 /*4668*/	uint8				unknown4704[32];	//
 /*4700*/	float				y;					// Player y position
 /*4704*/	float				x;					// Player x position
@@ -1053,7 +1048,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[EQ::invtype::TRIBUTE_SIZE];
+/*7224*/	Tribute_Struct		tributes[EQEmu::invtype::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1080,7 +1075,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[EQ::profile::BANDOLIERS_SIZE];
+/*12844*/	Bandolier_Struct	bandoliers[EQEmu::profile::BANDOLIERS_SIZE];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -1098,16 +1093,16 @@ struct PlayerProfile_Struct
 /*19568*/
 
 	// All player profile packets are translated and this overhead is ignored in out-bound packets
-	PlayerProfile_Struct() : m_player_profile_version(EQ::versions::MobVersion::Unknown) { }
+	PlayerProfile_Struct() : m_player_profile_version(EQEmu::versions::MobVersion::Unknown) { }
 
-	EQ::versions::MobVersion PlayerProfileVersion() { return m_player_profile_version; }
-	void SetPlayerProfileVersion(EQ::versions::MobVersion mob_version) { m_player_profile_version = EQ::versions::ValidateMobVersion(mob_version); }
-	void SetPlayerProfileVersion(EQ::versions::ClientVersion client_version) { SetPlayerProfileVersion(EQ::versions::ConvertClientVersionToMobVersion(client_version)); }
+	EQEmu::versions::MobVersion PlayerProfileVersion() { return m_player_profile_version; }
+	void SetPlayerProfileVersion(EQEmu::versions::MobVersion mob_version) { m_player_profile_version = EQEmu::versions::ValidateMobVersion(mob_version); }
+	void SetPlayerProfileVersion(EQEmu::versions::ClientVersion client_version) { SetPlayerProfileVersion(EQEmu::versions::ConvertClientVersionToMobVersion(client_version)); }
 
 private:
 	// No need for gm flag since pp already has one
 	// No need for lookup pointer since this struct is not tied to any one system
-	EQ::versions::MobVersion m_player_profile_version;
+	EQEmu::versions::MobVersion m_player_profile_version;
 };
 
 
@@ -1193,20 +1188,6 @@ struct SpecialMesg_Struct
 /*24*/	char	message[1];				// What is being said?
 };
 
-struct SpecialMesgHeader_Struct
-{
-/*00*/	char	SpeakMode;				// 2 shouts, 4 %1 %2, 3 %2, 5 tells group, 0 copy, default says
-/*01*/	char	JournalMode;			// 1 and 2 go to journal
-/*02*/	char	language;
-/*03*/	uint32	msg_type;				// Color of text (see MT_*** below)
-/*07*/	uint32	target_spawn_id;		// Who is it being said to?
-/*11*/ // speaker's name
-/*xx*/ // unknown, location, client doesn't care
-/*xx*/ // unknown
-/*xx*/ // unknown
-/*xx*/ // message
-};
-
 /*
 ** When somebody changes what they're wearing or give a pet a weapon (model changes)
 ** Length: 19 Bytes
@@ -1218,7 +1199,7 @@ struct WearChange_Struct {
 /*010*/ uint32                       elite_material;    // 1 for Drakkin Elite Material
 /*014*/ uint32                       hero_forge_model; // New to VoA
 /*018*/ uint32                       unknown18; // New to RoF
-/*022*/ EQ::textures::Tint_Struct color;
+/*022*/ EQEmu::textures::Tint_Struct color;
 /*026*/ uint8                        wear_slot_id;
 /*027*/
 };
@@ -1363,24 +1344,21 @@ struct BecomeCorpse_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/	uint16		spawn_id;
-/*0002*/	uint16		vehicle_id;
-/*0004*/	signed		padding0004 : 12;
-			signed		y_pos : 19;			// y coord
-			unsigned	padding : 1;
-/*0008*/	signed		delta_z : 13;		// change in z
-			signed		delta_x : 13;		// change in x
-			signed		padding0008 : 6;
-/*0012*/	signed		x_pos : 19;			// x coord
-			unsigned	heading : 12;		// heading
-			signed		padding0016 : 1;
-/*0016*/	signed		delta_heading : 10;	// change in heading
-			signed		z_pos : 19;			// z coord
-			signed		padding0020 : 3;
-/*0020*/	signed		animation : 10;		// animation
-			signed		delta_y : 13;		// change in y
-			signed		padding0024 : 9;
-/*0024*/
+/*0000*/ uint16		spawn_id;
+/*0002*/ int32		delta_heading:10,	// change in heading
+					x_pos:19,			// x coord
+					padding0002:3;		// ***Placeholder
+/*0006*/ int32		y_pos:19,			// y coord
+					animation:10,		// animation
+					padding0006:3;		// ***Placeholder
+/*0010*/ int32		z_pos:19,			// z coord
+					delta_y:13;			// change in y
+/*0014*/ int32		delta_x:13,			// change in x
+					heading:12,			// heading
+					padding0014:7;		// ***Placeholder
+/*0018*/ int32		delta_z:13,			// change in z
+					padding0018:19;		// ***Placeholder
+/*0022*/
 };
 
 /*
@@ -1391,23 +1369,21 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/	uint16		sequence;			// increments one each packet - Verified
-/*0002*/	uint16		spawn_id;			// Player's spawn id
-/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
-/*0006*/	uint8		unknown0004[4];		// ***Placeholder
-/*0010*/	float		delta_x;			// Change in x
-/*0014*/	unsigned	heading : 12;		// Directional heading
-			unsigned	padding0040 : 20;	// ***Placeholder
-/*0018*/	float		x_pos;				// x coord (2nd loc value)
-/*0022*/	float		delta_z;			// Change in z
-/*0026*/	float		z_pos;				// z coord (3rd loc value)
-/*0030*/	float		y_pos;				// y coord (1st loc value)
-/*0034*/	unsigned	animation : 10;		// ***Placeholder
-			unsigned	padding0024 : 22;	// animation
-/*0038*/	float		delta_y;			// Change in y
-/*0042*/	signed		delta_heading : 10;	// change in heading
-			unsigned	padding0041 : 22;	// ***Placeholder
-/*0046*/
+/*0000*/ uint16	spawn_id;
+/*0002*/ uint16	sequence;			//increments one each packet
+/*0004*/ float	y_pos;				// y coord
+/*0008*/ float	delta_z;			// Change in z
+/*0012*/ float	delta_x;			// Change in x
+/*0016*/ float	delta_y;			// Change in y
+/*0020*/ int32	animation:10,		// animation
+				delta_heading:10,	// change in heading
+				padding0020:12;		// ***Placeholder (mostly 1)
+/*0024*/ float	x_pos;				// x coord
+/*0028*/ float	z_pos;				// z coord
+/*0032*/ uint16	heading:12,			// Directional heading
+				padding0004:4;		// ***Placeholder
+/*0034*/ uint8	unknown0006[2];		// ***Placeholder
+/*0036*/
 };
 
 struct SpawnPositionUpdate_Struct
@@ -2126,7 +2102,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	EQ::ItemData item;
+	EQEmu::ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 
@@ -2152,7 +2128,7 @@ struct Illusion_Struct { //size: 256 - SoF
 /*092*/	uint32	drakkin_heritage;	//
 /*096*/	uint32	drakkin_tattoo;		//
 /*100*/	uint32	drakkin_details;	//
-/*104*/	EQ::TintProfile	armor_tint;	//
+/*104*/	EQEmu::TintProfile	armor_tint;	//
 /*140*/	uint8	eyecolor1;		// Field Not Identified in any Illusion Struct
 /*141*/	uint8	eyecolor2;		// Field Not Identified in any Illusion Struct
 /*142*/	uint8	unknown138[114];	//
@@ -2185,7 +2161,14 @@ struct QuestReward_Struct
 	/*024*/ uint32	silver;		// Gives silver to the client
 	/*028*/ uint32	gold;		// Gives gold to the client
 	/*032*/ uint32	platinum;	// Gives platinum to the client
-	/*036*/ int32	item_id[QUESTREWARD_COUNT];	// -1 for nothing
+	/*036*/ uint32	item_id;
+	/*040*/ uint32	unknown040;
+	/*044*/ uint32	unknown044;
+	/*048*/ uint32	unknown048;
+	/*052*/ uint32	unknown052;
+	/*056*/ uint32	unknown056;
+	/*060*/ uint32	unknown060;
+	/*064*/ uint32	unknown064;
 	/*068*/
 };
 
@@ -2970,12 +2953,6 @@ struct	ItemViewRequest_Struct {
 /*046*/	char	unknown046[2];
 };
 
-struct ItemAdvancedLoreText_Struct {
-	int32	item_id;
-	char	item_name[64];
-	char	advanced_lore[ADVANCED_LORE_LENGTH];
-};
-
 struct	LDONItemViewRequest_Struct {
 	uint32	item_id;
 	uint8	unknown004[4];
@@ -3492,8 +3469,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EQ::invtype::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQ::invtype::TRIBUTE_SIZE];		//all 00's
+	uint32	tributes[EQEmu::invtype::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EQEmu::invtype::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -4404,7 +4381,7 @@ struct AnnoyingZoneUnknown_Struct {
 };
 
 struct LoadSpellSet_Struct {
-	uint32 spell[EQ::spells::SPELL_GEM_COUNT];	// 0xFFFFFFFF if no action, slot number if to unmem starting at 0
+	uint32 spell[EQEmu::spells::SPELL_GEM_COUNT];	// 0xFFFFFFFF if no action, slot number if to unmem starting at 0
 	uint32 unknown;					//there seems to be an extra field in this packet...
 };
 
@@ -4835,98 +4812,17 @@ struct BuffIcon_Struct
 	BuffIconEntry_Struct entries[0];
 };
 
-struct ExpeditionInvite_Struct
-{
-/*000*/ uint32 client_id;            // unique character id
-/*004*/ uint32 unknown004;           // added after titanium
-/*008*/ char   inviter_name[64];
-/*072*/ char   expedition_name[128];
-/*200*/ uint8  swapping;             // 0: adding 1: swapping
-/*201*/ char   swap_name[64];        // if swapping, swap name being removed
-/*265*/ uint8  padding[3];
-/*268*/ uint16 dz_zone_id;           // dz_id zone/instance pair, sent back in reply
-/*270*/ uint16 dz_instance_id;
-};
-
-struct ExpeditionInviteResponse_Struct
-{
-/*000*/ uint32 unknown000;
-/*004*/ uint32 unknown004;     // added after titanium
-/*008*/ uint16 dz_zone_id;     // dz_id pair sent in invite
-/*010*/ uint16 dz_instance_id;
-/*012*/ uint8  accepted;       // 0: declined 1: accepted
-/*013*/ uint8  swapping;       // 0: adding 1: swapping (sent in invite)
-/*014*/ char   swap_name[64];  // swap name sent in invite
-/*078*/ uint8  unknown078;     // padding garbage?
-/*079*/ uint8  unknown079;     // padding garbage?
-};
-
 struct ExpeditionInfo_Struct
 {
-/*000*/ uint32 client_id;
-/*004*/ uint32 unknown004; // added after titanium
-/*008*/ uint32 assigned;   // padded bool, 0: not in expedition (clear data), 1: in expedition
-/*012*/ uint32 max_players;
-/*016*/ char   expedition_name[128];
-/*144*/ char   leader_name[64];
+/*000*/ uint32 max_players;
+/*004*/ char expedition_name[128];
+/*132*/ char leader_name[64];
 };
 
-struct ExpeditionMemberEntry_Struct
+struct ExpeditionJoinPrompt_Struct
 {
-/*000*/ char  name[64];          // variable length, null terminated, max 0x40 (64)
-/*064*/ uint8 expedition_status; // 0: unknown, 1: Online, 2: Offline, 3: In Dynamic Zone, 4: Link Dead
-};
-
-struct ExpeditionMemberList_Struct
-{
-/*000*/ uint32 client_id;
-/*004*/ uint32 member_count;
-/*008*/ ExpeditionMemberEntry_Struct members[0]; // variable length
-};
-
-struct ExpeditionMemberListName_Struct
-{
-/*000*/ uint32 client_id;
-/*004*/ uint32 unknown004;
-/*008*/ uint32 add_name; // padded bool, 0: remove name, 1: add name with unknown status
-/*012*/ char   name[64];
-};
-
-struct ExpeditionLockoutTimerEntry_Struct
-{
-/*000*/ char   expedition_name[128]; // variable length, null terminated, max 0x80 (128)
-/*000*/ uint32 seconds_remaining;
-/*000*/ int32  event_type;           // seen -1 (0xffffffff) for replay timers and 1 for event timers
-/*000*/ char   event_name[256];      // variable length, null terminated, max 0x100 (256)
-};
-
-struct ExpeditionLockoutTimers_Struct
-{
-/*000*/ uint32 client_id;
-/*004*/ uint32 count;
-/*008*/ ExpeditionLockoutTimerEntry_Struct timers[0];
-};
-
-struct ExpeditionSetLeaderName_Struct
-{
-/*000*/ uint32 client_id;
-/*004*/ uint32 unknown004;
-/*008*/ char   leader_name[64];
-};
-
-struct ExpeditionCommand_Struct
-{
-/*000*/ uint32 unknown000;
-/*004*/ uint32 unknown004;
-/*008*/ char name[64];
-};
-
-struct ExpeditionCommandSwap_Struct
-{
-/*000*/ uint32 unknown000;
-/*004*/ uint32 unknown004;
-/*008*/ char add_player_name[64]; // swap to (player must confirm)
-/*072*/ char rem_player_name[64]; // swap from
+/*000*/ char player_name[64];
+/*064*/ char expedition_name[64];
 };
 
 struct ExpeditionExpireWarning
@@ -4934,67 +4830,48 @@ struct ExpeditionExpireWarning
 /*008*/ uint32 minutes_remaining;
 };
 
-struct DynamicZoneCompassEntry_Struct
+struct ExpeditionCompassEntry_Struct
 {
-/*000*/ uint16 dz_zone_id;      // target dz id pair
-/*002*/ uint16 dz_instance_id;
-/*004*/ uint32 dz_type;         // 1: Expedition, 2: Tutorial (purple), 3: Task, 4: Mission, 5: Quest (green)
-/*008*/ uint32 unknown008;
-/*012*/ float y;
-/*016*/ float x;
-/*020*/ float z;
+/*000*/ uint32 enabled; //guess
+/*004*/ float y;
+/*008*/ float x;
+/*012*/ float z;
 };
 
-struct DynamicZoneCompass_Struct
+struct ExpeditionCompass_Struct
 {
-/*000*/ uint32 client_id;
 /*000*/ uint32 count;
-/*004*/ DynamicZoneCompassEntry_Struct entries[0];
+/*004*/ ExpeditionCompassEntry_Struct entries[0];
 };
 
-struct DynamicZoneChooseZoneEntry_Struct
+struct ExpeditionMemberEntry_Struct
 {
-/*000*/ uint16 dz_zone_id;       // dz_id pair
-/*002*/ uint16 dz_instance_id;
-/*004*/ uint32 unknown_id1;      // seen 28 00 00 00 (40), sent back in reply
-/*008*/ uint32 dz_type;          // 1: Expedition, 2: Tutorial, 3: Task, 4: Mission, 5: Quest -- sent back in reply
-/*012*/ uint32 unknown_id2;      // possibly an id based on dz type, for expeditions this was same as dz_id (zone|instance) but task dz was different
-/*016*/ char   description[128]; // variable length, null terminated
-/*144*/ char   leader_name[64];  // variable length, null terminated
+	char name[64];
+	char status;
 };
 
-struct DynamicZoneChooseZone_Struct
+struct ExpeditionMemberList_Struct
 {
-/*000*/ uint32 client_id;
-/*004*/ uint32 count;
-/*008*/ DynamicZoneChooseZoneEntry_Struct choices[0];
+/*000*/ uint32 count;
+/*004*/ ExpeditionMemberEntry_Struct entries[0];
 };
 
-struct DynamicZoneChooseZoneReply_Struct
+struct ExpeditionLockoutEntry_Struct
 {
-/*000*/ uint32 unknown000;     // ff ff ff ff
-/*004*/ uint32 unknown004;     // seen 69 00 00 00
-/*008*/ uint32 unknown008;     // ff ff ff ff
-/*012*/ uint32 unknown_id1;    // from choose zone entry message
-/*016*/ uint16 dz_zone_id;     // dz_id pair
-/*018*/ uint16 dz_instance_id;
-/*020*/ uint32 dz_type;        // 1: Expedition, 2: Tutorial, 3: Task, 4: Mission, 5: Quest
-/*024*/ uint32 unknown_id2;    // from choose zone entry message
-/*028*/ uint32 unknown028;     // 00 00 00 00
-/*032*/ uint32 unknown032;     // always same as unknown044
-/*036*/ uint32 unknown036;
-/*040*/ uint32 unknown040;
-/*044*/ uint32 unknown044;     // always same as unknown032
-/*048*/ uint32 unknown048;     // seen 01 00 00 00 and 02 00 00 00
+/*000*/ uint32 time_left;
+/*004*/ char expedition[128];
+/*132*/ char expedition_event[128];
 };
 
-struct KickPlayers_Struct
+struct ExpeditionLockoutList_Struct
 {
-/*000*/ char   char_name[64];
-/*064*/ uint32 unknown064;      // always 0
-/*068*/ uint8  kick_expedition; // true if /kickplayers exp
-/*069*/ uint8  kick_task;       // true if /kickplayers task
-/*070*/ uint8  padding[2];
+/*000*/ uint32 count;
+/*004*/ ExpeditionLockoutEntry_Struct entries[0];
+};
+
+struct ExpeditionLeaderSet_Struct
+{
+/*000*/ char leader_name[64];
 };
 
 struct CorpseDrag_Struct
@@ -5444,20 +5321,18 @@ struct MercenaryMerchantResponse_Struct {
 
 struct ServerLootItem_Struct {
 	uint32	item_id;	  // uint32	item_id;
-	int16  equip_slot;	  // int16	equip_slot;
-	uint16 charges;	  // uint8	charges;
-	uint16 lootslot;	  // uint16	lootslot;
-	uint32 aug_1;		  // uint32	aug_1;
-	uint32 aug_2;		  // uint32	aug_2;
-	uint32 aug_3;		  // uint32	aug_3;
-	uint32 aug_4;		  // uint32	aug_4;
-	uint32 aug_5;		  // uint32	aug_5;
-	uint32 aug_6;		  // uint32	aug_5;
-	uint8  attuned;
-	uint16 trivial_min_level;
-	uint16 trivial_max_level;
-	uint16 npc_min_level;
-	uint16 npc_max_level;
+	int16	equip_slot;	  // int16	equip_slot;
+	uint16	charges;	  // uint8	charges;
+	uint16	lootslot;	  // uint16	lootslot;
+	uint32	aug_1;		  // uint32	aug_1;
+	uint32	aug_2;		  // uint32	aug_2;
+	uint32	aug_3;		  // uint32	aug_3;
+	uint32	aug_4;		  // uint32	aug_4;
+	uint32	aug_5;		  // uint32	aug_5;
+	uint32	aug_6;		  // uint32	aug_5;
+	uint8	attuned;
+	uint8	min_level;
+	uint8	max_level;
 };
 
 //Found in client near a ref to the string:

common/eq_stream.cpp

@@ -84,14 +84,14 @@ void EQStream::init(bool resetSession) {
 
 	OpMgr = nullptr;
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		LogNetcode(_L "init Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+		Log(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 }
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	LogNetcode(_L "Creating new application packet, length [{}]" __L, p->size);
+	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __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;
-	LogNetcode(_L "Creating new application packet, length [{}]" __L, len);
+	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __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) {
-		LogNetcode(_L "Session not initialized, packet ignored" __L);
+		Log(Logs::Detail, Logs::Netcode, _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);
-				LogNetcode(_L "Extracting combined packet of length [{}]" __L, subpacket_length);
+				Log(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __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) {
-					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
+					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, 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));
-					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
+					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, 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))
 			{
-				LogNetcode(_L "Received OP_Packet that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _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) {
-					LogNetcode(_L "Future OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
+					Log(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 					// _raw(NET__DEBUG, seq, p);
 
 					PacketQueue[seq]=p->Copy();
-					LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
+					Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				LogNetcode(_L "Duplicate OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __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) {
-					LogNetcode("[NET_TRACE] OP_Packet: Removing older queued packet with sequence [{}]", seq);
+					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", 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);
-					LogNetcode(_L "seq [{}], Extracting combined packet of length [{}]" __L, seq, subp->size);
+					Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __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))
 			{
-				LogNetcode(_L "Received OP_Fragment that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _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) {
-				LogNetcode(_L "Future OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 
 				PacketQueue[seq]=p->Copy();
-				LogNetcode(_L "OP_Fragment Queue size=[{}]" __L, PacketQueue.size());
+				Log(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				LogNetcode(_L "Duplicate OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __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) {
-					LogNetcode("[NET_TRACE] OP_Fragment: Removing older queued packet with sequence [{}]", seq);
+					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", 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;
-					LogNetcode(_L "Fragment of oversized of length [{}], seq [{}]: now at [{}]/[{}]" __L, p->size-2, seq, oversize_offset, oversize_length);
+					Log(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);
 					if (oversize_offset==oversize_length) {
 						if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 							EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
-							LogNetcode(_L "seq [{}], Extracting combined oversize packet of length [{}]" __L, seq, subp->size);
+							Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __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);
-							LogNetcode(_L "seq [{}], completed combined oversize packet of length [{}]" __L, seq, ap->size);
+							Log(Logs::Detail, Logs::Netcode, _L "seq %d, completed combined oversize packet of length %d" __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;
-					LogNetcode(_L "First fragment of oversized of seq [{}]: now at [{}]/[{}]" __L, seq, oversize_offset, oversize_length);
+					Log(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
 				}
 			}
 		}
 		break;
 		case OP_KeepAlive: {
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
-			LogNetcode(_L "Received and queued reply to keep alive" __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
 		}
 		break;
 		case OP_Ack: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				LogNetcode(_L "Received OP_Ack that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _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))
 			{
-				LogNetcode(_L "Received OP_SessionRequest that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
 			if (GetState()==ESTABLISHED) {
-				LogNetcode(_L "Received OP_SessionRequest in ESTABLISHED state ([{}]) streamactive ([{}]) attempt ([{}])" __L, GetState(),streamactive,sessionAttempts);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __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));
-			LogNetcode(_L "Received OP_SessionRequest: session [{}], maxlen [{}]" __L, (unsigned long)Session, MaxLen);
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __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))
 			{
-				LogNetcode(_L "Received OP_SessionResponse that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _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);
 
-			LogNetcode(_L "Received OP_SessionResponse: session [{}], maxlen [{}], key [{}], compressed? [{}], encoded? [{}]" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
+			Log(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");
 
 			// 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?
-				LogNetcode(_L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect" __L);
+				Log(Logs::Detail, Logs::Netcode, _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.
-				LogNetcode(_L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though" __L);
+				Log(Logs::Detail, Logs::Netcode, _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)
-				LogNetcode(_L "Received expected OP_SessionDisconnect. Moving to closed state" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
 				SetState(CLOSED);
 			}
 		}
@@ -397,14 +397,14 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_OutOfOrderAck: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				LogNetcode(_L "Received OP_OutOfOrderAck that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _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) {
-				LogNetcode(_L "Pre-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __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.
@@ -414,7 +414,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 
 				uint16 sqsize = SequencedQueue.size();
 				uint16 index = seq - SequencedBase;
-				LogNetcode(_L "OP_OutOfOrderAck marking packet acked in queue (queue index = [{}], queue size = [{}])" __L, index, sqsize);
+				Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __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;
-							LogNetcode(_L "OP_OutOfOrderAck Flagging packet [{}] for retransmission" __L, SequencedBase + count);
+							Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
 						}
 					}
 				}
@@ -432,11 +432,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimer = Timer::GetCurrentTime();
 				}
 			} else {
-				LogNetcode(_L "Received OP_OutOfOrderAck for out-of-window [{}]. Window ([{}]->[{}])" __L, seq, SequencedBase, NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				LogNetcode(_L "Post-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 
 			MOutboundQueue.unlock();
@@ -445,7 +445,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionStatRequest: {
 			if(p->Size() < sizeof(ClientSessionStats))
 			{
-				LogNetcode(_L "Received OP_SessionStatRequest that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
 			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
@@ -468,7 +468,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
-					LogNetcode(_L "Retransmit timeout recalculated to [{}]ms" __L, retransmittimeout);
+					Log(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
 				}
 			}
 
@@ -485,11 +485,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_SessionStatResponse: {
-			LogNetcode(_L "Received OP_SessionStatResponse. Ignoring" __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
 		}
 		break;
 		case OP_OutOfSession: {
-			LogNetcode(_L "Received OP_OutOfSession. Ignoring" __L);
+			Log(Logs::Detail, Logs::Netcode, _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) {
-		LogNetcode(_L "Packet enqueued into a stream with no opcode manager, dropping" __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
 		delete pack;
 		return;
 	}
@@ -559,18 +559,18 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 
 	// Convert the EQApplicationPacket to 1 or more EQProtocolPackets
 	if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
-		LogNetcode(_L "Making oversized packet, len [{}]" __L, p->Size());
+		Log(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
 
 		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
 		if (length != p->Size())
-			LogNetcode(_L "Packet adjustment, len [{}] to [{}]" __L, p->Size(), length);
+			Log(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __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);
-		LogNetcode(_L "First fragment: used [{}]/[{}]. Payload size [{}] in the packet" __L, used, length, p->size);
+		Log(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d 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;
-			LogNetcode(_L "Subsequent fragment: len [{}], used [{}]/[{}]" __L, chunksize, used, length);
+			Log(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
@@ -623,7 +623,7 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
-	LogNetcode(_L "Pushing non-sequenced packet of length [{}]" __L, p->size);
+	Log(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __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);
-	LogNetcode(_L "Sending ack with sequence [{}]" __L, seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
 	SetLastAckSent(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
 }
 
 void EQStream::SendOutOfOrderAck(uint16 seq)
 {
-	LogNetcode(_L "Sending out of order ack with sequence [{}]" __L, seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __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();
-				LogNetcode(_L "Starting combined packet with non-seq packet of len [{}]" __L, p->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __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)
-				LogNetcode(_L "Combined packet full at len [{}], next non-seq packet is len [{}]" __L, p->size, (NonSequencedQueue.front())->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __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
-					LogNetcode(_L "Exceeded write threshold in nonseq ([{}] > [{}])" __L, BytesWritten, threshold);
+					Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
 					break;
 				}
 			} else {
 				// Combine worked, so just remove this packet and it's spot in the queue
-				LogNetcode(_L "Combined non-seq packet of len [{}], yeilding [{}] combined" __L, (NonSequencedQueue.front())->size, p->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Combined non-seq packet of len %d, yeilding %d 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()) {
-				LogNetcode(_L "Tried to write a packet with an empty queue ([{}] is past next out [{}])" __L, seq_send, NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
 				continue;
 			}
@@ -728,35 +728,35 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
+						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
 					}
-					LogNetcode(_L "Not retransmitting seq packet [{}] because already marked as acked" __L, seq_send);
+					Log(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d 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();
-					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __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)
-					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send + 1, (*sitr)->size);
+					Log(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);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
+						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					LogNetcode(_L "Combined seq packet [{}] of len [{}], yeilding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d 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) {
-						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
+						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __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();
-					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __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)
-					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send, (*sitr)->size);
+					Log(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);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 
 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
+						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					LogNetcode(_L "Combined seq packet [{}] of len [{}], yielding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d 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) {
-				LogNetcode(_L "Post send Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __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) {
-		LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
+		Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __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)) {
-			LogNetcode(_L "All outgoing data flushed, closing stream" __L );
+			Log(Logs::Detail, Logs::Netcode, _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();
@@ -910,7 +910,7 @@ void EQStream::SendSessionRequest()
 	Request->Session=htonl(time(nullptr));
 	Request->MaxLength=htonl(512);
 
-	LogNetcode(_L "Sending OP_SessionRequest: session [{}], maxlen=[{}]" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __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);
 
-	LogNetcode(_L "Sending OP_SessionDisconnect: session [{}]" __L, (unsigned long)Session);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
 }
 
 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@@ -976,7 +976,7 @@ EQRawApplicationPacket *p=nullptr;
 		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if(emu_op == OP_Unknown) {
-				LogNetcode("Unable to convert EQ opcode {:#04x} to an Application opcode", p->opcode);
+				Log(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
 			}
 
 			p->SetOpcode(emu_op);
@@ -1004,7 +1004,7 @@ void EQStream::InboundQueueClear()
 {
 EQApplicationPacket *p=nullptr;
 
-	LogNetcode(_L "Clearing inbound queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
 
 	MInboundQueue.lock();
 	if (!InboundQueue.empty()) {
@@ -1047,7 +1047,7 @@ void EQStream::OutboundQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	LogNetcode(_L "Clearing outbound queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
 
 	MOutboundQueue.lock();
 	while(!NonSequencedQueue.empty()) {
@@ -1069,7 +1069,7 @@ void EQStream::PacketQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	LogNetcode(_L "Clearing future packet queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _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 {
-		LogNetcode(_L "Incoming packet failed checksum" __L);
+		Log(Logs::Detail, Logs::Netcode, _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...
-		LogNetcode(_L "Received an ack with no window advancement (seq [{}])" __L, seq);
+		Log(Logs::Detail, Logs::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
 	} else if(ord == SeqPast) {
 		//they are nacking blocks going back before our buffer, wtf?
-		LogNetcode(_L "Received an ack with backward window advancement (they gave [{}], our window starts at [{}]). This is bad" __L, seq, SequencedBase);
+		Log(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);
 	} else {
-		LogNetcode(_L "Received an ack up through sequence [{}]. Our base is [{}]" __L, seq, SequencedBase);
+		Log(Logs::Detail, Logs::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __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()) {
-				LogNetcode(_L "OUT OF PACKETS acked packet with sequence [{}]. Next send is [{}] before this" __L, (unsigned long)SequencedBase, SequencedQueue.size());
+				Log(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());
 				SequencedBase = NextOutSeq;
 				break;
 			}
-			LogNetcode(_L "Removing acked packet with sequence [{}]" __L, (unsigned long)SequencedBase);
+			Log(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __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) {
-			LogNetcode(_L "Post-Ack on [{}] Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
+			Log(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
 		}
 	}
 
@@ -1166,7 +1166,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 void EQStream::SetNextAckToSend(uint32 seq)
 {
 	MAcks.lock();
-	LogNetcode(_L "Set Next Ack To Send to [{}]" __L, (unsigned long)seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
 	NextAckToSend=seq;
 	MAcks.unlock();
 }
@@ -1174,7 +1174,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
 void EQStream::SetLastAckSent(uint32 seq)
 {
 	MAcks.lock();
-	LogNetcode(_L "Set Last Ack Sent to [{}]" __L, (unsigned long)seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
 	LastAckSent=seq;
 	MAcks.unlock();
 }
@@ -1187,10 +1187,10 @@ void EQStream::ProcessQueue()
 
 	EQProtocolPacket *qp=nullptr;
 	while((qp=RemoveQueue(NextInSeq))!=nullptr) {
-		LogNetcode(_L "Processing Queued Packet: Seq=[{}]" __L, NextInSeq);
+		Log(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
 		ProcessPacket(qp);
 		delete qp;
-		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
+		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 }
 
@@ -1201,21 +1201,21 @@ EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
-		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
+		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 	return qp;
 }
 
 void EQStream::SetStreamType(EQStreamType type)
 {
-	LogNetcode(_L "Changing stream type from [{}] to [{}]" __L, StreamTypeString(StreamType), StreamTypeString(type));
+	Log(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
 	StreamType=type;
 	switch (StreamType) {
 		case LoginStream:
 			app_opcode_size=1;
 			compressed=false;
 			encoded=false;
-			LogNetcode(_L "Login stream has app opcode size [{}], is not compressed or encoded" __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "Login stream has app opcode size %d, 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;
-			LogNetcode(_L "Chat/Mail stream has app opcode size [{}], is not compressed, and is encoded" __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "Chat/Mail stream has app opcode size %d, 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;
-			LogNetcode(_L "World/Zone stream has app opcode size [{}], is compressed, and is not encoded" __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "World/Zone stream has app opcode size %d, 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();
-	LogNetcode(_L "Changing state from [{}] to [{}]" __L, State, state);
+	Log(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __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) {
-		LogNetcode(_L "Out of data in closing state, disconnecting" __L);
+		Log(Logs::Detail, Logs::Netcode, _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
-			LogNetcode(_L "Timeout expired in closing state. Moving to closed state" __L);
+			Log(Logs::Detail, Logs::Netcode, _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.
-			LogNetcode(_L "Timeout expired in disconnecting state. Moving to closed state" __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
 			SetState(CLOSED);
 			break;
 		case CLOSED:
-			LogNetcode(_L "Timeout expired in closed state??" __L);
+			Log(Logs::Detail, Logs::Netcode, _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.
-			LogNetcode(_L "Timeout expired in established state. Closing connection" __L);
+			Log(Logs::Detail, Logs::Netcode, _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;
-				LogNetcode(_L "Timeout exceeded for seq [{}].  Flagging packet for retransmission" __L, SequencedBase + count);
+				Log(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
 			}
 		}
 		MOutboundQueue.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.
-		LogNetcode(_L "Stream requested to Close(), but there is pending data, waiting for it" __L);
+		Log(Logs::Detail, Logs::Netcode, _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();
-		LogNetcode(_L "Stream closing immediate due to Close()" __L);
+		Log(Logs::Detail, Logs::Netcode, _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) {
-				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length matched [{}]", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				Log(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);
 				res = MatchSuccessful;
 			} else if(sig->first_length == 0) {
-				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length ([{}]) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				Log(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);
 				res = MatchSuccessful;
 			} else {
 				//opcode matched but length did not.
-				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);
+				Log(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);
 				res = MatchFailed;
 			}
 		} else {
 			//first opcode did not match..
-			LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode {:#04x} did not match expected {:#04x}", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
+			Log(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);
 			res = MatchFailed;
 		}
 	}

common/eq_stream_ident.cpp

@@ -46,7 +46,7 @@ void EQStreamIdentifier::Process() {
 
 		//first see if this stream has expired
 		if(r.expire.Check(false)) {
-			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before timeout", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
+			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
 			r.stream->Close();
 
 			cur = m_streams.erase(cur);
@@ -62,23 +62,23 @@ void EQStreamIdentifier::Process() {
 		}
 		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before it closed", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			Log(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()));
 			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				LogNetcode("[StreamIdentify] Stream state was Established");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
 				break;
 			case CLOSING:
-				LogNetcode("[StreamIdentify] Stream state was Closing");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				LogNetcode("[StreamIdentify] Stream state was Disconnecting");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				LogNetcode("[StreamIdentify] Stream state was Closed");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
 				break;
 			default:
-				LogNetcode("[StreamIdentify] Stream state was Unestablished or unknown");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
 				break;
 			}
 			r.stream->ReleaseFromUse();
@@ -102,13 +102,13 @@ void EQStreamIdentifier::Process() {
 			switch(res) {
 			case EQStreamInterface::MatchNotReady:
 				//the stream has not received enough packets to compare with this signature
-//				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());
+//				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());
 				all_ready = false;
 				break;
 			case EQStreamInterface::MatchSuccessful: {
 				//yay, a match.
 
-				LogNetcode("[StreamIdentify] Identified stream [{}:{}] with signature [{}]", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				Log(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());
 
 				// 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);
@@ -122,7 +122,7 @@ void EQStreamIdentifier::Process() {
 			}
 			case EQStreamInterface::MatchFailed:
 				//do nothing...
-				LogNetcode("[StreamIdentify] [{}:{}] Tried patch [{}] and it did not match", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				Log(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());
 				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.
-			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}], no match found", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			Log(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()));
 			r.stream->ReleaseFromUse();
 		}
 

common/eq_stream_intf.h

@@ -100,7 +100,7 @@ public:
 	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 const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
 	virtual Stats GetStats() const = 0;
 	virtual void ResetStats() = 0;
 	virtual EQStreamManagerInterface* GetManager() const = 0;

common/eq_stream_proxy.cpp

@@ -22,7 +22,7 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQ::versions::ClientVersion EQStreamProxy::ClientVersion() const
+const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
 {
 	return m_structs->ClientVersion();
 }
@@ -42,8 +42,8 @@ void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 		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());
+		Log(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_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
 	}
 
 	EQApplicationPacket *newp = p->Copy();

common/eq_stream_proxy.h

@@ -28,7 +28,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const EQ::versions::ClientVersion ClientVersion() const;
+	virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 	virtual EQStreamState GetState();
 	virtual void SetOpcodeManager(OpcodeManager **opm);
 	virtual Stats GetStats() const;

common/eqemu_config.cpp

@@ -104,15 +104,6 @@ void EQEmuConfig::parse_config()
 	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
 	 */

common/eqemu_config.h

@@ -74,13 +74,6 @@ class EQEmuConfig
 		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;
@@ -172,7 +165,7 @@ class EQEmuConfig
 				fconfig >> _config->_root;
 				_config->parse_config();
 			}
-			catch (std::exception &) {
+			catch (std::exception) {
 				return false;
 			}			
 			return true;

common/eqemu_exception.cpp

@@ -18,7 +18,7 @@
 
 #include "eqemu_exception.h"
 
-namespace EQ
+namespace EQEmu
 {
 	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 EQ
+namespace EQEmu
 {
 	//! EQEmu Exception Class
 	/*!
@@ -104,7 +104,7 @@ namespace EQ
 } // EQEmu
 
 #ifndef EQ_EXCEPT
-#define EQ_EXCEPT(n, d) throw EQ::Exception(n, d, __FILE__, __LINE__)
+#define EQ_EXCEPT(n, d) throw EQEmu::Exception(n, d, __FILE__, __LINE__)
 #endif
 
 #endif

common/eqemu_logsys.cpp

@@ -19,7 +19,6 @@
 */
 
 #include "eqemu_logsys.h"
-#include "rulesys.h"
 #include "platform.h"
 #include "string_util.h"
 #include "database.h"
@@ -82,19 +81,31 @@ namespace Console {
 	};
 }
 
+enum GameChatColor {
+	yellow       = 15,
+	red          = 13,
+	light_green  = 14,
+	light_cyan   = 258,
+	light_purple = 5
+};
+
 /**
  * EQEmuLogSys Constructor
  */
 EQEmuLogSys::EQEmuLogSys()
 {
-	on_log_gmsay_hook   = [](uint16 log_type, const std::string &) {};
-	on_log_console_hook = [](uint16 debug_level, uint16 log_type, const std::string &) {};
+	on_log_gmsay_hook      = [](uint16 log_type, const std::string &) {};
+	on_log_console_hook    = [](uint16 debug_level, uint16 log_type, const std::string &) {};
+	bool file_logs_enabled = false;
+	int  log_platform      = 0;
 }
 
 /**
  * EQEmuLogSys Deconstructor
  */
-EQEmuLogSys::~EQEmuLogSys() = default;
+EQEmuLogSys::~EQEmuLogSys()
+{
+}
 
 void EQEmuLogSys::LoadLogSettingsDefaults()
 {
@@ -102,7 +113,7 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	 * Get Executable platform currently running this code (Zone/World/etc)
 	 */
 	log_platform = GetExecutablePlatformInt();
-
+	
 	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;
@@ -115,29 +126,15 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	/**
 	 * 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);
+	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;
+	log_settings[Logs::Headless_Client].log_to_console = Logs::General;
+	log_settings[Logs::NPCScaling].log_to_gmsay        = Logs::General;
 
 	/**
 	 * Set Category enabled status on defaults
@@ -178,41 +175,20 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	}
 }
 
-/**
- * @param log_category
- * @return
- */
-bool EQEmuLogSys::IsRfc5424LogCategory(uint16 log_category)
-{
-	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
-	);
-}
-
 /**
  * @param log_category
  * @param in_message
  * @return
  */
-std::string EQEmuLogSys::FormatOutMessageString(
-	uint16 log_category,
-	const std::string &in_message
-)
+std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
 {
-	std::string return_string;
-
-	if (IsRfc5424LogCategory(log_category)) {
-		return_string = "[" + GetPlatformName() + "] ";
-	}
-
-	return return_string + "[" + Logs::LogCategoryName[log_category] + "] " + in_message;
+	std::string ret;
+	ret.push_back('[');
+	ret.append(Logs::LogCategoryName[log_category]);
+	ret.push_back(']');
+	ret.push_back(' ');
+	ret.append(in_message);
+	return ret;
 }
 
 /**
@@ -220,11 +196,7 @@ std::string EQEmuLogSys::FormatOutMessageString(
  * @param log_category
  * @param message
  */
-void EQEmuLogSys::ProcessGMSay(
-	uint16 debug_level,
-	uint16 log_category,
-	const std::string &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
@@ -246,11 +218,7 @@ void EQEmuLogSys::ProcessGMSay(
  * @param log_category
  * @param message
  */
-void EQEmuLogSys::ProcessLogWrite(
-	uint16 debug_level,
-	uint16 log_category,
-	const std::string &message
-)
+void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message)
 {
 	if (log_category == Logs::Crash) {
 		char time_stamp[80];
@@ -312,8 +280,6 @@ std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category)
 		case Logs::Normal:
 			return LC_YELLOW;
 		case Logs::MySQLError:
-		case Logs::Warning:
-		case Logs::Critical:
 		case Logs::Error:
 			return LC_RED;
 		case Logs::MySQLQuery:
@@ -340,22 +306,22 @@ uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category)
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
-			return Chat::Yellow;
+			return GameChatColor::yellow;
 		case Logs::MySQLError:
 		case Logs::Error:
-			return Chat::Red;
+			return GameChatColor::red;
 		case Logs::MySQLQuery:
 		case Logs::Debug:
-			return Chat::Lime;
+			return GameChatColor::light_green;
 		case Logs::Quests:
-			return Chat::Group;
+			return GameChatColor::light_cyan;
 		case Logs::Commands:
 		case Logs::Mercenaries:
-			return Chat::Magenta;
+			return GameChatColor::light_purple;
 		case Logs::Crash:
-			return Chat::Red;
+			return GameChatColor::red;
 		default:
-			return Chat::Yellow;
+			return GameChatColor::yellow;
 	}
 }
 
@@ -385,42 +351,6 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 	on_log_console_hook(debug_level, log_category, message);
 }
 
-/**
- * @param str
- * @return
- */
-constexpr const char *str_end(const char *str)
-{
-	return *str ? str_end(str + 1) : str;
-}
-
-/**
- * @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
  *
@@ -429,15 +359,7 @@ constexpr const char *base_file_name(const char *str)
  * @param message
  * @param ...
  */
-void EQEmuLogSys::Out(
-	Logs::DebugLevel debug_level,
-	uint16 log_category,
-	const char *file,
-	const char *func,
-	int line,
-	const char *message,
-	...
-)
+void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
 	bool log_to_console = true;
 	if (log_settings[log_category].log_to_console < debug_level) {
@@ -459,18 +381,12 @@ void EQEmuLogSys::Out(
 		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, args);
+	std::string output_message = vStringFormat(message.c_str(), args);
 	va_end(args);
 
-	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, prefix + output_message);
+	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, output_message);
 
 	if (log_to_console) {
 		EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
@@ -506,7 +422,7 @@ void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
 		return;
 	_mkdir(directory_name.c_str());
 #else
-	struct stat st{};
+	struct stat st;
 	if (stat(directory_name.c_str(), &st) == 0) { // exists
 		return;
 	}
@@ -547,7 +463,12 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 			return;
 		}
 
-		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());
+		EQEmuLogSys::Out(
+			Logs::General,
+			Logs::Status,
+			"Starting File Log 'logs/%s_%i.log'",
+			platform_file_name.c_str(),
+			getpid());
 
 		/**
 		 * Make directory if not exists
@@ -567,11 +488,17 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 		/**
 		 * All other processes
 		 */
+
 		if (platform_file_name.empty()) {
 			return;
 		}
 
-		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());
+		EQEmuLogSys::Out(
+			Logs::General,
+			Logs::Status,
+			"Starting File Log 'logs/%s_%i.log'",
+			platform_file_name.c_str(),
+			getpid());
 
 		/**
 		 * Open file pointer
@@ -582,25 +509,3 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 		);
 	}
 }
-
-/**
- * Silence console logging
- */
-void EQEmuLogSys::SilenceConsoleLogging()
-{
-	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
-		log_settings[log_index].log_to_console      = 0;
-		log_settings[log_index].is_category_enabled = 0;
-	}
-}
-
-/**
- * Enables console logging
- */
-void EQEmuLogSys::EnableConsoleLogging()
-{
-	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
-		log_settings[log_index].log_to_console      = Logs::General;
-		log_settings[log_index].is_category_enabled = 1;
-	}
-}

common/eqemu_logsys.h

@@ -25,14 +25,6 @@
 #include <fstream>
 #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 {
@@ -53,7 +45,7 @@ namespace Logs {
 		AI,
 		Aggro,
 		Attack,
-		PacketClientServer,
+		Client_Server_Packet,
 		Combat,
 		Commands,
 		Crash,
@@ -67,60 +59,40 @@ namespace Logs {
 		Normal,
 		Object,
 		Pathing,
-		QSServer,
+		QS_Server,
 		Quests,
 		Rules,
 		Skills,
 		Spawns,
 		Spells,
 		Status,
-		TCPConnection,
+		TCP_Connection,
 		Tasks,
 		Tradeskills,
 		Trading,
 		Tribute,
-		UCSServer,
-		WebInterfaceServer,
-		WorldServer,
-		ZoneServer,
+		UCS_Server,
+		WebInterface_Server,
+		World_Server,
+		Zone_Server,
 		MySQLError,
 		MySQLQuery,
 		Mercenaries,
 		QuestDebug,
-		PacketServerClient,
-		PacketClientServerUnhandled,
-		PacketServerClientWithDump,
-		PacketClientServerWithDump,
-		Loginserver,
-		ClientLogin,
-		HeadlessClient,
-		HPUpdate,
+		Server_Client_Packet,
+		Client_Server_Packet_Unhandled,
+		Server_Client_Packet_With_Dump,
+		Client_Server_Packet_With_Dump,
+		Login_Server,
+		Client_Login,
+		Headless_Client,
+		HP_Update,
 		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 */
 	};
 
@@ -180,31 +152,19 @@ namespace Logs {
 		"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",
+		"Mob Appearance"
 	};
 }
 
-#include "eqemu_logsys_log_aliases.h"
+#define Log(debug_level, log_category, message, ...) do {\
+    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
+        LogSys.Out(debug_level, log_category, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogF(debug_level, log_category, message, ...) do {\
+    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
+        OutF(LogSys, debug_level, log_category, message, ##__VA_ARGS__);\
+} while (0)
 
 class EQEmuLogSys {
 public:
@@ -217,10 +177,6 @@ public:
 	 */
 	void CloseFileLogs();
 	void LoadLogSettingsDefaults();
-
-	/**
-	 * @param directory_name
-	 */
 	void MakeDirectory(const std::string &directory_name);
 
 	/**
@@ -232,25 +188,12 @@ public:
 	 *		- 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,
-		const char *file,
-		const char *func,
-		int line,
-		const char *message,
-		...
-	);
+	void Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...);
 
 	/**
 	 * Used in file logs to prepend a timestamp entry for logs
-	 * @param time_stamp
 	 */
 	void SetCurrentTimeStamp(char* time_stamp);
-
-	/**
-	 * @param log_name
-	 */
 	void StartFileLogs(const std::string &log_name = "");
 
 	/**
@@ -275,14 +218,14 @@ public:
 	 * 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 = false;
+	bool file_logs_enabled;
 
 	/**
 	 * Sets Executable platform (Zone/World/UCS) etc.
 	 */
-	int log_platform = 0;
+	int log_platform;
 
 	/**
 	 * File name used in writing logs
@@ -297,26 +240,9 @@ public:
 	 */
 	uint16 GetGMSayColorFromCategory(uint16 log_category);
 
-	/**
-	 * @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:
 
 	/**
@@ -332,7 +258,6 @@ private:
 
 	/**
 	 * Linux console color messages mapped by category
-	 *
 	 * @param log_category
 	 * @return
 	 */
@@ -343,57 +268,11 @@ private:
 	 */
 	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 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/eqemu_logsys_fmt.h

@@ -16,21 +16,15 @@
  * 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_IP_UTIL_H
-#define EQEMU_IP_UTIL_H
+#pragma once
 
-#include "types.h"
-#include "iostream"
+#include <fmt/format.h>
 
-class IpUtil {
-public:
-
-	static uint32_t IPToUInt(const std::string &ip);
-	static bool IsIpInRange(const std::string &ip, const std::string &network, const std::string &mask);
-	static bool IsIpInPrivateRfc1918(const std::string &ip);
-
-};
-
-#endif //EQEMU_IP_UTIL_H
+template <typename... Args>
+void OutF(EQEmuLogSys &ls, Logs::DebugLevel debug_level, uint16 log_category, const char *fmt, const Args&... args)
+{
+	std::string log_str = fmt::format(fmt, args...);
+	ls.Out(debug_level, log_category, log_str);
+}

common/event/event_loop.h

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

common/event/task.h

@@ -8,7 +8,7 @@ namespace EQ {
 	class Task
 	{
 	public:
-		typedef std::function<void(const EQ::Any&)> ResolveFn;
+		typedef std::function<void(const EQEmu::Any&)> ResolveFn;
 		typedef std::function<void(const std::exception&)> RejectFn;
 		typedef std::function<void()> FinallyFn;
 		typedef std::function<void(ResolveFn, RejectFn)> TaskFn;
@@ -19,7 +19,7 @@ namespace EQ {
 			RejectFn on_catch;
 			FinallyFn on_finally;
 			bool has_result;
-			EQ::Any result;
+			EQEmu::Any result;
 			bool has_error;
 			std::exception error;
 		};
@@ -63,7 +63,7 @@ namespace EQ {
 			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->fn([baton](const EQEmu::Any& result) {
 					baton->has_error = false;
 					baton->has_result = true;
 					baton->result = result;

common/event/task_scheduler.h

@@ -1,114 +0,0 @@
-#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/extprofile.h

@@ -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 */
-	EQ::TextureMaterialProfile	pet_items; /* Not Used */
+	EQEmu::TextureMaterialProfile	pet_items; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */

common/file_util.cpp

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

common/file_util.h

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

common/fixed_memory_hash_set.h

@@ -23,7 +23,7 @@
 #include "eqemu_exception.h"
 #include "types.h"
 
-namespace EQ {
+namespace EQEmu {
 
 	/*! Simple HashSet designed to be used in fixed memory that may be difficult to use an
 	allocator for (shared memory), we assume all keys are unsigned int

common/fixed_memory_variable_hash_set.h

@@ -23,7 +23,7 @@
 #include "eqemu_exception.h"
 #include "types.h"
 
-namespace EQ {
+namespace EQEmu {
 
 	/*! Simple HashSet designed to be used in fixed memory that may be difficult to use an
 	allocator for (shared memory), we assume all keys are unsigned int, values are a pointer and size

common/guild_base.cpp

@@ -46,7 +46,7 @@ bool BaseGuildManager::LoadGuilds() {
 	ClearGuilds();
 
 	if(m_db == nullptr) {
-		LogGuilds("Requested to load guilds when we have no database object");
+		Log(Logs::Detail, Logs::Guilds, "Requested to load guilds when we have no database object.");
 		return(false);
 	}
 
@@ -77,13 +77,13 @@ bool BaseGuildManager::LoadGuilds() {
 		uint8 rankn = atoi(row[1]);
 
 		if(rankn > GUILD_MAX_RANK) {
-			LogGuilds("Found invalid (too high) rank [{}] for guild [{}], skipping", rankn, guild_id);
+			Log(Logs::Detail, Logs::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
 			continue;
 		}
 
 		res = m_guilds.find(guild_id);
 		if(res == m_guilds.end()) {
-			LogGuilds("Found rank [{}] for non-existent guild [{}], skipping", rankn, guild_id);
+			Log(Logs::Detail, Logs::Guilds, "Found rank %d for non-existent guild %d, skipping.", rankn, guild_id);
 			continue;
 		}
 
@@ -105,7 +105,7 @@ bool BaseGuildManager::LoadGuilds() {
 
 bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to refresh guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id);
 		return(false);
 	}
 
@@ -123,7 +123,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 
 	if (results.RowCount() == 0)
 	{
-		LogGuilds("Unable to find guild [{}] in the database", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Unable to find guild %d in the database.", guild_id);
 		return false;
 	}
 
@@ -145,7 +145,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 		uint8 rankn = atoi(row[1]);
 
 		if(rankn > GUILD_MAX_RANK) {
-			LogGuilds("Found invalid (too high) rank [{}] for guild [{}], skipping", rankn, guild_id);
+			Log(Logs::Detail, Logs::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
 			continue;
 		}
 
@@ -162,7 +162,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 		rank.permissions[GUILD_WARPEACE] = (row[10][0] == '1') ? true: false;
 	}
 
-	LogGuilds("Successfully refreshed guild [{}] from the database", guild_id);
+	Log(Logs::Detail, Logs::Guilds, "Successfully refreshed guild %d from the database.", guild_id);
 
 	return true;
 }
@@ -214,14 +214,14 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 
 bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to store guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to store guild %d when we have no database object.", guild_id);
 		return(false);
 	}
 
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end()) {
-		LogGuilds("Requested to store non-existent guild [{}]", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to store non-existent guild %d", guild_id);
 		return(false);
 	}
 	GuildInfo *info = res->second;
@@ -289,14 +289,14 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 		safe_delete_array(title_esc);
 	}
 
-	LogGuilds("Stored guild [{}] in the database", guild_id);
+	Log(Logs::Detail, Logs::Guilds, "Stored guild %d in the database", guild_id);
 
 	return true;
 }
 
 uint32 BaseGuildManager::_GetFreeGuildID() {
 	if(m_db == nullptr) {
-		LogGuilds("Requested find a free guild ID when we have no database object");
+		Log(Logs::Detail, Logs::Guilds, "Requested find a free guild ID when we have no database object.");
 		return(GUILD_NONE);
 	}
 
@@ -330,12 +330,12 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
 
 		if (results.RowCount() == 0)
 		{
-			LogGuilds("Located free guild ID [{}] in the database", index);
+			Log(Logs::Detail, Logs::Guilds, "Located free guild ID %d in the database", index);
 			return index;
 		}
 	}
 
-	LogGuilds("Unable to find a free guild ID when requested");
+	Log(Logs::Detail, Logs::Guilds, "Unable to find a free guild ID when requested.");
 	return GUILD_NONE;
 }
 
@@ -505,11 +505,11 @@ uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
 
 	//now store the resulting guild setup into the DB.
 	if(!_StoreGuildDB(new_id)) {
-		LogGuilds("Error storing new guild. It may have been partially created which may need manual removal");
+		Log(Logs::Detail, Logs::Guilds, "Error storing new guild. It may have been partially created which may need manual removal.");
 		return(GUILD_NONE);
 	}
 
-	LogGuilds("Created guild [{}] in the database", new_id);
+	Log(Logs::Detail, Logs::Guilds, "Created guild %d in the database.", new_id);
 
 	return(new_id);
 }
@@ -525,7 +525,7 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
 	}
 
 	if(m_db == nullptr) {
-		LogGuilds("Requested to delete guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to delete guild %d when we have no database object.", guild_id);
 		return(false);
 	}
 
@@ -545,14 +545,14 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
 	query = StringFormat("DELETE FROM guild_bank WHERE guildid=%lu", (unsigned long)guild_id);
 	QueryWithLogging(query, "deleting guild bank");
 
-	LogGuilds("Deleted guild [{}] from the database", guild_id);
+	Log(Logs::Detail, Logs::Guilds, "Deleted guild %d from the database.", guild_id);
 
 	return(true);
 }
 
 bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to rename guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to rename guild %d when we have no database object.", guild_id);
 		return false;
 	}
 
@@ -573,13 +573,13 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 	if (!results.Success())
 	{
-		LogGuilds("Error renaming guild [{}] [{}]: [{}]", guild_id, query.c_str(), results.Success());
+		Log(Logs::Detail, Logs::Guilds, "Error renaming guild %d '%s': %s", guild_id, query.c_str(), results.Success());
 		safe_delete_array(esc);
 		return false;
 	}
 	safe_delete_array(esc);
 
-	LogGuilds("Renamed guild [{}] ([{}]) to [{}] in database", info->name.c_str(), guild_id, name);
+	Log(Logs::Detail, Logs::Guilds, "Renamed guild %s (%d) to %s in database.", info->name.c_str(), guild_id, name);
 
 	info->name = name;	//update our local record.
 
@@ -588,7 +588,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to set the leader for guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id);
 		return false;
 	}
 
@@ -614,7 +614,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
 	if(!DBSetGuildRank(leader, GUILD_LEADER))
 		return false;
 
-	LogGuilds("Set guild leader for guild [{}] to [{}] in the database", guild_id, leader);
+	Log(Logs::Detail, Logs::Guilds, "Set guild leader for guild %d to %d in the database", guild_id, leader);
 
 	info->leader_char_id = leader;	//update our local record.
 
@@ -623,7 +623,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
 
 bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to set the MOTD for guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id);
 		return(false);
 	}
 
@@ -654,7 +654,7 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 	safe_delete_array(esc);
 	safe_delete_array(esc_set);
 
-	LogGuilds("Set MOTD for guild [{}] in the database", guild_id);
+	Log(Logs::Detail, Logs::Guilds, "Set MOTD for guild %d in the database", guild_id);
 
 	info->motd = motd;	//update our local record.
 	info->motd_setter = setter;	//update our local record.
@@ -688,7 +688,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 	}
 	safe_delete_array(esc);
 
-	LogGuilds("Set URL for guild [{}] in the database", GuildID);
+	Log(Logs::Detail, Logs::Guilds, "Set URL for guild %d in the database", GuildID);
 
 	info->url = URL;	//update our local record.
 
@@ -722,7 +722,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 	}
 	safe_delete_array(esc);
 
-	LogGuilds("Set Channel for guild [{}] in the database", GuildID);
+	Log(Logs::Detail, Logs::Guilds, "Set Channel for guild %d in the database", GuildID);
 
 	info->channel = Channel;	//update our local record.
 
@@ -731,7 +731,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 
 bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested to set char to guild [{}] when we have no database object", guild_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id);
 		return(false);
 	}
 
@@ -753,7 +753,7 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 			return false;
 		}
     }
-	LogGuilds("Set char [{}] to guild [{}] and rank [{}] in the database", charid, guild_id, rank);
+	Log(Logs::Detail, Logs::Guilds, "Set char %d to guild %d and rank %d in the database.", charid, guild_id, rank);
 	return true;
 }
 
@@ -845,7 +845,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 		return false;
 	}
 
-	LogGuilds("Set public not for char [{}]", charid);
+	Log(Logs::Detail, Logs::Guilds, "Set public not for char %d", charid);
 
 	return true;
 }
@@ -912,7 +912,7 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		return(false);
 
 	//load up the rank info for each guild.
-	std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d AND c.deleted_at IS NULL", guild_id);
+	std::string query = StringFormat(GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id);
 	auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
@@ -924,14 +924,14 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		members.push_back(ci);
 	}
 
-	LogGuilds("Retreived entire guild member list for guild [{}] from the database", guild_id);
+	Log(Logs::Detail, Logs::Guilds, "Retreived entire guild member list for guild %d from the database", guild_id);
 
 	return true;
 }
 
 bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested char info on [{}] when we have no database object", char_name);
+		Log(Logs::Detail, Logs::Guilds, "Requested char info on %s when we have no database object.", char_name);
 		return(false);
 	}
 
@@ -941,7 +941,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
-    std::string query = StringFormat(GuildMemberBaseQuery " WHERE c.name='%s' AND c.deleted_at IS NULL", esc);
+    std::string query = StringFormat(GuildMemberBaseQuery " WHERE c.name='%s'", esc);
     safe_delete_array(esc);
     auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {
@@ -953,7 +953,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 
     auto row = results.begin();
     ProcessGuildMember(row, into);
-    LogGuilds("Retreived guild member info for char [{}] from the database", char_name);
+    Log(Logs::Detail, Logs::Guilds, "Retreived guild member info for char %s from the database", char_name);
 
 	return true;
 
@@ -962,16 +962,16 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 
 bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 	if(m_db == nullptr) {
-		LogGuilds("Requested char info on [{}] when we have no database object", char_id);
+		Log(Logs::Detail, Logs::Guilds, "Requested char info on %d when we have no database object.", char_id);
 		return false;
 	}
 
 	//load up the rank info for each guild.
 	std::string query;
 #ifdef BOTS
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C' AND c.deleted_at IS NULL", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C'", char_id);
 #else
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.deleted_at IS NULL", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
 #endif
     auto results = m_db->QueryDatabase(query);
 	if (!results.Success()) {
@@ -983,7 +983,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 
     auto row = results.begin();
     ProcessGuildMember(row, into);
-    LogGuilds("Retreived guild member info for char [{}]", char_id);
+    Log(Logs::Detail, Logs::Guilds, "Retreived guild member info for char %d", char_id);
 
 	return true;
 
@@ -1098,16 +1098,16 @@ bool BaseGuildManager::GuildExists(uint32 guild_id) const {
 
 bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
 	if(guild_id == GUILD_NONE) {
-		LogGuilds("Check leader for char [{}]: not a guild", char_id);
+		Log(Logs::Detail, Logs::Guilds, "Check leader for char %d: not a guild.", char_id);
 		return(false);
 	}
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end()) {
-		LogGuilds("Check leader for char [{}]: invalid guild", char_id);
+		Log(Logs::Detail, Logs::Guilds, "Check leader for char %d: invalid guild.", char_id);
 		return(false);	//invalid guild
 	}
-	LogGuilds("Check leader for guild [{}], char [{}]: leader id=[{}]", guild_id, char_id, res->second->leader_char_id);
+	Log(Logs::Detail, Logs::Guilds, "Check leader for guild %d, char %d: leader id=%d", guild_id, char_id, res->second->leader_char_id);
 	return(char_id == res->second->leader_char_id);
 }
 
@@ -1137,20 +1137,20 @@ uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 cha
 
 bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
 	if(status >= 250) {
-		LogGuilds("Check permission on guild [{}] with user status [{}] > 250, granted", guild_id, status);
+		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status);
 		return(true);	//250+ as allowed anything
 	}
 
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end()) {
-		LogGuilds("Check permission on guild [{}] with user status [{}], no such guild, denied", guild_id, status);
+		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d, no such guild, denied.", guild_id, status);
 		return(false);	//invalid guild
 	}
 
 	bool granted = (res->second->minstatus <= status);
 
-	LogGuilds("Check permission on guild [{}] ([{}]) with user status [{}]. Min status [{}]: [{}]",
+	Log(Logs::Detail, Logs::Guilds, "Check permission on guild %s (%d) with user status %d. Min status %d: %s",
 		res->second->name.c_str(), guild_id, status, res->second->minstatus, granted?"granted":"denied");
 
 	return(granted);
@@ -1158,21 +1158,21 @@ bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
 
 bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const {
 	if(rank > GUILD_MAX_RANK) {
-		LogGuilds("Check permission on guild [{}] and rank [{}] for action [{}] ([{}]): Invalid rank, denied",
+		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.",
 			guild_id, rank, GuildActionNames[act], act);
 		return(false);	//invalid rank
 	}
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end()) {
-		LogGuilds("Check permission on guild [{}] and rank [{}] for action [{}] ([{}]): Invalid guild, denied",
+		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid guild, denied.",
 			guild_id, rank, GuildActionNames[act], act);
 		return(false);	//invalid guild
 	}
 
 	bool granted = res->second->ranks[rank].permissions[act];
 
-	LogGuilds("Check permission on guild [{}] ([{}]) and rank [{}] ([{}]) for action [{}] ([{}]): [{}]",
+	Log(Logs::Detail, Logs::Guilds, "Check permission on guild %s (%d) and rank %s (%d) for action %s (%d): %s",
 		res->second->name.c_str(), guild_id,
 		res->second->ranks[rank].name.c_str(), rank,
 		GuildActionNames[act], act,

common/inventory_profile.cpp

@@ -33,7 +33,7 @@
 
 #include <iostream>
 
-std::list<EQ::ItemInstance*> dirty_inst;
+std::list<EQEmu::ItemInstance*> dirty_inst;
 
 
 //
@@ -48,50 +48,50 @@ ItemInstQueue::~ItemInstQueue()
 }
 
 // Put item onto back of queue
-void ItemInstQueue::push(EQ::ItemInstance* inst)
+void ItemInstQueue::push(EQEmu::ItemInstance* inst)
 {
 	m_list.push_back(inst);
 }
 
 // Put item onto front of queue
-void ItemInstQueue::push_front(EQ::ItemInstance* inst)
+void ItemInstQueue::push_front(EQEmu::ItemInstance* inst)
 {
 	m_list.push_front(inst);
 }
 
 // Remove item from front of queue
-EQ::ItemInstance* ItemInstQueue::pop()
+EQEmu::ItemInstance* ItemInstQueue::pop()
 {
 	if (m_list.empty())
 		return nullptr;
 
-	EQ::ItemInstance* inst = m_list.front();
+	EQEmu::ItemInstance* inst = m_list.front();
 	m_list.pop_front();
 	return inst;
 }
 
 // Remove item from back of queue
-EQ::ItemInstance* ItemInstQueue::pop_back()
+EQEmu::ItemInstance* ItemInstQueue::pop_back()
 {
 	if (m_list.empty())
 		return nullptr;
 
-	EQ::ItemInstance* inst = m_list.back();
+	EQEmu::ItemInstance* inst = m_list.back();
 	m_list.pop_back();
 	return inst;
 }
 
 // Look at item at front of queue
-EQ::ItemInstance* ItemInstQueue::peek_front() const
+EQEmu::ItemInstance* ItemInstQueue::peek_front() const
 {
 	return (m_list.empty()) ? nullptr : m_list.front();
 }
 
 
 //
-// class EQ::InventoryProfile
+// class EQEmu::InventoryProfile
 //
-EQ::InventoryProfile::~InventoryProfile()
+EQEmu::InventoryProfile::~InventoryProfile()
 {
 	for (auto iter = m_worn.begin(); iter != m_worn.end(); ++iter) {
 		safe_delete(iter->second);
@@ -119,18 +119,18 @@ EQ::InventoryProfile::~InventoryProfile()
 	m_trade.clear();
 }
 
-void EQ::InventoryProfile::SetInventoryVersion(versions::MobVersion inventory_version) {
+void EQEmu::InventoryProfile::SetInventoryVersion(versions::MobVersion inventory_version) {
 	m_mob_version = versions::ValidateMobVersion(inventory_version);
 	SetGMInventory(m_gm_inventory);
 }
 
-void EQ::InventoryProfile::SetGMInventory(bool gmi_flag) {
+void EQEmu::InventoryProfile::SetGMInventory(bool gmi_flag) {
 	m_gm_inventory = gmi_flag;
 
 	m_lookup = inventory::DynamicLookup(m_mob_version, gmi_flag);
 }
 
-void EQ::InventoryProfile::CleanDirty() {
+void EQEmu::InventoryProfile::CleanDirty() {
 	auto iter = dirty_inst.begin();
 	while (iter != dirty_inst.end()) {
 		delete (*iter);
@@ -139,14 +139,14 @@ void EQ::InventoryProfile::CleanDirty() {
 	dirty_inst.clear();
 }
 
-void EQ::InventoryProfile::MarkDirty(ItemInstance *inst) {
+void EQEmu::InventoryProfile::MarkDirty(ItemInstance *inst) {
 	if (inst) {
 		dirty_inst.push_back(inst);
 	}
 }
 
 // Retrieve item at specified slot; returns false if item not found
-EQ::ItemInstance* EQ::InventoryProfile::GetItem(int16 slot_id) const
+EQEmu::ItemInstance* EQEmu::InventoryProfile::GetItem(int16 slot_id) const
 {
 	ItemInstance* result = nullptr;
 
@@ -219,31 +219,31 @@ EQ::ItemInstance* EQ::InventoryProfile::GetItem(int16 slot_id) const
 }
 
 // Retrieve item at specified position within bag
-EQ::ItemInstance* EQ::InventoryProfile::GetItem(int16 slot_id, uint8 bagidx) const
+EQEmu::ItemInstance* EQEmu::InventoryProfile::GetItem(int16 slot_id, uint8 bagidx) const
 {
 	return GetItem(InventoryProfile::CalcSlotId(slot_id, bagidx));
 }
 
 // Put an item snto specified slot
-int16 EQ::InventoryProfile::PutItem(int16 slot_id, const ItemInstance& inst)
+int16 EQEmu::InventoryProfile::PutItem(int16 slot_id, const ItemInstance& inst)
 {
-	if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
+	if (slot_id <= EQEmu::invslot::POSSESSIONS_END && slot_id >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 		if ((((uint64)1 << slot_id) & m_lookup->PossessionsBitmask) == 0)
-			return EQ::invslot::SLOT_INVALID;
+			return EQEmu::invslot::SLOT_INVALID;
 	}
-	else if (slot_id <= EQ::invbag::GENERAL_BAGS_END && slot_id >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-		auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((slot_id - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
+	else if (slot_id <= EQEmu::invbag::GENERAL_BAGS_END && slot_id >= EQEmu::invbag::GENERAL_BAGS_BEGIN) {
+		auto temp_slot = EQEmu::invslot::GENERAL_BEGIN + ((slot_id - EQEmu::invbag::GENERAL_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT);
 		if ((((uint64)1 << temp_slot) & m_lookup->PossessionsBitmask) == 0)
-			return EQ::invslot::SLOT_INVALID;
+			return EQEmu::invslot::SLOT_INVALID;
 	}
-	else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
-		if ((slot_id - EQ::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank)
-			return EQ::invslot::SLOT_INVALID;
+	else if (slot_id <= EQEmu::invslot::BANK_END && slot_id >= EQEmu::invslot::BANK_BEGIN) {
+		if ((slot_id - EQEmu::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank)
+			return EQEmu::invslot::SLOT_INVALID;
 	}
-	else if (slot_id <= EQ::invbag::BANK_BAGS_END && slot_id >= EQ::invbag::BANK_BAGS_BEGIN) {
-		auto temp_slot = (slot_id - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
+	else if (slot_id <= EQEmu::invbag::BANK_BAGS_END && slot_id >= EQEmu::invbag::BANK_BAGS_BEGIN) {
+		auto temp_slot = (slot_id - EQEmu::invbag::BANK_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT;
 		if (temp_slot >= m_lookup->InventoryTypeSize.Bank)
-			return EQ::invslot::SLOT_INVALID;
+			return EQEmu::invslot::SLOT_INVALID;
 	}
 	
 	// Clean up item already in slot (if exists)
@@ -259,17 +259,17 @@ int16 EQ::InventoryProfile::PutItem(int16 slot_id, const ItemInstance& inst)
 	return _PutItem(slot_id, inst.Clone());
 }
 
-int16 EQ::InventoryProfile::PushCursor(const ItemInstance &inst) {
+int16 EQEmu::InventoryProfile::PushCursor(const ItemInstance &inst) {
 	m_cursor.push(inst.Clone());
 	return invslot::slotCursor;
 }
 
-EQ::ItemInstance* EQ::InventoryProfile::GetCursorItem() {
+EQEmu::ItemInstance* EQEmu::InventoryProfile::GetCursorItem() {
 	return m_cursor.peek_front();
 }
 
 // Swap items in inventory
-bool EQ::InventoryProfile::SwapItem(
+bool EQEmu::InventoryProfile::SwapItem(
 	int16 source_slot,
 	int16 destination_slot,
 	SwapItemFailState &fail_state,
@@ -280,54 +280,54 @@ bool EQ::InventoryProfile::SwapItem(
 ) {
 	fail_state = swapInvalid;
 
-	if (source_slot <= EQ::invslot::POSSESSIONS_END && source_slot >= EQ::invslot::POSSESSIONS_BEGIN) {
+	if (source_slot <= EQEmu::invslot::POSSESSIONS_END && source_slot >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 		if ((((uint64) 1 << source_slot) & m_lookup->PossessionsBitmask) == 0) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (source_slot <= EQ::invbag::GENERAL_BAGS_END && source_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-		auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((source_slot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
+	else if (source_slot <= EQEmu::invbag::GENERAL_BAGS_END && source_slot >= EQEmu::invbag::GENERAL_BAGS_BEGIN) {
+		auto temp_slot = EQEmu::invslot::GENERAL_BEGIN + ((source_slot - EQEmu::invbag::GENERAL_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT);
 		if ((((uint64)1 << temp_slot) & m_lookup->PossessionsBitmask) == 0) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (source_slot <= EQ::invslot::BANK_END && source_slot >= EQ::invslot::BANK_BEGIN) {
-		if ((source_slot - EQ::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank) {
+	else if (source_slot <= EQEmu::invslot::BANK_END && source_slot >= EQEmu::invslot::BANK_BEGIN) {
+		if ((source_slot - EQEmu::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (source_slot <= EQ::invbag::BANK_BAGS_END && source_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
-		auto temp_slot = (source_slot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
+	else if (source_slot <= EQEmu::invbag::BANK_BAGS_END && source_slot >= EQEmu::invbag::BANK_BAGS_BEGIN) {
+		auto temp_slot = (source_slot - EQEmu::invbag::BANK_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT;
 		if (temp_slot >= m_lookup->InventoryTypeSize.Bank) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
 
-	if (destination_slot <= EQ::invslot::POSSESSIONS_END && destination_slot >= EQ::invslot::POSSESSIONS_BEGIN) {
+	if (destination_slot <= EQEmu::invslot::POSSESSIONS_END && destination_slot >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 		if ((((uint64)1 << destination_slot) & m_lookup->PossessionsBitmask) == 0) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (destination_slot <= EQ::invbag::GENERAL_BAGS_END && destination_slot >= EQ::invbag::GENERAL_BAGS_BEGIN) {
-		auto temp_slot = EQ::invslot::GENERAL_BEGIN + ((destination_slot - EQ::invbag::GENERAL_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT);
+	else if (destination_slot <= EQEmu::invbag::GENERAL_BAGS_END && destination_slot >= EQEmu::invbag::GENERAL_BAGS_BEGIN) {
+		auto temp_slot = EQEmu::invslot::GENERAL_BEGIN + ((destination_slot - EQEmu::invbag::GENERAL_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT);
 		if ((((uint64)1 << temp_slot) & m_lookup->PossessionsBitmask) == 0) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (destination_slot <= EQ::invslot::BANK_END && destination_slot >= EQ::invslot::BANK_BEGIN) {
-		if ((destination_slot - EQ::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank) {
+	else if (destination_slot <= EQEmu::invslot::BANK_END && destination_slot >= EQEmu::invslot::BANK_BEGIN) {
+		if ((destination_slot - EQEmu::invslot::BANK_BEGIN) >= m_lookup->InventoryTypeSize.Bank) {
 			fail_state = swapNotAllowed;
 			return false;
 		}
 	}
-	else if (destination_slot <= EQ::invbag::BANK_BAGS_END && destination_slot >= EQ::invbag::BANK_BAGS_BEGIN) {
-		auto temp_slot = (destination_slot - EQ::invbag::BANK_BAGS_BEGIN) / EQ::invbag::SLOT_COUNT;
+	else if (destination_slot <= EQEmu::invbag::BANK_BAGS_END && destination_slot >= EQEmu::invbag::BANK_BAGS_BEGIN) {
+		auto temp_slot = (destination_slot - EQEmu::invbag::BANK_BAGS_BEGIN) / EQEmu::invbag::SLOT_COUNT;
 		if (temp_slot >= m_lookup->InventoryTypeSize.Bank) {
 			fail_state = swapNotAllowed;
 			return false;
@@ -399,7 +399,7 @@ bool EQ::InventoryProfile::SwapItem(
 }
 
 // Remove item from inventory (with memory delete)
-bool EQ::InventoryProfile::DeleteItem(int16 slot_id, uint8 quantity) {
+bool EQEmu::InventoryProfile::DeleteItem(int16 slot_id, uint8 quantity) {
 	// Pop item out of inventory map (or queue)
 	ItemInstance *item_to_delete = PopItem(slot_id);
 
@@ -434,7 +434,7 @@ bool EQ::InventoryProfile::DeleteItem(int16 slot_id, uint8 quantity) {
 }
 
 // Checks All items in a bag for No Drop
-bool EQ::InventoryProfile::CheckNoDrop(int16 slot_id, bool recurse)
+bool EQEmu::InventoryProfile::CheckNoDrop(int16 slot_id, bool recurse)
 {
 	ItemInstance* inst = GetItem(slot_id);
 	if (!inst)
@@ -445,7 +445,7 @@ bool EQ::InventoryProfile::CheckNoDrop(int16 slot_id, bool recurse)
 
 // Remove item from bucket without memory delete
 // Returns item pointer if full delete was successful
-EQ::ItemInstance* EQ::InventoryProfile::PopItem(int16 slot_id)
+EQEmu::ItemInstance* EQEmu::InventoryProfile::PopItem(int16 slot_id)
 {
 	ItemInstance* p = nullptr;
 
@@ -488,7 +488,7 @@ EQ::ItemInstance* EQ::InventoryProfile::PopItem(int16 slot_id)
 	return p;
 }
 
-bool EQ::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Quantity) {
+bool EQEmu::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Quantity) {
 
 	if (ItemToTry->Stackable) {
 
@@ -592,7 +592,7 @@ bool EQ::InventoryProfile::HasSpaceForItem(const ItemData *ItemToTry, int16 Quan
 
 //This function has a flaw in that it only returns the last stack that it looked at
 //when quantity is greater than 1 and not all of quantity can be found in 1 stack.
-int16 EQ::InventoryProfile::HasItem(uint32 item_id, uint8 quantity, uint8 where)
+int16 EQEmu::InventoryProfile::HasItem(uint32 item_id, uint8 quantity, uint8 where)
 {
 	int16 slot_id = INVALID_INDEX;
 
@@ -642,7 +642,7 @@ int16 EQ::InventoryProfile::HasItem(uint32 item_id, uint8 quantity, uint8 where)
 }
 
 //this function has the same quantity flaw mentioned above in HasItem()
-int16 EQ::InventoryProfile::HasItemByUse(uint8 use, uint8 quantity, uint8 where)
+int16 EQEmu::InventoryProfile::HasItemByUse(uint8 use, uint8 quantity, uint8 where)
 {
 	int16 slot_id = INVALID_INDEX;
 
@@ -688,7 +688,7 @@ int16 EQ::InventoryProfile::HasItemByUse(uint8 use, uint8 quantity, uint8 where)
 	return slot_id;
 }
 
-int16 EQ::InventoryProfile::HasItemByLoreGroup(uint32 loregroup, uint8 where)
+int16 EQEmu::InventoryProfile::HasItemByLoreGroup(uint32 loregroup, uint8 where)
 {
 	int16 slot_id = INVALID_INDEX;
 
@@ -736,7 +736,7 @@ int16 EQ::InventoryProfile::HasItemByLoreGroup(uint32 loregroup, uint8 where)
 
 // Locate an available inventory slot
 // Returns slot_id when there's one available, else SLOT_INVALID
-int16 EQ::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, bool is_arrow)
+int16 EQEmu::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size, bool is_arrow)
 {
 	// Check basic inventory
 	for (int16 i = invslot::GENERAL_BEGIN; i <= invslot::GENERAL_END; i++) {
@@ -786,7 +786,7 @@ int16 EQ::InventoryProfile::FindFreeSlot(bool for_bag, bool try_cursor, uint8 mi
 }
 
 // This is a mix of HasSpaceForItem and FindFreeSlot..due to existing coding behavior, it was better to add a new helper function...
-int16 EQ::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst, int16 general_start, uint8 bag_start) {
+int16 EQEmu::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst, int16 general_start, uint8 bag_start) {
 	// Do not arbitrarily use this function..it is designed for use with Client::ResetTrade() and Client::FinishTrade().
 	// If you have a need, use it..but, understand it is not a suitable replacement for InventoryProfile::FindFreeSlot().
 	//
@@ -924,7 +924,7 @@ int16 EQ::InventoryProfile::FindFreeSlotForTradeItem(const ItemInstance* inst, i
 }
 
 // Opposite of below: Get parent bag slot_id from a slot inside of bag
-int16 EQ::InventoryProfile::CalcSlotId(int16 slot_id) {
+int16 EQEmu::InventoryProfile::CalcSlotId(int16 slot_id) {
 	int16 parent_slot_id = INVALID_INDEX;
 
 	// this is not a bag range... using this risks over-writing existing items
@@ -952,7 +952,7 @@ int16 EQ::InventoryProfile::CalcSlotId(int16 slot_id) {
 }
 
 // Calculate slot_id for an item within a bag
-int16 EQ::InventoryProfile::CalcSlotId(int16 bagslot_id, uint8 bagidx) {
+int16 EQEmu::InventoryProfile::CalcSlotId(int16 bagslot_id, uint8 bagidx) {
 	if (!InventoryProfile::SupportsContainers(bagslot_id))
 		return INVALID_INDEX;
 
@@ -977,7 +977,7 @@ int16 EQ::InventoryProfile::CalcSlotId(int16 bagslot_id, uint8 bagidx) {
 	return slot_id;
 }
 
-uint8 EQ::InventoryProfile::CalcBagIdx(int16 slot_id) {
+uint8 EQEmu::InventoryProfile::CalcBagIdx(int16 slot_id) {
 	uint8 index = 0;
 
 	// this is not a bag range... using this risks over-writing existing items
@@ -1006,7 +1006,7 @@ uint8 EQ::InventoryProfile::CalcBagIdx(int16 slot_id) {
 	return index;
 }
 
-int16 EQ::InventoryProfile::CalcSlotFromMaterial(uint8 material)
+int16 EQEmu::InventoryProfile::CalcSlotFromMaterial(uint8 material)
 {
 	switch (material)
 	{
@@ -1033,7 +1033,7 @@ int16 EQ::InventoryProfile::CalcSlotFromMaterial(uint8 material)
 	}
 }
 
-uint8 EQ::InventoryProfile::CalcMaterialFromSlot(int16 equipslot)
+uint8 EQEmu::InventoryProfile::CalcMaterialFromSlot(int16 equipslot)
 {
 	switch (equipslot)
 	{
@@ -1061,7 +1061,7 @@ uint8 EQ::InventoryProfile::CalcMaterialFromSlot(int16 equipslot)
 	}
 }
 
-bool EQ::InventoryProfile::CanItemFitInContainer(const ItemData *ItemToTry, const ItemData *Container) {
+bool EQEmu::InventoryProfile::CanItemFitInContainer(const ItemData *ItemToTry, const ItemData *Container) {
 
 	if (!ItemToTry || !Container)
 		return false;
@@ -1078,7 +1078,7 @@ bool EQ::InventoryProfile::CanItemFitInContainer(const ItemData *ItemToTry, cons
 	return true;
 }
 
-bool EQ::InventoryProfile::SupportsClickCasting(int16 slot_id)
+bool EQEmu::InventoryProfile::SupportsClickCasting(int16 slot_id)
 {
 	// there are a few non-potion items that identify as ItemTypePotion..so, we still need to ubiquitously include the equipment range
 	if (slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) {
@@ -1095,7 +1095,7 @@ bool EQ::InventoryProfile::SupportsClickCasting(int16 slot_id)
 	return false;
 }
 
-bool EQ::InventoryProfile::SupportsPotionBeltCasting(int16 slot_id)
+bool EQEmu::InventoryProfile::SupportsPotionBeltCasting(int16 slot_id)
 {
 	// does this have the same criteria as 'SupportsClickCasting' above? (bag clicking per client)
 	if (slot_id >= invslot::EQUIPMENT_BEGIN && slot_id <= invslot::EQUIPMENT_END) {
@@ -1112,7 +1112,7 @@ bool EQ::InventoryProfile::SupportsPotionBeltCasting(int16 slot_id)
 }
 
 // Test whether a given slot can support a container item
-bool EQ::InventoryProfile::SupportsContainers(int16 slot_id)
+bool EQEmu::InventoryProfile::SupportsContainers(int16 slot_id)
 {
 	if ((slot_id == invslot::slotCursor) ||
 		(slot_id >= invslot::GENERAL_BEGIN && slot_id <= invslot::GENERAL_END) ||
@@ -1126,7 +1126,7 @@ bool EQ::InventoryProfile::SupportsContainers(int16 slot_id)
 	return false;
 }
 
-int EQ::InventoryProfile::GetSlotByItemInst(ItemInstance *inst) {
+int EQEmu::InventoryProfile::GetSlotByItemInst(ItemInstance *inst) {
 	if (!inst)
 		return INVALID_INDEX;
 
@@ -1162,7 +1162,7 @@ int EQ::InventoryProfile::GetSlotByItemInst(ItemInstance *inst) {
 	return INVALID_INDEX;
 }
 
-uint8 EQ::InventoryProfile::FindBrightestLightType()
+uint8 EQEmu::InventoryProfile::FindBrightestLightType()
 {
 	uint8 brightest_light_type = 0;
 
@@ -1213,7 +1213,7 @@ uint8 EQ::InventoryProfile::FindBrightestLightType()
 	return brightest_light_type;
 }
 
-void EQ::InventoryProfile::dumpEntireInventory() {
+void EQEmu::InventoryProfile::dumpEntireInventory() {
 
 	dumpWornItems();
 	dumpInventory();
@@ -1223,29 +1223,29 @@ void EQ::InventoryProfile::dumpEntireInventory() {
 	std::cout << std::endl;
 }
 
-void EQ::InventoryProfile::dumpWornItems() {
+void EQEmu::InventoryProfile::dumpWornItems() {
 	std::cout << "Worn items:" << std::endl;
 	dumpItemCollection(m_worn);
 }
 
-void EQ::InventoryProfile::dumpInventory() {
+void EQEmu::InventoryProfile::dumpInventory() {
 	std::cout << "Inventory items:" << std::endl;
 	dumpItemCollection(m_inv);
 }
 
-void EQ::InventoryProfile::dumpBankItems() {
+void EQEmu::InventoryProfile::dumpBankItems() {
 
 	std::cout << "Bank items:" << std::endl;
 	dumpItemCollection(m_bank);
 }
 
-void EQ::InventoryProfile::dumpSharedBankItems() {
+void EQEmu::InventoryProfile::dumpSharedBankItems() {
 
 	std::cout << "Shared Bank items:" << std::endl;
 	dumpItemCollection(m_shbank);
 }
 
-int EQ::InventoryProfile::GetSlotByItemInstCollection(const std::map<int16, ItemInstance*> &collection, ItemInstance *inst) {
+int EQEmu::InventoryProfile::GetSlotByItemInstCollection(const std::map<int16, ItemInstance*> &collection, ItemInstance *inst) {
 	for (auto iter = collection.begin(); iter != collection.end(); ++iter) {
 		ItemInstance *t_inst = iter->second;
 		if (t_inst == inst) {
@@ -1261,10 +1261,10 @@ int EQ::InventoryProfile::GetSlotByItemInstCollection(const std::map<int16, Item
 		}
 	}
 
-	return EQ::invslot::SLOT_INVALID;
+	return EQEmu::invslot::SLOT_INVALID;
 }
 
-void EQ::InventoryProfile::dumpItemCollection(const std::map<int16, ItemInstance*> &collection)
+void EQEmu::InventoryProfile::dumpItemCollection(const std::map<int16, ItemInstance*> &collection)
 {
 	for (auto it = collection.cbegin(); it != collection.cend(); ++it) {
 		auto inst = it->second;
@@ -1278,7 +1278,7 @@ void EQ::InventoryProfile::dumpItemCollection(const std::map<int16, ItemInstance
 	}
 }
 
-void EQ::InventoryProfile::dumpBagContents(ItemInstance *inst, std::map<int16, ItemInstance*>::const_iterator *it)
+void EQEmu::InventoryProfile::dumpBagContents(ItemInstance *inst, std::map<int16, ItemInstance*>::const_iterator *it)
 {
 	if (!inst || !inst->IsClassBag())
 		return;
@@ -1297,14 +1297,14 @@ void EQ::InventoryProfile::dumpBagContents(ItemInstance *inst, std::map<int16, I
 }
 
 // Internal Method: Retrieves item within an inventory bucket
-EQ::ItemInstance* EQ::InventoryProfile::_GetItem(const std::map<int16, ItemInstance*>& bucket, int16 slot_id) const
+EQEmu::ItemInstance* EQEmu::InventoryProfile::_GetItem(const std::map<int16, ItemInstance*>& bucket, int16 slot_id) const
 {
-	if (slot_id <= EQ::invslot::POSSESSIONS_END && slot_id >= EQ::invslot::POSSESSIONS_BEGIN) {
+	if (slot_id <= EQEmu::invslot::POSSESSIONS_END && slot_id >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 		if ((((uint64)1 << slot_id) & m_lookup->PossessionsBitmask) == 0)
 			return nullptr;
 	}
-	else if (slot_id <= EQ::invslot::BANK_END && slot_id >= EQ::invslot::BANK_BEGIN) {
-		if (slot_id - EQ::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
+	else if (slot_id <= EQEmu::invslot::BANK_END && slot_id >= EQEmu::invslot::BANK_BEGIN) {
+		if (slot_id - EQEmu::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
 			return nullptr;
 	}
 	
@@ -1319,7 +1319,7 @@ EQ::ItemInstance* EQ::InventoryProfile::_GetItem(const std::map<int16, ItemInsta
 
 // Internal Method: "put" item into bucket, without regard for what is currently in bucket
 // Assumes item has already been allocated
-int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
+int16 EQEmu::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 {
 	// What happens here when we _PutItem(MainCursor)? Bad things..really bad things...
 	//
@@ -1356,7 +1356,7 @@ int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 		result = slot_id;
 	}
 	else if (slot_id >= invslot::BANK_BEGIN && slot_id <= invslot::BANK_END) {
-		if (slot_id - EQ::invslot::BANK_BEGIN < m_lookup->InventoryTypeSize.Bank) {
+		if (slot_id - EQEmu::invslot::BANK_BEGIN < m_lookup->InventoryTypeSize.Bank) {
 			m_bank[slot_id] = inst;
 			result = slot_id;
 		}
@@ -1381,7 +1381,7 @@ int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 	}
 	
 	if (result == INVALID_INDEX) {
-		LogError("InventoryProfile::_PutItem: Invalid slot_id specified ({}) with parent slot id ({})", slot_id, parentSlot);
+		Log(Logs::General, Logs::Error, "InventoryProfile::_PutItem: Invalid slot_id specified (%i) with parent slot id (%i)", slot_id, parentSlot);
 		InventoryProfile::MarkDirty(inst); // Slot not found, clean up
 	}
 
@@ -1389,17 +1389,17 @@ int16 EQ::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 }
 
 // Internal Method: Checks an inventory bucket for a particular item
-int16 EQ::InventoryProfile::_HasItem(std::map<int16, ItemInstance*>& bucket, uint32 item_id, uint8 quantity)
+int16 EQEmu::InventoryProfile::_HasItem(std::map<int16, ItemInstance*>& bucket, uint32 item_id, uint8 quantity)
 {
 	uint32 quantity_found = 0;
 
 	for (auto iter = bucket.begin(); iter != bucket.end(); ++iter) {
-		if (iter->first <= EQ::invslot::POSSESSIONS_END && iter->first >= EQ::invslot::POSSESSIONS_BEGIN) {
+		if (iter->first <= EQEmu::invslot::POSSESSIONS_END && iter->first >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 			if ((((uint64)1 << iter->first) & m_lookup->PossessionsBitmask) == 0)
 				continue;
 		}
-		else if (iter->first <= EQ::invslot::BANK_END && iter->first >= EQ::invslot::BANK_BEGIN) {
-			if (iter->first - EQ::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
+		else if (iter->first <= EQEmu::invslot::BANK_END && iter->first >= EQEmu::invslot::BANK_BEGIN) {
+			if (iter->first - EQEmu::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
 				continue;
 		}
 
@@ -1440,7 +1440,7 @@ int16 EQ::InventoryProfile::_HasItem(std::map<int16, ItemInstance*>& bucket, uin
 }
 
 // Internal Method: Checks an inventory queue type bucket for a particular item
-int16 EQ::InventoryProfile::_HasItem(ItemInstQueue& iqueue, uint32 item_id, uint8 quantity)
+int16 EQEmu::InventoryProfile::_HasItem(ItemInstQueue& iqueue, uint32 item_id, uint8 quantity)
 {
 	// The downfall of this (these) queue procedure is that callers presume that when an item is
 	// found, it is presented as being available on the cursor. In cases of a parity check, this
@@ -1491,17 +1491,17 @@ int16 EQ::InventoryProfile::_HasItem(ItemInstQueue& iqueue, uint32 item_id, uint
 }
 
 // Internal Method: Checks an inventory bucket for a particular item
-int16 EQ::InventoryProfile::_HasItemByUse(std::map<int16, ItemInstance*>& bucket, uint8 use, uint8 quantity)
+int16 EQEmu::InventoryProfile::_HasItemByUse(std::map<int16, ItemInstance*>& bucket, uint8 use, uint8 quantity)
 {
 	uint32 quantity_found = 0;
 
 	for (auto iter = bucket.begin(); iter != bucket.end(); ++iter) {
-		if (iter->first <= EQ::invslot::POSSESSIONS_END && iter->first >= EQ::invslot::POSSESSIONS_BEGIN) {
+		if (iter->first <= EQEmu::invslot::POSSESSIONS_END && iter->first >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 			if ((((uint64)1 << iter->first) & m_lookup->PossessionsBitmask) == 0)
 				continue;
 		}
-		else if (iter->first <= EQ::invslot::BANK_END && iter->first >= EQ::invslot::BANK_BEGIN) {
-			if (iter->first - EQ::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
+		else if (iter->first <= EQEmu::invslot::BANK_END && iter->first >= EQEmu::invslot::BANK_BEGIN) {
+			if (iter->first - EQEmu::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
 				continue;
 		}
 
@@ -1532,7 +1532,7 @@ int16 EQ::InventoryProfile::_HasItemByUse(std::map<int16, ItemInstance*>& bucket
 }
 
 // Internal Method: Checks an inventory queue type bucket for a particular item
-int16 EQ::InventoryProfile::_HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint8 quantity)
+int16 EQEmu::InventoryProfile::_HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint8 quantity)
 {
 	uint32 quantity_found = 0;
 
@@ -1566,15 +1566,15 @@ int16 EQ::InventoryProfile::_HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint
 	return INVALID_INDEX;
 }
 
-int16 EQ::InventoryProfile::_HasItemByLoreGroup(std::map<int16, ItemInstance*>& bucket, uint32 loregroup)
+int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(std::map<int16, ItemInstance*>& bucket, uint32 loregroup)
 {
 	for (auto iter = bucket.begin(); iter != bucket.end(); ++iter) {
-		if (iter->first <= EQ::invslot::POSSESSIONS_END && iter->first >= EQ::invslot::POSSESSIONS_BEGIN) {
+		if (iter->first <= EQEmu::invslot::POSSESSIONS_END && iter->first >= EQEmu::invslot::POSSESSIONS_BEGIN) {
 			if ((((uint64)1 << iter->first) & m_lookup->PossessionsBitmask) == 0)
 				continue;
 		}
-		else if (iter->first <= EQ::invslot::BANK_END && iter->first >= EQ::invslot::BANK_BEGIN) {
-			if (iter->first - EQ::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
+		else if (iter->first <= EQEmu::invslot::BANK_END && iter->first >= EQEmu::invslot::BANK_BEGIN) {
+			if (iter->first - EQEmu::invslot::BANK_BEGIN >= m_lookup->InventoryTypeSize.Bank)
 				continue;
 		}
 
@@ -1611,11 +1611,11 @@ int16 EQ::InventoryProfile::_HasItemByLoreGroup(std::map<int16, ItemInstance*>&
 		}
 	}
 
-	return EQ::invslot::SLOT_INVALID;
+	return EQEmu::invslot::SLOT_INVALID;
 }
 
 // Internal Method: Checks an inventory queue type bucket for a particular item
-int16 EQ::InventoryProfile::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup)
+int16 EQEmu::InventoryProfile::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup)
 {
 	for (auto iter = iqueue.cbegin(); iter != iqueue.cend(); ++iter) {
 		auto inst = *iter;
@@ -1654,5 +1654,5 @@ int16 EQ::InventoryProfile::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 lo
 		break;
 	}
 	
-	return EQ::invslot::SLOT_INVALID;
+	return EQEmu::invslot::SLOT_INVALID;
 }

common/inventory_profile.h

@@ -52,30 +52,30 @@ public:
 	// Public Methods
 	/////////////////////////
 
-	inline std::list<EQ::ItemInstance*>::const_iterator cbegin() { return m_list.cbegin(); }
-	inline std::list<EQ::ItemInstance*>::const_iterator cend() { return m_list.cend(); }
+	inline std::list<EQEmu::ItemInstance*>::const_iterator cbegin() { return m_list.cbegin(); }
+	inline std::list<EQEmu::ItemInstance*>::const_iterator cend() { return m_list.cend(); }
 
 	inline int size() { return static_cast<int>(m_list.size()); } // TODO: change to size_t
 	inline bool empty() { return m_list.empty(); }
 
-	void push(EQ::ItemInstance* inst);
-	void push_front(EQ::ItemInstance* inst);
-	EQ::ItemInstance* pop();
-	EQ::ItemInstance* pop_back();
-	EQ::ItemInstance* peek_front() const;
+	void push(EQEmu::ItemInstance* inst);
+	void push_front(EQEmu::ItemInstance* inst);
+	EQEmu::ItemInstance* pop();
+	EQEmu::ItemInstance* pop_back();
+	EQEmu::ItemInstance* peek_front() const;
 
 protected:
 	/////////////////////////
 	// Protected Members
 	/////////////////////////
 
-	std::list<EQ::ItemInstance*> m_list;
+	std::list<EQEmu::ItemInstance*> m_list;
 };
 
 // ########################################
-// Class: EQ::InventoryProfile
+// Class: EQEmu::InventoryProfile
 //	Character inventory
-namespace EQ
+namespace EQEmu
 {
 	class InventoryProfile
 	{

common/inventory_slot.cpp

@@ -22,7 +22,7 @@
 #include "string_util.h"
 
 
-int8 EQ::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
+int8 EQEmu::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
 {
 	switch (slot_index) {
 	case invslot::slotHead:
@@ -48,7 +48,7 @@ int8 EQ::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
 	}
 }
 
-int8 EQ::inventory::ConvertEquipmentSlotToTextureIndex(const InventorySlot& inventory_slot)
+int8 EQEmu::inventory::ConvertEquipmentSlotToTextureIndex(const InventorySlot& inventory_slot)
 {
 	if ((!inventory_slot.Typeless() && !inventory_slot.IsTypeIndex(invtype::typePossessions)) || !inventory_slot.IsContainerIndex(invbag::SLOT_INVALID) || !inventory_slot.IsSocketIndex(invaug::SOCKET_INVALID))
 		return textures::textureInvalid;
@@ -56,7 +56,7 @@ int8 EQ::inventory::ConvertEquipmentSlotToTextureIndex(const InventorySlot& inve
 	return ConvertEquipmentIndexToTextureIndex(inventory_slot.SlotIndex());
 }
 
-int16 EQ::inventory::ConvertTextureIndexToEquipmentIndex(int8 texture_index)
+int16 EQEmu::inventory::ConvertTextureIndexToEquipmentIndex(int8 texture_index)
 {
 	switch (texture_index) {
 	case textures::armorHead:
@@ -82,7 +82,7 @@ int16 EQ::inventory::ConvertTextureIndexToEquipmentIndex(int8 texture_index)
 	}
 }
 
-bool EQ::InventorySlot::IsValidSlot() const
+bool EQEmu::InventorySlot::IsValidSlot() const
 {
 	if (_typeless)
 		return false;
@@ -100,7 +100,7 @@ bool EQ::InventorySlot::IsValidSlot() const
 	return true;
 }
 
-bool EQ::InventorySlot::IsDeleteSlot() const
+bool EQEmu::InventorySlot::IsDeleteSlot() const
 {
 	if (_typeless)
 		return (_slot_index == invslot::SLOT_INVALID && _container_index == invbag::SLOT_INVALID && _socket_index == invaug::SOCKET_INVALID);
@@ -108,7 +108,7 @@ bool EQ::InventorySlot::IsDeleteSlot() const
 		return (_type_index == invtype::TYPE_INVALID && _slot_index == invslot::SLOT_INVALID && _container_index == invbag::SLOT_INVALID && _socket_index == invaug::SOCKET_INVALID);
 }
 
-bool EQ::InventorySlot::IsEquipmentIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsEquipmentIndex(int16 slot_index)
 {
 	if (slot_index < invslot::EQUIPMENT_BEGIN || slot_index > invslot::EQUIPMENT_END)
 		return false;
@@ -116,7 +116,7 @@ bool EQ::InventorySlot::IsEquipmentIndex(int16 slot_index)
 	return true;
 }
 
-bool EQ::InventorySlot::IsGeneralIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsGeneralIndex(int16 slot_index)
 {
 	if (slot_index < invslot::GENERAL_BEGIN || slot_index > invslot::GENERAL_END)
 		return false;
@@ -124,7 +124,7 @@ bool EQ::InventorySlot::IsGeneralIndex(int16 slot_index)
 	return true;
 }
 
-bool EQ::InventorySlot::IsCursorIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsCursorIndex(int16 slot_index)
 {
 	if (slot_index == invslot::slotCursor)
 		return true;
@@ -132,7 +132,7 @@ bool EQ::InventorySlot::IsCursorIndex(int16 slot_index)
 	return false;
 }
 
-bool EQ::InventorySlot::IsWeaponIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsWeaponIndex(int16 slot_index)
 {
 	if (slot_index == invslot::slotPrimary || slot_index == invslot::slotSecondary || slot_index == invslot::slotRange)
 		return true;
@@ -140,7 +140,7 @@ bool EQ::InventorySlot::IsWeaponIndex(int16 slot_index)
 	return false;
 }
 
-bool EQ::InventorySlot::IsTextureIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsTextureIndex(int16 slot_index)
 {
 	switch (slot_index) {
 	case invslot::slotHead:
@@ -158,7 +158,7 @@ bool EQ::InventorySlot::IsTextureIndex(int16 slot_index)
 	}
 }
 
-bool EQ::InventorySlot::IsTintableIndex(int16 slot_index)
+bool EQEmu::InventorySlot::IsTintableIndex(int16 slot_index)
 {
 	switch (slot_index) {
 	case invslot::slotHead:
@@ -174,7 +174,7 @@ bool EQ::InventorySlot::IsTintableIndex(int16 slot_index)
 	}
 }
 
-bool EQ::InventorySlot::IsEquipmentSlot() const
+bool EQEmu::InventorySlot::IsEquipmentSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -185,7 +185,7 @@ bool EQ::InventorySlot::IsEquipmentSlot() const
 	return IsEquipmentIndex(_slot_index);
 }
 
-bool EQ::InventorySlot::IsGeneralSlot() const
+bool EQEmu::InventorySlot::IsGeneralSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -196,7 +196,7 @@ bool EQ::InventorySlot::IsGeneralSlot() const
 	return IsGeneralIndex(_socket_index);
 }
 
-bool EQ::InventorySlot::IsCursorSlot() const
+bool EQEmu::InventorySlot::IsCursorSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -207,7 +207,7 @@ bool EQ::InventorySlot::IsCursorSlot() const
 	return IsCursorIndex(_slot_index);
 }
 
-bool EQ::InventorySlot::IsWeaponSlot() const
+bool EQEmu::InventorySlot::IsWeaponSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -218,7 +218,7 @@ bool EQ::InventorySlot::IsWeaponSlot() const
 	return IsWeaponIndex(_slot_index);
 }
 
-bool EQ::InventorySlot::IsTextureSlot() const
+bool EQEmu::InventorySlot::IsTextureSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -229,7 +229,7 @@ bool EQ::InventorySlot::IsTextureSlot() const
 	return IsTextureIndex(_slot_index);
 }
 
-bool EQ::InventorySlot::IsTintableSlot() const
+bool EQEmu::InventorySlot::IsTintableSlot() const
 {
 	if (!_typeless && (_type_index != invtype::typePossessions))
 		return false;
@@ -240,7 +240,7 @@ bool EQ::InventorySlot::IsTintableSlot() const
 	return IsTintableIndex(_slot_index);
 }
 
-bool EQ::InventorySlot::IsSlot() const
+bool EQEmu::InventorySlot::IsSlot() const
 {
 	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
@@ -254,7 +254,7 @@ bool EQ::InventorySlot::IsSlot() const
 	return true;
 }
 
-bool EQ::InventorySlot::IsSlotSocket() const
+bool EQEmu::InventorySlot::IsSlotSocket() const
 {
 	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
@@ -268,7 +268,7 @@ bool EQ::InventorySlot::IsSlotSocket() const
 	return true;
 }
 
-bool EQ::InventorySlot::IsContainer() const
+bool EQEmu::InventorySlot::IsContainer() const
 {
 	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
@@ -282,7 +282,7 @@ bool EQ::InventorySlot::IsContainer() const
 	return true;
 }
 
-bool EQ::InventorySlot::IsContainerSocket() const
+bool EQEmu::InventorySlot::IsContainerSocket() const
 {
 	if (!_typeless && (_type_index == invtype::TYPE_INVALID))
 		return false;
@@ -296,12 +296,12 @@ bool EQ::InventorySlot::IsContainerSocket() const
 	return true;
 }
 
-EQ::InventorySlot EQ::InventorySlot::ToTopOwner() const
+EQEmu::InventorySlot EQEmu::InventorySlot::ToTopOwner() const
 {
 	return InventorySlot(_type_index, _slot_index);
 }
 
-EQ::InventorySlot EQ::InventorySlot::ToOwner() const
+EQEmu::InventorySlot EQEmu::InventorySlot::ToOwner() const
 {
 	if (IsSlot() || IsSlotSocket() || IsContainer())
 		return InventorySlot(_type_index, _slot_index);
@@ -312,17 +312,17 @@ EQ::InventorySlot EQ::InventorySlot::ToOwner() const
 	return InventorySlot();
 }
 
-const std::string EQ::InventorySlot::ToString() const
+const std::string EQEmu::InventorySlot::ToString() const
 {
 	return StringFormat("(%i%s, %i, %i, %i)", _type_index, (_typeless ? " [typeless]" : ""), _slot_index, _container_index, _socket_index);
 }
 
-const std::string EQ::InventorySlot::ToName() const
+const std::string EQEmu::InventorySlot::ToName() const
 {
 	return StringFormat("InventorySlot - _type_index: %i%s, _slot_index: %i, _container_index: %i, _socket_index: %i", _type_index, (_typeless ? " [typeless]" : ""), _slot_index, _container_index, _socket_index);
 }
 
-void EQ::InventorySlot::SetInvalidSlot()
+void EQEmu::InventorySlot::SetInvalidSlot()
 {
 	_type_index = invtype::TYPE_INVALID;
 	_slot_index = invslot::SLOT_INVALID;
@@ -330,7 +330,7 @@ void EQ::InventorySlot::SetInvalidSlot()
 	_socket_index = invaug::SOCKET_INVALID;
 }
 
-//bool EQ::InventorySlot::IsBonusIndex(int16 slot_index)
+//bool EQEmu::InventorySlot::IsBonusIndex(int16 slot_index)
 //{
 //	if ((slot_index >= inventory::EquipmentBegin) && (slot_index <= inventory::EquipmentEnd) && (slot_index != inventory::slotAmmo))
 //		return true;
@@ -338,7 +338,7 @@ void EQ::InventorySlot::SetInvalidSlot()
 //	return false;
 //}
 
-//bool EQ::InventorySlot::IsBonusSlot() const
+//bool EQEmu::InventorySlot::IsBonusSlot() const
 //{
 //	if ((_type_index != inventory::typePossessions) || (_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
 //		return false;
@@ -346,7 +346,7 @@ void EQ::InventorySlot::SetInvalidSlot()
 //	return IsBonusIndex(_slot_index);
 //}
 
-bool inventory_slot_typeless_lessthan(const EQ::InventorySlot& lhs, const EQ::InventorySlot& rhs)
+bool inventory_slot_typeless_lessthan(const EQEmu::InventorySlot& lhs, const EQEmu::InventorySlot& rhs)
 {
 	if (lhs.SlotIndex() < rhs.SlotIndex())
 		return true;
@@ -360,7 +360,7 @@ bool inventory_slot_typeless_lessthan(const EQ::InventorySlot& lhs, const EQ::In
 	return false;
 }
 
-bool EQ::InventorySlot::operator<(const InventorySlot& rhs) const
+bool EQEmu::InventorySlot::operator<(const InventorySlot& rhs) const
 {
 	if (Typeless() || rhs.Typeless())
 		return inventory_slot_typeless_lessthan(*this, rhs);
@@ -380,7 +380,7 @@ bool EQ::InventorySlot::operator<(const InventorySlot& rhs) const
 	return false;
 }
 
-bool EQ::operator==(const InventorySlot& lhs, const InventorySlot& rhs)
+bool EQEmu::operator==(const InventorySlot& lhs, const InventorySlot& rhs)
 {
 	if (lhs.Typeless() || rhs.Typeless())
 		return ((lhs.SlotIndex() == rhs.SlotIndex()) && (lhs.ContainerIndex() == rhs.ContainerIndex()) && (lhs.SocketIndex() == rhs.SocketIndex()));

common/inventory_slot.h

@@ -23,7 +23,7 @@
 #include "emu_constants.h"
 
 
-namespace EQ
+namespace EQEmu
 {
 	class InventorySlot;
 

common/ip_util.cpp

@@ -1,72 +0,0 @@
-/**
- * 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 "ip_util.h"
-
-/**
- * @param ip
- * @return
- */
-uint32_t IpUtil::IPToUInt(const std::string &ip)
-{
-	int      a, b, c, d;
-	uint32_t addr = 0;
-
-	if (sscanf(ip.c_str(), "%d.%d.%d.%d", &a, &b, &c, &d) != 4) {
-		return 0;
-	}
-
-	addr = a << 24;
-	addr |= b << 16;
-	addr |= c << 8;
-	addr |= d;
-	return addr;
-}
-
-/**
- * @param ip
- * @param network
- * @param mask
- * @return
- */
-bool IpUtil::IsIpInRange(const std::string &ip, const std::string &network, const std::string &mask)
-{
-	uint32_t ip_addr      = IpUtil::IPToUInt(ip);
-	uint32_t network_addr = IpUtil::IPToUInt(network);
-	uint32_t mask_addr    = IpUtil::IPToUInt(mask);
-
-	uint32_t net_lower = (network_addr & mask_addr);
-	uint32_t net_upper = (net_lower | (~mask_addr));
-
-	return ip_addr >= net_lower && ip_addr <= net_upper;
-}
-
-/**
- * @param ip
- * @return
- */
-bool IpUtil::IsIpInPrivateRfc1918(const std::string &ip)
-{
-	return (
-		IpUtil::IsIpInRange(ip, "10.0.0.0", "255.0.0.0") ||
-		IpUtil::IsIpInRange(ip, "172.16.0.0", "255.240.0.0") ||
-		IpUtil::IsIpInRange(ip, "192.168.0.0", "255.255.0.0")
-	);
-}

common/ipc_mutex.cpp

@@ -31,7 +31,7 @@
 #include "eqemu_exception.h"
 #include "eqemu_config.h"
 
-namespace EQ {
+namespace EQEmu {
 	struct IPCMutex::Implementation {
 #ifdef _WINDOWS
 		HANDLE mut_;

common/ipc_mutex.h

@@ -21,7 +21,7 @@
 
 #include <string>
 
-namespace EQ {
+namespace EQEmu {
 
 	//! Interprocess Named Binary Semaphore (Mutex)
 	/*!

common/item_data.cpp

@@ -23,7 +23,7 @@
 //#include "deity.h"
 
 
-uint32 EQ::item::ConvertAugTypeToAugTypeBit(uint8 aug_type)
+uint32 EQEmu::item::ConvertAugTypeToAugTypeBit(uint8 aug_type)
 {
 	switch (aug_type) {
 	case AugTypeGeneralSingleStat:
@@ -95,7 +95,7 @@ uint32 EQ::item::ConvertAugTypeToAugTypeBit(uint8 aug_type)
 	}
 }
 
-uint8 EQ::item::ConvertAugTypeBitToAugType(uint32 aug_type_bit)
+uint8 EQEmu::item::ConvertAugTypeBitToAugType(uint32 aug_type_bit)
 {
 	switch (aug_type_bit) {
 	case bit_AugTypeGeneralSingleStat:
@@ -167,7 +167,7 @@ uint8 EQ::item::ConvertAugTypeBitToAugType(uint32 aug_type_bit)
 	}
 }
 
-bool EQ::ItemData::IsEquipable(uint16 race_id, uint16 class_id) const
+bool EQEmu::ItemData::IsEquipable(uint16 race_id, uint16 class_id) const
 {
 	if (!(Races & GetPlayerRaceBit(race_id)))
 		return false;
@@ -178,37 +178,37 @@ bool EQ::ItemData::IsEquipable(uint16 race_id, uint16 class_id) const
 	return true;
 }
 
-bool EQ::ItemData::IsClassCommon() const
+bool EQEmu::ItemData::IsClassCommon() const
 {
 	return (ItemClass == item::ItemClassCommon);
 }
 
-bool EQ::ItemData::IsClassBag() const
+bool EQEmu::ItemData::IsClassBag() const
 {
 	return (ItemClass == item::ItemClassBag);
 }
 
-bool EQ::ItemData::IsClassBook() const
+bool EQEmu::ItemData::IsClassBook() const
 {
 	return (ItemClass == item::ItemClassBook);
 }
 
-bool EQ::ItemData::IsType1HWeapon() const
+bool EQEmu::ItemData::IsType1HWeapon() const
 {
 	return ((ItemType == item::ItemType1HBlunt) || (ItemType == item::ItemType1HSlash) || (ItemType == item::ItemType1HPiercing) || (ItemType == item::ItemTypeMartial));
 }
 
-bool EQ::ItemData::IsType2HWeapon() const
+bool EQEmu::ItemData::IsType2HWeapon() const
 {
 	return ((ItemType == item::ItemType2HBlunt) || (ItemType == item::ItemType2HSlash) || (ItemType == item::ItemType2HPiercing));
 }
 
-bool EQ::ItemData::IsTypeShield() const
+bool EQEmu::ItemData::IsTypeShield() const
 {
 	return (ItemType == item::ItemTypeShield);
 }
 
-bool EQ::ItemData::CheckLoreConflict(const ItemData* l_item, const ItemData* r_item)
+bool EQEmu::ItemData::CheckLoreConflict(const ItemData* l_item, const ItemData* r_item)
 {
 	if (!l_item || !r_item)
 		return false;

common/item_data.h

@@ -47,7 +47,7 @@
 #include "emu_constants.h"
 
 
-namespace EQ
+namespace EQEmu
 {
 	namespace item {
 		enum ItemClass {
@@ -413,7 +413,7 @@ namespace EQ
 		int32	SkillModMax;	// Max skill point modification
 		uint32	SkillModType;	// Type of skill for SkillModValue to apply to
 		uint32	BaneDmgRace;	// Bane Damage Race
-		int32	BaneDmgAmt;		// Bane Damage Body Amount
+		int8	BaneDmgAmt;		// Bane Damage Body Amount
 		uint32	BaneDmgBody;	// Bane Damage Body
 		bool	Magic;			// True=Magic Item, False=not
 		int32	CastTime_;
@@ -434,7 +434,6 @@ namespace EQ
 		//uint32	Unk054;
 		int16	MaxCharges;		// Maximum charges items can hold: -1 if not a chargeable item
 		uint8	ItemType;		// Item Type/Skill (itemClass* from above)
-		int32	SubType;		// Some items have sub types that can be used for other things (unbreakable fishing poles, SE_FFItemClass)
 		uint8	Material;		// Item material type
 		uint32	HerosForgeModel;// Hero's Forge Armor Model Type (2-13?)
 		float	SellRate;		// Sell rate

common/item_fieldlist.h

@@ -203,4 +203,3 @@ F(procname)
 F(wornname)
 F(focusname)
 F(scrollname)
-F(subtype)

common/item_instance.cpp

@@ -54,9 +54,9 @@ static inline int32 GetNextItemInstSerialNumber() {
 }
 
 //
-// class EQ::ItemInstance
+// class EQEmu::ItemInstance
 //
-EQ::ItemInstance::ItemInstance(const ItemData* item, int16 charges) {
+EQEmu::ItemInstance::ItemInstance(const ItemData* item, int16 charges) {
 	m_use_type = ItemInstNormal;
 	if(item) {
 		m_item = new ItemData(*item);
@@ -87,7 +87,7 @@ EQ::ItemInstance::ItemInstance(const ItemData* item, int16 charges) {
 	m_new_id_file = 0;
 }
 
-EQ::ItemInstance::ItemInstance(SharedDatabase *db, uint32 item_id, int16 charges) {
+EQEmu::ItemInstance::ItemInstance(SharedDatabase *db, uint32 item_id, int16 charges) {
 	m_use_type = ItemInstNormal;
 	m_item = db->GetItem(item_id);
 	if(m_item) {
@@ -121,7 +121,7 @@ EQ::ItemInstance::ItemInstance(SharedDatabase *db, uint32 item_id, int16 charges
 	m_new_id_file = 0;
 }
 
-EQ::ItemInstance::ItemInstance(ItemInstTypes use_type) {
+EQEmu::ItemInstance::ItemInstance(ItemInstTypes use_type) {
 	m_use_type = use_type;
 	m_item = nullptr;
 	m_charges = 0;
@@ -143,8 +143,8 @@ EQ::ItemInstance::ItemInstance(ItemInstTypes use_type) {
 	m_new_id_file = 0;
 }
 
-// Make a copy of an EQ::ItemInstance object
-EQ::ItemInstance::ItemInstance(const ItemInstance& copy)
+// Make a copy of an EQEmu::ItemInstance object
+EQEmu::ItemInstance::ItemInstance(const ItemInstance& copy)
 {
 	m_use_type=copy.m_use_type;
 	if(copy.m_item)
@@ -202,7 +202,7 @@ EQ::ItemInstance::ItemInstance(const ItemInstance& copy)
 }
 
 // Clean up container contents
-EQ::ItemInstance::~ItemInstance()
+EQEmu::ItemInstance::~ItemInstance()
 {
 	Clear();
 	safe_delete(m_item);
@@ -211,7 +211,7 @@ EQ::ItemInstance::~ItemInstance()
 }
 
 // Query item type
-bool EQ::ItemInstance::IsType(item::ItemClass item_class) const
+bool EQEmu::ItemInstance::IsType(item::ItemClass item_class) const
 {
 	// IsType(<ItemClassTypes>) does not protect against 'm_item = nullptr'
 	
@@ -225,23 +225,23 @@ bool EQ::ItemInstance::IsType(item::ItemClass item_class) const
 	return (m_item->ItemClass == item_class);
 }
 
-bool EQ::ItemInstance::IsClassCommon() const
+bool EQEmu::ItemInstance::IsClassCommon() const
 {
 	return (m_item && m_item->IsClassCommon());
 }
 
-bool EQ::ItemInstance::IsClassBag() const
+bool EQEmu::ItemInstance::IsClassBag() const
 {
 	return (m_item && m_item->IsClassBag());
 }
 
-bool EQ::ItemInstance::IsClassBook() const
+bool EQEmu::ItemInstance::IsClassBook() const
 {
 	return (m_item && m_item->IsClassBook());
 }
 
 // Is item stackable?
-bool EQ::ItemInstance::IsStackable() const
+bool EQEmu::ItemInstance::IsStackable() const
 {
 	if (!m_item)
 		return false;
@@ -249,7 +249,7 @@ bool EQ::ItemInstance::IsStackable() const
 	return m_item->Stackable;
 }
 
-bool EQ::ItemInstance::IsCharged() const
+bool EQEmu::ItemInstance::IsCharged() const
 {
 	if (!m_item)
 		return false;
@@ -261,7 +261,7 @@ bool EQ::ItemInstance::IsCharged() const
 }
 
 // Can item be equipped?
-bool EQ::ItemInstance::IsEquipable(uint16 race, uint16 class_) const
+bool EQEmu::ItemInstance::IsEquipable(uint16 race, uint16 class_) const
 {
 	if (!m_item || (m_item->Slots == 0))
 		return false;
@@ -270,18 +270,18 @@ bool EQ::ItemInstance::IsEquipable(uint16 race, uint16 class_) const
 }
 
 // Can equip at this slot?
-bool EQ::ItemInstance::IsEquipable(int16 slot_id) const
+bool EQEmu::ItemInstance::IsEquipable(int16 slot_id) const
 {
 	if (!m_item)
 		return false;
 
-	if (slot_id < EQ::invslot::EQUIPMENT_BEGIN || slot_id > EQ::invslot::EQUIPMENT_END)
+	if (slot_id < EQEmu::invslot::EQUIPMENT_BEGIN || slot_id > EQEmu::invslot::EQUIPMENT_END)
 		return false;
 
 	return ((m_item->Slots & (1 << slot_id)) != 0);
 }
 
-bool EQ::ItemInstance::IsAugmentable() const
+bool EQEmu::ItemInstance::IsAugmentable() const
 {
 	if (!m_item)
 		return false;
@@ -294,7 +294,7 @@ bool EQ::ItemInstance::IsAugmentable() const
 	return false;
 }
 
-bool EQ::ItemInstance::AvailableWearSlot(uint32 aug_wear_slots) const {
+bool EQEmu::ItemInstance::AvailableWearSlot(uint32 aug_wear_slots) const {
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
 
@@ -306,10 +306,10 @@ bool EQ::ItemInstance::AvailableWearSlot(uint32 aug_wear_slots) const {
 		}
 	}
 
-	return (index <= EQ::invslot::EQUIPMENT_END);
+	return (index <= EQEmu::invslot::EQUIPMENT_END);
 }
 
-int8 EQ::ItemInstance::AvailableAugmentSlot(int32 augtype) const
+int8 EQEmu::ItemInstance::AvailableAugmentSlot(int32 augtype) const
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return INVALID_INDEX;
@@ -324,7 +324,7 @@ int8 EQ::ItemInstance::AvailableAugmentSlot(int32 augtype) const
 	return (index <= invaug::SOCKET_END) ? index : INVALID_INDEX;
 }
 
-bool EQ::ItemInstance::IsAugmentSlotAvailable(int32 augtype, uint8 slot) const
+bool EQEmu::ItemInstance::IsAugmentSlotAvailable(int32 augtype, uint8 slot) const
 {
 	if (!m_item || !m_item->IsClassCommon())
 		 return false;
@@ -336,7 +336,7 @@ bool EQ::ItemInstance::IsAugmentSlotAvailable(int32 augtype, uint8 slot) const
 }
 
 // Retrieve item inside container
-EQ::ItemInstance* EQ::ItemInstance::GetItem(uint8 index) const
+EQEmu::ItemInstance* EQEmu::ItemInstance::GetItem(uint8 index) const
 {
 	auto it = m_contents.find(index);
 	if (it != m_contents.end()) {
@@ -346,7 +346,7 @@ EQ::ItemInstance* EQ::ItemInstance::GetItem(uint8 index) const
 	return nullptr;
 }
 
-uint32 EQ::ItemInstance::GetItemID(uint8 slot) const
+uint32 EQEmu::ItemInstance::GetItemID(uint8 slot) const
 {
 	ItemInstance *item = GetItem(slot);
 	if (item)
@@ -355,7 +355,7 @@ uint32 EQ::ItemInstance::GetItemID(uint8 slot) const
 	return 0;
 }
 
-void EQ::ItemInstance::PutItem(uint8 index, const ItemInstance& inst)
+void EQEmu::ItemInstance::PutItem(uint8 index, const ItemInstance& inst)
 {
 	// Clean up item already in slot (if exists)
 	DeleteItem(index);
@@ -365,7 +365,7 @@ void EQ::ItemInstance::PutItem(uint8 index, const ItemInstance& inst)
 }
 
 // Remove item inside container
-void EQ::ItemInstance::DeleteItem(uint8 index)
+void EQEmu::ItemInstance::DeleteItem(uint8 index)
 {
 	ItemInstance* inst = PopItem(index);
 	safe_delete(inst);
@@ -373,7 +373,7 @@ void EQ::ItemInstance::DeleteItem(uint8 index)
 
 // Remove item from container without memory delete
 // Hands over memory ownership to client of this function call
-EQ::ItemInstance* EQ::ItemInstance::PopItem(uint8 index)
+EQEmu::ItemInstance* EQEmu::ItemInstance::PopItem(uint8 index)
 {
 	auto iter = m_contents.find(index);
 	if (iter != m_contents.end()) {
@@ -386,7 +386,7 @@ EQ::ItemInstance* EQ::ItemInstance::PopItem(uint8 index)
 }
 
 // Remove all items from container
-void EQ::ItemInstance::Clear()
+void EQEmu::ItemInstance::Clear()
 {
 	// Destroy container contents
 	for (auto iter = m_contents.begin(); iter != m_contents.end(); ++iter) {
@@ -396,7 +396,7 @@ void EQ::ItemInstance::Clear()
 }
 
 // Remove all items from container
-void EQ::ItemInstance::ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent)
+void EQEmu::ItemInstance::ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent)
 {
 	// TODO: This needs work...
 
@@ -458,7 +458,7 @@ void EQ::ItemInstance::ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_no
 	}
 }
 
-uint8 EQ::ItemInstance::FirstOpenSlot() const
+uint8 EQEmu::ItemInstance::FirstOpenSlot() const
 {
 	if (!m_item)
 		return INVALID_INDEX;
@@ -472,7 +472,7 @@ uint8 EQ::ItemInstance::FirstOpenSlot() const
 	return (i < slots) ? i : INVALID_INDEX;
 }
 
-uint8 EQ::ItemInstance::GetTotalItemCount() const
+uint8 EQEmu::ItemInstance::GetTotalItemCount() const
 {
 	if (!m_item)
 		return 0;
@@ -486,7 +486,7 @@ uint8 EQ::ItemInstance::GetTotalItemCount() const
 	return item_count;
 }
 
-bool EQ::ItemInstance::IsNoneEmptyContainer()
+bool EQEmu::ItemInstance::IsNoneEmptyContainer()
 {
 	if (!m_item || !m_item->IsClassBag())
 		return false;
@@ -500,7 +500,7 @@ bool EQ::ItemInstance::IsNoneEmptyContainer()
 }
 
 // Retrieve augment inside item
-EQ::ItemInstance* EQ::ItemInstance::GetAugment(uint8 slot) const
+EQEmu::ItemInstance* EQEmu::ItemInstance::GetAugment(uint8 slot) const
 {
 	if (m_item && m_item->IsClassCommon())
 		return GetItem(slot);
@@ -508,7 +508,7 @@ EQ::ItemInstance* EQ::ItemInstance::GetAugment(uint8 slot) const
 	return nullptr;
 }
 
-EQ::ItemInstance* EQ::ItemInstance::GetOrnamentationAug(int32 ornamentationAugtype) const
+EQEmu::ItemInstance* EQEmu::ItemInstance::GetOrnamentationAug(int32 ornamentationAugtype) const
 {
 	if (!m_item || !m_item->IsClassCommon()) { return nullptr; }
 	if (ornamentationAugtype == 0) { return nullptr; }
@@ -533,7 +533,7 @@ EQ::ItemInstance* EQ::ItemInstance::GetOrnamentationAug(int32 ornamentationAugty
 	return nullptr;
 }
 
-uint32 EQ::ItemInstance::GetOrnamentHeroModel(int32 material_slot) const {
+uint32 EQEmu::ItemInstance::GetOrnamentHeroModel(int32 material_slot) const {
 	// Not a Hero Forge item.
 	if (m_ornament_hero_model == 0 || material_slot < 0)
 		return 0;
@@ -546,7 +546,7 @@ uint32 EQ::ItemInstance::GetOrnamentHeroModel(int32 material_slot) const {
 	return (m_ornament_hero_model * 100) + material_slot;
 }
 
-bool EQ::ItemInstance::UpdateOrnamentationInfo() {
+bool EQEmu::ItemInstance::UpdateOrnamentationInfo() {
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
 	
@@ -582,7 +582,7 @@ bool EQ::ItemInstance::UpdateOrnamentationInfo() {
 	return ornamentSet;
 }
 
-bool EQ::ItemInstance::CanTransform(const ItemData *ItemToTry, const ItemData *Container, bool AllowAll) {
+bool EQEmu::ItemInstance::CanTransform(const ItemData *ItemToTry, const ItemData *Container, bool AllowAll) {
 	if (!ItemToTry || !Container) return false;
 
 	if (ItemToTry->ItemType == item::ItemTypeArrow || strnlen(Container->CharmFile, 30) == 0)
@@ -629,7 +629,7 @@ bool EQ::ItemInstance::CanTransform(const ItemData *ItemToTry, const ItemData *C
 	return false;
 }
 
-uint32 EQ::ItemInstance::GetAugmentItemID(uint8 slot) const
+uint32 EQEmu::ItemInstance::GetAugmentItemID(uint8 slot) const
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return 0;
@@ -638,7 +638,7 @@ uint32 EQ::ItemInstance::GetAugmentItemID(uint8 slot) const
 }
 
 // Add an augment to the item
-void EQ::ItemInstance::PutAugment(uint8 slot, const ItemInstance& augment)
+void EQEmu::ItemInstance::PutAugment(uint8 slot, const ItemInstance& augment)
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return;
@@ -646,7 +646,7 @@ void EQ::ItemInstance::PutAugment(uint8 slot, const ItemInstance& augment)
 	PutItem(slot, augment);
 }
 
-void EQ::ItemInstance::PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id)
+void EQEmu::ItemInstance::PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id)
 {
 	if (item_id == 0) { return; }
 	if (db == nullptr) { return; /* TODO: add log message for nullptr */ }
@@ -659,7 +659,7 @@ void EQ::ItemInstance::PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id
 }
 
 // Remove augment from item and destroy it
-void EQ::ItemInstance::DeleteAugment(uint8 index)
+void EQEmu::ItemInstance::DeleteAugment(uint8 index)
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return;
@@ -668,7 +668,7 @@ void EQ::ItemInstance::DeleteAugment(uint8 index)
 }
 
 // Remove augment from item and return it
-EQ::ItemInstance* EQ::ItemInstance::RemoveAugment(uint8 index)
+EQEmu::ItemInstance* EQEmu::ItemInstance::RemoveAugment(uint8 index)
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return nullptr;
@@ -676,7 +676,7 @@ EQ::ItemInstance* EQ::ItemInstance::RemoveAugment(uint8 index)
 	return PopItem(index);
 }
 
-bool EQ::ItemInstance::IsAugmented()
+bool EQEmu::ItemInstance::IsAugmented()
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
@@ -690,7 +690,7 @@ bool EQ::ItemInstance::IsAugmented()
 }
 
 // Has attack/delay?
-bool EQ::ItemInstance::IsWeapon() const
+bool EQEmu::ItemInstance::IsWeapon() const
 {
 	if (!m_item || !m_item->IsClassCommon())
 		return false;
@@ -701,7 +701,7 @@ bool EQ::ItemInstance::IsWeapon() const
 		return ((m_item->Damage != 0) && (m_item->Delay != 0));
 }
 
-bool EQ::ItemInstance::IsAmmo() const
+bool EQEmu::ItemInstance::IsAmmo() const
 {
 	if (!m_item)
 		return false;
@@ -717,7 +717,7 @@ bool EQ::ItemInstance::IsAmmo() const
 
 }
 
-const EQ::ItemData* EQ::ItemInstance::GetItem() const
+const EQEmu::ItemData* EQEmu::ItemInstance::GetItem() const
 {
 	if (!m_item)
 		return nullptr;
@@ -728,13 +728,13 @@ const EQ::ItemData* EQ::ItemInstance::GetItem() const
 	return m_item;
 }
 
-const EQ::ItemData* EQ::ItemInstance::GetUnscaledItem() const
+const EQEmu::ItemData* EQEmu::ItemInstance::GetUnscaledItem() const
 {
 	// No operator calls and defaults to nullptr
 	return m_item;
 }
 
-std::string EQ::ItemInstance::GetCustomDataString() const {
+std::string EQEmu::ItemInstance::GetCustomDataString() const {
 	std::string ret_val;
 	auto iter = m_custom_data.begin();
 	while (iter != m_custom_data.end()) {
@@ -753,7 +753,7 @@ std::string EQ::ItemInstance::GetCustomDataString() const {
 	return ret_val;
 }
 
-std::string EQ::ItemInstance::GetCustomData(std::string identifier) {
+std::string EQEmu::ItemInstance::GetCustomData(std::string identifier) {
 	std::map<std::string, std::string>::const_iterator iter = m_custom_data.find(identifier);
 	if (iter != m_custom_data.end()) {
 		return iter->second;
@@ -762,49 +762,49 @@ std::string EQ::ItemInstance::GetCustomData(std::string identifier) {
 	return "";
 }
 
-void EQ::ItemInstance::SetCustomData(std::string identifier, std::string value) {
+void EQEmu::ItemInstance::SetCustomData(std::string identifier, std::string value) {
 	DeleteCustomData(identifier);
 	m_custom_data[identifier] = value;
 }
 
-void EQ::ItemInstance::SetCustomData(std::string identifier, int value) {
+void EQEmu::ItemInstance::SetCustomData(std::string identifier, int value) {
 	DeleteCustomData(identifier);
 	std::stringstream ss;
 	ss << value;
 	m_custom_data[identifier] = ss.str();
 }
 
-void EQ::ItemInstance::SetCustomData(std::string identifier, float value) {
+void EQEmu::ItemInstance::SetCustomData(std::string identifier, float value) {
 	DeleteCustomData(identifier);
 	std::stringstream ss;
 	ss << value;
 	m_custom_data[identifier] = ss.str();
 }
 
-void EQ::ItemInstance::SetCustomData(std::string identifier, bool value) {
+void EQEmu::ItemInstance::SetCustomData(std::string identifier, bool value) {
 	DeleteCustomData(identifier);
 	std::stringstream ss;
 	ss << value;
 	m_custom_data[identifier] = ss.str();
 }
 
-void EQ::ItemInstance::DeleteCustomData(std::string identifier) {
+void EQEmu::ItemInstance::DeleteCustomData(std::string identifier) {
 	auto iter = m_custom_data.find(identifier);
 	if (iter != m_custom_data.end()) {
 		m_custom_data.erase(iter);
 	}
 }
 
-// Clone a type of EQ::ItemInstance object
+// Clone a type of EQEmu::ItemInstance object
 // c++ doesn't allow a polymorphic copy constructor,
 // so we have to resort to a polymorphic Clone()
-EQ::ItemInstance* EQ::ItemInstance::Clone() const
+EQEmu::ItemInstance* EQEmu::ItemInstance::Clone() const
 {
 	// Pseudo-polymorphic copy constructor
 	return new ItemInstance(*this);
 }
 
-bool EQ::ItemInstance::IsSlotAllowed(int16 slot_id) const {
+bool EQEmu::ItemInstance::IsSlotAllowed(int16 slot_id) const {
 	if (!m_item) { return false; }
 	else if (InventoryProfile::SupportsContainers(slot_id)) { return true; }
 	else if (m_item->Slots & (1 << slot_id)) { return true; }
@@ -812,7 +812,7 @@ bool EQ::ItemInstance::IsSlotAllowed(int16 slot_id) const {
 	else { return false; }
 }
 
-bool EQ::ItemInstance::IsDroppable(bool recurse) const
+bool EQEmu::ItemInstance::IsDroppable(bool recurse) const
 {
 	if (!m_item)
 		return false;
@@ -838,7 +838,7 @@ bool EQ::ItemInstance::IsDroppable(bool recurse) const
 	return true;
 }
 
-void EQ::ItemInstance::Initialize(SharedDatabase *db) {
+void EQEmu::ItemInstance::Initialize(SharedDatabase *db) {
 	// if there's no actual item, don't do anything
 	if (!m_item)
 		return;
@@ -855,7 +855,7 @@ void EQ::ItemInstance::Initialize(SharedDatabase *db) {
 	}
 }
 
-void EQ::ItemInstance::ScaleItem() {
+void EQEmu::ItemInstance::ScaleItem() {
 	if (!m_item)
 		return;
 
@@ -939,18 +939,18 @@ void EQ::ItemInstance::ScaleItem() {
 	m_scaledItem->CharmFileID = 0;	// this stops the client from trying to scale the item itself.
 }
 
-bool EQ::ItemInstance::EvolveOnAllKills() const {
+bool EQEmu::ItemInstance::EvolveOnAllKills() const {
 	return (m_evolveInfo && m_evolveInfo->AllKills);
 }
 
-int8 EQ::ItemInstance::GetMaxEvolveLvl() const {
+int8 EQEmu::ItemInstance::GetMaxEvolveLvl() const {
 	if (m_evolveInfo)
 		return m_evolveInfo->MaxLvl;
 	else
 		return 0;
 }
 
-uint32 EQ::ItemInstance::GetKillsNeeded(uint8 currentlevel) {
+uint32 EQEmu::ItemInstance::GetKillsNeeded(uint8 currentlevel) {
 	uint32 kills = -1;	// default to -1 (max uint32 value) because this value is usually divided by, so we don't want to ever return zero.
 	if (m_evolveInfo)
 		if (currentlevel != m_evolveInfo->MaxLvl)
@@ -962,24 +962,24 @@ uint32 EQ::ItemInstance::GetKillsNeeded(uint8 currentlevel) {
 	return kills;
 }
 
-void EQ::ItemInstance::SetTimer(std::string name, uint32 time) {
+void EQEmu::ItemInstance::SetTimer(std::string name, uint32 time) {
 	Timer t(time);
 	t.Start(time, false);
 	m_timers[name] = t;
 }
 
-void EQ::ItemInstance::StopTimer(std::string name) {
+void EQEmu::ItemInstance::StopTimer(std::string name) {
 	auto iter = m_timers.find(name);
 	if(iter != m_timers.end()) {
 		m_timers.erase(iter);
 	}
 }
 
-void EQ::ItemInstance::ClearTimers() {
+void EQEmu::ItemInstance::ClearTimers() {
 	m_timers.clear();
 }
 
-int EQ::ItemInstance::GetItemArmorClass(bool augments) const
+int EQEmu::ItemInstance::GetItemArmorClass(bool augments) const
 {
 	int ac = 0;
 	const auto item = GetItem();
@@ -993,7 +993,7 @@ int EQ::ItemInstance::GetItemArmorClass(bool augments) const
 	return ac;
 }
 
-int EQ::ItemInstance::GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments) const
+int EQEmu::ItemInstance::GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments) const
 {
 	const auto item = GetItem();
 	if (item) {
@@ -1035,7 +1035,7 @@ int EQ::ItemInstance::GetItemElementalDamage(int &magic, int &fire, int &cold, i
 	return magic + fire + cold + poison + disease + chromatic + prismatic + physical + corruption;
 }
 
-int EQ::ItemInstance::GetItemElementalFlag(bool augments) const
+int EQEmu::ItemInstance::GetItemElementalFlag(bool augments) const
 {
 	int flag = 0;
 	const auto item = GetItem();
@@ -1056,7 +1056,7 @@ int EQ::ItemInstance::GetItemElementalFlag(bool augments) const
 	return flag;
 }
 
-int EQ::ItemInstance::GetItemElementalDamage(bool augments) const
+int EQEmu::ItemInstance::GetItemElementalDamage(bool augments) const
 {
 	int damage = 0;
 	const auto item = GetItem();
@@ -1077,7 +1077,7 @@ int EQ::ItemInstance::GetItemElementalDamage(bool augments) const
 	return damage;
 }
 
-int EQ::ItemInstance::GetItemRecommendedLevel(bool augments) const
+int EQEmu::ItemInstance::GetItemRecommendedLevel(bool augments) const
 {
 	int level = 0;
 	const auto item = GetItem();
@@ -1099,7 +1099,7 @@ int EQ::ItemInstance::GetItemRecommendedLevel(bool augments) const
 	return level;
 }
 
-int EQ::ItemInstance::GetItemRequiredLevel(bool augments) const
+int EQEmu::ItemInstance::GetItemRequiredLevel(bool augments) const
 {
 	int level = 0;
 	const auto item = GetItem();
@@ -1121,7 +1121,7 @@ int EQ::ItemInstance::GetItemRequiredLevel(bool augments) const
 	return level;
 }
 
-int EQ::ItemInstance::GetItemWeaponDamage(bool augments) const
+int EQEmu::ItemInstance::GetItemWeaponDamage(bool augments) const
 {
 	int damage = 0;
 	const auto item = GetItem();
@@ -1137,7 +1137,7 @@ int EQ::ItemInstance::GetItemWeaponDamage(bool augments) const
 	return damage;
 }
 
-int EQ::ItemInstance::GetItemBackstabDamage(bool augments) const
+int EQEmu::ItemInstance::GetItemBackstabDamage(bool augments) const
 {
 	int damage = 0;
 	const auto item = GetItem();
@@ -1153,7 +1153,7 @@ int EQ::ItemInstance::GetItemBackstabDamage(bool augments) const
 	return damage;
 }
 
-int EQ::ItemInstance::GetItemBaneDamageBody(bool augments) const
+int EQEmu::ItemInstance::GetItemBaneDamageBody(bool augments) const
 {
 	int body = 0;
 	const auto item = GetItem();
@@ -1174,7 +1174,7 @@ int EQ::ItemInstance::GetItemBaneDamageBody(bool augments) const
 	return body;
 }
 
-int EQ::ItemInstance::GetItemBaneDamageRace(bool augments) const
+int EQEmu::ItemInstance::GetItemBaneDamageRace(bool augments) const
 {
 	int race = 0;
 	const auto item = GetItem();
@@ -1195,7 +1195,7 @@ int EQ::ItemInstance::GetItemBaneDamageRace(bool augments) const
 	return race;
 }
 
-int EQ::ItemInstance::GetItemBaneDamageBody(bodyType against, bool augments) const
+int EQEmu::ItemInstance::GetItemBaneDamageBody(bodyType against, bool augments) const
 {
 	int damage = 0;
 	const auto item = GetItem();
@@ -1212,7 +1212,7 @@ int EQ::ItemInstance::GetItemBaneDamageBody(bodyType against, bool augments) con
 	return damage;
 }
 
-int EQ::ItemInstance::GetItemBaneDamageRace(uint16 against, bool augments) const
+int EQEmu::ItemInstance::GetItemBaneDamageRace(uint16 against, bool augments) const
 {
 	int damage = 0;
 	const auto item = GetItem();
@@ -1229,7 +1229,7 @@ int EQ::ItemInstance::GetItemBaneDamageRace(uint16 against, bool augments) const
 	return damage;
 }
 
-int EQ::ItemInstance::GetItemMagical(bool augments) const
+int EQEmu::ItemInstance::GetItemMagical(bool augments) const
 {
 	const auto item = GetItem();
 	if (item) {
@@ -1245,7 +1245,7 @@ int EQ::ItemInstance::GetItemMagical(bool augments) const
 	return 0;
 }
 
-int EQ::ItemInstance::GetItemHP(bool augments) const
+int EQEmu::ItemInstance::GetItemHP(bool augments) const
 {
 	int hp = 0;
 	const auto item = GetItem();
@@ -1259,7 +1259,7 @@ int EQ::ItemInstance::GetItemHP(bool augments) const
 	return hp;
 }
 
-int EQ::ItemInstance::GetItemMana(bool augments) const
+int EQEmu::ItemInstance::GetItemMana(bool augments) const
 {
 	int mana = 0;
 	const auto item = GetItem();
@@ -1273,7 +1273,7 @@ int EQ::ItemInstance::GetItemMana(bool augments) const
 	return mana;
 }
 
-int EQ::ItemInstance::GetItemEndur(bool augments) const
+int EQEmu::ItemInstance::GetItemEndur(bool augments) const
 {
 	int endur = 0;
 	const auto item = GetItem();
@@ -1287,7 +1287,7 @@ int EQ::ItemInstance::GetItemEndur(bool augments) const
 	return endur;
 }
 
-int EQ::ItemInstance::GetItemAttack(bool augments) const
+int EQEmu::ItemInstance::GetItemAttack(bool augments) const
 {
 	int atk = 0;
 	const auto item = GetItem();
@@ -1301,7 +1301,7 @@ int EQ::ItemInstance::GetItemAttack(bool augments) const
 	return atk;
 }
 
-int EQ::ItemInstance::GetItemStr(bool augments) const
+int EQEmu::ItemInstance::GetItemStr(bool augments) const
 {
 	int str = 0;
 	const auto item = GetItem();
@@ -1315,7 +1315,7 @@ int EQ::ItemInstance::GetItemStr(bool augments) const
 	return str;
 }
 
-int EQ::ItemInstance::GetItemSta(bool augments) const
+int EQEmu::ItemInstance::GetItemSta(bool augments) const
 {
 	int sta = 0;
 	const auto item = GetItem();
@@ -1329,7 +1329,7 @@ int EQ::ItemInstance::GetItemSta(bool augments) const
 	return sta;
 }
 
-int EQ::ItemInstance::GetItemDex(bool augments) const
+int EQEmu::ItemInstance::GetItemDex(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1343,7 +1343,7 @@ int EQ::ItemInstance::GetItemDex(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemAgi(bool augments) const
+int EQEmu::ItemInstance::GetItemAgi(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1357,7 +1357,7 @@ int EQ::ItemInstance::GetItemAgi(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemInt(bool augments) const
+int EQEmu::ItemInstance::GetItemInt(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1371,7 +1371,7 @@ int EQ::ItemInstance::GetItemInt(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemWis(bool augments) const
+int EQEmu::ItemInstance::GetItemWis(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1385,7 +1385,7 @@ int EQ::ItemInstance::GetItemWis(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemCha(bool augments) const
+int EQEmu::ItemInstance::GetItemCha(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1399,7 +1399,7 @@ int EQ::ItemInstance::GetItemCha(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemMR(bool augments) const
+int EQEmu::ItemInstance::GetItemMR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1413,7 +1413,7 @@ int EQ::ItemInstance::GetItemMR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemFR(bool augments) const
+int EQEmu::ItemInstance::GetItemFR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1427,7 +1427,7 @@ int EQ::ItemInstance::GetItemFR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemCR(bool augments) const
+int EQEmu::ItemInstance::GetItemCR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1441,7 +1441,7 @@ int EQ::ItemInstance::GetItemCR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemPR(bool augments) const
+int EQEmu::ItemInstance::GetItemPR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1455,7 +1455,7 @@ int EQ::ItemInstance::GetItemPR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemDR(bool augments) const
+int EQEmu::ItemInstance::GetItemDR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1469,7 +1469,7 @@ int EQ::ItemInstance::GetItemDR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemCorrup(bool augments) const
+int EQEmu::ItemInstance::GetItemCorrup(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1483,7 +1483,7 @@ int EQ::ItemInstance::GetItemCorrup(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicStr(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicStr(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1497,7 +1497,7 @@ int EQ::ItemInstance::GetItemHeroicStr(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicSta(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicSta(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1511,7 +1511,7 @@ int EQ::ItemInstance::GetItemHeroicSta(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicDex(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicDex(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1525,7 +1525,7 @@ int EQ::ItemInstance::GetItemHeroicDex(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicAgi(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicAgi(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1539,7 +1539,7 @@ int EQ::ItemInstance::GetItemHeroicAgi(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicInt(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicInt(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1553,7 +1553,7 @@ int EQ::ItemInstance::GetItemHeroicInt(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicWis(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicWis(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1567,7 +1567,7 @@ int EQ::ItemInstance::GetItemHeroicWis(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicCha(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicCha(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1581,7 +1581,7 @@ int EQ::ItemInstance::GetItemHeroicCha(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicMR(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicMR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1595,7 +1595,7 @@ int EQ::ItemInstance::GetItemHeroicMR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicFR(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicFR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1609,7 +1609,7 @@ int EQ::ItemInstance::GetItemHeroicFR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicCR(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicCR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1623,7 +1623,7 @@ int EQ::ItemInstance::GetItemHeroicCR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicPR(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicPR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1637,7 +1637,7 @@ int EQ::ItemInstance::GetItemHeroicPR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicDR(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicDR(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1651,7 +1651,7 @@ int EQ::ItemInstance::GetItemHeroicDR(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHeroicCorrup(bool augments) const
+int EQEmu::ItemInstance::GetItemHeroicCorrup(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();
@@ -1665,7 +1665,7 @@ int EQ::ItemInstance::GetItemHeroicCorrup(bool augments) const
 	return total;
 }
 
-int EQ::ItemInstance::GetItemHaste(bool augments) const
+int EQEmu::ItemInstance::GetItemHaste(bool augments) const
 {
 	int total = 0;
 	const auto item = GetItem();

common/item_instance.h

@@ -38,7 +38,7 @@ class EvolveInfo;			// Stores information about an evolving item family
 #include <map>
 
 
-// Specifies usage type for item inside EQ::ItemInstance
+// Specifies usage type for item inside EQEmu::ItemInstance
 enum ItemInstTypes
 {
 	ItemInstNormal = 0,
@@ -54,14 +54,14 @@ typedef enum {
 class SharedDatabase;
 
 // ########################################
-// Class: EQ::ItemInstance
+// Class: EQEmu::ItemInstance
 //	Base class for an instance of an item
 //	An item instance encapsulates item data + data specific
 //	to an item instance (includes dye, augments, charges, etc)
-namespace EQ
+namespace EQEmu
 {
 	class InventoryProfile;
-
+	
 	class ItemInstance {
 	public:
 		/////////////////////////
@@ -222,7 +222,7 @@ namespace EQ
 		inline int32 GetSerialNumber() const { return m_SerialNumber; }
 		inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
 
-		std::map<std::string, ::Timer>& GetTimers() { return m_timers; }
+		std::map<std::string, Timer>& GetTimers() { return m_timers; }
 		void SetTimer(std::string name, uint32 time);
 		void StopTimer(std::string name);
 		void ClearTimers();
@@ -316,13 +316,13 @@ namespace EQ
 		// Items inside of this item (augs or contents);
 		std::map<uint8, ItemInstance*>		m_contents; // Zero-based index: min=0, max=9
 		std::map<std::string, std::string>	m_custom_data;
-		std::map<std::string, ::Timer>		m_timers;
+		std::map<std::string, Timer>		m_timers;
 	};
 }
 
 class EvolveInfo {
 public:
-	friend class EQ::ItemInstance;
+	friend class EQEmu::ItemInstance;
 	//temporary
 	uint16				LvlKills[9];
 	uint32				FirstItem;

common/json/jsoncpp.cpp

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

common/json_config.cpp

@@ -1,29 +1,26 @@
 #include "json_config.h"
 #include <fstream>
-#include <iostream>
 
-EQ::JsonConfigFile::JsonConfigFile() = default;
+EQ::JsonConfigFile::JsonConfigFile()
+{
+}
 
 EQ::JsonConfigFile::JsonConfigFile(const Json::Value &value)
 {
 	m_root = value;
 }
 
-EQ::JsonConfigFile::~JsonConfigFile() = default;
+EQ::JsonConfigFile::~JsonConfigFile()
+{
+}
 
-/**
- * @param file_name
- * @return
- */
-EQ::JsonConfigFile EQ::JsonConfigFile::Load(
-	const std::string &file_name
-)
+EQ::JsonConfigFile EQ::JsonConfigFile::Load(const std::string &filename)
 {
 	JsonConfigFile ret;
 	ret.m_root = Json::Value();
 
 	std::ifstream ifs;
-	ifs.open(file_name, std::ifstream::in);
+	ifs.open(filename, std::ifstream::in);
 
 	if (!ifs.good()) {
 		return ret;
@@ -32,128 +29,59 @@ EQ::JsonConfigFile EQ::JsonConfigFile::Load(
 	try {
 		ifs >> ret.m_root;
 	}
-	catch (std::exception &) {
+	catch (std::exception) {
 		return ret;
 	}
 
 	return ret;
 }
 
-/**
- * @param file_name
- * @return
- */
-void EQ::JsonConfigFile::Save(
-	const std::string &file_name
-)
-{
-	std::ofstream opened_config_file;
-	opened_config_file.open(file_name);
-
-	/**
-	 * Grab and build config contents
-	 */
-	Json::StreamWriterBuilder write_builder;
-	write_builder["indentation"] = "  ";
-	std::string document = Json::writeString(write_builder, m_root);
-
-	/**
-	 * Write current contents and close
-	 */
-	opened_config_file << document;
-	opened_config_file.close();
-}
-
-/**
- * @param title
- * @param parameter
- * @param default_value
- * @return
- */
-std::string EQ::JsonConfigFile::GetVariableString(
-	const std::string &title,
-	const std::string &parameter,
-	const std::string &default_value
-)
-{
+std::string EQ::JsonConfigFile::GetVariableString(const std::string &title, const std::string &parameter, const std::string &default_value) {
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asString();
 		}
 	}
-	catch (std::exception &) {
+	catch (std::exception) {
 		return default_value;
 	}
 
 	return default_value;
 }
 
-/**
- * @param title
- * @param parameter
- * @param default_value
- * @return
- */
-int EQ::JsonConfigFile::GetVariableInt(
-	const std::string &title,
-	const std::string &parameter,
-	const int default_value
-)
-{
+int EQ::JsonConfigFile::GetVariableInt(const std::string &title, const std::string &parameter, const int default_value) {
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asInt();
 		}
 	}
-	catch (std::exception &) {
+	catch (std::exception) {
 		return default_value;
 	}
 
 	return default_value;
 }
 
-/**
- * @param title
- * @param parameter
- * @param default_value
- * @return
- */
-bool EQ::JsonConfigFile::GetVariableBool(
-	const std::string &title,
-	const std::string &parameter,
-	const bool default_value
-)
-{
+bool EQ::JsonConfigFile::GetVariableBool(const std::string &title, const std::string &parameter, const bool default_value) {
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asBool();
 		}
 	}
-	catch (std::exception &) {
+	catch (std::exception) {
 		return default_value;
 	}
 
 	return default_value;
 }
 
-/**
- * @param title
- * @param parameter
- * @param default_value
- * @return
- */
-double EQ::JsonConfigFile::GetVariableDouble(
-	const std::string &title,
-	const std::string &parameter,
-	const double default_value
-)
-{
+double EQ::JsonConfigFile::GetVariableDouble(const std::string &title, const std::string &parameter, const double default_value) {
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asDouble();
 		}
 	}
-	catch (std::exception &) {
+	catch (std::exception) {
 		return default_value;
 	}
 

common/json_config.h

@@ -7,12 +7,10 @@ namespace EQ
 	class JsonConfigFile
 	{
 	public:
-		JsonConfigFile();
 		JsonConfigFile(const Json::Value &value);
 		~JsonConfigFile();
 
-		static JsonConfigFile Load(const std::string &file_name);
-		void Save(const std::string &file_name);
+		static JsonConfigFile Load(const std::string &filename);
 
 		std::string GetVariableString(const std::string &title, const std::string &parameter, const std::string &default_value);
 		int GetVariableInt(const std::string &title, const std::string &parameter, const int default_value);
@@ -21,6 +19,7 @@ namespace EQ
 		
 		Json::Value& RawHandle() { return m_root; }
 	private:
+		JsonConfigFile();
 		Json::Value m_root;
 	};
 

common/light_source.cpp

@@ -22,7 +22,7 @@
 #include <string.h>
 
 
-uint8 EQ::lightsource::TypeToLevel(uint8 light_type)
+uint8 EQEmu::lightsource::TypeToLevel(uint8 light_type)
 {
 	switch (light_type) {
 	case LightTypeGlobeOfStars:
@@ -55,7 +55,7 @@ uint8 EQ::lightsource::TypeToLevel(uint8 light_type)
 	}
 }
 
-bool EQ::lightsource::IsLevelGreater(uint8 left_type, uint8 right_type)
+bool EQEmu::lightsource::IsLevelGreater(uint8 left_type, uint8 right_type)
 {
 	static const uint8 light_levels[LightTypeCount] = {
 		LightLevelUnlit,			/* LightTypeNone */
@@ -82,17 +82,17 @@ bool EQ::lightsource::IsLevelGreater(uint8 left_type, uint8 right_type)
 	return (light_levels[left_type] > light_levels[right_type]);
 }
 
-EQ::LightSource_Struct::LightSource_Struct()
+EQEmu::LightSource_Struct::LightSource_Struct()
 {
 	Clear();
 }
 
-void EQ::LightSource_Struct::Clear()
+void EQEmu::LightSource_Struct::Clear()
 {
 	memset(&Slot, 0, (sizeof(uint8) * lightsource::LightCount));
 }
 
-void EQ::LightSourceProfile::Clear()
+void EQEmu::LightSourceProfile::Clear()
 {
 	Type.Clear();
 	Level.Clear();

common/light_source.h

@@ -23,7 +23,7 @@
 #include "types.h"
 
 
-namespace EQ
+namespace EQEmu
 {
 	namespace lightsource {
 		enum LightSlot {

common/linked_list.h

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

common/loottable.h

@@ -39,15 +39,13 @@ struct LootTable_Struct {
 };
 
 struct LootDropEntries_Struct {
-	uint32 item_id;
-	int8   item_charges;
-	uint8  equip_item;
-	float  chance;
-	uint16 trivial_min_level;
-	uint16 trivial_max_level;
-	uint16 npc_min_level;
-	uint16 npc_max_level;
-	uint8  multiplier;
+	uint32	item_id;
+	int8	item_charges;
+	uint8	equip_item;
+	float	chance;
+	uint8	minlevel;
+	uint8	maxlevel;
+	uint8	multiplier;
 };
 
 struct LootDrop_Struct {

common/memory_buffer.cpp

@@ -20,7 +20,7 @@
 #include "memory_buffer.h"
 
 
-EQ::MemoryBuffer::MemoryBuffer()
+EQEmu::MemoryBuffer::MemoryBuffer()
 {
 	buffer_ = nullptr;
 	size_ = 0;
@@ -29,7 +29,7 @@ EQ::MemoryBuffer::MemoryBuffer()
 	write_pos_ = 0;
 }
 
-EQ::MemoryBuffer::MemoryBuffer(size_t sz)
+EQEmu::MemoryBuffer::MemoryBuffer(size_t sz)
 {
 	buffer_ = nullptr;
 	size_ = 0;
@@ -39,7 +39,7 @@ EQ::MemoryBuffer::MemoryBuffer(size_t sz)
 	Resize(sz);
 }
 
-EQ::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
+EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
 {
 	if(other.capacity_) {
 		buffer_ = new uchar[other.capacity_];
@@ -54,7 +54,7 @@ EQ::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
 	read_pos_ = other.read_pos_;
 }
 
-EQ::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
+EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
 {
 	uchar *tbuf = other.buffer_;
 	size_t tsz = other.size_;
@@ -75,7 +75,7 @@ EQ::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
 	read_pos_ = tread_pos;
 }
 
-EQ::MemoryBuffer& EQ::MemoryBuffer::operator=(const MemoryBuffer &other)
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other)
 {
 	if(this == &other) {
 		return *this;
@@ -100,7 +100,7 @@ EQ::MemoryBuffer& EQ::MemoryBuffer::operator=(const MemoryBuffer &other)
 	return *this;
 }
 
-EQ::MemoryBuffer& EQ::MemoryBuffer::operator=(MemoryBuffer &&other)
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other)
 {
 	uchar *tbuf = other.buffer_;
 	size_t tsz = other.size_;
@@ -122,7 +122,7 @@ EQ::MemoryBuffer& EQ::MemoryBuffer::operator=(MemoryBuffer &&other)
 	return *this;
 }
 
-EQ::MemoryBuffer& EQ::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
 {
 	if(!rhs.buffer_) {
 		return *this;
@@ -142,52 +142,52 @@ EQ::MemoryBuffer& EQ::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
 	return *this;
 }
 
-EQ::MemoryBuffer::~MemoryBuffer()
+EQEmu::MemoryBuffer::~MemoryBuffer()
 {
 	Clear();
 }
 
-uchar& EQ::MemoryBuffer::operator[](size_t pos)
+uchar& EQEmu::MemoryBuffer::operator[](size_t pos)
 {
 	return buffer_[pos];
 }
 
-const uchar& EQ::MemoryBuffer::operator[](size_t pos) const
+const uchar& EQEmu::MemoryBuffer::operator[](size_t pos) const
 {
 	return buffer_[pos];
 }
 
-bool EQ::MemoryBuffer::Empty()
+bool EQEmu::MemoryBuffer::Empty()
 {
 	return size_ == 0;
 }
 
-bool EQ::MemoryBuffer::Empty() const
+bool EQEmu::MemoryBuffer::Empty() const
 {
 	return size_ == 0;
 }
 
-size_t EQ::MemoryBuffer::Size()
+size_t EQEmu::MemoryBuffer::Size()
 {
 	return size_;
 }
 
-size_t EQ::MemoryBuffer::Size() const
+size_t EQEmu::MemoryBuffer::Size() const
 {
 	return size_;
 }
 
-size_t EQ::MemoryBuffer::Capacity()
+size_t EQEmu::MemoryBuffer::Capacity()
 {
 	return capacity_;
 }
 
-size_t EQ::MemoryBuffer::Capacity() const
+size_t EQEmu::MemoryBuffer::Capacity() const
 {
 	return capacity_;
 }
 
-void EQ::MemoryBuffer::Resize(size_t sz)
+void EQEmu::MemoryBuffer::Resize(size_t sz)
 {
 	if(!buffer_) {
 		size_t new_size = sz + 64;
@@ -213,7 +213,7 @@ void EQ::MemoryBuffer::Resize(size_t sz)
 	}
 }
 
-void EQ::MemoryBuffer::Clear()
+void EQEmu::MemoryBuffer::Clear()
 {
 	if(buffer_) {
 		delete[] buffer_;
@@ -226,14 +226,14 @@ void EQ::MemoryBuffer::Clear()
 	read_pos_ = 0;
 }
 
-void EQ::MemoryBuffer::Zero()
+void EQEmu::MemoryBuffer::Zero()
 {
 	if(buffer_) {
 		memset(buffer_, 0, capacity_);
 	}
 }
 
-void EQ::MemoryBuffer::Write(const char *val, size_t len)
+void EQEmu::MemoryBuffer::Write(const char *val, size_t len)
 {
 	size_t size_needed = write_pos_ + len;
 	Resize(size_needed);
@@ -242,20 +242,20 @@ void EQ::MemoryBuffer::Write(const char *val, size_t len)
 	write_pos_ += len;
 }
 
-void EQ::MemoryBuffer::Read(uchar *buf, size_t len)
+void EQEmu::MemoryBuffer::Read(uchar *buf, size_t len)
 {
 	memcpy(buf, &buffer_[read_pos_], len);
 	read_pos_ += len;
 }
 
-void EQ::MemoryBuffer::Read(char *str)
+void EQEmu::MemoryBuffer::Read(char *str)
 {
 	size_t len = strlen((const char*)&buffer_[read_pos_]);
 	memcpy(str, &buffer_[read_pos_], len);
 	read_pos_ += len;
 }
 
-void EQ::OutBuffer::overwrite(OutBuffer::pos_type position, const char *_Str, std::streamsize _Count)
+void EQEmu::OutBuffer::overwrite(OutBuffer::pos_type position, const char *_Str, std::streamsize _Count)
 {
 	auto last_pos = tellp();
 	seekp(position);
@@ -263,7 +263,7 @@ void EQ::OutBuffer::overwrite(OutBuffer::pos_type position, const char *_Str, st
 	seekp(last_pos);
 }
 
-uchar* EQ::OutBuffer::detach()
+uchar* EQEmu::OutBuffer::detach()
 {
 	size_t buffer_size = tellp();
 	if (buffer_size == 0)

common/memory_buffer.h

@@ -28,7 +28,7 @@
 #include <sstream>
 
 
-namespace EQ
+namespace EQEmu
 {
 	class MemoryBuffer {
 	public: