Update fmtlib

Removed platform code, refactored logging to account for it and removed logging global var.
Merge pull request #942 from noudess/patch-1
2026-05-24 14:12:27 +00:00 · 2020-01-06 20:41:45 -08:00 · 2020-01-06 18:15:55 -08:00 · 2020-01-04 20:17:07 -05:00 · 2020-01-04 16:17:25 -05:00 · 2020-01-04 01:56:45 -05:00
607 changed files with 70179 additions and 32060 deletions
@@ -23,21 +23,16 @@ CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
-Build/
-build/
-Build32/
-build32/
-Build64/
-build64/
-Build_32/
-build_32/
-Build_64/
-build_64/
-x64/
-x86/
+[Bb]uild*/
 log/
 logs/
 vcpkg/
+perl/

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

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-IF(POLICY CMP0074)
-	cmake_policy(SET CMP0074 NEW)
-ENDIF()
-
-#FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})

-#Our project name is EQEmu
+IF(POLICY CMP0074)
+	CMAKE_POLICY(SET CMP0074 NEW)
+ENDIF()
+
 PROJECT(EQEmu)

-#Default build type is set to RelWithDebInfo for generators that honor that like makefiles
 IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
 ENDIF(NOT CMAKE_BUILD_TYPE)

-SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
-
-#Add our various windows definitions
-IF(MSVC OR MINGW)
-	ADD_DEFINITIONS(-D_WINDOWS)
-	IF(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN64)
-	ELSE(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN32)
-	ENDIF(CMAKE_CL_64)
-ENDIF(MSVC OR MINGW)
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)

 IF(MSVC)
-	IF(CMAKE_CL_64)
-		SET(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(-D_CRT_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-DNOMINMAX)
+	ADD_DEFINITIONS(-DCRASH_LOGGING)
+	
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 ELSE(MSVC)
-	#Normally set by perl but we don't use the perl flags anymore so we set it.
 	ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
 ENDIF(MSVC)

@@ -133,179 +39,283 @@ IF(UNIX)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
 ENDIF(UNIX)

-#debug level, 5 is default. Most people wont ever change this but it's there if you want to
-SET(EQEMU_DEBUG_LEVEL 5 CACHE STRING "EQEmu debug level:
-	0 - Quiet mode Errors to file Status and Normal ignored
-	1 - Status and Normal to console, Errors to logfile
-	2 - Status, Normal, and Error to console and logfile
-	3 - Light debug release errors and status
-	4 - Moderate debug release errors and status
-	5 - Maximum debug release errors and status
-	10 - More errors than you ever wanted to see"
-)
+ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
+ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
+ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)

-SET(EQEMU_LOG_LEVEL_STATUS 2 CACHE STRING "EQEmu logging level for [Status]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+#MSVC can fetch dependencies automatically.
+IF(MSVC)
+	INCLUDE("${CMAKE_SOURCE_DIR}/cmake/DependencyHelperMSVC.cmake")
+ENDIF()

-SET(EQEMU_LOG_LEVEL_NORMAL 3 CACHE STRING "EQEmu logging level for [Normal]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+#Find everything we need
+FIND_PACKAGE(Boost REQUIRED)
+FIND_PACKAGE(MySQL)
+FIND_PACKAGE(MariaDB)
+FIND_PACKAGE(ZLIB)
+FIND_PACKAGE(OpenSSL)
+FIND_PACKAGE(Lua51)
+FIND_PACKAGE(PerlLibs)
+FIND_PACKAGE(Sodium)
+FIND_PACKAGE(mbedTLS)

-SET(EQEMU_LOG_LEVEL_ERROR 2 CACHE STRING "EQEmu logging level for [Error]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Detection                              *")
+MESSAGE(STATUS "**************************************************")

-SET(EQEMU_LOG_LEVEL_DEBUG 3 CACHE STRING "EQEmu logging level for [Debug]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(MYSQL_FOUND)
+	MESSAGE(STATUS "* MySQL:                                   FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MySQL:                                 MISSING *")
+ENDIF()

-SET(EQEMU_LOG_LEVEL_QUEST 2 CACHE STRING "EQEmu logging level for [Quest]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(MARIADB_FOUND)
+	MESSAGE(STATUS "* MariaDB:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MariaDB:                               MISSING *")
+ENDIF()

-SET(EQEMU_LOG_LEVEL_COMMANDS 1 CACHE STRING "EQEmu logging level for [Commands]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(ZLIB_FOUND)
+	MESSAGE(STATUS "* ZLIB:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* ZLIB:                                  MISSING *")
+ENDIF()

-SET(EQEMU_LOG_LEVEL_CRASH 3 CACHE STRING "EQEmu logging level for [Crash]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(Lua51_FOUND)
+	MESSAGE(STATUS "* Lua:                                     FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Lua:                                   MISSING *")
+ENDIF()

-MARK_AS_ADVANCED(EQEMU_LOG_LEVEL_STATUS EQEMU_LOG_LEVEL_NORMAL EQEMU_LOG_LEVEL_ERROR EQEMU_LOG_LEVEL_DEBUG EQEMU_LOG_LEVEL_QUEST EQEMU_LOG_LEVEL_COMMANDS EQEMU_LOG_LEVEL_CRASH)
+IF(PerlLibs_FOUND)
+	MESSAGE(STATUS "* Perl:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Perl:                                  MISSING *")
+ENDIF()

-#NPC Types Cache Behavior
+IF(SODIUM_FOUND)
+	MESSAGE(STATUS "* libsodium:                               FOUND *")
+ELSE()
+	MESSAGE(STATUS "* libsodium:                             MISSING *")
+ENDIF()
+
+IF(OpenSSL_FOUND)
+	MESSAGE(STATUS "* OpenSSL:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* OpenSSL:                               MISSING *")
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+	MESSAGE(STATUS "* mbedTLS:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* mbedTLS:                               MISSING *")
+ENDIF()
+
+MESSAGE(STATUS "**************************************************")
+
+#options
 OPTION(EQEMU_DEPOP_INVALIDATES_CACHE "#repop invalidates the npc_types cache (will cause a larger database hit on #repop but is more convienent)." ON)
-
-#Bots are a compile time option so on/off
 OPTION(EQEMU_ENABLE_BOTS "Enable Bots" OFF)
-
-#Disable entire _mlog system (excludes trade/command logs)
-OPTION(EQEMU_DISABLE_LOGSYS "Disable Logging INI System" ON)
-
-#Enable GM Command log system
 OPTION(EQEMU_COMMANDS_LOGGING "Enable GM Command logs" ON)
+OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
+OPTION(EQEMU_BUILD_LOGIN "Build the login server." ON)
+OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
+OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
+OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)

 IF(EQEMU_COMMANDS_LOGGING)
 	ADD_DEFINITIONS(-DCOMMANDS_LOGGING)
 ENDIF(EQEMU_COMMANDS_LOGGING)

-IF(EQEMU_DISABLE_LOGSYS)
-	ADD_DEFINITIONS(-DDISABLE_LOGSYS)
-ENDIF(EQEMU_DISABLE_LOGSYS)
-
 IF(EQEMU_ENABLE_BOTS)
 	ADD_DEFINITIONS(-DBOTS)
 ENDIF(EQEMU_ENABLE_BOTS)

-#What to build
-OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
-OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
-OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
-OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
-OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
-OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
-OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
-
-#C++11 stuff
-IF(NOT MSVC)
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-	IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal")
+#database
+IF(MySQL_FOUND AND MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_SELECTION MySQL CACHE STRING "Database library to use:
+			MySQL
+			MariaDB"
+	)
+	
+	IF(DATABASE_LIBRARY_SELECTION STREQUAL "MySQL")
+		SET(DATABASE_LIBRARY_TYPE "  MySQL")
+		SET(DATABASE_LIBRARY_LIBS ${MySQL_LIBRARIES})
+		SET(DATABASE_LIBRARY_INCLUDE ${MySQL_INCLUDE_DIR})
+	ELSEIF(DATABASE_LIBRARY_SELECTION STREQUAL "MariaDB")
+		SET(DATABASE_LIBRARY_TYPE "MariaDB")
+		SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+		SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+	ELSE()
+		MESSAGE(FATAL_ERROR "Unknown database library set, should be one of: MySQL, MariaDB")
 	ENDIF()
-ENDIF(NOT MSVC)
+ELSEIF(MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "MariaDB")
+	SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+ELSEIF(MySQL_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "  MySQL")
+	SET(DATABASE_LIBRARY_LIBS ${MySQL_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MySQL_INCLUDE_DIR})
+ELSE()
+	MESSAGE(FATAL_ERROR "One of MySQL or MariaDB is a required dependency.")
+ENDIF()

-#Various definitions
-IF(EQEMU_BUILD_PERL)
-	ADD_DEFINITIONS(-DEMBPERL)
-	ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
-ENDIF(EQEMU_BUILD_PERL)
-IF(EQEMU_BUILD_LUA)
-	ADD_DEFINITIONS(-DLUA_EQEMU)
-ENDIF(EQEMU_BUILD_LUA)
+#security
+#prefer openssl to mbedtls (arbitrary)
+IF(OpenSSL_FOUND AND MBEDTLS_FOUND)
+	SET(TLS_LIBRARY_SELECTION OpenSSL CACHE STRING "TLS library to use:
+			OpenSSL
+			mbedTLS"
+	)
+	
+	IF(TLS_LIBRARY_SELECTION STREQUAL "OpenSSL")
+		SET(TLS_LIBRARY_TYPE " OpenSSL")
+		SET(TLS_LIBRARY_ENABLED ON)
+		SET(TLS_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+		SET(TLS_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+		ADD_DEFINITIONS(-DEQEMU_USE_OPENSSL)
+	ELSEIF(TLS_LIBRARY_SELECTION STREQUAL "mbedTLS")
+		SET(TLS_LIBRARY_TYPE " mbedTLS")
+		SET(TLS_LIBRARY_ENABLED ON)
+		SET(TLS_LIBRARY_LIBS ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+		SET(TLS_LIBRARY_INCLUDE ${MBEDTLS_INCLUDE_DIR})
+		ADD_DEFINITIONS(-DEQEMU_USE_MBEDTLS)
+	ELSE()
+		MESSAGE(FATAL_ERROR "Unknown TLS library set, should be one of: OpenSSL, mbedTLS")
+	ENDIF()
+ELSEIF(OpenSSL_FOUND)
+	SET(TLS_LIBRARY_TYPE " OpenSSL")
+	SET(TLS_LIBRARY_ENABLED ON)
+	SET(TLS_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+	SET(TLS_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+	ADD_DEFINITIONS(-DEQEMU_USE_OPENSSL)
+ELSEIF(MBEDTLS_FOUND)
+	SET(TLS_LIBRARY_TYPE " mbedTLS")
+	SET(TLS_LIBRARY_ENABLED ON)
+	SET(TLS_LIBRARY_LIBS ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+	SET(TLS_LIBRARY_INCLUDE ${MBEDTLS_INCLUDE_DIR})
+	ADD_DEFINITIONS(-DEQEMU_USE_MBEDTLS)
+ELSE()
+	SET(TLS_LIBRARY_TYPE "Disabled")
+	SET(TLS_LIBRARY_ENABLED OFF)
+ENDIF()

-#Disabled until reevaluation performed
-#OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-#IF(EQEMU_USE_MAP_MMFS)
-#	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-#ENDIF(EQEMU_USE_MAP_MMFS)
-
-SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
-
-ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
-ADD_DEFINITIONS(-DINVERSEXY)
-ADD_DEFINITIONS(-DFIELD_ITEMS)
-ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
-ADD_DEFINITIONS(-DLOG_LEVEL_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)
-	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
-	IF(EQEMU_ENABLE_SECURITY)
-		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
-		ADD_DEFINITIONS(-DENABLE_SECURITY)
-		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_TYPE "Libsodium")
+	SET(SODIUM_LIBRARY_ENABLED ON)
+	SET(SODIUM_LIBRARY_LIBS ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_INCLUDE ${SODIUM_INCLUDE_DIRS})
+	ADD_DEFINITIONS(-DENABLE_SECURITY)
+ELSE()
+	SET(SODIUM_LIBRARY_TYPE " Disabled")
+	SET(SODIUM_LIBRARY_ENABLED OFF)
+ENDIF()
+
+IF(Lua51_FOUND)
+	SET(LUA_LIBRARY_TYPE " Lua 5.1")
+	SET(LUA_LIBRARY_ENABLED ON)
+	SET(LUA_LIBRARY_LIBS ${LUA_LIBRARY} luabind)
+	SET(LUA_LIBRARY_INCLUDE ${LUA_INCLUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+ELSE()
+	SET(LUA_LIBRARY_TYPE "Disabled")
+	SET(LUA_LIBRARY_ENABLED OFF)
+ENDIF()
+
+IF(PerlLibs_FOUND)
+	SET(PERL_LIBRARY_TYPE "    Perl")
+	SET(PERL_LIBRARY_ENABLED ON)
+	SET(PERL_LIBRARY_LIBS ${PERL_LIBRARY})
+	SET(PERL_LIBRARY_INCLUDE ${PERL_INCLUDE_PATH})
+ELSE()
+	SET(PERL_LIBRARY_TYPE "Disabled")
+	SET(PERL_LIBRARY_ENABLED OFF)
+ENDIF()
+
+#use zlib if exists
+IF(ZLIB_FOUND)
+	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." ON)
+	IF(EQEMU_BUILD_ZLIB)
+		SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+		SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+		SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+	ELSE()
+		SET(ZLIB_LIBRARY_TYPE "   zlib")
+		SET(ZLIB_LIBRARY_LIBS ${ZLIB_LIBRARY})
+		SET(ZLIB_LIBRARY_INCLUDE ${ZLIB_INCLUDE_DIRS})
+	ENDIF()
+ELSE()
+	SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+	SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+	SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng")
+ENDIF()
+
+MESSAGE(STATUS "")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Usage                                  *")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Database:                              ${DATABASE_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* TLS:                                  ${TLS_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Sodium:                              ${SODIUM_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Lua:                                  ${LUA_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Perl:                                 ${PERL_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* zlib:                                  ${ZLIB_LIBRARY_TYPE} *")
+MESSAGE(STATUS "**************************************************")
+
+#setup server libs and headers
+SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)
+
+INCLUDE_DIRECTORIES(SYSTEM "${DATABASE_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${Boost_INCLUDE_DIRS}")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/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()
 ENDIF()

@@ -321,34 +331,13 @@ IF(UNIX)
 	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
 ENDIF()

-IF(EQEMU_BUILD_LUA)
-	FIND_PACKAGE(EQLua51 REQUIRED)
-	SET(Boost_USE_STATIC_LIBS OFF)
-	SET(Boost_USE_MULTITHREADED ON)
-	SET(Boost_USE_STATIC_RUNTIME OFF)
-	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
+IF(EQEMU_BUILD_LOGIN AND NOT TLS_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Login server requires a TLS Library to build.")
+ENDIF()

-	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
-
-	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
-	IF(EQEMU_SANITIZE_LUA_LIBS)
-		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
-	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
-ENDIF(EQEMU_BUILD_LUA)
-
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
-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")
+IF(EQEMU_BUILD_HC AND NOT TLS_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Headless client requires a TLS Library to build.")
+ENDIF()

 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)
@@ -356,11 +345,18 @@ IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_H
 	ADD_SUBDIRECTORY(submodules/fmt)
 	ADD_SUBDIRECTORY(submodules/libuv)
 	
+	IF(EQEMU_BUILD_ZLIB)
+		SET(ZLIB_COMPAT ON CACHE BOOL "Compile with zlib compatible API")
+		SET(ZLIB_ENABLE_TESTS OFF CACHE BOOL "Build test binaries")
+		ADD_SUBDIRECTORY(libs/zlibng)
+	ENDIF()
+	
 	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
 	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
 	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
 	ADD_SUBDIRECTORY(submodules/recastnavigation)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
+
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -369,6 +365,7 @@ IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(queryserv)
 	ADD_SUBDIRECTORY(eqlaunch)
 ENDIF(EQEMU_BUILD_SERVER)
+
 IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)
@@ -70,3 +70,9 @@ 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>
@@ -0,0 +1,3 @@
+# Security Policy - Reporting Vulnerabilities
+
+When reporting active hacks, exploits and other vulnerabilities, please describe how to reproduce said report and if you can provide context into a possible solution
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)

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

 SET(export_sources
 	main.cpp
@@ -22,43 +22,38 @@
 #include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
-#include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"

-EQEmuLogSys LogSys;
-
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
 void ExportDBStrings(SharedDatabase *db);

 int main(int argc, char **argv) {
-	RegisterExecutablePlatform(ExePlatformClientExport);
-	LogSys.LoadLogSettingsDefaults();
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("client_export");
 	set_exception_handler();

-	Log(Logs::General, Logs::Status, "Client Files Export Utility");
+	LogInfo("Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
+		LogError("Unable to load configuration file");
 		return 1;
 	}

 	auto Config = EQEmuConfig::get();

 	SharedDatabase database;
-	Log(Logs::General, Logs::Status, "Connecting to database...");
+	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)) {
-		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
-			"database connection");
+		LogError("Unable to connect to the database, cannot continue without a database connection");
 		return 1;
 	}

 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
-	LogSys.StartFileLogs();
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
+	EQEmuLogSys::Get()->StartFileLogs();

 	std::string arg_1;

@@ -88,17 +83,17 @@ int main(int argc, char **argv) {
 	ExportBaseData(&database);
 	ExportDBStrings(&database);

-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();

 	return 0;
 }

 void ExportSpells(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Spells...");
+	LogInfo("Exporting Spells");

 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		LogError("Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}

@@ -165,11 +160,11 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
 }

 void ExportSkillCaps(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Skill Caps...");
+	LogInfo("Exporting Skill Caps");

 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		LogError("Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}

@@ -194,11 +189,11 @@ void ExportSkillCaps(SharedDatabase *db) {
 }

 void ExportBaseData(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Base Data...");
+	LogInfo("Exporting Base Data");

 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		LogError("Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}

@@ -225,11 +220,11 @@ void ExportBaseData(SharedDatabase *db) {
 }

 void ExportDBStrings(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting DB Strings...");
+	LogInfo("Exporting DB Strings");

 	FILE *f = fopen("export/dbstr_us.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
+		LogError("Unable to open export/dbstr_us.txt to write, skipping.");
 		return;
 	}

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

 SET(import_sources
 	main.cpp
@@ -20,49 +20,45 @@
 #include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
-#include "../../common/platform.h"
 #include "../../common/crash.h"
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"

-EQEmuLogSys LogSys;
-
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
 void ImportDBStrings(SharedDatabase *db);

 int main(int argc, char **argv) {
-	RegisterExecutablePlatform(ExePlatformClientImport);
-	LogSys.LoadLogSettingsDefaults();
+	EQEmuLogSys::Get()->LoadLogSettingsDefaults("client_import");
 	set_exception_handler();

-	Log(Logs::General, Logs::Status, "Client Files Import Utility");
+	LogInfo("Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
+		LogError("Unable to load configuration file.");
 		return 1;
 	}

 	auto Config = EQEmuConfig::get();

 	SharedDatabase database;
-	Log(Logs::General, Logs::Status, "Connecting to database...");
+	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)) {
-		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+		LogError("Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}

-	database.LoadLogSettings(LogSys.log_settings);
-	LogSys.StartFileLogs();
+	database.LoadLogSettings(EQEmuLogSys::Get()->log_settings);
+	EQEmuLogSys::Get()->StartFileLogs();

 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
 	ImportDBStrings(&database);

-	LogSys.CloseFileLogs();
+	EQEmuLogSys::Get()->CloseFileLogs();
 	
 	return 0;
 }
@@ -97,10 +93,10 @@ bool IsStringField(int i) {
 }

 void ImportSpells(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Spells...");
+	LogInfo("Importing Spells");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		LogError("Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}

@@ -173,23 +169,23 @@ void ImportSpells(SharedDatabase *db) {

 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+			LogInfo("[{}] spells imported", spells_imported);
 		}
 	}

 	if(spells_imported % 1000 != 0) {
-		Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+		LogInfo("[{}] spells imported", spells_imported);
 	}

 	fclose(f);
 }

 void ImportSkillCaps(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Skill Caps...");
+	LogInfo("Importing Skill Caps");

 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		LogError("Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}

@@ -220,11 +216,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }

 void ImportBaseData(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Base Data...");
+	LogInfo("Importing Base Data");

 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		LogError("Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}

@@ -265,11 +261,11 @@ void ImportBaseData(SharedDatabase *db) {
 }

 void ImportDBStrings(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing DB Strings...");
+	LogInfo("Importing DB Strings");

 	FILE *f = fopen("import/dbstr_us.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
+		LogError("Unable to open import/dbstr_us.txt to read, skipping.");
 		return;
 	}

@@ -0,0 +1,94 @@
+OPTION(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG "Automatically fetch vcpkg dependencies for MSCV" ON)
+OPTION(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL "Automatically fetch perl dependencies for MSCV" ON)
+
+MARK_AS_ADVANCED(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG)
+MARK_AS_ADVANCED(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL)
+
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86 "https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x86.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64 "https://github.com/EQEmu/Server/releases/download/v1.2/vcpkg-export-x64.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86 "http://strawberryperl.com/download/5.24.4.1/strawberry-perl-5.24.4.1-32bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64 "http://strawberryperl.com/download/5.24.4.1/strawberry-perl-5.24.4.1-64bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_ZIP "vcpkg-export-x86.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_ZIP "vcpkg-export-x64.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_DIR "vcpkg-export-x86")
+SET(EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_DIR "vcpkg-export-x64")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86_ZIP "strawberry-perl-5.24.4.1-32bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64_ZIP "strawberry-perl-5.24.4.1-64bit-portable.zip")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X86_DIR "x86")
+SET(EQEMU_MSVC_DEPENDENCIES_PERL_X64_DIR "x64")
+
+IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
+	SET(EQEMU_VCPKG_URL ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64})
+	SET(EQEMU_PERL_URL ${EQEMU_MSVC_DEPENDENCIES_PERL_X64})
+	SET(EQEMU_VCPKG_ZIP ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_ZIP})
+	SET(EQEMU_VCPKG_DIR ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X64_DIR})
+	SET(EQEMU_PERL_ZIP ${EQEMU_MSVC_DEPENDENCIES_PERL_X64_ZIP})
+	SET(EQEMU_PERL_DIR ${EQEMU_MSVC_DEPENDENCIES_PERL_X64_DIR})
+ELSE()
+	SET(EQEMU_VCPKG_URL ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86})
+	SET(EQEMU_PERL_URL ${EQEMU_MSVC_DEPENDENCIES_PERL_X86})
+	SET(EQEMU_VCPKG_ZIP ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_ZIP})
+	SET(EQEMU_VCPKG_DIR ${EQEMU_MSVC_DEPENDENCIES_VCPKG_X86_DIR})
+	SET(EQEMU_PERL_ZIP ${EQEMU_MSVC_DEPENDENCIES_PERL_X86_ZIP})
+	SET(EQEMU_PERL_DIR ${EQEMU_MSVC_DEPENDENCIES_PERL_X86_DIR})
+ENDIF()
+
+IF(EQEMU_FETCH_MSVC_DEPENDENCIES_VCPKG)
+	MESSAGE(STATUS "Resolving vcpkg dependencies...")
+	
+	IF(NOT EXISTS ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP})
+		EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/vcpkg)
+		
+		MESSAGE(STATUS "Downloading existing vcpkg dependencies from releases...")
+		FILE(DOWNLOAD ${EQEMU_VCPKG_URL} ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP} 
+			SHOW_PROGRESS
+			STATUS DOWNLOAD_STATUS)
+			
+		LIST(GET DOWNLOAD_STATUS 0 STATUS_CODE)
+		IF(NOT STATUS_CODE EQUAL 0)
+			MESSAGE(FATAL_ERROR "Was unable to download dependencies from ${EQEMU_VCPKG_URL}")
+		ENDIF()
+		
+		MESSAGE(STATUS "Extracting files...")
+		EXECUTE_PROCESS(
+			COMMAND ${CMAKE_COMMAND} -E tar xzf ${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_ZIP}
+			WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/vcpkg
+		)
+	ENDIF()
+	
+	INCLUDE(${PROJECT_SOURCE_DIR}/vcpkg/${EQEMU_VCPKG_DIR}/scripts/buildsystems/vcpkg.cmake)
+ENDIF()
+
+IF(EQEMU_FETCH_MSVC_DEPENDENCIES_PERL)
+	#Try to find perl first, (so you can use your active install first)
+	FIND_PACKAGE(PerlLibs)
+	
+	IF(NOT PerlLibs_FOUND)
+		MESSAGE(STATUS "Resolving perl dependencies...")
+		
+		IF(NOT EXISTS ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP})
+			EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/perl)
+			EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR})
+			
+			MESSAGE(STATUS "Downloading portable perl...")
+			FILE(DOWNLOAD ${EQEMU_PERL_URL} ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP} 
+				SHOW_PROGRESS
+				STATUS DOWNLOAD_STATUS)
+				
+			LIST(GET DOWNLOAD_STATUS 0 STATUS_CODE)
+			IF(NOT STATUS_CODE EQUAL 0)
+				MESSAGE(FATAL_ERROR "Was unable to download dependencies from ${EQEMU_PERL_URL}")
+			ENDIF()
+			
+			MESSAGE(STATUS "Extracting files...")
+			EXECUTE_PROCESS(
+				COMMAND ${CMAKE_COMMAND} -E tar xzf ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_ZIP}
+				WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}
+			)
+		ENDIF()
+		
+		SET(PERL_EXECUTABLE ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/bin/perl.exe CACHE FILEPATH "Path to perl program" FORCE)
+		SET(PERL_INCLUDE_PATH ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/lib/CORE CACHE PATH "Path to perl include files" FORCE)
+		SET(PERL_LIBRARY ${PROJECT_SOURCE_DIR}/perl/${EQEMU_PERL_DIR}/perl/lib/CORE/libperl524.a CACHE FILEPATH "Path to perl library" FORCE)
+	ENDIF()
+ENDIF()
@@ -1,124 +0,0 @@
-#CMake - Cross Platform Makefile Generator
-#Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
-#All rights reserved.
-#
-#Redistribution and use in source and binary forms, with or without
-#modification, are permitted provided that the following conditions
-#are met:
-#
-#* Redistributions of source code must retain the above copyright
-#  notice, this list of conditions and the following disclaimer.
-#
-#* Redistributions in binary form must reproduce the above copyright
-#  notice, this list of conditions and the following disclaimer in the
-#  documentation and/or other materials provided with the distribution.
-#
-#* Neither the names of Kitware, Inc., the Insight Software Consortium,
-#  nor the names of their contributors may be used to endorse or promote
-#  products derived from this software without specific prior written
-#  permission.
-#
-#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-#"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-#HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-#LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-#DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-#THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# This module defines
-#  LUA51_FOUND, if false, do not try to link to Lua
-#  LUA_LIBRARIES
-#  LUA_INCLUDE_DIR, where to find lua.h
-#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
-
-IF(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include src
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ELSE(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ENDIF(LUA_ROOT)
-
-IF(LUA_LIBRARY)
-	# include the math library for Unix
-	IF(UNIX AND NOT APPLE)
-		FIND_LIBRARY(LUA_MATH_LIBRARY m)
-	SET(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
-	# For Windows and Mac, don't need to explicitly include the math library
-	ELSE()
-		SET( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
-	ENDIF()
-ENDIF()
-
-IF(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
-	FILE(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
-
-	STRING(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
-	UNSET(lua_version_str)
-ENDIF()
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
-                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
-                                  VERSION_VAR LUA_VERSION_STRING)
-
-MARK_AS_ADVANCED(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
-
-
@@ -0,0 +1,91 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+# Modified from the FindLua51 that comes with CMake
+
+#[=======================================================================[.rst:
+FindLua51
+---------
+
+
+
+Locate Lua51 library This module defines
+
+::
+
+  LUA51_FOUND, if false, do not try to link to Lua
+  LUA_LIBRARIES
+  LUA_INCLUDE_DIR, where to find lua.h
+  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+
+
+
+Note that the expected include convention is
+
+::
+
+  #include "lua.h"
+
+and not
+
+::
+
+  #include <lua/lua.h>
+
+This is because, the lua location is not standardized and may exist in
+locations other than lua/
+#]=======================================================================]
+
+find_path(LUA_INCLUDE_DIR lua.h
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES include/lua51 include/lua5.1 include/lua-5.1 include/lua include/luajit include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+find_library(LUA_LIBRARY
+  NAMES lua51 lua5.1 lua-5.1 lua luajit
+  HINTS
+    ENV LUA_DIR
+  PATH_SUFFIXES lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+if(LUA_LIBRARY)
+  # include the math library for Unix
+  if(UNIX AND NOT APPLE AND NOT BEOS AND NOT HAIKU)
+    find_library(LUA_MATH_LIBRARY m)
+    set( LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+  # For Windows and Mac, don't need to explicitly include the math library
+  else()
+    set( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+  endif()
+endif()
+
+if(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
+  file(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
+
+  string(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
+  unset(lua_version_str)
+endif()
+
+include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
+# handle the QUIETLY and REQUIRED arguments and set LUA51_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
+
@@ -0,0 +1,87 @@
+# - Find mariadbclient
+#
+# -*- cmake -*-
+#
+# Find the native MariaDB includes and library
+#
+#	MariaDB_INCLUDE_DIR	- where to find mysql.h, etc.
+#	MariaDB_LIBRARIES		- List of libraries when using MariaDB.
+#	MariaDB_FOUND			- True if MariaDB found.
+#	The following can be used as a hint as to where to search:
+#	MARIADB_ROOT
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+	# Already in cache, be silent
+	SET(MariaDB_FIND_QUIETLY TRUE)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+
+# Include dir
+IF(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATHS ${MARIADB_ROOT}/include
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+# Library
+SET(MariaDB_NAMES libmariadb)
+IF(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATHS ${MARIADB_ROOT}/lib
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES} mariadbclient_r mariadbclient
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND TRUE)
+	SET(MariaDB_LIBRARIES ${MariaDB_LIBRARY})
+ELSE (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND FALSE)
+	SET(MariaDB_LIBRARIES)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+
+
+# handle the QUIETLY and REQUIRED arguments and set MariaDB_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MariaDB DEFAULT_MSG MariaDB_LIBRARY MariaDB_INCLUDE_DIR)
+
+IF(MariaDB_FOUND)
+	SET( MariaDB_LIBRARY_RELEASE ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARY_DEBUG ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARIES ${MariaDB_LIBRARY_RELEASE} ${MariaDB_LIBRARY_DEBUG} )
+ELSE(MariaDB_FOUND)
+	SET( MariaDB_LIBRARIES )
+ENDIF(MariaDB_FOUND)
+
+MARK_AS_ADVANCED(
+	MariaDB_LIBRARY_DEBUG
+	MariaDB_LIBRARY_RELEASE
+	MariaDB_INCLUDE_DIR
+	)
@@ -0,0 +1,93 @@
+# - Try to find mbedTLS
+# Once done this will define
+#
+# Read-Only variables
+#  MBEDTLS_FOUND - system has mbedTLS
+#  MBEDTLS_INCLUDE_DIR - the mbedTLS include directory
+#  MBEDTLS_LIBRARY_DIR - the mbedTLS library directory
+#  MBEDTLS_LIBRARIES - Link these to use mbedTLS
+#  MBEDTLS_LIBRARY - path to mbedTLS library
+#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
+#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
+#
+# Hint
+#  MBEDTLS_ROOT_DIR can be pointed to a local mbedTLS installation.
+
+SET(_MBEDTLS_ROOT_HINTS
+    ${MBEDTLS_ROOT_DIR}
+    ENV MBEDTLS_ROOT_DIR
+)
+
+SET(_MBEDTLS_ROOT_HINTS_AND_PATHS
+    HINTS ${_MBEDTLS_ROOT_HINTS}
+    PATHS ${_MBEDTLS_ROOT_PATHS}
+)
+
+FIND_PATH(MBEDTLS_INCLUDE_DIR
+    NAMES mbedtls/version.h
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES include
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
+    # Already in cache, be silent
+    SET(MBEDTLS_FIND_QUIETLY TRUE)
+ENDIF()
+
+FIND_LIBRARY(MBEDTLS_LIBRARY
+    NAMES mbedtls libmbedtls
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDX509_LIBRARY
+    NAMES mbedx509 libmbedx509
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDCRYPTO_LIBRARY
+    NAMES mbedcrypto libmbedcrypto
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
+     SET(MBEDTLS_FOUND TRUE)
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+    # split mbedTLS into -L and -l linker options, so we can set them for pkg-config
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_DIR ${MBEDTLS_LIBRARY} PATH)
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY} NAME_WE)
+    STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
+    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
+
+    IF(NOT MBEDTLS_FIND_QUIETLY)
+        MESSAGE(STATUS "Found mbedTLS:")
+        FILE(READ ${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h MBEDTLSCONTENT)
+        STRING(REGEX MATCH "MBEDTLS_VERSION_STRING +\"[0-9|.]+\"" MBEDTLSMATCH ${MBEDTLSCONTENT})
+        IF (MBEDTLSMATCH)
+            STRING(REGEX REPLACE "MBEDTLS_VERSION_STRING +\"([0-9|.]+)\"" "\\1" MBEDTLS_VERSION ${MBEDTLSMATCH})
+            MESSAGE(STATUS "  version ${MBEDTLS_VERSION}")
+        ENDIF(MBEDTLSMATCH)
+        MESSAGE(STATUS "  TLS: ${MBEDTLS_LIBRARY}")
+        MESSAGE(STATUS "  X509: ${MBEDX509_LIBRARY}")
+        MESSAGE(STATUS "  Crypto: ${MBEDCRYPTO_LIBRARY}")
+    ENDIF(NOT MBEDTLS_FIND_QUIETLY)
+ELSE(MBEDTLS_FOUND)
+    IF(MBEDTLS_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find mbedTLS")
+    ENDIF(MBEDTLS_FIND_REQUIRED)
+ENDIF(MBEDTLS_FOUND)
+
+MARK_AS_ADVANCED(
+    MBEDTLS_INCLUDE_DIR
+    MBEDTLS_LIBRARY_DIR
+    MBEDTLS_LIBRARIES
+    MBEDTLS_LIBRARY
+    MBEDX509_LIBRARY
+    MBEDCRYPTO_LIBRARY
+)
@@ -1,8 +1,9 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.2)

 SET(common_sources
 	base_packet.cpp
 	classes.cpp
+	cli/eqemu_command_handler.cpp
 	compression.cpp
 	condition.cpp
 	crash.cpp
@@ -35,6 +36,7 @@ SET(common_sources
 	inventory_profile.cpp
 	inventory_slot.cpp
 	ipc_mutex.cpp
+	ip_util.cpp
 	item_data.cpp
 	item_instance.cpp
 	json_config.cpp
@@ -71,8 +73,6 @@ SET(common_sources
 	textures.cpp
 	timer.cpp
 	unix.cpp
-	xml_parser.cpp
-	platform.cpp
 	json/jsoncpp.cpp
 	net/console_server.cpp
 	net/console_server_connection.cpp
@@ -86,6 +86,8 @@ SET(common_sources
 	net/servertalk_server_connection.cpp
 	net/tcp_connection.cpp
 	net/tcp_server.cpp
+	net/websocket_server.cpp
+	net/websocket_server_connection.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sod_limits.cpp
@@ -100,13 +102,8 @@ 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
-)
+	util/uuid.cpp)

 SET(common_headers
 	any.h
@@ -119,8 +116,12 @@ SET(common_headers
 	crash.h
 	crc16.h
 	crc32.h
+	cli/argh.h
+	cli/eqemu_command_handler.h
+	cli/terminal_color.hpp
 	data_verification.h
 	database.h
+	database_schema.h
 	dbcore.h
 	deity.h
 	emu_constants.h
@@ -136,7 +137,7 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
-	eqemu_logsys_fmt.h
+	eqemu_logsys_log_aliases.h
 	eq_limits.h
 	eq_packet.h
 	eq_stream_ident.h
@@ -154,9 +155,11 @@ SET(common_headers
 	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
@@ -180,7 +183,6 @@ SET(common_headers
 	packet_dump.h
 	packet_dump_file.h
 	packet_functions.h
-	platform.h
 	proc_launcher.h
 	profanity_manager.h
 	profiler.h
@@ -207,7 +209,6 @@ SET(common_headers
 	unix.h
 	useperl.h
 	version.h
-	xml_parser.h
 	zone_numbers.h
 	event/event_loop.h
 	event/task.h
@@ -230,6 +231,8 @@ SET(common_headers
 	net/servertalk_server_connection.h
 	net/tcp_connection.h
 	net/tcp_server.h
+	net/websocket_server.h
+	net/websocket_server_connection.h
 	patches/patches.h
 	patches/sod.h
 	patches/sod_limits.h
@@ -259,12 +262,9 @@ 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
@@ -309,6 +309,10 @@ SOURCE_GROUP(Net FILES
 	net/tcp_connection.h
 	net/tcp_server.cpp
 	net/tcp_server.h
+	net/websocket_server.cpp
+	net/websocket_server.h
+	net/websocket_server_connection.cpp
+	net/websocket_server_connection.h
 )

 SOURCE_GROUP(Patches FILES
@@ -360,15 +364,6 @@ 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
@@ -377,7 +372,7 @@ SOURCE_GROUP(Util FILES
 	util/uuid.h
 )

-INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
+INCLUDE_DIRECTORIES(Patches SocketLib StackWalker)

 ADD_LIBRARY(common ${common_sources} ${common_headers})

@@ -75,6 +75,7 @@ public:
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }
+	void ReadString(std::string &str) { str = reinterpret_cast<char *>(pBuffer + _rpos); _rpos += str.length() + 1; }
 	void ReadString(char *str, uint32 Offset, uint32 MaxLength) const;

 	uint32 GetWritePosition() { return _wpos; }
@@ -573,6 +573,20 @@ bool IsNonSpellFighterClass(uint8 class_id)
 	}
 }

+bool IsHybridClass(uint8 class_id)
+{
+	switch (class_id) {
+	case PALADIN:
+	case RANGER:
+	case SHADOWKNIGHT:
+	case BARD:
+	case BEASTLORD:
+		return true;
+	default:
+		return false;
+	}
+}
+
 bool IsCasterClass(uint8 class_id)
 {
 	switch (class_id) {
@@ -135,6 +135,7 @@ uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit);
 bool IsFighterClass(uint8 class_id);
 bool IsSpellFighterClass(uint8 class_id);
 bool IsNonSpellFighterClass(uint8 class_id);
+bool IsHybridClass(uint8 class_id);
 bool IsCasterClass(uint8 class_id);
 bool IsINTCasterClass(uint8 class_id);
 bool IsWISCasterClass(uint8 class_id);
@@ -0,0 +1,434 @@
+#pragma once
+
+#include <algorithm>
+#include <sstream>
+#include <limits>
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+#include <cassert>
+
+namespace argh
+{
+	// Terminology:
+	// A command line is composed of 2 types of args:
+	// 1. Positional args, i.e. free standing values
+	// 2. Options: args beginning with '-'. We identify two kinds:
+	//    2.1: Flags: boolean options =>  (exist ? true : false)
+	//    2.2: Parameters: a name followed by a non-option value
+
+#if !defined(__GNUC__) || (__GNUC__ >= 5)
+	using string_stream = std::istringstream;
+#else
+	// Until GCC 5, istringstream did not have a move constructor.
+	// stringstream_proxy is used instead, as a workaround.
+	class stringstream_proxy
+	{
+	public:
+		stringstream_proxy() = default;
+
+		// Construct with a value.
+		stringstream_proxy(std::string const& value) :
+			stream_(value)
+		{}
+
+		// Copy constructor.
+		stringstream_proxy(const stringstream_proxy& other) :
+			stream_(other.stream_.str())
+		{
+			stream_.setstate(other.stream_.rdstate());
+		}
+
+		void setstate(std::ios_base::iostate state) { stream_.setstate(state); }
+
+		// Stream out the value of the parameter.
+		// If the conversion was not possible, the stream will enter the fail state,
+		// and operator bool will return false.
+		template<typename T>
+		stringstream_proxy& operator >> (T& thing)
+		{
+			stream_ >> thing;
+			return *this;
+		}
+
+
+		// Get the string value.
+		std::string str() const { return stream_.str(); }
+
+		std::stringbuf* rdbuf() const { return stream_.rdbuf(); }
+
+		// Check the state of the stream.
+		// False when the most recent stream operation failed
+		operator bool() const { return !!stream_; }
+
+		~stringstream_proxy() = default;
+	private:
+		std::istringstream stream_;
+	};
+	using string_stream = stringstream_proxy;
+#endif
+
+	class parser
+	{
+	public:
+		enum Mode { PREFER_FLAG_FOR_UNREG_OPTION = 1 << 0,
+					PREFER_PARAM_FOR_UNREG_OPTION = 1 << 1,
+					NO_SPLIT_ON_EQUALSIGN = 1 << 2,
+					SINGLE_DASH_IS_MULTIFLAG = 1 << 3,
+		};
+
+		parser() = default;
+
+		parser(std::initializer_list<char const* const> pre_reg_names)
+		{  add_params(pre_reg_names); }
+
+		parser(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
+		{  parse(argv, mode); }
+
+		parser(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
+		{  parse(argc, argv, mode); }
+
+		void add_param(std::string const& name);
+		void add_params(std::initializer_list<char const* const> init_list);
+
+		void parse(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
+		void parse(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
+
+		std::multiset<std::string>          const& flags()    const { return flags_;    }
+		std::map<std::string, std::string>  const& params()   const { return params_;   }
+		std::vector<std::string>            const& pos_args() const { return pos_args_; }
+
+		// begin() and end() for using range-for over positional args.
+		std::vector<std::string>::const_iterator begin() const { return pos_args_.cbegin(); }
+		std::vector<std::string>::const_iterator end()   const { return pos_args_.cend();   }
+		size_t size()                                    const { return pos_args_.size();   }
+
+		//////////////////////////////////////////////////////////////////////////
+		// Accessors
+
+		// flag (boolean) accessors: return true if the flag appeared, otherwise false.
+		bool operator[](std::string const& name) const;
+
+		// multiple flag (boolean) accessors: return true if at least one of the flag appeared, otherwise false.
+		bool operator[](std::initializer_list<char const* const> init_list) const;
+
+		// returns positional arg string by order. Like argv[] but without the options
+		std::string const& operator[](size_t ind) const;
+
+		// returns a std::istream that can be used to convert a positional arg to a typed value.
+		string_stream operator()(size_t ind) const;
+
+		// same as above, but with a default value in case the arg is missing (index out of range).
+		template<typename T>
+		string_stream operator()(size_t ind, T&& def_val) const;
+
+		// parameter accessors, give a name get an std::istream that can be used to convert to a typed value.
+		// call .str() on result to get as string
+		string_stream operator()(std::string const& name) const;
+
+		// accessor for a parameter with multiple names, give a list of names, get an std::istream that can be used to convert to a typed value.
+		// call .str() on result to get as string
+		// returns the first value in the list to be found.
+		string_stream operator()(std::initializer_list<char const* const> init_list) const;
+
+		// same as above, but with a default value in case the param was missing.
+		// Non-string def_val types must have an operator<<() (output stream operator)
+		// If T only has an input stream operator, pass the string version of the type as in "3" instead of 3.
+		template<typename T>
+		string_stream operator()(std::string const& name, T&& def_val) const;
+
+		// same as above but for a list of names. returns the first value to be found.
+		template<typename T>
+		string_stream operator()(std::initializer_list<char const* const> init_list, T&& def_val) const;
+
+	private:
+		string_stream bad_stream() const;
+		std::string trim_leading_dashes(std::string const& name) const;
+		bool is_number(std::string const& arg) const;
+		bool is_option(std::string const& arg) const;
+		bool got_flag(std::string const& name) const;
+		bool is_param(std::string const& name) const;
+
+	private:
+		std::vector<std::string> args_;
+		std::map<std::string, std::string> params_;
+		std::vector<std::string> pos_args_;
+		std::multiset<std::string> flags_;
+		std::set<std::string> registeredParams_;
+		std::string empty_;
+	};
+
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::parse(const char * const argv[], int mode)
+	{
+		int argc = 0;
+		for (auto argvp = argv; *argvp; ++argc, ++argvp);
+		parse(argc, argv, mode);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::parse(int argc, const char* const argv[], int mode /*= PREFER_FLAG_FOR_UNREG_OPTION*/)
+	{
+		// convert to strings
+		args_.resize(argc);
+		std::transform(argv, argv + argc, args_.begin(), [](const char* const arg) { return arg;  });
+
+		// parse line
+		for (auto i = 0u; i < args_.size(); ++i)
+		{
+			if (!is_option(args_[i]))
+			{
+				pos_args_.emplace_back(args_[i]);
+				continue;
+			}
+
+			auto name = trim_leading_dashes(args_[i]);
+
+			if (!(mode & NO_SPLIT_ON_EQUALSIGN))
+			{
+				auto equalPos = name.find('=');
+				if (equalPos != std::string::npos)
+				{
+					params_.insert({ name.substr(0, equalPos), name.substr(equalPos + 1) });
+					continue;
+				}
+			}
+
+			// if the option is unregistered and should be a multi-flag
+			if (1 == (args_[i].size() - name.size()) &&         // single dash
+				argh::parser::SINGLE_DASH_IS_MULTIFLAG & mode && // multi-flag mode
+				!is_param(name))                                  // unregistered
+			{
+				std::string keep_param;
+
+				if (!name.empty() && is_param(std::string(1ul, name.back()))) // last char is param
+				{
+					keep_param += name.back();
+					name.resize(name.size() - 1);
+				}
+
+				for (auto const& c : name)
+				{
+					flags_.emplace(std::string{ c });
+				}
+
+				if (!keep_param.empty())
+				{
+					name = keep_param;
+				}
+				else
+				{
+					continue; // do not consider other options for this arg
+				}
+			}
+
+			// any potential option will get as its value the next arg, unless that arg is an option too
+			// in that case it will be determined a flag.
+			if (i == args_.size() - 1 || is_option(args_[i + 1]))
+			{
+				flags_.emplace(name);
+				continue;
+			}
+
+			// if 'name' is a pre-registered option, then the next arg cannot be a free parameter to it is skipped
+			// otherwise we have 2 modes:
+			// PREFER_FLAG_FOR_UNREG_OPTION: a non-registered 'name' is determined a flag.
+			//                               The following value (the next arg) will be a free parameter.
+			//
+			// PREFER_PARAM_FOR_UNREG_OPTION: a non-registered 'name' is determined a parameter, the next arg
+			//                                will be the value of that option.
+
+			assert(!(mode & argh::parser::PREFER_FLAG_FOR_UNREG_OPTION)
+				   || !(mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION));
+
+			bool preferParam = mode & argh::parser::PREFER_PARAM_FOR_UNREG_OPTION;
+
+			if (is_param(name) || preferParam)
+			{
+				params_.insert({ name, args_[i + 1] });
+				++i; // skip next value, it is not a free parameter
+				continue;
+			}
+			else
+			{
+				flags_.emplace(name);
+			}
+		};
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::bad_stream() const
+	{
+		string_stream bad;
+		bad.setstate(std::ios_base::failbit);
+		return bad;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::is_number(std::string const& arg) const
+	{
+		// inefficient but simple way to determine if a string is a number (which can start with a '-')
+		std::istringstream istr(arg);
+		double number;
+		istr >> number;
+		return !(istr.fail() || istr.bad());
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::is_option(std::string const& arg) const
+	{
+		assert(0 != arg.size());
+		if (is_number(arg))
+			return false;
+		return '-' == arg[0];
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline std::string parser::trim_leading_dashes(std::string const& name) const
+	{
+		auto pos = name.find_first_not_of('-');
+		return std::string::npos != pos ? name.substr(pos) : name;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool argh::parser::got_flag(std::string const& name) const
+	{
+		return flags_.end() != flags_.find(trim_leading_dashes(name));
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool argh::parser::is_param(std::string const& name) const
+	{
+		return registeredParams_.count(name);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::operator[](std::string const& name) const
+	{
+		return got_flag(name);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline bool parser::operator[](std::initializer_list<char const* const> init_list) const
+	{
+		return std::any_of(init_list.begin(), init_list.end(), [&](char const* const name) { return got_flag(name); });
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline std::string const& parser::operator[](size_t ind) const
+	{
+		if (ind < pos_args_.size())
+			return pos_args_[ind];
+		return empty_;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(std::string const& name) const
+	{
+		auto optIt = params_.find(trim_leading_dashes(name));
+		if (params_.end() != optIt)
+			return string_stream(optIt->second);
+		return bad_stream();
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(std::initializer_list<char const* const> init_list) const
+	{
+		for (auto& name : init_list)
+		{
+			auto optIt = params_.find(trim_leading_dashes(name));
+			if (params_.end() != optIt)
+				return string_stream(optIt->second);
+		}
+		return bad_stream();
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	template<typename T>
+	string_stream parser::operator()(std::string const& name, T&& def_val) const
+	{
+		auto optIt = params_.find(trim_leading_dashes(name));
+		if (params_.end() != optIt)
+			return string_stream(optIt->second);
+
+		std::ostringstream ostr;
+		ostr.precision(std::numeric_limits<long double>::max_digits10);
+		ostr << def_val;
+		return string_stream(ostr.str()); // use default
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	// same as above but for a list of names. returns the first value to be found.
+	template<typename T>
+	string_stream parser::operator()(std::initializer_list<char const* const> init_list, T&& def_val) const
+	{
+		for (auto& name : init_list)
+		{
+			auto optIt = params_.find(trim_leading_dashes(name));
+			if (params_.end() != optIt)
+				return string_stream(optIt->second);
+		}
+		std::ostringstream ostr;
+		ostr.precision(std::numeric_limits<long double>::max_digits10);
+		ostr << def_val;
+		return string_stream(ostr.str()); // use default
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline string_stream parser::operator()(size_t ind) const
+	{
+		if (pos_args_.size() <= ind)
+			return bad_stream();
+
+		return string_stream(pos_args_[ind]);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	template<typename T>
+	string_stream parser::operator()(size_t ind, T&& def_val) const
+	{
+		if (pos_args_.size() <= ind)
+		{
+			std::ostringstream ostr;
+			ostr.precision(std::numeric_limits<long double>::max_digits10);
+			ostr << def_val;
+			return string_stream(ostr.str());
+		}
+
+		return string_stream(pos_args_[ind]);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::add_param(std::string const& name)
+	{
+		registeredParams_.insert(trim_leading_dashes(name));
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+
+	inline void parser::add_params(std::initializer_list<char const* const> init_list)
+	{
+		for (auto& name : init_list)
+			registeredParams_.insert(trim_leading_dashes(name));
+	}
+}
@@ -0,0 +1,194 @@
+/**
+ * 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"
+
+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) {
+			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" : "") <<
+						   termcolor::reset << termcolor::cyan << options_string << termcolor::reset;
+
+			std::cout << command_string.str() << std::endl;
+
+			exit(1);
+		}
+	}
+
+	/**
+	 * @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,
+		const std::string& platform,
+		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 [" + platform + "] 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_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(1);
+		}
+
+		if (ran_command) {
+			std::exit(1);
+		}
+	}
+
+}
@@ -0,0 +1,76 @@
+/**
+ * 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,
+		const std::string &platform,
+		int argc,
+		char **argv
+	);
+};
+
+
+#endif //EQEMU_EQEMU_COMMAND_HANDLER_H
@@ -0,0 +1,557 @@
+//!
+//! termcolor
+//! ~~~~~~~~~
+//!
+//! termcolor is a header-only c++ library for printing colored messages
+//! to the terminal. Written just for fun with a help of the Force.
+//!
+//! :copyright: (c) 2013 by Ihor Kalnytskyi
+//! :license: BSD, see LICENSE for details
+//!
+
+#ifndef TERMCOLOR_HPP_
+#define TERMCOLOR_HPP_
+
+// the following snippet of code detects the current OS and
+// defines the appropriate macro that is used to wrap some
+// platform specific things
+#if defined(_WIN32) || defined(_WIN64)
+#   define TERMCOLOR_OS_WINDOWS
+#elif defined(__APPLE__)
+#   define TERMCOLOR_OS_MACOS
+#elif defined(__unix__) || defined(__unix)
+#   define TERMCOLOR_OS_LINUX
+#else
+#   error unsupported platform
+#endif
+
+
+// This headers provides the `isatty()`/`fileno()` functions,
+// which are used for testing whether a standart stream refers
+// to the terminal. As for Windows, we also need WinApi funcs
+// for changing colors attributes of the terminal.
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+#   include <unistd.h>
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#   include <io.h>
+#   include <windows.h>
+#endif
+
+
+#include <iostream>
+#include <cstdio>
+
+
+
+namespace termcolor
+{
+	// Forward declaration of the `_internal` namespace.
+	// All comments are below.
+	namespace _internal
+	{
+		// An index to be used to access a private storage of I/O streams. See
+		// colorize / nocolorize I/O manipulators for details.
+		static int colorize_index = std::ios_base::xalloc();
+
+		inline FILE* get_standard_stream(const std::ostream& stream);
+		inline bool is_colorized(std::ostream& stream);
+		inline bool is_atty(const std::ostream& stream);
+
+#if defined(TERMCOLOR_OS_WINDOWS)
+		inline void win_change_attributes(std::ostream& stream, int foreground, int background=-1);
+#endif
+	}
+
+	inline
+	std::ostream& colorize(std::ostream& stream)
+	{
+		stream.iword(_internal::colorize_index) = 1L;
+		return stream;
+	}
+
+	inline
+	std::ostream& nocolorize(std::ostream& stream)
+	{
+		stream.iword(_internal::colorize_index) = 0L;
+		return stream;
+	}
+
+	inline
+	std::ostream& reset(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;00m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1, -1);
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& bold(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;1m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& dark(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;2m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& underline(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;4m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& blink(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;5m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& reverse(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;7m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& concealed(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;8m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+#endif
+		}
+		return stream;
+	}
+
+
+	inline
+	std::ostream& grey(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;30m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                0   // grey (black)
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& red(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;31m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& green(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;32m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& yellow(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;33m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_GREEN | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& blue(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;34m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& magenta(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;35m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& cyan(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;36m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& white(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;37m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream,
+                FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+
+
+	inline
+	std::ostream& on_grey(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;40m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                0   // grey (black)
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_red(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;41m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_green(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;42m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_yellow(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;43m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_blue(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;44m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_magenta(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;45m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_BLUE | BACKGROUND_RED
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_cyan(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;46m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE
+            );
+#endif
+		}
+		return stream;
+	}
+
+	inline
+	std::ostream& on_white(std::ostream& stream)
+	{
+		if (_internal::is_colorized(stream))
+		{
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			stream << "\e[1;47m";
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			_internal::win_change_attributes(stream, -1,
+                BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED
+            );
+#endif
+		}
+
+		return stream;
+	}
+
+
+
+	//! Since C++ hasn't a way to hide something in the header from
+	//! the outer access, I have to introduce this namespace which
+	//! is used for internal purpose and should't be access from
+	//! the user code.
+	namespace _internal
+	{
+		//! Since C++ hasn't a true way to extract stream handler
+		//! from the a given `std::ostream` object, I have to write
+		//! this kind of hack.
+		inline
+		FILE* get_standard_stream(const std::ostream& stream)
+		{
+			if (&stream == &std::cout)
+				return stdout;
+			else if ((&stream == &std::cerr) || (&stream == &std::clog))
+				return stderr;
+
+			return 0;
+		}
+
+		// Say whether a given stream should be colorized or not. It's always
+		// true for ATTY streams and may be true for streams marked with
+		// colorize flag.
+		inline
+		bool is_colorized(std::ostream& stream)
+		{
+			return is_atty(stream) || static_cast<bool>(stream.iword(colorize_index));
+		}
+
+		//! Test whether a given `std::ostream` object refers to
+		//! a terminal.
+		inline
+		bool is_atty(const std::ostream& stream)
+		{
+			FILE* std_stream = get_standard_stream(stream);
+
+			// Unfortunately, fileno() ends with segmentation fault
+			// if invalid file descriptor is passed. So we need to
+			// handle this case gracefully and assume it's not a tty
+			// if standard stream is not detected, and 0 is returned.
+			if (!std_stream)
+				return false;
+
+#if defined(TERMCOLOR_OS_MACOS) || defined(TERMCOLOR_OS_LINUX)
+			return ::isatty(fileno(std_stream));
+#elif defined(TERMCOLOR_OS_WINDOWS)
+			return ::_isatty(_fileno(std_stream));
+#endif
+		}
+
+#if defined(TERMCOLOR_OS_WINDOWS)
+		//! Change Windows Terminal colors attribute. If some
+        //! parameter is `-1` then attribute won't changed.
+        inline void win_change_attributes(std::ostream& stream, int foreground, int background)
+        {
+            // yeah, i know.. it's ugly, it's windows.
+            static WORD defaultAttributes = 0;
+
+            // Windows doesn't have ANSI escape sequences and so we use special
+            // API to change Terminal output color. That means we can't
+            // manipulate colors by means of "std::stringstream" and hence
+            // should do nothing in this case.
+            if (!_internal::is_atty(stream))
+                return;
+
+            // get terminal handle
+            HANDLE hTerminal = INVALID_HANDLE_VALUE;
+            if (&stream == &std::cout)
+                hTerminal = GetStdHandle(STD_OUTPUT_HANDLE);
+            else if (&stream == &std::cerr)
+                hTerminal = GetStdHandle(STD_ERROR_HANDLE);
+
+            // save default terminal attributes if it unsaved
+            if (!defaultAttributes)
+            {
+                CONSOLE_SCREEN_BUFFER_INFO info;
+                if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                    return;
+                defaultAttributes = info.wAttributes;
+            }
+
+            // restore all default settings
+            if (foreground == -1 && background == -1)
+            {
+                SetConsoleTextAttribute(hTerminal, defaultAttributes);
+                return;
+            }
+
+            // get current settings
+            CONSOLE_SCREEN_BUFFER_INFO info;
+            if (!GetConsoleScreenBufferInfo(hTerminal, &info))
+                return;
+
+            if (foreground != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0x0F);
+                info.wAttributes |= static_cast<WORD>(foreground);
+            }
+
+            if (background != -1)
+            {
+                info.wAttributes &= ~(info.wAttributes & 0xF0);
+                info.wAttributes |= static_cast<WORD>(background);
+            }
+
+            SetConsoleTextAttribute(hTerminal, info.wAttributes);
+        }
+#endif // TERMCOLOR_OS_WINDOWS
+
+	} // namespace _internal
+
+} // namespace termcolor
+
+
+#undef TERMCOLOR_OS_WINDOWS
+#undef TERMCOLOR_OS_MACOS
+#undef TERMCOLOR_OS_LINUX
+
+#endif // TERMCOLOR_HPP_
@@ -111,7 +111,60 @@ 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>
+
+void print_trace()
+{
+	auto uid = geteuid();
+
+	std::string temp_output_file = "/tmp/dump-output";
+
+	char pid_buf[30];
+	sprintf(pid_buf, "%d", getpid());
+	char name_buf[512];
+	name_buf[readlink("/proc/self/exe", name_buf, 511)] = 0;
+	int child_pid = fork();
+	if (!child_pid) {
+		int fd = open(temp_output_file.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+
+		dup2(fd, 1); // redirect output to stderr
+		fprintf(stdout, "stack trace for %s pid=%s\n", name_buf, pid_buf);
+		if (uid == 0) {
+			execlp("gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt", name_buf, pid_buf, NULL);
+		}
+		else {
+			execlp("sudo", "gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt", name_buf, pid_buf, NULL);
+		}
+
+		close(fd);
+
+		abort(); /* If gdb failed to start */
+	}
+	else {
+		waitpid(child_pid, NULL, 0);
+	}
+
+	std::ifstream    input(temp_output_file);
+	for (std::string line; getline(input, line);) {
+		LogCrash("{}", line);
+	}
+
+	std::remove(temp_output_file.c_str());
+
+	exit(1);
+}
+
 // crash is off or an unhandled platform
-void set_exception_handler() {
+void set_exception_handler()
+{
+	signal(SIGABRT, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGFPE, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGFPE, reinterpret_cast<void (*)(int)>(print_trace));
+	signal(SIGSEGV, reinterpret_cast<void (*)(int)>(print_trace));
 }
 #endif
@@ -1,53 +1,57 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */

 #pragma once

 #include <algorithm>
 #include <cmath>

-namespace EQEmu
-{
-	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*/

@@ -64,11 +64,11 @@ bool Database::Connect(const char* host, const char* user, const char* passwd, c
 	uint32 errnum= 0;
 	char errbuf[MYSQL_ERRMSG_SIZE];
 	if (!Open(host, user, passwd, database, port, &errnum, errbuf)) {
-		Log(Logs::General, Logs::Error, "Failed to connect to database: Error: %s", errbuf); 
-		return false; 
+		LogError("Failed to connect to database: Error: {}", errbuf);
+		return false;
 	}
 	else {
-		Log(Logs::General, Logs::Status, "Using database '%s' at %s:%d", database, host,port);
+		LogInfo("Using database [{}] at [{}]:[{}]", database, host,port);
 		return true;
 	}
 }
@@ -86,7 +86,7 @@ Database::~Database()
 	Return the account id or zero if no account matches.
 	Zero will also be returned if there is a database error.
 */
-uint32 Database::CheckLogin(const char* name, const char* password, int16* oStatus) {
+uint32 Database::CheckLogin(const char* name, const char* password, const char *loginserver, int16* oStatus) {

 	if(strlen(name) >= 50 || strlen(password) >= 50)
 		return(0);
@@ -97,9 +97,10 @@ uint32 Database::CheckLogin(const char* name, const char* password, int16* oStat
 	DoEscapeString(tmpUN, name, strlen(name));
 	DoEscapeString(tmpPW, password, strlen(password));

-	std::string query = StringFormat("SELECT id, status FROM account WHERE name='%s' AND password is not null "
+	std::string query = StringFormat("SELECT id, status FROM account WHERE `name`='%s' AND ls_id='%s' AND password is not null "
 		"and length(password) > 0 and (password='%s' or password=MD5('%s'))",
-		tmpUN, tmpPW, tmpPW);
+		tmpUN, EscapeString(loginserver).c_str(), tmpPW, tmpPW);
+
 	auto results = QueryDatabase(query);

 	if (!results.Success())
@@ -123,7 +124,7 @@ uint32 Database::CheckLogin(const char* name, const char* password, int16* oStat
 //Get Banned IP Address List - Only return false if the incoming connection's IP address is not present in the banned_ips table.
 bool Database::CheckBannedIPs(const char* loginIP)
 {
-	std::string query = StringFormat("SELECT ip_address FROM Banned_IPs WHERE ip_address='%s'", loginIP);
+	std::string query = StringFormat("SELECT ip_address FROM banned_ips WHERE ip_address='%s'", loginIP);

 	auto results = QueryDatabase(query);

@@ -139,16 +140,16 @@ bool Database::CheckBannedIPs(const char* loginIP)
 }

 bool Database::AddBannedIP(char* bannedIP, const char* notes) {
-	std::string query = StringFormat("INSERT into Banned_IPs SET ip_address='%s', notes='%s'", bannedIP, notes); 
-	auto results = QueryDatabase(query); 
+	std::string query = StringFormat("INSERT into banned_ips SET ip_address='%s', notes='%s'", bannedIP, notes);
+	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
-	} 
+	}
 	return true;
 }

 bool Database::CheckGMIPs(const char* ip_address, uint32 account_id) {
-	std::string query = StringFormat("SELECT * FROM `gm_ips` WHERE `ip_address` = '%s' AND `account_id` = %i", ip_address, account_id); 
+	std::string query = StringFormat("SELECT * FROM `gm_ips` WHERE `ip_address` = '%s' AND `account_id` = %i", ip_address, account_id);
 	auto results = QueryDatabase(query);

 	if (!results.Success())
@@ -161,73 +162,99 @@ bool Database::AddBannedIP(char* bannedIP, const char* notes) {
 }

 bool Database::AddGMIP(char* ip_address, char* name) {
-	std::string query = StringFormat("INSERT into `gm_ips` SET `ip_address` = '%s', `name` = '%s'", ip_address, name); 
-	auto results = QueryDatabase(query); 
+	std::string query = StringFormat("INSERT into `gm_ips` SET `ip_address` = '%s', `name` = '%s'", ip_address, name);
+	auto results = QueryDatabase(query);
 	return results.Success();
 }

 void Database::LoginIP(uint32 AccountID, const char* LoginIP) {
-	std::string query = StringFormat("INSERT INTO account_ip SET accid=%i, ip='%s' ON DUPLICATE KEY UPDATE count=count+1, lastused=now()", AccountID, LoginIP); 
-	QueryDatabase(query); 
+	std::string query = StringFormat("INSERT INTO account_ip SET accid=%i, ip='%s' ON DUPLICATE KEY UPDATE count=count+1, lastused=now()", AccountID, LoginIP);
+	QueryDatabase(query);
 }

-int16 Database::CheckStatus(uint32 account_id) {
-	std::string query = StringFormat("SELECT `status`, UNIX_TIMESTAMP(`suspendeduntil`) as `suspendeduntil`, UNIX_TIMESTAMP() as `current`"
-							" FROM `account` WHERE `id` = %i", account_id);
+int16 Database::CheckStatus(uint32 account_id)
+{
+	std::string query = StringFormat(
+	    "SELECT `status`, TIMESTAMPDIFF(SECOND, NOW(), `suspendeduntil`) FROM `account` WHERE `id` = %i",
+	    account_id);

-	auto results = QueryDatabase(query); 
-	if (!results.Success()) {
+	auto results = QueryDatabase(query);
+	if (!results.Success())
 		return 0;
-	}

 	if (results.RowCount() != 1)
 		return 0;
-	
-	auto row = results.begin(); 
-	int16 status = atoi(row[0]); 
-	int32 suspendeduntil = 0;

-	// MariaDB initalizes with NULL if unix_timestamp() is out of range
-	if (row[1] != nullptr) {
-		suspendeduntil = atoi(row[1]);
-	}
+	auto row = results.begin();
+	int16 status = atoi(row[0]);
+	int32 date_diff = 0;

-	int32 current = atoi(row[2]);
+	if (row[1] != nullptr)
+		date_diff = atoi(row[1]);

-	if(suspendeduntil > current)
+	if (date_diff > 0)
 		return -1;

 	return status;
 }

-uint32 Database::CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id) {
+/**
+ * @param name
+ * @param password
+ * @param status
+ * @param loginserver
+ * @param lsaccount_id
+ * @return
+ */
+uint32 Database::CreateAccount(
+	const char *name,
+	const char *password,
+	int16 status,
+	const char *loginserver,
+	uint32 lsaccount_id
+)
+{
 	std::string query;

-	if (password)
-		query = StringFormat("INSERT INTO account SET name='%s', password='%s', status=%i, lsaccount_id=%i, time_creation=UNIX_TIMESTAMP();",name,password,status, lsaccount_id);
-	else
-		query = StringFormat("INSERT INTO account SET name='%s', status=%i, lsaccount_id=%i, time_creation=UNIX_TIMESTAMP();",name, status, lsaccount_id);
+	if (password) {
+		query = StringFormat(
+			"INSERT INTO account SET name='%s', password='%s', status=%i, ls_id='%s', lsaccount_id=%i, time_creation=UNIX_TIMESTAMP();",
+			name,
+			password,
+			status,
+			loginserver,
+			lsaccount_id
+		);
+	}
+	else {
+		query = StringFormat(
+			"INSERT INTO account SET name='%s', status=%i, ls_id='%s', lsaccount_id=%i, time_creation=UNIX_TIMESTAMP();",
+			name,
+			status,
+			loginserver,
+			lsaccount_id
+		);
+	}

-	Log(Logs::General, Logs::World_Server, "Account Attempting to be created: '%s' status: %i", name, status);
+	LogInfo("Account Attempting to be created: [{0}:{1}] status: {2}", loginserver, name, status);
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
 		return 0;
 	}

-	if (results.LastInsertedID() == 0)
-	{
+	if (results.LastInsertedID() == 0) {
 		return 0;
 	}

 	return results.LastInsertedID();
 }

-bool Database::DeleteAccount(const char* name) {
-	std::string query = StringFormat("DELETE FROM account WHERE name='%s';",name); 
-	Log(Logs::General, Logs::World_Server, "Account Attempting to be deleted:'%s'", name);
+bool Database::DeleteAccount(const char* name, const char *loginserver) {
+	std::string query = StringFormat("DELETE FROM account WHERE `name`='%s' AND ls_id='%s'", name, loginserver);
+	LogInfo("Account Attempting to be deleted:'[{}]:[{}]'", loginserver, name);

-	auto results = QueryDatabase(query); 
+	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
 	}
@@ -260,7 +287,38 @@ bool Database::SetAccountStatus(const char* name, int16 status) {
 	if (results.RowsAffected() == 0)
 	{
 		std::cout << "Account: " << name << " does not exist, therefore it cannot be flagged\n";
-		return false; 
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * @param account_name
+ * @param status
+ * @return
+ */
+bool Database::SetAccountStatus(const std::string& account_name, int16 status)
+{
+	LogInfo("Account [{}] is attempting to be set to status [{}]", account_name, status);
+
+	std::string query = fmt::format(
+		SQL(
+			UPDATE account SET status = {} WHERE name = '{}'
+		),
+		status,
+		account_name
+	);
+
+	auto results = QueryDatabase(query);
+
+	if (!results.Success()) {
+		return false;
+	}
+
+	if (results.RowsAffected() == 0) {
+		LogWarning("Account [{}] does not exist!", account_name);
+		return false;
 	}

 	return true;
@@ -272,14 +330,14 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) {
 		if (row[0] && atoi(row[0]) > 0){
-			Log(Logs::General, Logs::World_Server, "Account: %i tried to request name: %s, but it is already taken...", account_id, name);
+			LogInfo("Account: [{}] tried to request name: [{}], but it is already taken", account_id, name);
 			return false;
 		}
 	}

-	query = StringFormat("INSERT INTO `character_data` SET `account_id` = %i, `name` = '%s'", account_id, name); 
+	query = StringFormat("INSERT INTO `character_data` SET `account_id` = %i, `name` = '%s'", account_id, name);
 	results = QueryDatabase(query);
-	if (!results.Success() || results.ErrorMessage() != ""){ return false; } 
+	if (!results.Success() || results.ErrorMessage() != ""){ return false; }
 	return true;
 }

@@ -290,18 +348,18 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 bool Database::DeleteCharacter(char *name) {
 	uint32 charid = 0;
 	if(!name ||	!strlen(name)) {
-		Log(Logs::General, Logs::World_Server, "DeleteCharacter: request to delete without a name (empty char slot)");
+		LogInfo("DeleteCharacter: request to delete without a name (empty char slot)");
 		return false;
 	}
-	Log(Logs::General, Logs::World_Server, "Database::DeleteCharacter name : '%s'", name);
+	LogInfo("Database::DeleteCharacter name : [{}]", name);

 	/* Get id from character_data before deleting record so we can clean up the rest of the tables */
 	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-	if (charid <= 0){ 
-		Log(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
-		return false; 
+	if (charid <= 0){
+		LogError("Database::DeleteCharacter :: Character ({}) not found, stopping delete...", name);
+		return false;
 	}

 	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
@@ -344,7 +402,7 @@ bool Database::DeleteCharacter(char *name) {
 	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
 #endif
 	QueryDatabase(query);
-	
+
 	return true;
 }

@@ -625,6 +683,7 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 		pp->RestTimer					  // " RestTimer)                 "
 	);
 	auto results = QueryDatabase(query);
+
 	/* Save Bind Points */
 	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
@@ -659,7 +718,7 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 			}
 		}
 	}
-	results = QueryDatabase(query); 
+	results = QueryDatabase(query);

 	/* Save Language */
 	firstquery = 0;
@@ -674,20 +733,20 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 			}
 		}
 	}
-	results = QueryDatabase(query); 
+	results = QueryDatabase(query);

 	return true;
 }

 /* This only for new Character creation storing */
 bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv) {
-	uint32 charid = 0; 
-	char zone[50]; 
-	float x, y, z; 
+	uint32 charid = 0;
+	char zone[50];
+	float x, y, z;
 	charid = GetCharacterID(pp->name);

 	if(!charid) {
-		Log(Logs::General, Logs::Error, "StoreCharacter: no character id");
+		LogError("StoreCharacter: no character id");
 		return false;
 	}

@@ -704,7 +763,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 	z = pp->z;

 	/* Saves Player Profile Data */
-	SaveCharacterCreate(charid, account_id, pp); 
+	SaveCharacterCreate(charid, account_id, pp);

 	/* Insert starting inventory... */
 	std::string invquery;
@@ -712,23 +771,23 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
-				charid, i, newinv->GetItem()->ID, newinv->GetCharges(), newinv->GetColor()); 
-			
-			auto results = QueryDatabase(invquery); 
+				charid, i, newinv->GetItem()->ID, newinv->GetCharges(), newinv->GetColor());
+
+			auto results = QueryDatabase(invquery);
 		}

 		if (i == EQEmu::invslot::slotCursor) {
-			i = EQEmu::invbag::GENERAL_BAGS_BEGIN; 
+			i = EQEmu::invbag::GENERAL_BAGS_BEGIN;
 			continue;
 		}
-		else if (i == EQEmu::invbag::CURSOR_BAG_END) { 
-			i = EQEmu::invslot::BANK_BEGIN; 
-			continue; 
+		else if (i == EQEmu::invbag::CURSOR_BAG_END) {
+			i = EQEmu::invslot::BANK_BEGIN;
+			continue;
+		}
+		else if (i == EQEmu::invslot::BANK_END) {
+			i = EQEmu::invbag::BANK_BAGS_BEGIN;
+			continue;
 		}
-		else if (i == EQEmu::invslot::BANK_END) { 
-			i = EQEmu::invbag::BANK_BAGS_BEGIN; 
-			continue; 
-		} 
 		i++;
 	}
 	return true;
@@ -742,7 +801,7 @@ uint32 Database::GetCharacterID(const char *name) {
 	{
 		return atoi(row[0]);
 	}
-	return 0; 
+	return 0;
 }

 /*
@@ -761,7 +820,7 @@ uint32 Database::GetAccountIDByChar(const char* charname, uint32* oCharID) {
 	}

 	if (results.RowCount() != 1)
-		return 0; 
+		return 0;

 	auto row = results.begin();

@@ -775,8 +834,8 @@ uint32 Database::GetAccountIDByChar(const char* charname, uint32* oCharID) {

 // Retrieve account_id for a given char_id
 uint32 Database::GetAccountIDByChar(uint32 char_id) {
-	std::string query = StringFormat("SELECT `account_id` FROM `character_data` WHERE `id` = %i LIMIT 1", char_id); 
-	auto results = QueryDatabase(query); 
+	std::string query = StringFormat("SELECT `account_id` FROM `character_data` WHERE `id` = %i LIMIT 1", char_id);
+	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return 0;
 	}
@@ -784,15 +843,16 @@ uint32 Database::GetAccountIDByChar(uint32 char_id) {
 	if (results.RowCount() != 1)
 		return 0;

-	auto row = results.begin(); 
+	auto row = results.begin();
 	return atoi(row[0]);
 }

-uint32 Database::GetAccountIDByName(const char* accname, int16* status, uint32* lsid) {
+uint32 Database::GetAccountIDByName(const char* accname, const char *loginserver, int16* status, uint32* lsid) {
 	if (!isAlphaNumeric(accname))
 		return 0;

-	std::string query = StringFormat("SELECT `id`, `status`, `lsaccount_id` FROM `account` WHERE `name` = '%s' LIMIT 1", accname);
+	std::string query = StringFormat("SELECT `id`, `status`, `lsaccount_id` FROM `account` WHERE `name` = '%s' AND `ls_id`='%s' LIMIT 1",
+		EscapeString(accname).c_str(), EscapeString(loginserver).c_str());
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
@@ -820,7 +880,7 @@ uint32 Database::GetAccountIDByName(const char* accname, int16* status, uint32*
 }

 void Database::GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID) {
-	std::string query = StringFormat("SELECT `name`, `lsaccount_id` FROM `account` WHERE `id` = '%i'", accountid); 
+	std::string query = StringFormat("SELECT `name`, `lsaccount_id` FROM `account` WHERE `id` = '%i'", accountid);
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
@@ -844,7 +904,7 @@ void Database::GetCharName(uint32 char_id, char* name) {
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
-		return; 
+		return;
 	}

 	auto row = results.begin();
@@ -921,21 +981,9 @@ bool Database::SetVariable(const std::string varname, const std::string &varvalu
 	return true;
 }

-uint32 Database::GetMiniLoginAccount(char* ip)
-{
-	std::string query = StringFormat("SELECT `id` FROM `account` WHERE `minilogin_ip` = '%s'", ip);
-	auto results = QueryDatabase(query);
-
-	if (!results.Success())
-		return 0;
-
-	auto row = results.begin(); 
-	return atoi(row[0]);
-}
-
 // Get zone starting points from DB
 bool Database::GetSafePoints(const char* short_name, uint32 version, float* safe_x, float* safe_y, float* safe_z, int16* minstatus, uint8* minlevel, char *flag_needed) {
-	
+
 	std::string query = StringFormat("SELECT safe_x, safe_y, safe_z, min_status, min_level, flag_needed FROM zone "
 		" WHERE short_name='%s' AND (version=%i OR version=0) ORDER BY version DESC", short_name, version);
 	auto results = QueryDatabase(query);
@@ -965,7 +1013,7 @@ bool Database::GetSafePoints(const char* short_name, uint32 version, float* safe
 }

 bool Database::GetZoneLongName(const char* short_name, char** long_name, char* file_name, float* safe_x, float* safe_y, float* safe_z, uint32* graveyard_id, uint32* maxclients) {
-	
+
 	std::string query = StringFormat("SELECT long_name, file_name, safe_x, safe_y, safe_z, graveyard_id, maxclients FROM zone WHERE short_name='%s' AND version=0", short_name);
 	auto results = QueryDatabase(query);

@@ -1018,7 +1066,7 @@ uint32 Database::GetZoneGraveyardID(uint32 zone_id, uint32 version) {
 }

 bool Database::GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid, float* graveyard_x, float* graveyard_y, float* graveyard_z, float* graveyard_heading) {
-	
+
 	std::string query = StringFormat("SELECT zone_id, x, y, z, heading FROM graveyard WHERE id=%i", graveyard_id);
 	auto results = QueryDatabase(query);

@@ -1090,7 +1138,7 @@ const char* Database::GetZoneName(uint32 zoneID, bool ErrorUnknown) {
 }

 uint8 Database::GetPEQZone(uint32 zoneID, uint32 version){
-	
+
 	std::string query = StringFormat("SELECT peqzone from zone where zoneidnumber='%i' AND (version=%i OR version=0) ORDER BY version DESC", zoneID, version);
 	auto results = QueryDatabase(query);

@@ -1154,7 +1202,7 @@ bool Database::CheckNameFilter(const char* name, bool surname)
 		}
 	}

-	
+
 	std::string query("SELECT name FROM name_filter");
 	auto results = QueryDatabase(query);

@@ -1179,7 +1227,7 @@ bool Database::CheckNameFilter(const char* name, bool surname)
 }

 bool Database::AddToNameFilter(const char* name) {
-	
+
 	std::string query = StringFormat("INSERT INTO name_filter (name) values ('%s')", name);
 	auto results = QueryDatabase(query);

@@ -1194,33 +1242,54 @@ bool Database::AddToNameFilter(const char* name) {
 	return true;
 }

-uint32 Database::GetAccountIDFromLSID(uint32 iLSID, char* oAccountName, int16* oStatus) {
+/**
+ * @param in_loginserver_id
+ * @param in_loginserver_account_id
+ * @param in_account_name
+ * @param in_status
+ * @return
+ */
+uint32 Database::GetAccountIDFromLSID(
+	const std::string &in_loginserver_id,
+	uint32 in_loginserver_account_id,
+	char *in_account_name,
+	int16 *in_status
+)
+{
 	uint32 account_id = 0;
-	std::string query = StringFormat("SELECT id, name, status FROM account WHERE lsaccount_id=%i", iLSID);
+	auto query = fmt::format(
+		"SELECT id, `name`, status FROM account WHERE lsaccount_id = {0} AND ls_id = '{1}'",
+		in_loginserver_account_id,
+		in_loginserver_id
+	);
+
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
 		return 0;
 	}

-	if (results.RowCount() != 1)
+	if (results.RowCount() != 1) {
 		return 0;
+	}

 	for (auto row = results.begin(); row != results.end(); ++row) {
-		account_id = atoi(row[0]);
+		account_id = std::stoi(row[0]);

-		if (oAccountName)
-			strcpy(oAccountName, row[1]);
-		if (oStatus)
-			*oStatus = atoi(row[2]);
+		if (in_account_name) {
+			strcpy(in_account_name, row[1]);
+		}
+		if (in_status) {
+			*in_status = std::stoi(row[2]);
+		}
 	}

 	return account_id;
 }

 void Database::GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus) {
-	
-	std::string query = StringFormat("SELECT name, status FROM account WHERE id=%i", id);
+
+	std::string query = StringFormat("SELECT `name`, status FROM account WHERE id=%i", id);
 	auto results = QueryDatabase(query);

 	if (!results.Success()){
@@ -1242,8 +1311,8 @@ void Database::ClearMerchantTemp(){
 	QueryDatabase("DELETE FROM merchantlist_temp");
 }

-bool Database::UpdateName(const char* oldname, const char* newname) { 
-	std::cout << "Renaming " << oldname << " to " << newname << "..." << std::endl; 
+bool Database::UpdateName(const char* oldname, const char* newname) {
+	std::cout << "Renaming " << oldname << " to " << newname << "..." << std::endl;
 	std::string query = StringFormat("UPDATE `character_data` SET `name` = '%s' WHERE `name` = '%s';", newname, oldname);
 	auto results = QueryDatabase(query);

@@ -1259,7 +1328,7 @@ bool Database::UpdateName(const char* oldname, const char* newname) {
 // If the name is used or an error occurs, it returns false, otherwise it returns true
 bool Database::CheckUsedName(const char* name) {
 	std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name` = '%s'", name);
-	auto results = QueryDatabase(query); 
+	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return false;
 	}
@@ -1272,7 +1341,7 @@ bool Database::CheckUsedName(const char* name) {

 uint8 Database::GetServerType() {
 	std::string query("SELECT `value` FROM `variables` WHERE `varname` = 'ServerType' LIMIT 1");
-	auto results = QueryDatabase(query); 
+	auto results = QueryDatabase(query);
 	if (!results.Success()) {
 		return 0;
 	}
@@ -1305,7 +1374,7 @@ bool Database::MoveCharacterToZone(const char* charname, const char* zonename) {
 	return MoveCharacterToZone(charname, zonename, GetZoneID(zonename));
 }

-bool Database::MoveCharacterToZone(uint32 iCharID, const char* iZonename) { 
+bool Database::MoveCharacterToZone(uint32 iCharID, const char* iZonename) {
 	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", GetZoneID(iZonename), iCharID);
 	auto results = QueryDatabase(query);

@@ -1316,7 +1385,7 @@ bool Database::MoveCharacterToZone(uint32 iCharID, const char* iZonename) {
 	return results.RowsAffected() != 0;
 }

-bool Database::SetHackerFlag(const char* accountname, const char* charactername, const char* hacked) { 
+bool Database::SetHackerFlag(const char* accountname, const char* charactername, const char* hacked) {
 	std::string query = StringFormat("INSERT INTO `hackers` (account, name, hacked) values('%s','%s','%s')", accountname, charactername, hacked);
 	auto results = QueryDatabase(query);

@@ -1327,7 +1396,7 @@ bool Database::SetHackerFlag(const char* accountname, const char* charactername,
 	return results.RowsAffected() != 0;
 }

-bool Database::SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone) { 
+bool Database::SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone) {
 	//Utilize the "hacker" table, but also give zone information.
 	std::string query = StringFormat("INSERT INTO hackers(account,name,hacked,zone) values('%s','%s','%s','%s')", accountname, charactername, hacked, zone);
 	auto results = QueryDatabase(query);
@@ -1343,7 +1412,7 @@ bool Database::SetMQDetectionFlag(const char* accountname, const char* character
 uint8 Database::GetRaceSkill(uint8 skillid, uint8 in_race)
 {
 	uint16 race_cap = 0;
-	
+
 	//Check for a racial cap!
 	std::string query = StringFormat("SELECT skillcap from race_skillcaps where skill = %i && race = %i", skillid, in_race);
 	auto results = QueryDatabase(query);
@@ -1362,7 +1431,7 @@ uint8 Database::GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16
 {
 	uint8 skill_level = 0, skill_formula = 0;
 	uint16 base_cap = 0, skill_cap = 0, skill_cap2 = 0, skill_cap3 = 0;
-	
+

 	//Fetch the data from DB.
 	std::string query = StringFormat("SELECT level, formula, pre50cap, post50cap, post60cap from skillcaps where skill = %i && class = %i", skillid, in_class);
@@ -1445,9 +1514,9 @@ uint32 Database::GetCharacterInfo(
 	return charid;
 }

-bool Database::UpdateLiveChar(char* charname,uint32 lsaccount_id) {
+bool Database::UpdateLiveChar(char* charname, uint32 account_id) {

-	std::string query = StringFormat("UPDATE account SET charname='%s' WHERE id=%i;",charname, lsaccount_id);
+	std::string query = StringFormat("UPDATE account SET charname='%s' WHERE id=%i;", charname, account_id);
 	auto results = QueryDatabase(query);

 	if (!results.Success()){
@@ -1476,24 +1545,24 @@ bool Database::GetLiveChar(uint32 account_id, char* cname) {
 	return true;
 }

-void Database::SetLFP(uint32 CharID, bool LFP) { 
+void Database::SetLFP(uint32 CharID, bool LFP) {
 	std::string query = StringFormat("UPDATE `character_data` SET `lfp` = %i WHERE `id` = %i",LFP, CharID);
-	QueryDatabase(query); 
+	QueryDatabase(query);
 }

-void Database::SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon) { 
+void Database::SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon) {
 	std::string query = StringFormat("update `character_data` SET `lfp` = %i, `lfg` = %i, `firstlogon` = %i WHERE `id` = %i",LFP, LFG, firstlogon, CharID);
-	QueryDatabase(query); 
+	QueryDatabase(query);
 }

-void Database::SetLFG(uint32 CharID, bool LFG) { 
+void Database::SetLFG(uint32 CharID, bool LFG) {
 	std::string query = StringFormat("update `character_data` SET `lfg` = %i WHERE `id` = %i",LFG, CharID);
-	QueryDatabase(query); 
+	QueryDatabase(query);
 }

-void Database::SetFirstLogon(uint32 CharID, uint8 firstlogon) { 
+void Database::SetFirstLogon(uint32 CharID, uint8 firstlogon) {
 	std::string query = StringFormat( "UPDATE `character_data` SET `firstlogon` = %i WHERE `id` = %i",firstlogon, CharID);
-	QueryDatabase(query); 
+	QueryDatabase(query);
 }

 void Database::AddReport(std::string who, std::string against, std::string lines)
@@ -1514,7 +1583,7 @@ void Database::SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ism
 		auto results = QueryDatabase(query);

 		if (!results.Success())
-			Log(Logs::General, Logs::Error, "Error deleting character from group id: %s", results.ErrorMessage().c_str());
+			LogError("Error deleting character from group id: {}", results.ErrorMessage().c_str());

 		return;
 	}
@@ -1533,7 +1602,7 @@ void Database::ClearAllGroups(void)

 void Database::ClearGroup(uint32 gid) {
 	ClearGroupLeader(gid);
-	
+
 	if(gid == 0)
 	{
 		//clear all groups
@@ -1546,7 +1615,7 @@ void Database::ClearGroup(uint32 gid) {
 	QueryDatabase(query);
 }

-uint32 Database::GetGroupID(const char* name){ 
+uint32 Database::GetGroupID(const char* name){
 	std::string query = StringFormat("SELECT groupid from group_id where name='%s'", name);
 	auto results = QueryDatabase(query);

@@ -1557,7 +1626,7 @@ uint32 Database::GetGroupID(const char* name){
 	if (results.RowCount() == 0)
 	{
 		// Commenting this out until logging levels can prevent this from going to console
-		//Log(Logs::General, Logs::None,, "Character not in a group: %s", name);
+		//LogDebug(, "Character not in a group: [{}]", name);
 		return 0;
 	}

@@ -1591,7 +1660,7 @@ char* Database::GetGroupLeaderForLogin(const char* name, char* leaderbuf) {
 	return leaderbuf;
 }

-void Database::SetGroupLeaderName(uint32 gid, const char* name) { 
+void Database::SetGroupLeaderName(uint32 gid, const char* name) {
 	std::string query = StringFormat("UPDATE group_leaders SET leadername = '%s' WHERE gid = %u", EscapeString(name).c_str(), gid);
 	auto result = QueryDatabase(query);

@@ -1604,7 +1673,7 @@ void Database::SetGroupLeaderName(uint32 gid, const char* name) {
 	result = QueryDatabase(query);

 	if(!result.Success()) {
-		Log(Logs::General, Logs::None, "Error in Database::SetGroupLeaderName: %s", result.ErrorMessage().c_str());
+		LogDebug("Error in Database::SetGroupLeaderName: [{}]", result.ErrorMessage().c_str());
 	}
 }

@@ -1679,7 +1748,7 @@ void Database::ClearAllGroupLeaders(void) {
 }

 void Database::ClearGroupLeader(uint32 gid) {
-	
+
 	if(gid == 0)
 	{
 		ClearAllGroupLeaders();
@@ -1750,7 +1819,7 @@ void Database::ClearAllRaidDetails(void)
 }

 void Database::ClearRaidDetails(uint32 rid) {
-	
+
 	if(rid == 0)
 	{
 		//clear all raids
@@ -1778,7 +1847,7 @@ void Database::PurgeAllDeletedDataBuckets() {
 // returns 0 on error or no raid for that character, or
 // the raid id that the character is a member of.
 uint32 Database::GetRaidID(const char* name)
-{ 
+{
 	std::string query = StringFormat("SELECT `raidid` FROM `raid_members` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);

@@ -1786,7 +1855,7 @@ uint32 Database::GetRaidID(const char* name)
 		return 0;
 	}

-	auto row = results.begin(); 
+	auto row = results.begin();
 	if (row == results.end()) {
 		return 0;
 	}
@@ -1805,12 +1874,12 @@ const char* Database::GetRaidLeaderName(uint32 raid_id)
 	// variable). C++0x standard states this should be thread safe
 	// but may not be fully supported in some compilers.
 	static char name[128];
-	
+
 	std::string query = StringFormat("SELECT `name` FROM `raid_members` WHERE `raidid` = %u AND `israidleader` = 1", raid_id);
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
-		Log(Logs::General, Logs::Debug, "Unable to get Raid Leader Name for Raid ID: %u", raid_id);
+		LogDebug("Unable to get Raid Leader Name for Raid ID: [{}]", raid_id);
 		return "UNKNOWN";
 	}

@@ -2033,7 +2102,7 @@ bool Database::GetAdventureStats(uint32 char_id, AdventureStats_Struct *as)
 		"FROM "
 		"`adventure_stats` "
 		"WHERE "
-		"player_id = %u ", 
+		"player_id = %u ",
 		char_id
 	);
 	auto results = QueryDatabase(query);
@@ -2062,7 +2131,7 @@ bool Database::GetAdventureStats(uint32 char_id, AdventureStats_Struct *as)
 	return true;
 }

-uint32 Database::GetGuildIDByCharID(uint32 character_id) 
+uint32 Database::GetGuildIDByCharID(uint32 character_id)
 {
 	std::string query = StringFormat("SELECT guild_id FROM guild_members WHERE char_id='%i'", character_id);
 	auto results = QueryDatabase(query);
@@ -2077,9 +2146,11 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)
 	return atoi(row[0]);
 }

-void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
-	// log_settings previously initialized to '0' by EQEmuLogSys::LoadLogSettingsDefaults()
-
+/**
+ * @param log_settings
+ */
+void Database::LoadLogSettings(EQEmuLogSys::LogSettings *log_settings)
+{
 	std::string query =
 					"SELECT "
 					"log_category_id, "
@@ -2091,11 +2162,10 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
 					"logsys_categories "
 					"ORDER BY log_category_id";

-	auto results = QueryDatabase(query);
+	auto results         = QueryDatabase(query);
+	int  log_category_id = 0;

-	int log_category_id = 0;
-
-	int categories_in_database[1000] = {};
+	int *categories_in_database = new int[1000];

 	for (auto row = results.begin(); row != results.end(); ++row) {
 		log_category_id = atoi(row[0]);
@@ -2125,7 +2195,7 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
 		 * If we go through this whole loop and nothing is set to any debug level, there is no point to create a file or keep anything open
 		 */
 		if (log_settings[log_category_id].log_to_file > 0) {
-			LogSys.file_logs_enabled = true;
+			EQEmuLogSys::Get()->file_logs_enabled = true;
 		}

 		categories_in_database[log_category_id] = 1;
@@ -2135,15 +2205,14 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
 	 * Auto inject categories that don't exist in the database...
 	 */
 	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
-		if (!categories_in_database[log_index]) {
+		if (categories_in_database[log_index] != 1) {

-			Log(Logs::General,
-				Logs::Status,
-				"New Log Category '%s' doesn't exist... Automatically adding to `logsys_categories` table...",
+			LogInfo(
+				"New Log Category [{0}] doesn't exist... Automatically adding to [logsys_categories] table...",
 				Logs::LogCategoryName[log_index]
 			);

-			std::string inject_query = StringFormat(
+			auto inject_query = fmt::format(
 				"INSERT INTO logsys_categories "
 				"(log_category_id, "
 				"log_category_description, "
@@ -2151,17 +2220,19 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
 				"log_to_file, "
 				"log_to_gmsay) "
 				"VALUES "
-				"(%i, '%s', %i, %i, %i)",
+				"({0}, '{1}', {2}, {3}, {4})",
 				log_index,
-				EscapeString(Logs::LogCategoryName[log_index]).c_str(),
-				log_settings[log_category_id].log_to_console,
-				log_settings[log_category_id].log_to_file,
-				log_settings[log_category_id].log_to_gmsay
+				EscapeString(Logs::LogCategoryName[log_index]),
+				std::to_string(log_settings[log_index].log_to_console),
+				std::to_string(log_settings[log_index].log_to_file),
+				std::to_string(log_settings[log_index].log_to_gmsay)
 			);

 			QueryDatabase(inject_query);
 		}
 	}
+
+	delete[] categories_in_database;
 }

 int Database::CountInvSnapshots() {
@@ -2198,7 +2269,7 @@ struct TimeOfDay_Struct Database::LoadTime(time_t &realtime)
 	auto results = QueryDatabase(query);

 	if (!results.Success() || results.RowCount() == 0){
-		Log(Logs::Detail, Logs::World_Server, "Loading EQ time of day failed. Using defaults.");
+		LogInfo("Loading EQ time of day failed. Using defaults");
 		eqTime.minute = 0;
 		eqTime.hour = 9;
 		eqTime.day = 1;
@@ -2232,12 +2303,12 @@ bool Database::SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year
 int Database::GetIPExemption(std::string account_ip) {
 	std::string query = StringFormat("SELECT `exemption_amount` FROM `ip_exemptions` WHERE `exemption_ip` = '%s'", account_ip.c_str());
 	auto results = QueryDatabase(query);
-	
+
 	if (results.Success() && results.RowCount() > 0) {
 		auto row = results.begin();
 		return atoi(row[0]);
 	}
-	
+
 	return RuleI(World, MaxClientsPerIP);
 }

@@ -94,6 +94,8 @@ class PTimerList;
 #	define _ISNAN_(a) std::isnan(a)
 #endif

+#define SQL(...) #__VA_ARGS__
+
 class Database : public DBcore {
 public:
 	Database();
@@ -118,7 +120,7 @@ public:

 	/* General Information Queries */

-	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the Banned_IPs table.
+	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the banned_ips table.
 	bool	AddGMIP(char* ip_address, char* name);
 	bool	CheckBannedIPs(const char* loginIP); //Check incoming connection against banned IP table.
 	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
@@ -127,7 +129,7 @@ public:

 	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
 	uint32	GetAccountIDByChar(uint32 char_id);
-	uint32	GetAccountIDByName(const char* accname, int16* status = 0, uint32* lsid = 0);
+	uint32	GetAccountIDByName(const char* accname, const char *loginserver, int16* status = 0, uint32* lsid = 0);
 	uint32	GetCharacterID(const char *name);
 	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0, float* oX = 0, float* oY = 0, float* oZ = 0);
 	uint32	GetGuildIDByCharID(uint32 char_id);
@@ -174,18 +176,18 @@ public:

 	/* Account Related */

-	bool	DeleteAccount(const char* name);
+	bool	DeleteAccount(const char *name, const char* loginserver);
 	bool	GetLiveChar(uint32 account_id, char* cname);
 	bool	SetAccountStatus(const char* name, int16 status);
+	bool	SetAccountStatus(const std::string& account_name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
-	bool	UpdateLiveChar(char* charname, uint32 lsaccount_id);
+	bool	UpdateLiveChar(char* charname, uint32 account_id);

 	int16	CheckStatus(uint32 account_id);

-	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
-	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
-	uint32	GetAccountIDFromLSID(uint32 iLSID, char* oAccountName = 0, int16* oStatus = 0);
-	uint32	GetMiniLoginAccount(char* ip);
+	uint32	CheckLogin(const char* name, const char* password, const char *loginserver, int16* oStatus = 0);
+	uint32	CreateAccount(const char* name, const char* password, int16 status, const char* loginserver, uint32 lsaccount_id);
+	uint32	GetAccountIDFromLSID(const std::string& in_loginserver_id, uint32 in_loginserver_account_id, char* in_account_name = 0, int16* in_status = 0);
 	uint8	GetAgreementFlag(uint32 acctid);

 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
@@ -476,7 +476,7 @@ bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertCorpseDeblob();

 	/* Run EQEmu Server script (Checks for database updates) */
-	system("perl eqemu_server.pl ran_from_world");
+	if(system("perl eqemu_server.pl ran_from_world"));

 	return true;
 }
@@ -0,0 +1,296 @@
+/**
+ * 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>
+
+namespace DatabaseSchema {
+
+	/**
+	 * Gets player tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetPlayerTables()
+	{
+		std::vector<std::string> tables = {
+			"aa_timers",
+			"account",
+			"account_ip",
+			"account_flags",
+			"account_rewards",
+			"adventure_details",
+			"adventure_stats",
+			"buyer",
+			"char_recipe_list",
+			"character_activities",
+			"character_alt_currency",
+			"character_alternate_abilities",
+			"character_auras",
+			"character_bandolier",
+			"character_bind",
+			"character_buffs",
+			"character_corpse_items",
+			"character_corpses",
+			"character_currency",
+			"character_data",
+			"character_disciplines",
+			"character_enabledtasks",
+			"character_inspect_messages",
+			"character_item_recast",
+			"character_languages",
+			"character_leadership_abilities",
+			"character_material",
+			"character_memmed_spells",
+			"character_pet_buffs",
+			"character_pet_info",
+			"character_pet_inventory",
+			"character_potionbelt",
+			"character_skills",
+			"character_spells",
+			"character_tasks",
+			"character_tribute",
+			"completed_tasks",
+			"data_buckets",
+			"faction_values",
+			"friends",
+			"guild_bank",
+			"guild_members",
+			"guild_ranks",
+			"guild_relations",
+			"guilds",
+			"instance_list_player",
+			"inventory",
+			"inventory_snapshots",
+			"keyring",
+			"mail",
+			"player_titlesets",
+			"quest_globals",
+			"sharedbank",
+			"timers",
+			"titles",
+			"trader",
+			"trader_audit",
+			"zone_flags"
+		};
+
+		return tables;
+	}
+
+	/**
+	 * Gets content tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetContentTables()
+	{
+		std::vector<std::string> tables = {
+			"aa_ability",
+			"aa_actions",
+			"aa_effects",
+			"aa_rank_effects",
+			"aa_rank_prereqs",
+			"aa_ranks",
+			"aa_required_level_cost",
+			"adventure_template",
+			"adventure_template_entry",
+			"adventure_template_entry_flavor",
+			"altadv_vars",
+			"alternate_currency",
+			"auras",
+			"base_data",
+			"blocked_spells",
+			"books",
+			"char_create_combinations",
+			"char_create_point_allocations",
+			"class_skill",
+			"damageshieldtypes",
+			"doors",
+			"faction_base_data",
+			"faction_list",
+			"faction_list_mod",
+			"fear_hints",
+			"fishing",
+			"forage",
+			"global_loot",
+			"goallists",
+			"graveyard",
+			"grid",
+			"grid_entries",
+			"ground_spawns",
+			"horses",
+			"instance_list",
+			"items",
+			"ldon_trap_entries",
+			"ldon_trap_templates",
+			"lootdrop",
+			"lootdrop_entries",
+			"loottable",
+			"loottable_entries",
+			"merchantlist",
+			"npc_emotes",
+			"npc_faction",
+			"npc_faction_entries",
+			"npc_scale_global_base",
+			"npc_spells",
+			"npc_spells_effects",
+			"npc_spells_effects_entries",
+			"npc_spells_entries",
+			"npc_types",
+			"npc_types_metadata",
+			"npc_types_tint",
+			"object",
+			"pets",
+			"pets_equipmentset",
+			"pets_equipmentset_entries",
+			"proximities",
+			"races",
+			"skill_caps",
+			"spawn2",
+			"spawn_condition_values",
+			"spawn_conditions",
+			"spawn_events",
+			"spawnentry",
+			"spawngroup",
+			"spells_new",
+			"start_zones",
+			"starting_items",
+			"task_activities",
+			"tasks",
+			"tasksets",
+			"titles",
+			"tradeskill_recipe",
+			"tradeskill_recipe_entries",
+			"traps",
+			"tribute_levels",
+			"tributes",
+			"veteran_reward_templates",
+			"zone",
+			"zone_points",
+			"zone_server",
+			"zoneserver_auth",
+		};
+
+		return tables;
+	}
+
+	/**
+	 * Gets server tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetServerTables()
+	{
+		std::vector<std::string> tables = {
+			"banned_ips",
+			"bugs",
+			"bug_reports",
+			"command_settings",
+			"db_str",
+			"discovered_items",
+			"eqtime",
+			"eventlog",
+			"gm_ips",
+			"hackers",
+			"ip_exemptions",
+			"launcher",
+			"launcher_zones",
+			"level_exp_mods",
+			"logsys_categories",
+			"name_filter",
+			"perl_event_export_settings",
+			"petitions",
+			"profanity_list",
+			"reports",
+			"rule_sets",
+			"rule_values",
+			"saylink",
+			"variables",
+		};
+
+		return tables;
+	}
+
+	/**
+	 * Gets state tables
+	 * Tables that keep track of server state
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetStateTables()
+	{
+		std::vector<std::string> tables = {
+			"adventure_members",
+			"chatchannels",
+			"group_id",
+			"group_leaders",
+			"item_tick",
+			"lfguild",
+			"merchantlist_temp",
+			"object_contents",
+			"raid_details",
+			"raid_leaders",
+			"raid_members",
+			"respawn_times",
+			"spell_buckets",
+			"spell_globals",
+		};
+
+		return tables;
+	}
+
+	/**
+	 * Gets login tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetLoginTables()
+	{
+		std::vector<std::string> tables = {
+			"login_accounts",
+			"login_api_tokens",
+			"login_server_admins",
+			"login_server_list_types",
+			"login_world_servers",
+		};
+
+		return tables;
+	}
+
+	/**
+	 * Gets login tables
+	 *
+	 * @return
+	 */
+	static std::vector<std::string> GetVersionTables()
+	{
+		std::vector<std::string> tables = {
+			"db_version",
+			"inventory_versions",
+		};
+
+		return tables;
+	}
+
+}
+
+#endif //EQEMU_DATABASE_SCHEMA_H
@@ -2,8 +2,9 @@
 #include <winsock2.h>
 #endif

-#include "../common/misc_functions.h"
-#include "../common/eqemu_logsys.h"
+#include "misc_functions.h"
+#include "eqemu_logsys.h"
+#include "timer.h"

 #include "dbcore.h"

@@ -14,33 +15,37 @@
 #include <string.h>

 #ifdef _WINDOWS
-	#define snprintf	_snprintf
-	#define strncasecmp	_strnicmp
-	#define strcasecmp	_stricmp
-	#include <process.h>
+#define snprintf	_snprintf
+#define strncasecmp	_strnicmp
+#define strcasecmp	_stricmp
+#include <process.h>
 #else
-	#include "unix.h"
-	#include <pthread.h>
+
+#include "unix.h"
+#include <pthread.h>
+
 #endif

 #ifdef _EQDEBUG
-	#define DEBUG_MYSQL_QUERIES 0
+#define DEBUG_MYSQL_QUERIES 0
 #else
-	#define DEBUG_MYSQL_QUERIES 0
+#define DEBUG_MYSQL_QUERIES 0
 #endif

-DBcore::DBcore() {
+DBcore::DBcore()
+{
 	mysql_init(&mysql);
-	pHost = 0;
-	pUser = 0;
+	pHost     = 0;
+	pUser     = 0;
 	pPassword = 0;
 	pDatabase = 0;
 	pCompress = false;
-	pSSL = false;
-	pStatus = Closed;
+	pSSL      = false;
+	pStatus   = Closed;
 }

-DBcore::~DBcore() {
+DBcore::~DBcore()
+{
 	mysql_close(&mysql);
 	safe_delete_array(pHost);
 	safe_delete_array(pUser);
@@ -49,7 +54,8 @@ DBcore::~DBcore() {
 }

 // Sends the MySQL server a keepalive
-void DBcore::ping() {
+void DBcore::ping()
+{
 	if (!MDatabase.trylock()) {
 		// well, if's it's locked, someone's using it. If someone's using it, it doesnt need a keepalive
 		return;
@@ -63,34 +69,35 @@ MySQLRequestResult DBcore::QueryDatabase(std::string query, bool retryOnFailureO
 	return QueryDatabase(query.c_str(), query.length(), retryOnFailureOnce);
 }

-MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce)
+MySQLRequestResult DBcore::QueryDatabase(const char *query, uint32 querylen, bool retryOnFailureOnce)
 {
+	BenchTimer timer;
+	timer.reset();
+
 	LockMutex lock(&MDatabase);

 	// Reconnect if we are not connected before hand.
-	if (pStatus != Connected)
+	if (pStatus != Connected) {
 		Open();
+	}

 	// request query. != 0 indicates some kind of error.
-	if (mysql_real_query(&mysql, query, querylen) != 0)
-	{
+	if (mysql_real_query(&mysql, query, querylen) != 0) {
 		unsigned int errorNumber = mysql_errno(&mysql);

-		if (errorNumber == CR_SERVER_GONE_ERROR)
+		if (errorNumber == CR_SERVER_GONE_ERROR) {
 			pStatus = Error;
+		}

 		// error appears to be a disconnect error, may need to try again.
-		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR)
-		{
+		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR) {

-			if (retryOnFailureOnce)
-			{
-				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
+			if (retryOnFailureOnce) {
+				LogInfo("Database Error: Lost connection, attempting to recover");
 				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);

-				if (requestResult.Success())
-				{
-					std::cout << "Reconnection to database successful." << std::endl;
+				if (requestResult.Success()) {
+					LogInfo("Reconnection to database successful");
 					return requestResult;
 				}

@@ -102,109 +109,154 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo

 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));

-			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
+			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32) mysql_errno(&mysql), errorBuffer);
 		}

 		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));

 		/* Implement Logging at the Root */
-		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
+		if (mysql_errno(&mysql) > 0 && strlen(query) > 0) {
+			if (EQEmuLogSys::Get()->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 (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1) {
 		if ((strncasecmp(query, "select", 6) == 0)) {
-			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
+			LogF(
+				Logs::General,
+				Logs::MySQLQuery,
+				"{0} ({1} row{2} returned) ({3}s)",
+				query,
+				requestResult.RowCount(),
+				requestResult.RowCount() == 1 ? "" : "s",
+				std::to_string(timer.elapsed())
+			);
 		}
 		else {
-			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+			LogF(
+				Logs::General,
+				Logs::MySQLQuery,
+				"{0} ({1} row{2} affected) ({3}s)",
+				query,
+				requestResult.RowsAffected(),
+				requestResult.RowsAffected() == 1 ? "" : "s",
+				std::to_string(timer.elapsed())
+			);
 		}
 	}

 	return requestResult;
 }

-void DBcore::TransactionBegin() {
+void DBcore::TransactionBegin()
+{
 	QueryDatabase("START TRANSACTION");
 }

-void DBcore::TransactionCommit() {
+void DBcore::TransactionCommit()
+{
 	QueryDatabase("COMMIT");
 }

-void DBcore::TransactionRollback() {
+void DBcore::TransactionRollback()
+{
 	QueryDatabase("ROLLBACK");
 }

-uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {
+uint32 DBcore::DoEscapeString(char *tobuf, const char *frombuf, uint32 fromlen)
+{
 //	No good reason to lock the DB, we only need it in the first place to check char encoding.
 //	LockMutex lock(&MDatabase);
 	return mysql_real_escape_string(&mysql, tobuf, frombuf, fromlen);
 }

-bool DBcore::Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase,uint32 iPort, uint32* errnum, char* errbuf, bool iCompress, bool iSSL) {
+bool DBcore::Open(
+	const char *iHost,
+	const char *iUser,
+	const char *iPassword,
+	const char *iDatabase,
+	uint32 iPort,
+	uint32 *errnum,
+	char *errbuf,
+	bool iCompress,
+	bool iSSL
+)
+{
 	LockMutex lock(&MDatabase);
 	safe_delete(pHost);
 	safe_delete(pUser);
 	safe_delete(pPassword);
 	safe_delete(pDatabase);
-	pHost = strcpy(new char[strlen(iHost) + 1], iHost);
-	pUser = strcpy(new char[strlen(iUser) + 1], iUser);
+	pHost     = strcpy(new char[strlen(iHost) + 1], iHost);
+	pUser     = strcpy(new char[strlen(iUser) + 1], iUser);
 	pPassword = strcpy(new char[strlen(iPassword) + 1], iPassword);
 	pDatabase = strcpy(new char[strlen(iDatabase) + 1], iDatabase);
 	pCompress = iCompress;
-	pPort = iPort;
-	pSSL = iSSL;
+	pPort     = iPort;
+	pSSL      = iSSL;
 	return Open(errnum, errbuf);
 }

-bool DBcore::Open(uint32* errnum, char* errbuf) {
-	if (errbuf)
+bool DBcore::Open(uint32 *errnum, char *errbuf)
+{
+	if (errbuf) {
 		errbuf[0] = 0;
+	}
 	LockMutex lock(&MDatabase);
-	if (GetStatus() == Connected)
+	if (GetStatus() == Connected) {
 		return true;
+	}
 	if (GetStatus() == Error) {
 		mysql_close(&mysql);
-		mysql_init(&mysql);		// Initialize structure again
+		mysql_init(&mysql);        // Initialize structure again
 	}
-	if (!pHost)
+	if (!pHost) {
 		return false;
+	}
 	/*
 	Added CLIENT_FOUND_ROWS flag to the connect
 	otherwise DB update calls would say 0 rows affected when the value already equalled
 	what the function was tring to set it to, therefore the function would think it failed
 	*/
 	uint32 flags = CLIENT_FOUND_ROWS;
-	if (pCompress)
+	if (pCompress) {
 		flags |= CLIENT_COMPRESS;
-	if (pSSL)
+	}
+	if (pSSL) {
 		flags |= CLIENT_SSL;
+	}
 	if (mysql_real_connect(&mysql, pHost, pUser, pPassword, pDatabase, pPort, 0, flags)) {
 		pStatus = Connected;
 		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;
 	}
@@ -77,6 +77,10 @@ namespace EQEmu

 	} // 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;
@@ -307,6 +311,12 @@ namespace EQEmu

 	} // namespace bug

+	enum WaypointStatus : int {
+		RoamBoxPauseInProgress = -3,
+		QuestControlNoGrid = -2,
+		QuestControlGrid = -1
+	};
+
 } /*EQEmu*/

 #endif /*COMMON_EMU_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,199 +87,114 @@ typedef enum {
 	_eaMaxAppearance
 } EmuAppearance;

-// msg_type's for custom usercolors
-#define MT_Say					256
-#define MT_Tell					257
-#define MT_Group				258
-#define MT_Guild				259
-#define MT_OOC					260
-#define MT_Auction				261
-#define MT_Shout				262
-#define MT_Emote				263
-#define MT_Spells				264
-#define MT_YouHitOther			265
-#define MT_OtherHitsYou			266
-#define MT_YouMissOther			267
-#define MT_OtherMissesYou		268
-#define MT_Broadcasts			269
-#define MT_Skills				270
-#define MT_Disciplines			271
-#define	MT_Unused1				272
-#define MT_DefaultText			273
-#define MT_Unused2				274
-#define MT_MerchantOffer		275
-#define MT_MerchantBuySell		276
-#define	MT_YourDeath			277
-#define MT_OtherDeath			278
-#define MT_OtherHits			279
-#define MT_OtherMisses			280
-#define	MT_Who					281
-#define MT_YellForHelp			282
-#define MT_NonMelee				283
-#define MT_WornOff				284
-#define MT_MoneySplit			285
-#define MT_LootMessages			286
-#define MT_DiceRoll				287
-#define MT_OtherSpells			288
-#define MT_SpellFailure			289
-#define MT_Chat					290
-#define MT_Channel1				291
-#define MT_Channel2				292
-#define MT_Channel3				293
-#define MT_Channel4				294
-#define MT_Channel5				295
-#define MT_Channel6				296
-#define MT_Channel7				297
-#define MT_Channel8				298
-#define MT_Channel9				299
-#define MT_Channel10			300
-#define MT_CritMelee			301
-#define MT_SpellCrits			302
-#define MT_TooFarAway			303
-#define MT_NPCRampage			304
-#define MT_NPCFlurry			305
-#define MT_NPCEnrage			306
-#define MT_SayEcho				307
-#define MT_TellEcho				308
-#define MT_GroupEcho			309
-#define MT_GuildEcho			310
-#define MT_OOCEcho				311
-#define MT_AuctionEcho			312
-#define MT_ShoutECho			313
-#define MT_EmoteEcho			314
-#define MT_Chat1Echo			315
-#define MT_Chat2Echo			316
-#define MT_Chat3Echo			317
-#define MT_Chat4Echo			318
-#define MT_Chat5Echo			319
-#define MT_Chat6Echo			320
-#define MT_Chat7Echo			321
-#define MT_Chat8Echo			322
-#define MT_Chat9Echo			323
-#define MT_Chat10Echo			324
-#define MT_DoTDamage			325
-#define MT_ItemLink				326
-#define MT_RaidSay				327
-#define MT_MyPet				328
-#define MT_DS					329
-#define MT_Leadership			330
-#define MT_PetFlurry			331
-#define MT_PetCrit				332
-#define MT_FocusEffect			333
-#define MT_Experience			334
-#define MT_System				335
-#define MT_PetSpell				336
-#define MT_PetResponse			337
-#define MT_ItemSpeech			338
-#define MT_StrikeThrough		339
-#define MT_Stun					340
+namespace Chat {
+	const uint16 White       = 0;
+	const uint16 DimGray     = 1;
+	const uint16 Default     = 1;
+	const uint16 Green       = 2;
+	const uint16 BrightBlue  = 3;
+	const uint16 LightBlue   = 4;
+	const uint16 Magenta     = 5;
+	const uint16 Gray        = 6;
+	const uint16 LightGray   = 7;
+	const uint16 NPCQuestSay = 10;
+	const uint16 DarkGray    = 12;
+	const uint16 Red         = 13;
+	const uint16 Lime        = 14;
+	const uint16 Yellow      = 15;
+	const uint16 Blue        = 16;
+	const uint16 LightNavy   = 17;
+	const uint16 Cyan        = 18;
+	const uint16 Black       = 20;

-// TODO: Really should combine above and below into one
-
-//from showeq
-enum ChatColor
-{
-	/*
-	CC_Default					= 0,
-	CC_DarkGrey					= 1,
-	CC_DarkGreen				= 2,
-	CC_DarkBlue					= 3,
-	CC_Purple					= 5,
-	CC_LightGrey				= 6,
-	*/
-
-	CC_WhiteSmoke				= 0,	// FF|F0F0F0
-	CC_Green					= 2,	// FF|008000
-	CC_BrightBlue				= 3,	// FF|0040FF
-	CC_Magenta					= 5,	// FF|F000F0
-	CC_Gray						= 6,	// FF|808080
-	CC_LightGray				= 7,	// FF|E0E0E0
-	//CC_WhiteSmoke2				= 10,	// FF|F0F0F0
-	CC_DarkGray					= 12,	// FF|A0A0A0
-	CC_Red						= 13,	// FF|F00000
-	CC_Lime						= 14,	// FF|00F000
-	CC_Yellow					= 15,	// FF|F0F000
-	CC_Blue						= 16,	// FF|0000F0
-	CC_LightNavy				= 17,	// FF|0000AF
-	CC_Cyan						= 18,	// FF|00F0F0
-	CC_Black					= 20,	// FF|000000
-	
-	// any index <= 255 that is not defined above
-	CC_DimGray					= 1,	// FF|606060
-	CC_Default					= 1,
-
-	CC_User_Say					= 256,
-	CC_User_Tell				= 257,
-	CC_User_Group				= 258,
-	CC_User_Guild				= 259,
-	CC_User_OOC					= 260,
-	CC_User_Auction				= 261,
-	CC_User_Shout				= 262,
-	CC_User_Emote				= 263,
-	CC_User_Spells				= 264,
-	CC_User_YouHitOther			= 265,
-	CC_User_OtherHitYou			= 266,
-	CC_User_YouMissOther		= 267,
-	CC_User_OtherMissYou		= 268,
-	CC_User_Duels				= 269,
-	CC_User_Skills				= 270,
-	CC_User_Disciplines			= 271,
-	CC_User_Default				= 273,
-	CC_User_MerchantOffer		= 275,
-	CC_User_MerchantExchange	= 276,
-	CC_User_YourDeath			= 277,
-	CC_User_OtherDeath			= 278,
-	CC_User_OtherHitOther		= 279,
-	CC_User_OtherMissOther		= 280,
-	CC_User_Who					= 281,
-	CC_User_Yell				= 282,
-	CC_User_NonMelee			= 283,
-	CC_User_SpellWornOff		= 284,
-	CC_User_MoneySplit			= 285,
-	CC_User_Loot				= 286,
-	CC_User_Random				= 287,
-	CC_User_OtherSpells			= 288,
-	CC_User_SpellFailure		= 289,
-	CC_User_ChatChannel			= 290,
-	CC_User_Chat1				= 291,
-	CC_User_Chat2				= 292,
-	CC_User_Chat3				= 293,
-	CC_User_Chat4				= 294,
-	CC_User_Chat5				= 295,
-	CC_User_Chat6				= 296,
-	CC_User_Chat7				= 297,
-	CC_User_Chat8				= 298,
-	CC_User_Chat9				= 299,
-	CC_User_Chat10				= 300,
-	CC_User_MeleeCrit			= 301,
-	CC_User_SpellCrit			= 302,
-	CC_User_TooFarAway			= 303,
-	CC_User_NPCRampage			= 304,
-	CC_User_NPCFurry			= 305,
-	CC_User_NPCEnrage			= 306,
-	CC_User_EchoSay				= 307,
-	CC_User_EchoTell			= 308,
-	CC_User_EchoGroup			= 309,
-	CC_User_EchoGuild			= 310,
-	CC_User_EchoOOC				= 311,
-	CC_User_EchoAuction			= 312,
-	CC_User_EchoShout			= 313,
-	CC_User_EchoEmote			= 314,
-	CC_User_EchoChat1			= 315,
-	CC_User_EchoChat2			= 316,
-	CC_User_EchoChat3			= 317,
-	CC_User_EchoChat4			= 318,
-	CC_User_EchoChat5			= 319,
-	CC_User_EchoChat6			= 320,
-	CC_User_EchoChat7			= 321,
-	CC_User_EchoChat8			= 322,
-	CC_User_EchoChat9			= 323,
-	CC_User_EchoChat10			= 324,
-	CC_User_UnusedAtThisTime	= 325,
-	CC_User_ItemTags			= 326,
-	CC_User_RaidSay				= 327,
-	CC_User_MyPet				= 328,
-	CC_User_DamageShield		= 329,
+	/**
+	 * User colors
+	 */
+	const uint16 Say              = 256;
+	const uint16 Tell             = 257;
+	const uint16 Group            = 258;
+	const uint16 Guild            = 259;
+	const uint16 OOC              = 260;
+	const uint16 Auction          = 261;
+	const uint16 Shout            = 262;
+	const uint16 Emote            = 263;
+	const uint16 Spells           = 264;
+	const uint16 YouHitOther      = 265;
+	const uint16 OtherHitYou      = 266;
+	const uint16 YouMissOther     = 267;
+	const uint16 OtherMissYou     = 268;
+	const uint16 Broadcasts       = 269;
+	const uint16 Skills           = 270;
+	const uint16 Disciplines      = 271;
+	const uint16 Unused1          = 272;
+	const uint16 DefaultText      = 273;
+	const uint16 Unused2          = 274;
+	const uint16 MerchantOffer    = 275;
+	const uint16 MerchantExchange = 276;
+	const uint16 YourDeath        = 277;
+	const uint16 OtherDeath       = 278;
+	const uint16 OtherHitOther    = 279;
+	const uint16 OtherMissOther   = 280;
+	const uint16 Who              = 281;
+	const uint16 YellForHelp      = 282;
+	const uint16 NonMelee         = 283;
+	const uint16 SpellWornOff     = 284;
+	const uint16 MoneySplit       = 285;
+	const uint16 Loot             = 286;
+	const uint16 DiceRoll         = 287;
+	const uint16 OtherSpells      = 288;
+	const uint16 SpellFailure     = 289;
+	const uint16 ChatChannel      = 290;
+	const uint16 Chat1            = 291;
+	const uint16 Chat2            = 292;
+	const uint16 Chat3            = 293;
+	const uint16 Chat4            = 294;
+	const uint16 Chat5            = 295;
+	const uint16 Chat6            = 296;
+	const uint16 Chat7            = 297;
+	const uint16 Chat8            = 298;
+	const uint16 Chat9            = 299;
+	const uint16 Chat10           = 300;
+	const uint16 MeleeCrit        = 301;
+	const uint16 SpellCrit        = 302;
+	const uint16 TooFarAway       = 303;
+	const uint16 NPCRampage       = 304;
+	const uint16 NPCFlurry        = 305;
+	const uint16 NPCEnrage        = 306;
+	const uint16 EchoSay          = 307;
+	const uint16 EchoTell         = 308;
+	const uint16 EchoGroup        = 309;
+	const uint16 EchoGuild        = 310;
+	const uint16 EchoOOC          = 311;
+	const uint16 EchoAuction      = 312;
+	const uint16 EchoShout        = 313;
+	const uint16 EchoEmote        = 314;
+	const uint16 EchoChat1        = 315;
+	const uint16 EchoChat2        = 316;
+	const uint16 EchoChat3        = 317;
+	const uint16 EchoChat4        = 318;
+	const uint16 EchoChat5        = 319;
+	const uint16 EchoChat6        = 320;
+	const uint16 EchoChat7        = 321;
+	const uint16 EchoChat8        = 322;
+	const uint16 EchoChat9        = 323;
+	const uint16 EchoChat10       = 324;
+	const uint16 DotDamage        = 325;
+	const uint16 ItemLink         = 326;
+	const uint16 RaidSay          = 327;
+	const uint16 MyPet            = 328;
+	const uint16 DamageShield     = 329;
+	const uint16 LeaderShip       = 330;
+	const uint16 PetFlurry        = 331;
+	const uint16 PetCritical      = 332;
+	const uint16 FocusEffect      = 333;
+	const uint16 Experience       = 334;
+	const uint16 System           = 335;
+	const uint16 PetSpell         = 336;
+	const uint16 PetResponse      = 337;
+	const uint16 ItemSpeech       = 338;
+	const uint16 StrikeThrough    = 339;
+	const uint16 Stun             = 340;
 };

 //ZoneChange_Struct->success values
@@ -523,4 +438,30 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang

 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*/
@@ -21,7 +21,6 @@
 #include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
-#include "platform.h"
 #include <iomanip>
 #include <iostream>
 #include <sstream>
@@ -154,52 +153,6 @@ void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 #endif
 }

-void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
-{
-	BasePacket::build_raw_header_dump(buffer, seq);
-	buffer += strlen(buffer);
-
-#ifdef STATIC_OPCODE
-	buffer += sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	buffer += sprintf(buffer, "[OpCode %s (0x%04x) Size=%u]\n", OpcodeManager::EmuToName(emu_opcode), opcode,size);
-#endif
-}
-
-void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
-{
-	char buff[196];
-	build_raw_header_dump(buff, seq);
-	fprintf(to, "%s", buff);
-}
-
-void EQRawApplicationPacket::build_header_dump(char *buffer) const
-{
-#ifdef STATIC_OPCODE
-	sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	sprintf(buffer, "[OpCode %s (0x%04x) Size=%u]", OpcodeManager::EmuToName(emu_opcode), opcode,size);
-#endif
-}
-
-void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
-{
-	if (src_ip) {
-		std::string sIP,dIP;;
-		sIP=long2ip(src_ip);
-		dIP=long2ip(dst_ip);
-		fprintf(to, "[%s:%d->%s:%d] ",sIP.c_str(),src_port,dIP.c_str(),dst_port);
-	}
-	if (seq != 0xffff)
-		fprintf(to, "[Seq=%u] ",seq);
-
-#ifdef STATIC_OPCODE
-	fprintf(to, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
-#else
-	fprintf(to, "[OpCode %s (0x%04x) Size=%lu]\n", OpcodeManager::EmuToName(emu_opcode), opcode,(unsigned long)size);
-#endif
-}
-
 uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 {
 	if (opcode>0xff) {
@@ -456,52 +409,6 @@ EQApplicationPacket *EQApplicationPacket::Copy() const {
 	return(new EQApplicationPacket(*this));
 }

-EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
-	res->copyInfo(this);
-	return(res);
-}
-
-EQRawApplicationPacket::EQRawApplicationPacket(uint16 opcode, const unsigned char *buf, const uint32 len)
-:	EQApplicationPacket(OP_Unknown, buf, len),
-	opcode(opcode)
-{
-}
-EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const uint32 len)
-: EQApplicationPacket(OP_Unknown, buf+sizeof(uint16), len-sizeof(uint16))
-{
-	if(GetExecutablePlatform() != ExePlatformUCS) {
-		opcode = *((const uint16 *) buf);
-		if(opcode == 0x0000)
-		{
-			if(len >= 3)
-			{
-				opcode = *((const uint16 *) (buf + 1));
-				const unsigned char *packet_start = (buf + 3);
-				const int32 packet_length = len - 3;
-				safe_delete_array(pBuffer);
-				if(packet_length >= 0)
-				{
-					size = packet_length;
-					pBuffer = new unsigned char[size];
-					memcpy(pBuffer, packet_start, size);
-				}
-				else
-				{
-					size = 0;
-				}
-			}
-			else
-			{
-				safe_delete_array(pBuffer);
-				size = 0;
-			}
-		}
-	} else {
-		opcode = *((const uint8 *) buf);
-	}
-}
-
 void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
 	if (iShowInfo) {
 		std::cout << "Dumping Applayer: 0x" << std::hex << std::setfill('0') << std::setw(4) << app->GetOpcode() << std::dec;
@@ -515,4 +422,4 @@ std::string DumpPacketToString(const EQApplicationPacket* app){
 	std::ostringstream out;
 	out << DumpPacketHexToString(app->pBuffer, app->size);
 	return out.str();
-}
+}
@@ -19,7 +19,6 @@
 #define _EQPACKET_H

 #include "base_packet.h"
-#include "platform.h"
 #include <iostream>

 #ifdef STATIC_OPCODE
@@ -57,8 +56,6 @@ protected:

 };

-class EQRawApplicationPacket;
-
 class EQProtocolPacket : public BasePacket {
 	friend class EQStream;
 	friend class EQStreamPair;
@@ -68,7 +65,6 @@ public:
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
 	EQProtocolPacket *Copy() { return new EQProtocolPacket(opcode,pBuffer,size); }
-	EQRawApplicationPacket *MakeAppPacket() const;

 	bool acked;
 	uint32 sent_time;
@@ -98,15 +94,15 @@ class EQApplicationPacket : public EQPacket {
 	friend class EQStream;
 public:
 	EQApplicationPacket() : EQPacket(OP_Unknown, nullptr, 0), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op) : EQPacket(op, nullptr, 0), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, const uint32 len) : EQPacket(op, nullptr, len), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op, buf, len), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	EQApplicationPacket(const EmuOpcode op, SerializeBuffer &buf) : EQPacket(op, buf), opcode_bypass(0)
-		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+		{ app_opcode_size = 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
 	uint32 Size() const { return size+app_opcode_size; }
@@ -134,25 +130,6 @@ private:

 };

-class EQRawApplicationPacket : public EQApplicationPacket {
-	friend class EQStream;
-public:
-	EQRawApplicationPacket(uint16 opcode, const unsigned char *buf, const uint32 len);
-	uint16 GetRawOpcode() const { return(opcode); }
-
-	virtual void build_raw_header_dump(char *buffer, uint16 seq=0xffff) const;
-	virtual void build_header_dump(char *buffer) const;
-	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
-	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;
-
-protected:
-
-	//the actual raw EQ opcode
-	uint16 opcode;
-
-	EQRawApplicationPacket(const unsigned char *buf, const uint32 len);
-};
-
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
 extern std::string DumpPacketToString(const EQApplicationPacket* app);

@@ -1188,6 +1188,20 @@ 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
@@ -1344,21 +1358,24 @@ struct BecomeCorpse_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ int32		delta_heading:10,	// change in heading
-					x_pos:19,			// x coord
-					padding0002:3;		// ***Placeholder
-/*0006*/ int32		y_pos:19,			// y coord
-					animation:10,		// animation
-					padding0006:3;		// ***Placeholder
-/*0010*/ int32		z_pos:19,			// z coord
-					delta_y:13;			// change in y
-/*0014*/ int32		delta_x:13,			// change in x
-					heading:12,			// heading
-					padding0014:7;		// ***Placeholder
-/*0018*/ int32		delta_z:13,			// change in z
-					padding0018:19;		// ***Placeholder
-/*0022*/
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_z : 13;		// change in z
+			signed		delta_x : 13;		// change in x
+			signed		padding0008 : 6;
+/*0012*/	signed		x_pos : 19;			// x coord
+			unsigned	heading : 12;		// heading
+			signed		padding0016 : 1;
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			signed		z_pos : 19;			// z coord
+			signed		padding0020 : 3;
+/*0020*/	signed		animation : 10;		// animation
+			signed		delta_y : 13;		// change in y
+			signed		padding0024 : 9;
+/*0024*/
 };

 /*
@@ -1369,21 +1386,23 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16	spawn_id;
-/*0002*/ uint16	sequence;			//increments one each packet
-/*0004*/ float	y_pos;				// y coord
-/*0008*/ float	delta_z;			// Change in z
-/*0012*/ float	delta_x;			// Change in x
-/*0016*/ float	delta_y;			// Change in y
-/*0020*/ int32	animation:10,		// animation
-				delta_heading:10,	// change in heading
-				padding0020:12;		// ***Placeholder (mostly 1)
-/*0024*/ float	x_pos;				// x coord
-/*0028*/ float	z_pos;				// z coord
-/*0032*/ uint16	heading:12,			// Directional heading
-				padding0004:4;		// ***Placeholder
-/*0034*/ uint8	unknown0006[2];		// ***Placeholder
-/*0036*/
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_x;			// Change in x
+/*0014*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 20;	// ***Placeholder
+/*0018*/	float		x_pos;				// x coord (2nd loc value)
+/*0022*/	float		delta_z;			// Change in z
+/*0026*/	float		z_pos;				// z coord (3rd loc value)
+/*0030*/	float		y_pos;				// y coord (1st loc value)
+/*0034*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 22;	// animation
+/*0038*/	float		delta_y;			// Change in y
+/*0042*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0041 : 22;	// ***Placeholder
+/*0046*/
 };

 struct SpawnPositionUpdate_Struct
@@ -84,14 +84,14 @@ void EQStream::init(bool resetSession) {

 	OpMgr = nullptr;
 	if(uint16(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);
+		LogNetcode(_L "init Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 }

 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
+	LogNetcode(_L "Creating new application packet, length [{}]" __L, p->size);
 	// _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
 	ap = p->MakeAppPacket();
 	return ap;
@@ -100,7 +100,7 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
+	LogNetcode(_L "Creating new application packet, length [{}]" __L, len);
 	ap = new EQRawApplicationPacket(buf, len);
 	return ap;
 }
@@ -130,7 +130,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 	}

 	if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
-		Log(Logs::Detail, Logs::Netcode, _L "Session not initialized, packet ignored" __L);
+		LogNetcode(_L "Session not initialized, packet ignored" __L);
 		// _raw(NET__DEBUG, 0xFFFF, p);
 		return;
 	}
@@ -141,7 +141,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed < p->size) {
 				subpacket_length=*(p->pBuffer+processed);
 				EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
-				Log(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
+				LogNetcode(_L "Extracting combined packet of length [{}]" __L, subpacket_length);
 				// _raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
 				subp->copyInfo(p);
 				ProcessPacket(subp);
@@ -156,12 +156,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed<p->size) {
 				EQRawApplicationPacket *ap=nullptr;
 				if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
-					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length);
 					processed+=subpacket_length+1;
 				} else {
 					subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1));
-					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					LogNetcode(_L "Extracting combined app packet of length [{}], short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length);
 					processed+=subpacket_length+3;
 				}
@@ -176,29 +176,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Packet: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Packet that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Packet that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-					Log(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+					LogNetcode(_L "Future OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 					// _raw(NET__DEBUG, seq, p);

 					PacketQueue[seq]=p->Copy();
-					Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+					LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());

 				//SendOutOfOrderAck(seq);

 			} else if (check == SeqPast) {
-				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Duplicate OP_Packet: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq); //we already got this packet but it was out of order
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
+					LogNetcode("[NET_TRACE] OP_Packet: Removing older queued packet with sequence [{}]", seq);
 					delete qp;
 				}

@@ -207,7 +207,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				// Check for an embedded OP_AppCombinded (protocol level 0x19)
 				if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 					EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2);
-					Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
+					LogNetcode(_L "seq [{}], Extracting combined packet of length [{}]" __L, seq, subp->size);
 					// _raw(NET__NET_CREATE_HEX, seq, subp);
 					subp->copyInfo(p);
 					ProcessPacket(subp);
@@ -226,29 +226,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Fragment: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Fragment that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Fragment that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-				Log(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Future OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);

 				PacketQueue[seq]=p->Copy();
-				Log(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
+				LogNetcode(_L "OP_Fragment Queue size=[{}]" __L, PacketQueue.size());

 				//SendOutOfOrderAck(seq);

 			} else if (check == SeqPast) {
-				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				LogNetcode(_L "Duplicate OP_Fragment: Expecting Seq=[{}], but got Seq=[{}]" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq);
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
+					LogNetcode("[NET_TRACE] OP_Fragment: Removing older queued packet with sequence [{}]", seq);
 					delete qp;
 				}
 				SetNextAckToSend(seq);
@@ -256,18 +256,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				if (oversize_buffer) {
 					memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2);
 					oversize_offset+=p->size-2;
-					Log(Logs::Detail, Logs::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
+					LogNetcode(_L "Fragment of oversized of length [{}], seq [{}]: now at [{}]/[{}]" __L, p->size-2, seq, oversize_offset, oversize_length);
 					if (oversize_offset==oversize_length) {
 						if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 							EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
-							Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
+							LogNetcode(_L "seq [{}], Extracting combined oversize packet of length [{}]" __L, seq, subp->size);
 							//// _raw(NET__NET_CREATE_HEX, subp);
 							subp->copyInfo(p);
 							ProcessPacket(subp);
 							delete subp;
 						} else {
 							EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
-							Log(Logs::Detail, Logs::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
+							LogNetcode(_L "seq [{}], completed combined oversize packet of length [{}]" __L, seq, ap->size);
 							if (ap) {
 								ap->copyInfo(p);
 								InboundQueuePush(ap);
@@ -282,20 +282,20 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					oversize_buffer=new unsigned char[oversize_length];
 					memcpy(oversize_buffer,p->pBuffer+6,p->size-6);
 					oversize_offset=p->size-6;
-					Log(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
+					LogNetcode(_L "First fragment of oversized of seq [{}]: now at [{}]/[{}]" __L, seq, oversize_offset, oversize_length);
 				}
 			}
 		}
 		break;
 		case OP_KeepAlive: {
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
-			Log(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
+			LogNetcode(_L "Received and queued reply to keep alive" __L);
 		}
 		break;
 		case OP_Ack: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
+				LogNetcode(_L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
@@ -309,11 +309,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionRequest: {
 			if(p->Size() < sizeof(SessionRequest))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
 			if (GetState()==ESTABLISHED) {
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
+				LogNetcode(_L "Received OP_SessionRequest in ESTABLISHED state ([{}]) streamactive ([{}]) attempt ([{}])" __L, GetState(),streamactive,sessionAttempts);

 				// client seems to try a max of 30 times (initial+3 retries) then gives up, giving it a few more attempts just in case
 				// streamactive means we identified the opcode for the stream, we cannot re-establish this connection
@@ -331,7 +331,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SessionRequest *Request=(SessionRequest *)p->pBuffer;
 			Session=ntohl(Request->Session);
 			SetMaxLen(ntohl(Request->MaxLength));
-			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
+			LogNetcode(_L "Received OP_SessionRequest: session [{}], maxlen [{}]" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
 			Key=0x11223344;
 			SendSessionResponse();
@@ -340,7 +340,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionResponse: {
 			if(p->Size() < sizeof(SessionResponse))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionResponse that was of malformed size" __L);
 				break;
 			}

@@ -356,7 +356,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			compressed=(Response->Format&FLAG_COMPRESSED);
 			encoded=(Response->Format&FLAG_ENCODED);

-			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
+			LogNetcode(_L "Received OP_SessionResponse: session [{}], maxlen [{}], key [{}], compressed? [{}], encoded? [{}]" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");

 			// Kinda kludgy, but trie for now
 			if (StreamType==UnknownStream) {
@@ -379,17 +379,17 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			EQStreamState state = GetState();
 			if(state == ESTABLISHED) {
 				//client initiated disconnect?
-				Log(Logs::Detail, Logs::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
+				LogNetcode(_L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect" __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else if(state == CLOSING) {
 				//we were waiting for this anyways, ignore pending messages, send the reply and be closed.
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
+				LogNetcode(_L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though" __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else {
 				//we are expecting this (or have already gotten it, but dont care either way)
-				Log(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
+				LogNetcode(_L "Received expected OP_SessionDisconnect. Moving to closed state" __L);
 				SetState(CLOSED);
 			}
 		}
@@ -397,14 +397,14 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_OutOfOrderAck: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
+				LogNetcode(_L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Pre-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
@@ -414,7 +414,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)

 				uint16 sqsize = SequencedQueue.size();
 				uint16 index = seq - SequencedBase;
-				Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+				LogNetcode(_L "OP_OutOfOrderAck marking packet acked in queue (queue index = [{}], queue size = [{}])" __L, index, sqsize);
 				if (index < sqsize) {
 					SequencedQueue[index]->acked = true;
 					// flag packets for a resend
@@ -423,7 +423,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
 						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
 							(*sitr)->sent_time = 0;
-							Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
+							LogNetcode(_L "OP_OutOfOrderAck Flagging packet [{}] for retransmission" __L, SequencedBase + count);
 						}
 					}
 				}
@@ -432,11 +432,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimer = Timer::GetCurrentTime();
 				}
 			} else {
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
+				LogNetcode(_L "Received OP_OutOfOrderAck for out-of-window [{}]. Window ([{}]->[{}])" __L, seq, SequencedBase, NextOutSeq);
 			}

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Post-OOA Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}

 			MOutboundQueue.unlock();
@@ -445,7 +445,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionStatRequest: {
 			if(p->Size() < sizeof(ClientSessionStats))
 			{
-				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
+				LogNetcode(_L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
 			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
@@ -468,7 +468,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
-					Log(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
+					LogNetcode(_L "Retransmit timeout recalculated to [{}]ms" __L, retransmittimeout);
 				}
 			}

@@ -485,11 +485,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_SessionStatResponse: {
-			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
+			LogNetcode(_L "Received OP_SessionStatResponse. Ignoring" __L);
 		}
 		break;
 		case OP_OutOfSession: {
-			Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
+			LogNetcode(_L "Received OP_OutOfSession. Ignoring" __L);
 		}
 		break;
 		default:
@@ -520,7 +520,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 		return;

 	if(OpMgr == nullptr || *OpMgr == nullptr) {
-		Log(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
+		LogNetcode(_L "Packet enqueued into a stream with no opcode manager, dropping" __L);
 		delete pack;
 		return;
 	}
@@ -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)
-		Log(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
+		LogNetcode(_L "Making oversized packet, len [{}]" __L, p->Size());

 		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
 		if (length != p->Size())
-			Log(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
+			LogNetcode(_L "Packet adjustment, len [{}] to [{}]" __L, p->Size(), length);

 		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
 		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
+		LogNetcode(_L "First fragment: used [{}]/[{}]. Payload size [{}] in the packet" __L, used, length, p->size);
 		SequencedPush(out);


@@ -581,7 +581,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			Log(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
+			LogNetcode(_L "Subsequent fragment: len [{}], used [{}]/[{}]" __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
@@ -623,7 +623,7 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
-	Log(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
+	LogNetcode(_L "Pushing non-sequenced packet of length [{}]" __L, p->size);
 	NonSequencedQueue.push(p);
 	MOutboundQueue.unlock();
 }
@@ -631,14 +631,14 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
 void EQStream::SendAck(uint16 seq)
 {
 uint16 Seq=htons(seq);
-	Log(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
+	LogNetcode(_L "Sending ack with sequence [{}]" __L, seq);
 	SetLastAckSent(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
 }

 void EQStream::SendOutOfOrderAck(uint16 seq)
 {
-	Log(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
+	LogNetcode(_L "Sending out of order ack with sequence [{}]" __L, seq);
 uint16 Seq=htons(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16)));
 }
@@ -688,24 +688,24 @@ void EQStream::Write(int eq_fd)
 				// If we don't have a packet to try to combine into, use this one as the base
 				// And remove it form the queue
 				p = NonSequencedQueue.front();
-				Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
+				LogNetcode(_L "Starting combined packet with non-seq packet of len [{}]" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
 				// Trying to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
-				Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
+				LogNetcode(_L "Combined packet full at len [{}], next non-seq packet is len [{}]" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
 				BytesWritten+=p->size;
 				p=nullptr;

 				if (BytesWritten > threshold) {
 					// Sent enough this round, lets stop to be fair
-					Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
+					LogNetcode(_L "Exceeded write threshold in nonseq ([{}] > [{}])" __L, BytesWritten, threshold);
 					break;
 				}
 			} else {
 				// Combine worked, so just remove this packet and it's spot in the queue
-				Log(Logs::Detail, Logs::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
+				LogNetcode(_L "Combined non-seq packet of len [{}], yeilding [{}] combined" __L, (NonSequencedQueue.front())->size, p->size);
 				delete NonSequencedQueue.front();
 				NonSequencedQueue.pop();
 			}
@@ -718,7 +718,7 @@ void EQStream::Write(int eq_fd)
 			uint16 seq_send = SequencedBase + count;	//just for logging...

 			if(SequencedQueue.empty()) {
-				Log(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
+				LogNetcode(_L "Tried to write a packet with an empty queue ([{}] is past next out [{}])" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
 				continue;
 			}
@@ -728,35 +728,35 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
 					}
-					Log(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
+					LogNetcode(_L "Not retransmitting seq packet [{}] because already marked as acked" __L, seq_send);
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
-					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
+					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send + 1, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					LogNetcode(_L "Combined seq packet [{}] of len [{}], yeilding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -766,7 +766,7 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
@@ -776,25 +776,25 @@ void EQStream::Write(int eq_fd)
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					(*sitr)->sent_time = Timer::GetCurrentTime();
-					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					LogNetcode(_L "Starting combined packet with seq packet [{}] of len [{}]" __L, seq_send, p->size);
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					LogNetcode(_L "Combined packet full at len [{}], next seq packet [{}] is len [{}]" __L, p->size, seq_send, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;

 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						LogNetcode(_L "Exceeded write threshold in seq ([{}] > [{}])" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					LogNetcode(_L "Combined seq packet [{}] of len [{}], yielding [{}] combined" __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -802,7 +802,7 @@ void EQStream::Write(int eq_fd)
 			}

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				LogNetcode(_L "Post send Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 		} else {
 			// No more sequenced packets
@@ -814,7 +814,7 @@ void EQStream::Write(int eq_fd)

 	// We have a packet still, must have run out of both seq and non-seq, so send it
 	if (p) {
-		Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+		LogNetcode(_L "Final combined packet not full, len [{}]" __L, p->size);
 		ReadyToSend.push(p);
 		BytesWritten+=p->size;
 	}
@@ -831,7 +831,7 @@ void EQStream::Write(int eq_fd)
 	if(SeqEmpty && NonSeqEmpty) {
 		//no more data to send
 		if(CheckState(CLOSING)) {
-			Log(Logs::Detail, Logs::Netcode, _L "All outgoing data flushed, closing stream." __L );
+			LogNetcode(_L "All outgoing data flushed, closing stream" __L );
 			//we are waiting for the queues to empty, now we can do our disconnect.
 			//this packet will not actually go out until the next call to Write().
 			_SendDisconnect();
@@ -910,7 +910,7 @@ void EQStream::SendSessionRequest()
 	Request->Session=htonl(time(nullptr));
 	Request->MaxLength=htonl(512);

-	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
+	LogNetcode(_L "Sending OP_SessionRequest: session [{}], maxlen=[{}]" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));

 	NonSequencedPush(out);
 }
@@ -924,7 +924,7 @@ void EQStream::_SendDisconnect()
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);

-	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
+	LogNetcode(_L "Sending OP_SessionDisconnect: session [{}]" __L, (unsigned long)Session);
 }

 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@@ -976,7 +976,7 @@ EQRawApplicationPacket *p=nullptr;
 		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if(emu_op == OP_Unknown) {
-				Log(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
+				LogNetcode("Unable to convert EQ opcode {:#04x} to an Application opcode", p->opcode);
 			}

 			p->SetOpcode(emu_op);
@@ -1004,7 +1004,7 @@ void EQStream::InboundQueueClear()
 {
 EQApplicationPacket *p=nullptr;

-	Log(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
+	LogNetcode(_L "Clearing inbound queue" __L);

 	MInboundQueue.lock();
 	if (!InboundQueue.empty()) {
@@ -1047,7 +1047,7 @@ void EQStream::OutboundQueueClear()
 {
 EQProtocolPacket *p=nullptr;

-	Log(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
+	LogNetcode(_L "Clearing outbound queue" __L);

 	MOutboundQueue.lock();
 	while(!NonSequencedQueue.empty()) {
@@ -1069,7 +1069,7 @@ void EQStream::PacketQueueClear()
 {
 EQProtocolPacket *p=nullptr;

-	Log(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
+	LogNetcode(_L "Clearing future packet queue" __L);

 	if(!PacketQueue.empty()) {
 		std::map<unsigned short,EQProtocolPacket *>::iterator itr;
@@ -1101,7 +1101,7 @@ void EQStream::Process(const unsigned char *buffer, const uint32 length)
 		delete p;
 		ProcessQueue();
 	} else {
-		Log(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
+		LogNetcode(_L "Incoming packet failed checksum" __L);
 	}
 }

@@ -1132,23 +1132,23 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 	SeqOrder ord = CompareSequence(SequencedBase, seq);
 	if(ord == SeqInOrder) {
 		//they are not acking anything new...
-		Log(Logs::Detail, Logs::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
+		LogNetcode(_L "Received an ack with no window advancement (seq [{}])" __L, seq);
 	} else if(ord == SeqPast) {
 		//they are nacking blocks going back before our buffer, wtf?
-		Log(Logs::Detail, Logs::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
+		LogNetcode(_L "Received an ack with backward window advancement (they gave [{}], our window starts at [{}]). This is bad" __L, seq, SequencedBase);
 	} else {
-		Log(Logs::Detail, Logs::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);
+		LogNetcode(_L "Received an ack up through sequence [{}]. Our base is [{}]" __L, seq, SequencedBase);


 		//this is a good ack, we get to ack some blocks.
 		seq++;	//we stop at the block right after their ack, counting on the wrap of both numbers.
 		while(SequencedBase != seq) {
 			if(SequencedQueue.empty()) {
-				Log(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, SequencedQueue.size());
+				LogNetcode(_L "OUT OF PACKETS acked packet with sequence [{}]. Next send is [{}] before this" __L, (unsigned long)SequencedBase, SequencedQueue.size());
 				SequencedBase = NextOutSeq;
 				break;
 			}
-			Log(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
+			LogNetcode(_L "Removing acked packet with sequence [{}]" __L, (unsigned long)SequencedBase);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
@@ -1156,7 +1156,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 			SequencedBase++;
 		}
 		if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-			Log(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
+			LogNetcode(_L "Post-Ack on [{}] Invalid Sequenced queue: BS [{}] + SQ [{}] != NOS [{}]" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
 		}
 	}

@@ -1166,7 +1166,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 void EQStream::SetNextAckToSend(uint32 seq)
 {
 	MAcks.lock();
-	Log(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
+	LogNetcode(_L "Set Next Ack To Send to [{}]" __L, (unsigned long)seq);
 	NextAckToSend=seq;
 	MAcks.unlock();
 }
@@ -1174,7 +1174,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
 void EQStream::SetLastAckSent(uint32 seq)
 {
 	MAcks.lock();
-	Log(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
+	LogNetcode(_L "Set Last Ack Sent to [{}]" __L, (unsigned long)seq);
 	LastAckSent=seq;
 	MAcks.unlock();
 }
@@ -1187,10 +1187,10 @@ void EQStream::ProcessQueue()

 	EQProtocolPacket *qp=nullptr;
 	while((qp=RemoveQueue(NextInSeq))!=nullptr) {
-		Log(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
+		LogNetcode(_L "Processing Queued Packet: Seq=[{}]" __L, NextInSeq);
 		ProcessPacket(qp);
 		delete qp;
-		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
 	}
 }

@@ -1201,21 +1201,21 @@ EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
-		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		LogNetcode(_L "OP_Packet Queue size=[{}]" __L, PacketQueue.size());
 	}
 	return qp;
 }

 void EQStream::SetStreamType(EQStreamType type)
 {
-	Log(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
+	LogNetcode(_L "Changing stream type from [{}] to [{}]" __L, StreamTypeString(StreamType), StreamTypeString(type));
 	StreamType=type;
 	switch (StreamType) {
 		case LoginStream:
 			app_opcode_size=1;
 			compressed=false;
 			encoded=false;
-			Log(Logs::Detail, Logs::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
+			LogNetcode(_L "Login stream has app opcode size [{}], is not compressed or encoded" __L, app_opcode_size);
 			break;
 		case ChatOrMailStream:
 		case ChatStream:
@@ -1223,7 +1223,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=1;
 			compressed=false;
 			encoded=true;
-			Log(Logs::Detail, Logs::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
+			LogNetcode(_L "Chat/Mail stream has app opcode size [{}], is not compressed, and is encoded" __L, app_opcode_size);
 			break;
 		case ZoneStream:
 		case WorldStream:
@@ -1231,7 +1231,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=2;
 			compressed=true;
 			encoded=false;
-			Log(Logs::Detail, Logs::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
+			LogNetcode(_L "World/Zone stream has app opcode size [{}], is compressed, and is not encoded" __L, app_opcode_size);
 			break;
 	}
 }
@@ -1281,7 +1281,7 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)

 void EQStream::SetState(EQStreamState state) {
 	MState.lock();
-	Log(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
+	LogNetcode(_L "Changing state from [{}] to [{}]" __L, State, state);
 	State=state;
 	MState.unlock();
 }
@@ -1293,29 +1293,29 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {

 	EQStreamState orig_state = GetState();
 	if (orig_state == CLOSING && !outgoing_data) {
-		Log(Logs::Detail, Logs::Netcode, _L "Out of data in closing state, disconnecting." __L);
+		LogNetcode(_L "Out of data in closing state, disconnecting" __L);
 		_SendDisconnect();
 		SetState(DISCONNECTING);
 	} else if (LastPacket && (now-LastPacket) > timeout) {
 		switch(orig_state) {
 		case CLOSING:
 			//if we time out in the closing state, they are not acking us, just give up
-			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L);
+			LogNetcode(_L "Timeout expired in closing state. Moving to closed state" __L);
 			_SendDisconnect();
 			SetState(CLOSED);
 			break;
 		case DISCONNECTING:
 			//we timed out waiting for them to send us the disconnect reply, just give up.
-			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
+			LogNetcode(_L "Timeout expired in disconnecting state. Moving to closed state" __L);
 			SetState(CLOSED);
 			break;
 		case CLOSED:
-			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in closed state??" __L);
+			LogNetcode(_L "Timeout expired in closed state??" __L);
 			break;
 		case ESTABLISHED:
 			//we timed out during normal operation. Try to be nice about it.
 			//we will almost certainly time out again waiting for the disconnect reply, but oh well.
-			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in established state. Closing connection." __L);
+			LogNetcode(_L "Timeout expired in established state. Closing connection" __L);
 			_SendDisconnect();
 			SetState(DISCONNECTING);
 			break;
@@ -1342,7 +1342,7 @@ void EQStream::Decay()
 		for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end(); ++sitr, count++) {
 			if (!(*sitr)->acked && (*sitr)->sent_time > 0 && ((*sitr)->sent_time + retransmittimeout) < Timer::GetCurrentTime()) {
 				(*sitr)->sent_time = 0;
-				Log(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
+				LogNetcode(_L "Timeout exceeded for seq [{}].  Flagging packet for retransmission" __L, SequencedBase + count);
 			}
 		}
 		MOutboundQueue.unlock();
@@ -1384,12 +1384,12 @@ void EQStream::AdjustRates(uint32 average_delta)
 void EQStream::Close() {
 	if(HasOutgoingData()) {
 		//there is pending data, wait for it to go out.
-		Log(Logs::Detail, Logs::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
+		LogNetcode(_L "Stream requested to Close(), but there is pending data, waiting for it" __L);
 		SetState(CLOSING);
 	} else {
 		//otherwise, we are done, we can drop immediately.
 		_SendDisconnect();
-		Log(Logs::Detail, Logs::Netcode, _L "Stream closing immediate due to Close()" __L);
+		LogNetcode(_L "Stream closing immediate due to Close()" __L);
 		SetState(DISCONNECTING);
 	}
 }
@@ -1417,19 +1417,19 @@ EQStream::MatchState EQStream::CheckSignature(const Signature *sig) {
 		} else if(p->opcode == sig->first_eq_opcode) {
 			//opcode matches, check length..
 			if(p->size == sig->first_length) {
-				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length matched [{}]", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else if(sig->first_length == 0) {
-				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x} and length ([{}]) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else {
 				//opcode matched but length did not.
-				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
+				LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode matched {:#04x}, but length [{}] did not match expected [{}]", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
 				res = MatchFailed;
 			}
 		} else {
 			//first opcode did not match..
-			Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
+			LogNetcode("[StreamIdentify] [{}]:[{}]: First opcode {:#04x} did not match expected {:#04x}", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
 			res = MatchFailed;
 		}
 	}
@@ -46,7 +46,7 @@ void EQStreamIdentifier::Process() {

 		//first see if this stream has expired
 		if(r.expire.Check(false)) {
-			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before timeout", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
 			r.stream->Close();

 			cur = m_streams.erase(cur);
@@ -62,23 +62,23 @@ void EQStreamIdentifier::Process() {
 		}
 		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			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()));
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}] before it closed", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
+				LogNetcode("[StreamIdentify] Stream state was Established");
 				break;
 			case CLOSING:
-				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
+				LogNetcode("[StreamIdentify] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
+				LogNetcode("[StreamIdentify] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
+				LogNetcode("[StreamIdentify] Stream state was Closed");
 				break;
 			default:
-				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
+				LogNetcode("[StreamIdentify] 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, "[IDENT_TRACE] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+//				Log.LogDebugType(Logs::General, Logs::Netcode, "[StreamIdentify] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				all_ready = false;
 				break;
 			case EQStreamInterface::MatchSuccessful: {
 				//yay, a match.

-				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());
+				LogNetcode("[StreamIdentify] Identified stream [{}:{}] with signature [{}]", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());

 				// before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further
 				r.stream->SetActive(true);
@@ -122,7 +122,7 @@ void EQStreamIdentifier::Process() {
 			}
 			case EQStreamInterface::MatchFailed:
 				//do nothing...
-				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());
+				LogNetcode("[StreamIdentify] [{}:{}] Tried patch [{}] and it did not match", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				break;
 			}
 		}
@@ -130,7 +130,7 @@ void EQStreamIdentifier::Process() {
 		//if we checked all patches and did not find a match.
 		if(all_ready && !found_one) {
 			//the stream cannot be identified.
-			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			LogNetcode("[StreamIdentify] Unable to identify stream from [{}:{}], no match found", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			r.stream->ReleaseFromUse();
 		}

@@ -27,7 +27,6 @@ struct EQStreamManagerInterfaceOptions

 	EQStreamManagerInterfaceOptions(int port, bool encoded, bool compressed) {
 		opcode_size = 2;
-		track_opcode_stats = false;

 		//World seems to support both compression and xor zone supports one or the others.
 		//Enforce one or the other in the convienence construct
@@ -54,8 +53,9 @@ public:
 	EQStreamManagerInterface(const EQStreamManagerInterfaceOptions &options) { m_options = options; }
 	virtual ~EQStreamManagerInterface() { };

+	EQStreamManagerInterfaceOptions GetOptions() { return m_options; }
 	const EQStreamManagerInterfaceOptions& GetOptions() const { return m_options; }
-	EQStreamManagerInterfaceOptions& MutateOptions() { return m_options; }
+	virtual void SetOptions(const EQStreamManagerInterfaceOptions& options) = 0;
 protected:
 	EQStreamManagerInterfaceOptions m_options;
 };
@@ -42,8 +42,8 @@ void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 		return;

 	if (p->GetOpcode() != OP_SpecialMesg) {
-		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());
+		Log(Logs::General, Logs::PacketServerClient, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+		Log(Logs::General, Logs::PacketServerClientWithDump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
 	}

 	EQApplicationPacket *newp = p->Copy();
@@ -26,24 +26,26 @@
 std::string EQEmuConfig::ConfigFile = "eqemu_config.json";
 EQEmuConfig *EQEmuConfig::_config = nullptr;

-void EQEmuConfig::parse_config() {
-	
-	ShortName = _root["server"]["world"].get("shortname", "").asString();
-	LongName = _root["server"]["world"].get("longname", "").asString();
+void EQEmuConfig::parse_config()
+{
+
+	ShortName    = _root["server"]["world"].get("shortname", "").asString();
+	LongName     = _root["server"]["world"].get("longname", "").asString();
 	WorldAddress = _root["server"]["world"].get("address", "").asString();
 	LocalAddress = _root["server"]["world"].get("localaddress", "").asString();
-	MaxClients = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
-	SharedKey = _root["server"]["world"].get("key", "").asString();
-	LoginCount = 0;
+	MaxClients   = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
+	SharedKey    = _root["server"]["world"].get("key", "").asString();
+	LoginCount   = 0;

 	if (_root["server"]["world"]["loginserver"].isObject()) {
-		LoginHost = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
-		LoginPort = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
+		LoginHost   = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
+		LoginPort   = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
 		LoginLegacy = false;
-		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") LoginLegacy = true;
-		LoginAccount = _root["server"]["world"]["loginserver"].get("account", "").asString();
+		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") { LoginLegacy = true; }
+		LoginAccount  = _root["server"]["world"]["loginserver"].get("account", "").asString();
 		LoginPassword = _root["server"]["world"]["loginserver"].get("password", "").asString();
-	} else {
+	}
+	else {
 		char str[32];
 		loginlist.Clear();
 		do {
@@ -53,74 +55,102 @@ void EQEmuConfig::parse_config() {
 			}

 			auto loginconfig = new LoginConfig;
-			loginconfig->LoginHost = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
-			loginconfig->LoginPort = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
-			loginconfig->LoginAccount = _root["server"]["world"][str].get("account", "").asString();
+			loginconfig->LoginHost     = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
+			loginconfig->LoginPort     = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
+			loginconfig->LoginAccount  = _root["server"]["world"][str].get("account", "").asString();
 			loginconfig->LoginPassword = _root["server"]["world"][str].get("password", "").asString();

 			loginconfig->LoginLegacy = false;
-			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") loginconfig->LoginLegacy = true;
+			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") { loginconfig->LoginLegacy = true; }
 			loginlist.Insert(loginconfig);
 		} while (LoginCount < 100);
 	}
-	
-	
+
+
 	//<locked> from xml converts to json as locked: "", so i default to "false". 
 	//The only way to enable locked is by switching to true, meaning this value is always false until manually set true
 	Locked = false;
-	if (_root["server"]["world"].get("locked", "false").asString() == "true") Locked = true;
-	WorldIP = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
+	if (_root["server"]["world"].get("locked", "false").asString() == "true") { Locked = true; }
+	WorldIP      = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
 	WorldTCPPort = atoi(_root["server"]["world"]["tcp"].get("port", "9000").asString().c_str());
-	
-	TelnetIP = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
+
+	TelnetIP      = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
 	TelnetTCPPort = atoi(_root["server"]["world"]["telnet"].get("port", "9001").asString().c_str());
 	TelnetEnabled = false;
-	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") TelnetEnabled = true;
+	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") { TelnetEnabled = true; }

 	WorldHTTPMimeFile = _root["server"]["world"]["http"].get("mimefile", "mime.types").asString();
-	WorldHTTPPort = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
-	WorldHTTPEnabled = false;
-	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") WorldHTTPEnabled = true;
+	WorldHTTPPort     = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
+	WorldHTTPEnabled  = false;

+	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") {
+		WorldHTTPEnabled = true;
+	}
+
+	/**
+	 * UCS
+	 */
 	ChatHost = _root["server"]["chatserver"].get("host", "eqchat.eqemulator.net").asString();
 	ChatPort = atoi(_root["server"]["chatserver"].get("port", "7778").asString().c_str());
-
 	MailHost = _root["server"]["mailserver"].get("host", "eqmail.eqemulator.net").asString();
 	MailPort = atoi(_root["server"]["mailserver"].get("port", "7778").asString().c_str());

+	/**
+	 * Database
+	 */
 	DatabaseUsername = _root["server"]["database"].get("username", "eq").asString();
 	DatabasePassword = _root["server"]["database"].get("password", "eq").asString();
-	DatabaseHost = _root["server"]["database"].get("host", "localhost").asString();
-	DatabasePort = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
-	DatabaseDB = _root["server"]["database"].get("db", "eq").asString();	
+	DatabaseHost     = _root["server"]["database"].get("host", "localhost").asString();
+	DatabasePort     = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
+	DatabaseDB       = _root["server"]["database"].get("db", "eq").asString();

-	QSDatabaseHost = _root["server"]["qsdatabase"].get("host", "localhost").asString();
-	QSDatabasePort = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
+	/**
+	 * QS
+	 */
+	QSDatabaseHost     = _root["server"]["qsdatabase"].get("host", "localhost").asString();
+	QSDatabasePort     = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
 	QSDatabaseUsername = _root["server"]["qsdatabase"].get("username", "eq").asString();
 	QSDatabasePassword = _root["server"]["qsdatabase"].get("password", "eq").asString();
-	QSDatabaseDB = _root["server"]["qsdatabase"].get("db", "eq").asString();
+	QSDatabaseDB       = _root["server"]["qsdatabase"].get("db", "eq").asString();

+	/**
+	 * Zones
+	 */
 	DefaultStatus = atoi(_root["server"]["zones"].get("defaultstatus", 0).asString().c_str());
-	ZonePortLow = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
-	ZonePortHigh = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());
+	ZonePortLow   = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
+	ZonePortHigh  = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());

-	SpellsFile = _root["server"]["files"].get("spells", "spells_us.txt").asString();
-	OpCodesFile = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
-	PluginPlFile = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();
+	/**
+	 * Files
+	 */
+	SpellsFile      = _root["server"]["files"].get("spells", "spells_us.txt").asString();
+	OpCodesFile     = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
+	MailOpCodesFile = _root["server"]["files"].get("mail_opcodes", "mail_opcodes.conf").asString();
+	PluginPlFile    = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();

-	MapDir = _root["server"]["directories"].get("maps", "Maps/").asString();
-	QuestDir = _root["server"]["directories"].get("quests", "quests/").asString();
-	PluginDir = _root["server"]["directories"].get("plugins", "plugins/").asString();
+	/**
+	 * Directories
+	 */
+	MapDir       = _root["server"]["directories"].get("maps", "Maps/").asString();
+	QuestDir     = _root["server"]["directories"].get("quests", "quests/").asString();
+	PluginDir    = _root["server"]["directories"].get("plugins", "plugins/").asString();
 	LuaModuleDir = _root["server"]["directories"].get("lua_modules", "lua_modules/").asString();
-	PatchDir = _root["server"]["directories"].get("patches", "./").asString();
+	PatchDir     = _root["server"]["directories"].get("patches", "./").asString();
 	SharedMemDir = _root["server"]["directories"].get("shared_memory", "shared/").asString();
-	LogDir = _root["server"]["directories"].get("logs", "logs/").asString();
+	LogDir       = _root["server"]["directories"].get("logs", "logs/").asString();

+	/**
+	 * Logs
+	 */
 	LogPrefix = _root["server"]["launcher"].get("logprefix", "logs/zone-").asString();
 	LogSuffix = _root["server"]["launcher"].get("logsuffix", ".log").asString();
-	RestartWait = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
-	TerminateWait = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
-	InitialBootWait = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
+
+	/**
+	 * Launcher
+	 */
+	RestartWait      = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
+	TerminateWait    = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
+	InitialBootWait  = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
 	ZoneBootInterval = atoi(_root["server"]["launcher"]["timers"].get("interval", "2000").asString().c_str());
 #ifdef WIN32
 	ZoneExe = _root["server"]["launcher"].get("exe", "zone.exe").asString();
@@ -230,6 +260,9 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "OpCodesFile") {
 		return (OpCodesFile);
 	}
+	if (var_name == "MailOpCodesFile") {
+		return (MailOpCodesFile);
+	}
 	if (var_name == "PluginPlFile") {
 		return (PluginPlFile);
 	}
@@ -312,6 +345,7 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
+	std::cout << "MailOpcodesFile = " << MailOpCodesFile << std::endl;
 	std::cout << "PluginPlFile = " << PluginPlFile << std::endl;
 	std::cout << "MapDir = " << MapDir << std::endl;
 	std::cout << "QuestDir = " << QuestDir << std::endl;
@@ -322,6 +356,6 @@ void EQEmuConfig::Dump() const
 	std::cout << "LogDir = " << LogDir << std::endl;
 	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
 	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
-	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
+	std::cout << "DefaultStatus = " << (int) DefaultStatus << std::endl;
 //	std::cout << "DynamicCount = " << DynamicCount << std::endl;
 }
@@ -84,6 +84,7 @@ class EQEmuConfig
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;
+		std::string MailOpCodesFile;
 		std::string PluginPlFile;

 		// From <directories/>
@@ -19,7 +19,7 @@
 */

 #include "eqemu_logsys.h"
-#include "platform.h"
+#include "rulesys.h"
 #include "string_util.h"
 #include "database.h"
 #include "misc.h"
@@ -81,38 +81,22 @@ 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 &) {};
-	bool file_logs_enabled = false;
-	int  log_platform      = 0;
+	on_log_gmsay_hook   = [](uint16 log_type, const std::string &) {};
+	on_log_console_hook = [](uint16 debug_level, uint16 log_type, const std::string &) {};
 }

 /**
 * EQEmuLogSys Deconstructor
 */
-EQEmuLogSys::~EQEmuLogSys()
-{
-}
+EQEmuLogSys::~EQEmuLogSys() = default;

-void EQEmuLogSys::LoadLogSettingsDefaults()
+void EQEmuLogSys::LoadLogSettingsDefaults(const std::string& platform)
 {
-	/**
-	 * 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;
@@ -125,15 +109,26 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	/**
 	 * Set Defaults
 	 */
-	log_settings[Logs::World_Server].log_to_console    = Logs::General;
-	log_settings[Logs::Zone_Server].log_to_console     = Logs::General;
-	log_settings[Logs::QS_Server].log_to_console       = Logs::General;
-	log_settings[Logs::UCS_Server].log_to_console      = Logs::General;
-	log_settings[Logs::Crash].log_to_console           = Logs::General;
-	log_settings[Logs::MySQLError].log_to_console      = Logs::General;
-	log_settings[Logs::Login_Server].log_to_console    = Logs::General;
-	log_settings[Logs::Headless_Client].log_to_console = Logs::General;
-	log_settings[Logs::NPCScaling].log_to_gmsay        = Logs::General;
+	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);
+
+	/**
+	 * RFC 5424
+	 */
+	log_settings[Logs::Emergency].log_to_console = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Alert].log_to_console     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Critical].log_to_console  = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Error].log_to_console     = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Warning].log_to_console   = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Notice].log_to_console    = static_cast<uint8>(Logs::General);
+	log_settings[Logs::Info].log_to_console      = static_cast<uint8>(Logs::General);

 	/**
 	 * Set Category enabled status on defaults
@@ -148,30 +143,25 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		}
 	}

-	/**
-	 * Declare process file names for log writing=
-	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld) {
-		platform_file_name = "world";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ) {
-		platform_file_name = "query_server";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
-		platform_file_name = "zone";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS) {
-		platform_file_name = "ucs";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin) {
-		platform_file_name = "login";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch) {
-		platform_file_name = "launcher";
-	}
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC) {
-		platform_file_name = "hc";
-	}
+	platform_file_name = platform;
+}
+
+/**
+ * @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
+	);
 }

 /**
@@ -179,15 +169,18 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 * @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 ret;
-	ret.push_back('[');
-	ret.append(Logs::LogCategoryName[log_category]);
-	ret.push_back(']');
-	ret.push_back(' ');
-	ret.append(in_message);
-	return ret;
+	std::string return_string;
+
+	if (IsRfc5424LogCategory(log_category)) {
+		return_string = "[" + platform_file_name + "] ";
+	}
+
+	return return_string + "[" + Logs::LogCategoryName[log_category] + "] " + in_message;
 }

 /**
@@ -195,7 +188,11 @@ std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::
 * @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
@@ -207,7 +204,7 @@ void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const st
 	/**
 	 * Check to see if the process that actually ran this is zone
 	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+	if (on_log_gmsay_hook) {
 		on_log_gmsay_hook(log_category, message);
 	}
 }
@@ -217,7 +214,11 @@ void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const st
 * @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];
@@ -279,6 +280,8 @@ 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:
@@ -305,22 +308,22 @@ uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category)
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
-			return GameChatColor::yellow;
+			return Chat::Yellow;
 		case Logs::MySQLError:
 		case Logs::Error:
-			return GameChatColor::red;
+			return Chat::Red;
 		case Logs::MySQLQuery:
 		case Logs::Debug:
-			return GameChatColor::light_green;
+			return Chat::Lime;
 		case Logs::Quests:
-			return GameChatColor::light_cyan;
+			return Chat::Group;
 		case Logs::Commands:
 		case Logs::Mercenaries:
-			return GameChatColor::light_purple;
+			return Chat::Magenta;
 		case Logs::Crash:
-			return GameChatColor::red;
+			return Chat::Red;
 		default:
-			return GameChatColor::yellow;
+			return Chat::Yellow;
 	}
 }

@@ -346,6 +349,44 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 #else
 	std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
 #endif
+
+	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;
 }

 /**
@@ -356,7 +397,15 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 * @param message
 * @param ...
 */
-void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
+void EQEmuLogSys::Out(
+	Logs::DebugLevel debug_level,
+	uint16 log_category,
+	const char *file,
+	const char *func,
+	int line,
+	const char *message,
+	...
+)
 {
 	bool log_to_console = true;
 	if (log_settings[log_category].log_to_console < debug_level) {
@@ -378,12 +427,18 @@ void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::st
 		return;
 	}

+	std::string prefix;
+
+	if (RuleB(Logging, PrintFileFunctionAndLine)) {
+		prefix = fmt::format("[{0}::{1}:{2}] ", base_file_name(file), func, line);
+	}
+
 	va_list args;
 	va_start(args, message);
-	std::string output_message = vStringFormat(message.c_str(), args);
+	std::string output_message = vStringFormat(message, args);
 	va_end(args);

-	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, output_message);
+	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, prefix + output_message);

 	if (log_to_console) {
 		EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
@@ -419,7 +474,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;
 	}
@@ -451,7 +506,7 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 	/**
 	 * Zone
 	 */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+	if (platform_file_name == "zone") {
 		if (!log_name.empty()) {
 			platform_file_name = log_name;
 		}
@@ -460,12 +515,7 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 			return;
 		}

-		EQEmuLogSys::Out(
-			Logs::General,
-			Logs::Status,
-			"Starting File Log 'logs/%s_%i.log'",
-			platform_file_name.c_str(),
-			getpid());
+		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());

 		/**
 		 * Make directory if not exists
@@ -485,17 +535,11 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 		/**
 		 * All other processes
 		 */
-
 		if (platform_file_name.empty()) {
 			return;
 		}

-		EQEmuLogSys::Out(
-			Logs::General,
-			Logs::Status,
-			"Starting File Log 'logs/%s_%i.log'",
-			platform_file_name.c_str(),
-			getpid());
+		LogInfo("Starting File Log [logs/{}_{}.log]", platform_file_name.c_str(), getpid());

 		/**
 		 * Open file pointer
@@ -505,4 +549,26 @@ void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 			std::ios_base::app | std::ios_base::out
 		);
 	}
-}
+}
+
+/**
+ * Silence console logging
+ */
+void EQEmuLogSys::SilenceConsoleLogging()
+{
+	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
+		log_settings[log_index].log_to_console      = 0;
+		log_settings[log_index].is_category_enabled = 0;
+	}
+}
+
+/**
+ * Enables console logging
+ */
+void EQEmuLogSys::EnableConsoleLogging()
+{
+	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
+		log_settings[log_index].log_to_console      = Logs::General;
+		log_settings[log_index].is_category_enabled = 1;
+	}
+}
@@ -25,6 +25,14 @@
 #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 {
@@ -45,7 +53,7 @@ namespace Logs {
 		AI,
 		Aggro,
 		Attack,
-		Client_Server_Packet,
+		PacketClientServer,
 		Combat,
 		Commands,
 		Crash,
@@ -59,40 +67,52 @@ namespace Logs {
 		Normal,
 		Object,
 		Pathing,
-		QS_Server,
+		QSServer,
 		Quests,
 		Rules,
 		Skills,
 		Spawns,
 		Spells,
 		Status,
-		TCP_Connection,
+		TCPConnection,
 		Tasks,
 		Tradeskills,
 		Trading,
 		Tribute,
-		UCS_Server,
-		WebInterface_Server,
-		World_Server,
-		Zone_Server,
+		UCSServer,
+		WebInterfaceServer,
+		WorldServer,
+		ZoneServer,
 		MySQLError,
 		MySQLQuery,
 		Mercenaries,
 		QuestDebug,
-		Server_Client_Packet,
-		Client_Server_Packet_Unhandled,
-		Server_Client_Packet_With_Dump,
-		Client_Server_Packet_With_Dump,
-		Login_Server,
-		Client_Login,
-		Headless_Client,
-		HP_Update,
+		PacketServerClient,
+		PacketClientServerUnhandled,
+		PacketServerClientWithDump,
+		PacketClientServerWithDump,
+		Loginserver,
+		ClientLogin,
+		HeadlessClient,
+		HPUpdate,
 		FixZ,
 		Food,
 		Traps,
 		NPCRoamBox,
 		NPCScaling,
 		MobAppearance,
+		Info,
+		Warning,
+		Critical,
+		Emergency,
+		Alert,
+		Notice,
+		AIScanClose,
+		AIYellForHelp,
+		AICastBeneficialClose,
+		AoeCast,
+		EntityManagement,
+		Flee,
 		MaxCategoryID /* Don't Remove this */
 	};

@@ -152,31 +172,43 @@ namespace Logs {
 		"Traps",
 		"NPC Roam Box",
 		"NPC Scaling",
-		"Mob Appearance"
+		"Mob Appearance",
+		"Info",
+		"Warning",
+		"Critical",
+		"Emergency",
+		"Alert",
+		"Notice",
+		"AI Scan Close",
+		"AI Yell For Help",
+		"AI Cast Beneficial Close",
+		"AOE Cast",
+		"Entity Management",
+		"Flee",
 	};
 }

-#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)
+#include "eqemu_logsys_log_aliases.h"

 class EQEmuLogSys {
 public:
-	EQEmuLogSys();
 	~EQEmuLogSys();

+	static EQEmuLogSys* Get() {
+		static EQEmuLogSys inst;
+		return &inst;
+	}
+
 	/**
 	 * Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else.
 	 * This should be handled on deconstructor but to be safe we use it anyways.
 	 */
 	void CloseFileLogs();
-	void LoadLogSettingsDefaults();
+	void LoadLogSettingsDefaults(const std::string &platform);
+
+	/**
+	 * @param directory_name
+	 */
 	void MakeDirectory(const std::string &directory_name);

 	/**
@@ -188,12 +220,25 @@ 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, std::string message, ...);
+	void Out(
+		Logs::DebugLevel debug_level,
+		uint16 log_category,
+		const char *file,
+		const char *func,
+		int line,
+		const char *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 = "");

 	/**
@@ -218,14 +263,9 @@ 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;
-
-	/**
-	 * Sets Executable platform (Zone/World/UCS) etc.
-	 */
-	int log_platform;
+	bool file_logs_enabled = false;

 	/**
 	 * File name used in writing logs
@@ -240,14 +280,36 @@ public:
 	 */
 	uint16 GetGMSayColorFromCategory(uint16 log_category);

-	void OnLogHookCallBackZone(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+	/**
+	 * @param f
+	 */
+	void SetGMSayHandler(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+
+	/**
+	 * @param f
+	 */
+	void SetConsoleHandler(std::function<void(uint16 debug_level, uint16 log_type, const std::string&)> f) { on_log_console_hook = f; }
+
+	/**
+	 * Silence console logging
+	 */
+	void SilenceConsoleLogging();
+
+	/**
+	 * Turn on all console logging
+	 */
+	void EnableConsoleLogging();

 private:
+	EQEmuLogSys();
+	EQEmuLogSys(const EQEmuLogSys&);
+	EQEmuLogSys& operator=(const EQEmuLogSys&);

 	/**
 	 * Callback pointer to zone process for hooking logs to zone using GMSay
 	 */
 	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook;
+	std::function<void(uint16 debug_level, uint16 log_category, const std::string&)> on_log_console_hook;

 	/**
 	 * Formats log messages like '[Category] This is a log message'
@@ -256,6 +318,7 @@ private:

 	/**
 	 * Linux console color messages mapped by category
+	 *
 	 * @param log_category
 	 * @return
 	 */
@@ -266,11 +329,55 @@ 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
@@ -0,0 +1,852 @@
+/**
+ * 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_LOGSYS_LOG_ALIASES_H
+#define EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H
+
+#ifdef BUILD_LOGGING
+
+/**
+ * RFC 5424
+ */
+
+#define LogEmergency(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Emergency].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Emergency, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAlert(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Alert].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Alert, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCritical(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Critical].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Critical, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogError(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Error].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Error, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogWarning(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Warning].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Warning, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNotice(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Notice].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Notice, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogInfo(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Info].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Info, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogDebug(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Debug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Debug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+/**
+ * Category
+ */
+
+#define LogAA(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAADetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AA].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AA, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAI(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AI].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AI, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAggro(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAggroDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Aggro].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Aggro, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAttack(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAttackDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Attack].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Attack, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogPacketClientServer(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogPacketClientServerDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::PacketClientServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::PacketClientServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCombat(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCombatDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Combat].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Combat, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCommands(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCommandsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Commands].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Commands, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCrash(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogCrashDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Crash].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Crash, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogDoors(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogDoorsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Doors].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Doors, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogGuilds(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogGuildsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Guilds].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Guilds, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogInventory(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogInventoryDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Inventory].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Inventory, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogLauncher(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogLauncherDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Launcher].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Launcher, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNetcode(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNetcodeDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Netcode].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Netcode, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNormal(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNormalDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Normal].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Normal, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogObject(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogObjectDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Object].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Object, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogPathing(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogPathingDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Pathing].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Pathing, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQSServer(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQSServerDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QSServer].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::QSServer, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQuests(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQuestsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Quests].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Quests, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogRules(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogRulesDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Rules].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Rules, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSkills(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSkillsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Skills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Skills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSpawns(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSpawnsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spawns].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Spawns, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSpells(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogSpellsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Spells].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Spells, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTCPConnection(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTCPConnectionDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::TCPConnection].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::TCPConnection, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTasks(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTasksDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tasks].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tasks, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTradeskills(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTradeskillsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tradeskills].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tradeskills, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTrading(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTradingDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Trading].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Trading, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTribute(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTributeDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Tribute].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Tribute, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMySQLError(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMySQLErrorDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLError].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MySQLError, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMySQLQuery(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMySQLQueryDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MySQLQuery].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MySQLQuery, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMercenaries(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMercenariesDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Mercenaries].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Mercenaries, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQuestDebug(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogQuestDebugDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::QuestDebug].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::QuestDebug, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogLoginserver(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogLoginserverDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Loginserver].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Loginserver, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogClientLogin(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogClientLoginDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::ClientLogin].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::ClientLogin, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHeadlessClient(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHeadlessClientDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HeadlessClient].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::HeadlessClient, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHPUpdate(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogHPUpdateDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::HPUpdate].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::HPUpdate, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFixZ(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFixZDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::FixZ].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::FixZ, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFood(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFoodDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Food].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Food, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTraps(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogTrapsDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Traps].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Traps, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNPCRoamBox(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNPCRoamBoxDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCRoamBox].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::NPCRoamBox, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNPCScaling(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogNPCScalingDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::NPCScaling].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::NPCScaling, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMobAppearance(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogMobAppearanceDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::MobAppearance].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::MobAppearance, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogStatus(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogStatusDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Status].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Status, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIScanClose(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIScanCloseDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIScanClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AIScanClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIYellForHelp(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAIYellForHelpDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AIYellForHelp].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AIYellForHelp, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAICastBeneficialClose(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAICastBeneficialCloseDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AICastBeneficialClose].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AICastBeneficialClose, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAoeCast(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogAoeCastDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::AoeCast].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::AoeCast, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogEntityManagement(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogEntityManagementDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::EntityManagement].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::EntityManagement, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFlee(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::General, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogFleeDetail(message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[Logs::Flee].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), Logs::Detail, Logs::Flee, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define Log(debug_level, log_category, message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
+        EQEmuLogSys::Get()->Out(debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#define LogF(debug_level, log_category, message, ...) do {\
+    if (EQEmuLogSys::Get()->log_settings[log_category].is_category_enabled == 1)\
+        OutF(EQEmuLogSys::Get(), debug_level, log_category, __FILE__, __func__, __LINE__, message, ##__VA_ARGS__);\
+} while (0)
+
+#else
+#define LogEmergency(message, ...) do {\
+} while (0)
+
+#define LogAlert(message, ...) do {\
+} while (0)
+
+#define LogCritical(message, ...) do {\
+} while (0)
+
+#define LogError(message, ...) do {\
+} while (0)
+
+#define LogWarning(message, ...) do {\
+} while (0)
+
+#define LogNotice(message, ...) do {\
+} while (0)
+
+#define LogInfo(message, ...) do {\
+} while (0)
+
+#define LogDebug(message, ...) do {\
+} while (0)
+
+/**
+ * Category
+ */
+
+#define LogAA(message, ...) do {\
+} while (0)
+
+#define LogAADetail(message, ...) do {\
+} while (0)
+
+#define LogAI(message, ...) do {\
+} while (0)
+
+#define LogAIDetail(message, ...) do {\
+} while (0)
+
+#define LogAggro(message, ...) do {\
+} while (0)
+
+#define LogAggroDetail(message, ...) do {\
+} while (0)
+
+#define LogAttack(message, ...) do {\
+} while (0)
+
+#define LogAttackDetail(message, ...) do {\
+} while (0)
+
+#define LogPacketClientServer(message, ...) do {\
+} while (0)
+
+#define LogPacketClientServerDetail(message, ...) do {\
+} while (0)
+
+#define LogCombat(message, ...) do {\
+} while (0)
+
+#define LogCombatDetail(message, ...) do {\
+} while (0)
+
+#define LogCommands(message, ...) do {\
+} while (0)
+
+#define LogCommandsDetail(message, ...) do {\
+} while (0)
+
+#define LogCrash(message, ...) do {\
+} while (0)
+
+#define LogCrashDetail(message, ...) do {\
+} while (0)
+
+#define LogDoors(message, ...) do {\
+} while (0)
+
+#define LogDoorsDetail(message, ...) do {\
+} while (0)
+
+#define LogGuilds(message, ...) do {\
+} while (0)
+
+#define LogGuildsDetail(message, ...) do {\
+} while (0)
+
+#define LogInventory(message, ...) do {\
+} while (0)
+
+#define LogInventoryDetail(message, ...) do {\
+} while (0)
+
+#define LogLauncher(message, ...) do {\
+} while (0)
+
+#define LogLauncherDetail(message, ...) do {\
+} while (0)
+
+#define LogNetcode(message, ...) do {\
+} while (0)
+
+#define LogNetcodeDetail(message, ...) do {\
+} while (0)
+
+#define LogNormal(message, ...) do {\
+} while (0)
+
+#define LogNormalDetail(message, ...) do {\
+} while (0)
+
+#define LogObject(message, ...) do {\
+} while (0)
+
+#define LogObjectDetail(message, ...) do {\
+} while (0)
+
+#define LogPathing(message, ...) do {\
+} while (0)
+
+#define LogPathingDetail(message, ...) do {\
+} while (0)
+
+#define LogQSServer(message, ...) do {\
+} while (0)
+
+#define LogQSServerDetail(message, ...) do {\
+} while (0)
+
+#define LogQuests(message, ...) do {\
+} while (0)
+
+#define LogQuestsDetail(message, ...) do {\
+} while (0)
+
+#define LogRules(message, ...) do {\
+} while (0)
+
+#define LogRulesDetail(message, ...) do {\
+} while (0)
+
+#define LogSkills(message, ...) do {\
+} while (0)
+
+#define LogSkillsDetail(message, ...) do {\
+} while (0)
+
+#define LogSpawns(message, ...) do {\
+} while (0)
+
+#define LogSpawnsDetail(message, ...) do {\
+} while (0)
+
+#define LogSpells(message, ...) do {\
+} while (0)
+
+#define LogSpellsDetail(message, ...) do {\
+} while (0)
+
+#define LogTCPConnection(message, ...) do {\
+} while (0)
+
+#define LogTCPConnectionDetail(message, ...) do {\
+} while (0)
+
+#define LogTasks(message, ...) do {\
+} while (0)
+
+#define LogTasksDetail(message, ...) do {\
+} while (0)
+
+#define LogTradeskills(message, ...) do {\
+} while (0)
+
+#define LogTradeskillsDetail(message, ...) do {\
+} while (0)
+
+#define LogTrading(message, ...) do {\
+} while (0)
+
+#define LogTradingDetail(message, ...) do {\
+} while (0)
+
+#define LogTribute(message, ...) do {\
+} while (0)
+
+#define LogTributeDetail(message, ...) do {\
+} while (0)
+
+#define LogMySQLError(message, ...) do {\
+} while (0)
+
+#define LogMySQLErrorDetail(message, ...) do {\
+} while (0)
+
+#define LogMySQLQuery(message, ...) do {\
+} while (0)
+
+#define LogMySQLQueryDetail(message, ...) do {\
+} while (0)
+
+#define LogMercenaries(message, ...) do {\
+} while (0)
+
+#define LogMercenariesDetail(message, ...) do {\
+} while (0)
+
+#define LogQuestDebug(message, ...) do {\
+} while (0)
+
+#define LogQuestDebugDetail(message, ...) do {\
+} while (0)
+
+#define LogLoginserver(message, ...) do {\
+} while (0)
+
+#define LogLoginserverDetail(message, ...) do {\
+} while (0)
+
+#define LogClientLogin(message, ...) do {\
+} while (0)
+
+#define LogClientLoginDetail(message, ...) do {\
+} while (0)
+
+#define LogHeadlessClient(message, ...) do {\
+} while (0)
+
+#define LogHeadlessClientDetail(message, ...) do {\
+} while (0)
+
+#define LogHPUpdate(message, ...) do {\
+} while (0)
+
+#define LogHPUpdateDetail(message, ...) do {\
+} while (0)
+
+#define LogFixZ(message, ...) do {\
+} while (0)
+
+#define LogFixZDetail(message, ...) do {\
+} while (0)
+
+#define LogFood(message, ...) do {\
+} while (0)
+
+#define LogFoodDetail(message, ...) do {\
+} while (0)
+
+#define LogTraps(message, ...) do {\
+} while (0)
+
+#define LogTrapsDetail(message, ...) do {\
+} while (0)
+
+#define LogNPCRoamBox(message, ...) do {\
+} while (0)
+
+#define LogNPCRoamBoxDetail(message, ...) do {\
+} while (0)
+
+#define LogNPCScaling(message, ...) do {\
+} while (0)
+
+#define LogNPCScalingDetail(message, ...) do {\
+} while (0)
+
+#define LogMobAppearance(message, ...) do {\
+} while (0)
+
+#define LogMobAppearanceDetail(message, ...) do {\
+} while (0)
+
+#define LogStatus(message, ...) do {\
+} while (0)
+
+#define LogStatusDetail(message, ...) do {\
+} while (0)
+
+#define Log(debug_level, log_category, message, ...) do {\
+} while (0)
+
+#define LogF(debug_level, log_category, message, ...) do {\
+} while (0)
+#endif
+
+#endif //EQEMU_EQEMU_LOGSYS_LOG_ALIASES_H
@@ -21,6 +21,10 @@ namespace EQ
 			uv_run(&m_loop, UV_RUN_NOWAIT);
 		}

+		void Run() {
+			uv_run(&m_loop, UV_RUN_DEFAULT);
+		}
+
 		uv_loop_t* Handle() { return &m_loop; }

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

 #include "faction.h"
 #include "races.h"
+#include "rulesys.h"

 const char *FactionValueToString(FACTION_VALUE fv)
 {
@@ -59,34 +60,31 @@ FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 	if (fm) {
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
 	}
-	if (character_value >= 1100) {
+	if (character_value >= RuleI(Faction, AllyFactionMinimum)) {
 		return FACTION_ALLY;
 	}
-	if (character_value >= 750 && character_value <= 1099) {
+	if (character_value >= RuleI(Faction, WarmlyFactionMinimum)) {
 		return FACTION_WARMLY;
 	}
-	if (character_value >= 500 && character_value <= 749) {
+	if (character_value >= RuleI(Faction, KindlyFactionMinimum)) {
 		return FACTION_KINDLY;
 	}
-	if (character_value >= 100 && character_value <= 499) {
+	if (character_value >= RuleI(Faction, AmiablyFactionMinimum)) {
 		return FACTION_AMIABLE;
 	}
-	if (character_value >= 0 && character_value <= 99) {
+	if (character_value >= RuleI(Faction, IndifferentlyFactionMinimum)) {
 		return FACTION_INDIFFERENT;
 	}
-	if (character_value >= -100 && character_value <= -1) {
+	if (character_value >= RuleI(Faction, ApprehensivelyFactionMinimum)) {
 		return FACTION_APPREHENSIVE;
 	}
-	if (character_value >= -500 && character_value <= -101) {
+	if (character_value >= RuleI(Faction, DubiouslyFactionMinimum)) {
 		return FACTION_DUBIOUS;
 	}
-	if (character_value >= -750 && character_value <= -501) {
+	if (character_value >= RuleI(Faction, ThreateninglyFactionMinimum)) {
 		return FACTION_THREATENLY;
 	}
-	if (character_value <= -751) {
-		return FACTION_SCOWLS;
-	}
-	return FACTION_INDIFFERENT;
+	return FACTION_SCOWLS;
 }

 // this function should check if some races have more than one race define
@@ -46,7 +46,7 @@ bool BaseGuildManager::LoadGuilds() {
 	ClearGuilds();

 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to load guilds when we have no database object.");
+		LogGuilds("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) {
-			Log(Logs::Detail, Logs::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
+			LogGuilds("Found invalid (too high) rank [{}] for guild [{}], skipping", rankn, guild_id);
 			continue;
 		}

 		res = m_guilds.find(guild_id);
 		if(res == m_guilds.end()) {
-			Log(Logs::Detail, Logs::Guilds, "Found rank %d for non-existent guild %d, skipping.", rankn, guild_id);
+			LogGuilds("Found rank [{}] for non-existent guild [{}], skipping", rankn, guild_id);
 			continue;
 		}

@@ -105,7 +105,7 @@ bool BaseGuildManager::LoadGuilds() {

 bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to refresh guild [{}] when we have no database object", guild_id);
 		return(false);
 	}

@@ -123,7 +123,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {

 	if (results.RowCount() == 0)
 	{
-		Log(Logs::Detail, Logs::Guilds, "Unable to find guild %d in the database.", guild_id);
+		LogGuilds("Unable to find guild [{}] 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) {
-			Log(Logs::Detail, Logs::Guilds, "Found invalid (too high) rank %d for guild %d, skipping.", rankn, guild_id);
+			LogGuilds("Found invalid (too high) rank [{}] for guild [{}], 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;
 	}

-	Log(Logs::Detail, Logs::Guilds, "Successfully refreshed guild %d from the database.", guild_id);
+	LogGuilds("Successfully refreshed guild [{}] 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) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to store guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to store guild [{}] 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()) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to store non-existent guild %d", guild_id);
+		LogGuilds("Requested to store non-existent guild [{}]", guild_id);
 		return(false);
 	}
 	GuildInfo *info = res->second;
@@ -289,14 +289,14 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 		safe_delete_array(title_esc);
 	}

-	Log(Logs::Detail, Logs::Guilds, "Stored guild %d in the database", guild_id);
+	LogGuilds("Stored guild [{}] in the database", guild_id);

 	return true;
 }

 uint32 BaseGuildManager::_GetFreeGuildID() {
 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested find a free guild ID when we have no database object.");
+		LogGuilds("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)
 		{
-			Log(Logs::Detail, Logs::Guilds, "Located free guild ID %d in the database", index);
+			LogGuilds("Located free guild ID [{}] in the database", index);
 			return index;
 		}
 	}

-	Log(Logs::Detail, Logs::Guilds, "Unable to find a free guild ID when requested.");
+	LogGuilds("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)) {
-		Log(Logs::Detail, Logs::Guilds, "Error storing new guild. It may have been partially created which may need manual removal.");
+		LogGuilds("Error storing new guild. It may have been partially created which may need manual removal");
 		return(GUILD_NONE);
 	}

-	Log(Logs::Detail, Logs::Guilds, "Created guild %d in the database.", new_id);
+	LogGuilds("Created guild [{}] in the database", new_id);

 	return(new_id);
 }
@@ -525,7 +525,7 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
 	}

 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to delete guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to delete guild [{}] 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");

-	Log(Logs::Detail, Logs::Guilds, "Deleted guild %d from the database.", guild_id);
+	LogGuilds("Deleted guild [{}] from the database", guild_id);

 	return(true);
 }

 bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to rename guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to rename guild [{}] 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())
 	{
-		Log(Logs::Detail, Logs::Guilds, "Error renaming guild %d '%s': %s", guild_id, query.c_str(), results.Success());
+		LogGuilds("Error renaming guild [{}] [{}]: [{}]", guild_id, query.c_str(), results.Success());
 		safe_delete_array(esc);
 		return false;
 	}
 	safe_delete_array(esc);

-	Log(Logs::Detail, Logs::Guilds, "Renamed guild %s (%d) to %s in database.", info->name.c_str(), guild_id, name);
+	LogGuilds("Renamed guild [{}] ([{}]) to [{}] 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) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to set the leader for guild [{}] 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;

-	Log(Logs::Detail, Logs::Guilds, "Set guild leader for guild %d to %d in the database", guild_id, leader);
+	LogGuilds("Set guild leader for guild [{}] to [{}] 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) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to set the MOTD for guild [{}] 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);

-	Log(Logs::Detail, Logs::Guilds, "Set MOTD for guild %d in the database", guild_id);
+	LogGuilds("Set MOTD for guild [{}] 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);

-	Log(Logs::Detail, Logs::Guilds, "Set URL for guild %d in the database", GuildID);
+	LogGuilds("Set URL for guild [{}] 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);

-	Log(Logs::Detail, Logs::Guilds, "Set Channel for guild %d in the database", GuildID);
+	LogGuilds("Set Channel for guild [{}] 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) {
-		Log(Logs::Detail, Logs::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id);
+		LogGuilds("Requested to set char to guild [{}] 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;
 		}
    }
-	Log(Logs::Detail, Logs::Guilds, "Set char %d to guild %d and rank %d in the database.", charid, guild_id, rank);
+	LogGuilds("Set char [{}] to guild [{}] and rank [{}] in the database", charid, guild_id, rank);
 	return true;
 }

@@ -845,7 +845,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 		return false;
 	}

-	Log(Logs::Detail, Logs::Guilds, "Set public not for char %d", charid);
+	LogGuilds("Set public not for char [{}]", charid);

 	return true;
 }
@@ -924,14 +924,14 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		members.push_back(ci);
 	}

-	Log(Logs::Detail, Logs::Guilds, "Retreived entire guild member list for guild %d from the database", guild_id);
+	LogGuilds("Retreived entire guild member list for guild [{}] from the database", guild_id);

 	return true;
 }

 bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested char info on %s when we have no database object.", char_name);
+		LogGuilds("Requested char info on [{}] when we have no database object", char_name);
 		return(false);
 	}

@@ -953,7 +953,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {

    auto row = results.begin();
    ProcessGuildMember(row, into);
-    Log(Logs::Detail, Logs::Guilds, "Retreived guild member info for char %s from the database", char_name);
+    LogGuilds("Retreived guild member info for char [{}] from the database", char_name);

 	return true;

@@ -962,7 +962,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {

 bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 	if(m_db == nullptr) {
-		Log(Logs::Detail, Logs::Guilds, "Requested char info on %d when we have no database object.", char_id);
+		LogGuilds("Requested char info on [{}] when we have no database object", char_id);
 		return false;
 	}

@@ -983,7 +983,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {

    auto row = results.begin();
    ProcessGuildMember(row, into);
-    Log(Logs::Detail, Logs::Guilds, "Retreived guild member info for char %d", char_id);
+    LogGuilds("Retreived guild member info for char [{}]", 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) {
-		Log(Logs::Detail, Logs::Guilds, "Check leader for char %d: not a guild.", char_id);
+		LogGuilds("Check leader for char [{}]: 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()) {
-		Log(Logs::Detail, Logs::Guilds, "Check leader for char %d: invalid guild.", char_id);
+		LogGuilds("Check leader for char [{}]: invalid guild", char_id);
 		return(false);	//invalid guild
 	}
-	Log(Logs::Detail, Logs::Guilds, "Check leader for guild %d, char %d: leader id=%d", guild_id, char_id, res->second->leader_char_id);
+	LogGuilds("Check leader for guild [{}], char [{}]: leader id=[{}]", 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) {
-		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status);
+		LogGuilds("Check permission on guild [{}] with user status [{}] > 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()) {
-		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d, no such guild, denied.", guild_id, status);
+		LogGuilds("Check permission on guild [{}] with user status [{}], no such guild, denied", guild_id, status);
 		return(false);	//invalid guild
 	}

 	bool granted = (res->second->minstatus <= status);

-	Log(Logs::Detail, Logs::Guilds, "Check permission on guild %s (%d) with user status %d. Min status %d: %s",
+	LogGuilds("Check permission on guild [{}] ([{}]) with user status [{}]. Min status [{}]: [{}]",
 		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) {
-		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.",
+		LogGuilds("Check permission on guild [{}] and rank [{}] for action [{}] ([{}]): 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()) {
-		Log(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid guild, denied.",
+		LogGuilds("Check permission on guild [{}] and rank [{}] for action [{}] ([{}]): Invalid guild, denied",
 			guild_id, rank, GuildActionNames[act], act);
 		return(false);	//invalid guild
 	}

 	bool granted = res->second->ranks[rank].permissions[act];

-	Log(Logs::Detail, Logs::Guilds, "Check permission on guild %s (%d) and rank %s (%d) for action %s (%d): %s",
+	LogGuilds("Check permission on guild [{}] ([{}]) and rank [{}] ([{}]) for action [{}] ([{}]): [{}]",
 		res->second->name.c_str(), guild_id,
 		res->second->ranks[rank].name.c_str(), rank,
 		GuildActionNames[act], act,
@@ -1381,7 +1381,7 @@ int16 EQEmu::InventoryProfile::_PutItem(int16 slot_id, ItemInstance* inst)
 	}
 	
 	if (result == INVALID_INDEX) {
-		Log(Logs::General, Logs::Error, "InventoryProfile::_PutItem: Invalid slot_id specified (%i) with parent slot id (%i)", slot_id, parentSlot);
+		LogError("InventoryProfile::_PutItem: Invalid slot_id specified ({}) with parent slot id ({})", slot_id, parentSlot);
 		InventoryProfile::MarkDirty(inst); // Slot not found, clean up
 	}

@@ -0,0 +1,72 @@
+/**
+ * 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")
+	);
+}
@@ -18,15 +18,19 @@
 *
 */

-#ifndef EQEMU_API_ZONE_DATA_SERVICE_H
-#define EQEMU_API_ZONE_DATA_SERVICE_H
+#ifndef EQEMU_IP_UTIL_H
+#define EQEMU_IP_UTIL_H

-#include "../common/json/json.h"
+#include "types.h"
+#include "iostream"

-class EQEmuApiZoneDataService {
+class IpUtil {
 public:
-	static void get(Json::Value &response, const std::vector<std::string> &args);
+
+	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_API_ZONE_DATA_SERVICE_H
+#endif //EQEMU_IP_UTIL_H
@@ -413,7 +413,7 @@ namespace EQEmu
 		int32	SkillModMax;	// Max skill point modification
 		uint32	SkillModType;	// Type of skill for SkillModValue to apply to
 		uint32	BaneDmgRace;	// Bane Damage Race
-		int8	BaneDmgAmt;		// Bane Damage Body Amount
+		int32	BaneDmgAmt;		// Bane Damage Body Amount
 		uint32	BaneDmgBody;	// Bane Damage Body
 		bool	Magic;			// True=Magic Item, False=not
 		int32	CastTime_;
@@ -5277,7 +5277,7 @@ void StreamWriterBuilder::setDefaults(Json::Value* settings)
 {
  //! [StreamWriterBuilderDefaults]
  (*settings)["commentStyle"] = "All";
-  (*settings)["indentation"] = "\t";
+  (*settings)["indentation"] = "  ";
  (*settings)["enableYAMLCompatibility"] = false;
  (*settings)["dropNullPlaceholders"] = false;
  (*settings)["useSpecialFloats"] = false;
@@ -1,26 +1,29 @@
 #include "json_config.h"
 #include <fstream>
+#include <iostream>

-EQ::JsonConfigFile::JsonConfigFile()
-{
-}
+EQ::JsonConfigFile::JsonConfigFile() = default;

 EQ::JsonConfigFile::JsonConfigFile(const Json::Value &value)
 {
 	m_root = value;
 }

-EQ::JsonConfigFile::~JsonConfigFile()
-{
-}
+EQ::JsonConfigFile::~JsonConfigFile() = default;

-EQ::JsonConfigFile EQ::JsonConfigFile::Load(const std::string &filename)
+/**
+ * @param file_name
+ * @return
+ */
+EQ::JsonConfigFile EQ::JsonConfigFile::Load(
+	const std::string &file_name
+)
 {
 	JsonConfigFile ret;
 	ret.m_root = Json::Value();

 	std::ifstream ifs;
-	ifs.open(filename, std::ifstream::in);
+	ifs.open(file_name, std::ifstream::in);

 	if (!ifs.good()) {
 		return ret;
@@ -36,7 +39,43 @@ EQ::JsonConfigFile EQ::JsonConfigFile::Load(const std::string &filename)
 	return ret;
 }

-std::string EQ::JsonConfigFile::GetVariableString(const std::string &title, const std::string &parameter, const std::string &default_value) {
+/**
+ * @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
+)
+{
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asString();
@@ -49,7 +88,18 @@ std::string EQ::JsonConfigFile::GetVariableString(const std::string &title, cons
 	return default_value;
 }

-int EQ::JsonConfigFile::GetVariableInt(const std::string &title, const std::string &parameter, const int 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
+)
+{
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asInt();
@@ -62,7 +112,18 @@ int EQ::JsonConfigFile::GetVariableInt(const std::string &title, const std::stri
 	return default_value;
 }

-bool EQ::JsonConfigFile::GetVariableBool(const std::string &title, const std::string &parameter, const bool 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
+)
+{
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asBool();
@@ -75,7 +136,18 @@ bool EQ::JsonConfigFile::GetVariableBool(const std::string &title, const std::st
 	return default_value;
 }

-double EQ::JsonConfigFile::GetVariableDouble(const std::string &title, const std::string &parameter, const double 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
+)
+{
 	try {
 		if (m_root.isMember(title) && m_root[title].isMember(parameter)) {
 			return m_root[title][parameter].asDouble();
@@ -7,10 +7,12 @@ namespace EQ
 	class JsonConfigFile
 	{
 	public:
+		JsonConfigFile();
 		JsonConfigFile(const Json::Value &value);
 		~JsonConfigFile();

-		static JsonConfigFile Load(const std::string &filename);
+		static JsonConfigFile Load(const std::string &file_name);
+		void Save(const std::string &file_name);

 		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);
@@ -19,7 +21,6 @@ namespace EQ
 		
 		Json::Value& RawHandle() { return m_root; }
 	private:
-		JsonConfigFile();
 		Json::Value m_root;
 	};

@@ -32,15 +32,15 @@
 //
 #define VARSTRUCT_DECODE_TYPE(Type, Buffer) *(Type *)Buffer; Buffer += sizeof(Type);
 #define VARSTRUCT_DECODE_STRING(String, Buffer) strcpy(String, Buffer); Buffer += strlen(String)+1;
-#define VARSTRUCT_ENCODE_STRING(Buffer, String) { sprintf(Buffer, "%s", String); Buffer += strlen(String) + 1; }
-#define VARSTRUCT_ENCODE_INTSTRING(Buffer, Number) { sprintf(Buffer, "%i", Number); Buffer += strlen(Buffer) + 1; }
+#define VARSTRUCT_ENCODE_STRING(Buffer, String) { int length = sprintf(Buffer, "%s", String); Buffer += length + 1; }
+#define VARSTRUCT_ENCODE_INTSTRING(Buffer, Number) { int length = sprintf(Buffer, "%i", Number); Buffer += length + 1; }
 #define VARSTRUCT_ENCODE_TYPE(Type, Buffer, Value) { *(Type *)Buffer = Value; Buffer += sizeof(Type); }
 #define VARSTRUCT_SKIP_TYPE(Type, Buffer) Buffer += sizeof(Type);

 #define VERIFY_PACKET_LENGTH(OPCode, Packet, StructName) \
 	if(Packet->size != sizeof(StructName)) \
 	{ \
-		Log(Logs::Detail, Logs::Netcode, "Size mismatch in " #OPCode " expected %i got %i", sizeof(StructName), Packet->size); \
+		LogNetcode("Size mismatch in " #OPCode " expected [{}] got [{}]", sizeof(StructName), Packet->size); \
 		DumpPacket(Packet); \
 		return; \
 	}
@@ -368,6 +368,7 @@ void EQ::Net::DaybreakConnection::QueuePacket(Packet &p, int stream, bool reliab
 		packet.PutUInt8(0, 0);
 		packet.PutPacket(1, p);
 		InternalQueuePacket(packet, stream, reliable);
+		return;
 	}

 	InternalQueuePacket(p, stream, reliable);
@@ -384,7 +385,7 @@ EQ::Net::DaybreakConnectionStats EQ::Net::DaybreakConnection::GetStats()

 void EQ::Net::DaybreakConnection::ResetStats()
 {
-	m_stats = DaybreakConnectionStats();
+	m_stats.Reset();
 }

 void EQ::Net::DaybreakConnection::Process()
@@ -417,6 +418,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)

 	auto opcode = p.GetInt8(1);
 	if (p.GetInt8(0) == 0 && (opcode == OP_KeepAlive || opcode == OP_OutboundPing)) {
+		m_stats.bytes_after_decode += p.Length();
 		return;
 	}

@@ -425,6 +427,8 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
 			if (m_owner->m_on_error_message) {
 				m_owner->m_on_error_message(fmt::format("Tossed packet that failed CRC of type {0:#x}", p.Length() >= 2 ? p.GetInt8(1) : 0));
 			}
+
+			m_stats.bytes_after_decode += p.Length();
 			return;
 		}

@@ -453,6 +457,7 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
 				}
 			}

+			m_stats.bytes_after_decode += temp.Length();
 			ProcessDecodedPacket(StaticPacket(temp.Data(), temp.Length()));
 		}
 		else {
@@ -471,10 +476,12 @@ void EQ::Net::DaybreakConnection::ProcessPacket(Packet &p)
 				}
 			}

+			m_stats.bytes_after_decode += temp.Length();
 			ProcessDecodedPacket(StaticPacket(temp.Data(), temp.Length()));
 		}
 	}
 	else {
+		m_stats.bytes_after_decode += p.Length();
 		ProcessDecodedPacket(p);
 	}
 }
@@ -993,7 +1000,7 @@ uint32_t Deflate(const uint8_t* in, uint32_t in_len, uint8_t* out, uint32_t out_
 	zstream.avail_in = in_len;
 	zstream.opaque = Z_NULL;

-	deflateInit(&zstream, Z_FINISH);
+	deflateInit(&zstream, Z_BEST_SPEED);
 	zstream.next_out = out;
 	zstream.avail_out = out_len;

@@ -1285,6 +1292,9 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
 	};

 	if (PacketCanBeEncoded(p)) {
+
+		m_stats.bytes_before_encode += p.Length();
+
 		DynamicPacket out;
 		out.PutPacket(0, p);

@@ -1332,6 +1342,8 @@ void EQ::Net::DaybreakConnection::InternalSend(Packet &p)
 		return;
 	}

+	m_stats.bytes_before_encode += p.Length();
+
 	uv_udp_send_t *send_req = new uv_udp_send_t;
 	sockaddr_in send_addr;
 	uv_ip4_addr(m_endpoint.c_str(), m_port, &send_addr);
@@ -91,6 +91,24 @@ namespace EQ
 				resent_fragments = 0;
 				resent_full = 0;
 				datarate_remaining = 0.0;
+				bytes_after_decode = 0;
+				bytes_before_encode = 0;
+			}
+
+			void Reset() {
+				recv_bytes = 0;
+				sent_bytes = 0;
+				min_ping = 0xFFFFFFFFFFFFFFFFUL;
+				max_ping = 0;
+				avg_ping = 0;
+				created = Clock::now();
+				dropped_datarate_packets = 0;
+				resent_packets = 0;
+				resent_fragments = 0;
+				resent_full = 0;
+				datarate_remaining = 0.0;
+				bytes_after_decode = 0;
+				bytes_before_encode = 0;
 			}

 			uint64_t recv_bytes;
@@ -111,6 +129,8 @@ namespace EQ
 			uint64_t resent_fragments;
 			uint64_t resent_full;
 			double datarate_remaining;
+			uint64_t bytes_after_decode;
+			uint64_t bytes_before_encode;
 		};

 		class DaybreakConnectionManager;
@@ -237,7 +257,7 @@ namespace EQ
 				resend_delay_min = 150;
 				resend_delay_max = 5000;
 				connect_delay_ms = 500;
-				stale_connection_ms = 90000;
+				stale_connection_ms = 60000;
 				connect_stale_ms = 5000;
 				crc_length = 2;
 				max_packet_size = 512;
@@ -249,7 +269,7 @@ namespace EQ
 				simulated_in_packet_loss = 0;
 				simulated_out_packet_loss = 0;
 				tic_rate_hertz = 60.0;
-				resend_timeout = 90000;
+				resend_timeout = 30000;
 				connection_close_time = 2000;
 				outgoing_data_rate = 0.0;
 			}
@@ -1,6 +1,5 @@
 #include "eqstream.h"
 #include "../eqemu_logsys.h"
-#include "../eqemu_logsys_fmt.h"

 EQ::Net::EQStreamManager::EQStreamManager(const EQStreamManagerInterfaceOptions &options) : EQStreamManagerInterface(options), m_daybreak(options.daybreak_options)
 {
@@ -13,6 +12,13 @@ EQ::Net::EQStreamManager::~EQStreamManager()
 {
 }

+void EQ::Net::EQStreamManager::SetOptions(const EQStreamManagerInterfaceOptions &options)
+{
+	m_options = options;
+	auto &opts = m_daybreak.GetOptions();
+	opts = options.daybreak_options;
+}
+
 void EQ::Net::EQStreamManager::DaybreakNewConnection(std::shared_ptr<DaybreakConnection> connection)
 {
 	std::shared_ptr<EQStream> stream(new EQStream(this, connection));
@@ -65,9 +71,7 @@ void EQ::Net::EQStream::QueuePacket(const EQApplicationPacket *p, bool ack_req)
 			opcode = p->GetOpcodeBypass();
 		}
 		else {
-			if (m_owner->GetOptions().track_opcode_stats) {
-				m_packet_sent_count[p->GetOpcode()]++; //Wont bother with bypass tracking of these since those are rare for testing anyway
-			}
+			m_packet_sent_count[static_cast<int>(p->GetOpcode())]++; //Wont bother with bypass tracking of these since those are rare for testing anyway
 			opcode = (*m_opcode_manager)->EmuToEQ(p->GetOpcode());
 		}

@@ -117,9 +121,7 @@ EQApplicationPacket *EQ::Net::EQStream::PopPacket() {
 		}

 		EmuOpcode emu_op = (*m_opcode_manager)->EQToEmu(opcode);
-		if (m_owner->GetOptions().track_opcode_stats) {
-			m_packet_recv_count[emu_op]++;
-		}
+		m_packet_recv_count[static_cast<int>(emu_op)]++;

 		EQApplicationPacket *ret = new EQApplicationPacket(emu_op, (unsigned char*)p->Data() + m_owner->GetOptions().opcode_size, p->Length() - m_owner->GetOptions().opcode_size);
 		ret->SetProtocolOpcode(opcode);
@@ -182,23 +184,23 @@ EQStreamInterface::MatchState EQ::Net::EQStream::CheckSignature(const Signature

 		if (opcode == sig->first_eq_opcode) {
 			if (length == sig->first_length) {
-				LogF(Logs::General, Logs::Netcode, "[IDENT_TRACE] {0}:{1}: First opcode matched {2:#x} and length matched {3}",
+				LogF(Logs::General, Logs::Netcode, "[StreamIdentify] {0}:{1}: First opcode matched {2:#x} and length matched {3}",
 					m_connection->RemoteEndpoint(), m_connection->RemotePort(), sig->first_eq_opcode, length);
 				return MatchSuccessful;
 			}
 			else if (length == 0) {
-				LogF(Logs::General, Logs::Netcode, "[IDENT_TRACE] {0}:{1}: First opcode matched {2:#x} and length is ignored.",
+				LogF(Logs::General, Logs::Netcode, "[StreamIdentify] {0}:{1}: First opcode matched {2:#x} and length is ignored.",
 					m_connection->RemoteEndpoint(), m_connection->RemotePort(), sig->first_eq_opcode);
 				return MatchSuccessful;
 			}
 			else {
-				LogF(Logs::General, Logs::Netcode, "[IDENT_TRACE] {0}:{1}: First opcode matched {2:#x} but length {3} did not match expected {4}",
+				LogF(Logs::General, Logs::Netcode, "[StreamIdentify] {0}:{1}: First opcode matched {2:#x} but length {3} did not match expected {4}",
 					m_connection->RemoteEndpoint(), m_connection->RemotePort(), sig->first_eq_opcode, length, sig->first_length);
 				return MatchFailed;
 			}
 		}
 		else {
-			LogF(Logs::General, Logs::Netcode, "[IDENT_TRACE] {0}:{1}: First opcode {1:#x} did not match expected {2:#x}",
+			LogF(Logs::General, Logs::Netcode, "[StreamIdentify] {0}:{1}: First opcode {1:#x} did not match expected {2:#x}",
 				m_connection->RemoteEndpoint(), m_connection->RemotePort(), opcode, sig->first_eq_opcode);
 			return MatchFailed;
 		}
@@ -19,6 +19,7 @@ namespace EQ
 			EQStreamManager(const EQStreamManagerInterfaceOptions &options);
 			~EQStreamManager();

+			virtual void SetOptions(const EQStreamManagerInterfaceOptions& options);
 			void OnNewConnection(std::function<void(std::shared_ptr<EQStream>)> func) { m_on_new_connection = func; }
 			void OnConnectionStateChange(std::function<void(std::shared_ptr<EQStream>, DbProtocolStatus, DbProtocolStatus)> func) { m_on_connection_state_change = func; }
 		private:
@@ -65,8 +66,8 @@ namespace EQ
 			std::shared_ptr<DaybreakConnection> m_connection;
 			OpcodeManager **m_opcode_manager;
 			std::deque<std::unique_ptr<EQ::Net::Packet>> m_packet_queue;
-			std::unordered_map<EmuOpcode, int> m_packet_recv_count;
-			std::unordered_map<EmuOpcode, int> m_packet_sent_count;
+			std::unordered_map<int, int> m_packet_recv_count;
+			std::unordered_map<int, int> m_packet_sent_count;
 			friend class EQStreamManager;
 		};
 	}
@@ -1,7 +1,6 @@
 #include "servertalk_client_connection.h"
 #include "dns.h"
 #include "../eqemu_logsys.h"
-#include "../eqemu_logsys_fmt.h"

 EQ::Net::ServertalkClient::ServertalkClient(const std::string &addr, int port, bool ipv6, const std::string &identifier, const std::string &credentials)
 	: m_timer(std::unique_ptr<EQ::Timer>(new EQ::Timer(100, true, std::bind(&EQ::Net::ServertalkClient::Connect, this))))
@@ -79,15 +78,15 @@ void EQ::Net::ServertalkClient::Connect()
 	m_connecting = true;
 	EQ::Net::TCPConnection::Connect(m_addr, m_port, false, [this](std::shared_ptr<EQ::Net::TCPConnection> connection) {
 		if (connection == nullptr) {
-			LogF(Logs::General, Logs::TCP_Connection, "Error connecting to {0}:{1}, attempting to reconnect...", m_addr, m_port);
+			LogF(Logs::General, Logs::TCPConnection, "Error connecting to {0}:{1}, attempting to reconnect...", m_addr, m_port);
 			m_connecting = false;
 			return;
 		}

-		LogF(Logs::General, Logs::TCP_Connection, "Connected to {0}:{1}", m_addr, m_port);
+		LogF(Logs::General, Logs::TCPConnection, "Connected to {0}:{1}", m_addr, m_port);
 		m_connection = connection;
 		m_connection->OnDisconnect([this](EQ::Net::TCPConnection *c) {
-			LogF(Logs::General, Logs::TCP_Connection, "Connection lost to {0}:{1}, attempting to reconnect...", m_addr, m_port);
+			LogF(Logs::General, Logs::TCPConnection, "Connection lost to {0}:{1}, attempting to reconnect...", m_addr, m_port);
 			m_encrypted = false;
 			m_connection.reset();
 		});
@@ -214,7 +213,7 @@ void EQ::Net::ServertalkClient::ProcessHello(EQ::Net::Packet &p)
 				}
 			}
 			else {
-				LogF(Logs::General, Logs::Error, "Could not process hello, size != {0}", 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
+				LogError("Could not process hello, size != {0}", 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
 			}
 		}
 		else {
@@ -226,7 +225,7 @@ void EQ::Net::ServertalkClient::ProcessHello(EQ::Net::Packet &p)
 		}
 	}
 	catch (std::exception &ex) {
-		LogF(Logs::General, Logs::Error, "Error parsing hello from server: {0}", ex.what());
+		LogError("Error parsing hello from server: {0}", ex.what());
 		m_connection->Disconnect();

 		if (m_on_connect_cb) {
@@ -253,7 +252,7 @@ void EQ::Net::ServertalkClient::ProcessHello(EQ::Net::Packet &p)
 		}
 }
 	catch (std::exception &ex) {
-		LogF(Logs::General, Logs::Error, "Error parsing hello from server: {0}", ex.what());
+		LogError("Error parsing hello from server: {0}", ex.what());
 		m_connection->Disconnect();

 		if (m_on_connect_cb) {
@@ -276,7 +275,7 @@ void EQ::Net::ServertalkClient::ProcessMessage(EQ::Net::Packet &p)
 				std::unique_ptr<unsigned char[]> decrypted_text(new unsigned char[message_len]);
 				if (crypto_box_open_easy_afternm(&decrypted_text[0], (unsigned char*)&data[0], length, m_nonce_theirs, m_shared_key))
 				{
-					LogF(Logs::General, Logs::Error, "Error decrypting message from server");
+					LogError("Error decrypting message from server");
 					(*(uint64_t*)&m_nonce_theirs[0])++;
 					return;
 				}
@@ -324,7 +323,7 @@ void EQ::Net::ServertalkClient::ProcessMessage(EQ::Net::Packet &p)
 		}
 	}
 	catch (std::exception &ex) {
-		LogF(Logs::General, Logs::Error, "Error parsing message from server: {0}", ex.what());
+		LogError("Error parsing message from server: {0}", ex.what());
 	}
 }

@@ -1,7 +1,6 @@
 #include "servertalk_legacy_client_connection.h"
 #include "dns.h"
 #include "../eqemu_logsys.h"
-#include "../eqemu_logsys_fmt.h"

 EQ::Net::ServertalkLegacyClient::ServertalkLegacyClient(const std::string &addr, int port, bool ipv6)
 	: m_timer(std::unique_ptr<EQ::Timer>(new EQ::Timer(100, true, std::bind(&EQ::Net::ServertalkLegacyClient::Connect, this))))
@@ -59,15 +58,15 @@ void EQ::Net::ServertalkLegacyClient::Connect()
 	m_connecting = true;
 	EQ::Net::TCPConnection::Connect(m_addr, m_port, false, [this](std::shared_ptr<EQ::Net::TCPConnection> connection) {
 		if (connection == nullptr) {
-			LogF(Logs::General, Logs::TCP_Connection, "Error connecting to {0}:{1}, attempting to reconnect...", m_addr, m_port);
+			LogF(Logs::General, Logs::TCPConnection, "Error connecting to {0}:{1}, attempting to reconnect...", m_addr, m_port);
 			m_connecting = false;
 			return;
 		}

-		LogF(Logs::General, Logs::TCP_Connection, "Connected to {0}:{1}", m_addr, m_port);
+		LogF(Logs::General, Logs::TCPConnection, "Connected to {0}:{1}", m_addr, m_port);
 		m_connection = connection;
 		m_connection->OnDisconnect([this](EQ::Net::TCPConnection *c) {
-			LogF(Logs::General, Logs::TCP_Connection, "Connection lost to {0}:{1}, attempting to reconnect...", m_addr, m_port);
+			LogF(Logs::General, Logs::TCPConnection, "Connection lost to {0}:{1}, attempting to reconnect...", m_addr, m_port);
 			m_connection.reset();
 		});

@@ -1,7 +1,6 @@
 #include "servertalk_server_connection.h"
 #include "servertalk_server.h"
 #include "../eqemu_logsys.h"
-#include "../eqemu_logsys_fmt.h"
 #include "../util/uuid.h"

 EQ::Net::ServertalkServerConnection::ServertalkServerConnection(std::shared_ptr<EQ::Net::TCPConnection> c, EQ::Net::ServertalkServer *parent, bool encrypted, bool allow_downgrade)
@@ -202,8 +201,8 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 {
 #ifdef ENABLE_SECURITY
 	if (downgrade_security && m_allow_downgrade && m_encrypted) {
-		LogF(Logs::General, Logs::TCP_Connection, "Downgraded encrypted connection to plaintext because otherside didn't support encryption {0}:{1}", 
-			m_connection->RemoteIP(), m_connection->RemotePort());
+		LogF(Logs::General, Logs::TCPConnection, "Downgraded encrypted connection to plaintext because otherside didn't support encryption {0}:{1}",
+			 m_connection->RemoteIP(), m_connection->RemotePort());
 		m_encrypted = false;
 	}

@@ -221,7 +220,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b

 				if (crypto_box_open_easy_afternm(&decrypted_text[0], (unsigned char*)p.Data() + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, cipher_len, m_nonce_theirs, m_shared_key))
 				{
-					LogF(Logs::General, Logs::Error, "Error decrypting handshake from client, dropping connection.");
+					LogError("Error decrypting handshake from client, dropping connection.");
 					m_connection->Disconnect();
 					return;
 				}
@@ -230,7 +229,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 				std::string credentials = (const char*)&decrypted_text[0] + (m_identifier.length() + 1);

 				if (!m_parent->CheckCredentials(credentials)) {
-					LogF(Logs::General, Logs::Error, "Got incoming connection with invalid credentials during handshake, dropping connection.");
+					LogError("Got incoming connection with invalid credentials during handshake, dropping connection.");
 					m_connection->Disconnect();
 					return;
 				}
@@ -240,7 +239,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 			}
 		}
 		catch (std::exception &ex) {
-			LogF(Logs::General, Logs::Error, "Error parsing handshake from client: {0}", ex.what());
+			LogError("Error parsing handshake from client: {0}", ex.what());
 			m_connection->Disconnect();
 		}
 	}
@@ -250,7 +249,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 			auto credentials = p.GetCString(m_identifier.length() + 1);

 			if (!m_parent->CheckCredentials(credentials)) {
-				LogF(Logs::General, Logs::Error, "Got incoming connection with invalid credentials during handshake, dropping connection.");
+				LogError("Got incoming connection with invalid credentials during handshake, dropping connection.");
 				m_connection->Disconnect();
 				return;
 			}
@@ -258,7 +257,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 			m_parent->ConnectionIdentified(this);
 		}
 		catch (std::exception &ex) {
-			LogF(Logs::General, Logs::Error, "Error parsing handshake from client: {0}", ex.what());
+			LogError("Error parsing handshake from client: {0}", ex.what());
 			m_connection->Disconnect();
 		}
 	}
@@ -268,7 +267,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 		auto credentials = p.GetCString(m_identifier.length() + 1);

 		if (!m_parent->CheckCredentials(credentials)) {
-			LogF(Logs::General, Logs::Error, "Got incoming connection with invalid credentials during handshake, dropping connection.");
+			LogError("Got incoming connection with invalid credentials during handshake, dropping connection.");
 			m_connection->Disconnect();
 			return;
 		}
@@ -276,7 +275,7 @@ void EQ::Net::ServertalkServerConnection::ProcessHandshake(EQ::Net::Packet &p, b
 		m_parent->ConnectionIdentified(this);
 	}
 	catch (std::exception &ex) {
-		LogF(Logs::General, Logs::Error, "Error parsing handshake from client: {0}", ex.what());
+		LogError("Error parsing handshake from client: {0}", ex.what());
 		m_connection->Disconnect();
 	}
 #endif
@@ -296,7 +295,7 @@ void EQ::Net::ServertalkServerConnection::ProcessMessage(EQ::Net::Packet &p)

 				if (crypto_box_open_easy_afternm(&decrypted_text[0], (unsigned char*)&data[0], length, m_nonce_theirs, m_shared_key))
 				{
-					LogF(Logs::General, Logs::Error, "Error decrypting message from client");
+					LogError("Error decrypting message from client");
 					(*(uint64_t*)&m_nonce_theirs[0])++;
 					return;
 				}
@@ -344,6 +343,6 @@ void EQ::Net::ServertalkServerConnection::ProcessMessage(EQ::Net::Packet &p)
 		}
 	}
 	catch (std::exception &ex) {
-		LogF(Logs::General, Logs::Error, "Error parsing message from client: {0}", ex.what());
+		LogError("Error parsing message from client: {0}", ex.what());
 	}
 }
@@ -203,6 +203,10 @@ int EQ::Net::TCPConnection::LocalPort() const

 std::string EQ::Net::TCPConnection::RemoteIP() const
 {
+	if (!m_socket) {
+		return "";
+	}
+
 	sockaddr_storage addr;
 	int addr_len = sizeof(addr);
 	uv_tcp_getpeername(m_socket, (sockaddr*)&addr, &addr_len);
@@ -220,6 +224,10 @@ std::string EQ::Net::TCPConnection::RemoteIP() const

 int EQ::Net::TCPConnection::RemotePort() const
 {
+	if (!m_socket) {
+		return 0;
+	}
+
 	sockaddr_storage addr;
 	int addr_len = sizeof(addr);
 	uv_tcp_getpeername(m_socket, (sockaddr*)&addr, &addr_len);
@@ -236,3 +244,11 @@ int EQ::Net::TCPConnection::RemotePort() const

 	return 0;
 }
+
+/**
+ * @return
+ */
+bool EQ::Net::TCPConnection::IsConnected() const
+{
+	return m_socket != nullptr;
+}
@@ -24,10 +24,12 @@ namespace EQ
 			void Read(const char *data, size_t count);
 			void Write(const char *data, size_t count);

+			bool IsConnected() const;
 			std::string LocalIP() const;
 			int LocalPort() const;
 			std::string RemoteIP() const;
 			int RemotePort() const;
+
 		private:
 			TCPConnection();

@@ -0,0 +1,265 @@
+#include "websocket_server.h"
+#include "../event/event_loop.h"
+#include "../event/timer.h"
+#include <fmt/format.h>
+#include <map>
+#include <unordered_set>
+#include <array>
+
+struct MethodHandlerEntry
+{
+	MethodHandlerEntry() {
+		status = 0;
+	}
+
+	MethodHandlerEntry(EQ::Net::WebsocketServer::MethodHandler h, int s) {
+		handler = h;
+		status = s;
+	}
+
+	EQ::Net::WebsocketServer::MethodHandler handler;
+	int status;
+};
+
+struct EQ::Net::WebsocketServer::Impl
+{
+	std::unique_ptr<TCPServer> server;
+	std::unique_ptr<EQ::Timer> ping_timer;
+	std::map<std::shared_ptr<websocket_connection>, std::unique_ptr<WebsocketServerConnection>> connections;
+	std::map<std::string, MethodHandlerEntry> methods;
+	websocket_server ws_server;
+	LoginHandler login_handler;
+	std::array<std::unordered_set<WebsocketServerConnection*>, SubscriptionEventMax> subscriptions;
+};
+
+EQ::Net::WebsocketServer::WebsocketServer(const std::string &addr, int port)
+{
+	_impl.reset(new Impl());
+	_impl->server.reset(new EQ::Net::TCPServer());
+	_impl->server->Listen(addr, port, false, [this](std::shared_ptr<EQ::Net::TCPConnection> connection) {
+		auto wsc = _impl->ws_server.get_connection();
+		WebsocketServerConnection *c = new WebsocketServerConnection(this, connection, wsc);
+		_impl->connections.insert(std::make_pair(wsc, std::unique_ptr<WebsocketServerConnection>(c)));
+	});
+
+	_impl->ws_server.set_write_handler(
+		[this](websocketpp::connection_hdl hdl, char const *data, size_t size) -> websocketpp::lib::error_code {
+		auto c = _impl->ws_server.get_con_from_hdl(hdl);
+		auto iter = _impl->connections.find(c);
+		if (iter != _impl->connections.end()) {
+			iter->second->GetTCPConnection()->Write(data, size);
+		}
+		
+		return websocketpp::lib::error_code();
+	});
+
+	_impl->ping_timer.reset(new EQ::Timer(5000, true, [this](EQ::Timer *t) {
+		auto iter = _impl->connections.begin();
+
+		while (iter != _impl->connections.end()) {
+			try {
+				auto &connection = iter->second;
+				connection->GetWebsocketConnection()->ping("keepalive");
+			}
+			catch (std::exception) {
+				iter->second->GetTCPConnection()->Disconnect();
+			}
+
+			iter++;
+		}
+	}));
+
+	_impl->methods.insert(std::make_pair("login", MethodHandlerEntry(std::bind(&WebsocketServer::Login, this, std::placeholders::_1, std::placeholders::_2), 0)));
+	_impl->methods.insert(std::make_pair("subscribe", MethodHandlerEntry(std::bind(&WebsocketServer::Subscribe, this, std::placeholders::_1, std::placeholders::_2), 0)));
+	_impl->methods.insert(std::make_pair("unsubscribe", MethodHandlerEntry(std::bind(&WebsocketServer::Unsubscribe, this, std::placeholders::_1, std::placeholders::_2), 0)));
+	_impl->login_handler = [](const WebsocketServerConnection* connection, const std::string& user, const std::string& pass) {
+		WebsocketLoginStatus ret;
+		ret.account_name = "admin";
+		
+		if (connection->RemoteIP() == "127.0.0.1" || connection->RemoteIP() == "::") {
+			ret.logged_in = true;
+			return ret;
+		}
+
+		ret.logged_in = false;
+		return ret;
+	};
+
+	_impl->ws_server.clear_access_channels(websocketpp::log::alevel::all);
+}
+
+EQ::Net::WebsocketServer::~WebsocketServer()
+{
+}
+
+void EQ::Net::WebsocketServer::ReleaseConnection(WebsocketServerConnection *connection)
+{
+	UnsubscribeAll(connection);
+
+	_impl->connections.erase(connection->GetWebsocketConnection());
+}
+
+Json::Value EQ::Net::WebsocketServer::HandleRequest(WebsocketServerConnection *connection, const std::string &method, const Json::Value &params)
+{
+	Json::Value err;
+	if (method != "login") {
+		if (!connection->IsAuthorized()) {
+			throw WebsocketException("Not logged in");
+		}
+	}
+
+	auto iter = _impl->methods.find(method);
+	if (iter != _impl->methods.end()) {
+		auto &s = iter->second;
+		if (s.status > connection->GetStatus()) {
+			throw WebsocketException("Status too low");
+		}
+
+		return s.handler(connection, params);
+	}
+
+	throw WebsocketException("Unknown Method");
+}
+
+void EQ::Net::WebsocketServer::SetMethodHandler(const std::string &method, MethodHandler handler, int required_status)
+{
+	//Reserved method names
+	if (method == "subscribe" || 
+		method == "unsubscribe" || 
+		method == "login") {
+		return;
+	}
+
+	_impl->methods[method] = MethodHandlerEntry(handler, required_status);
+}
+
+void EQ::Net::WebsocketServer::SetLoginHandler(LoginHandler handler)
+{
+	_impl->login_handler = handler;
+}
+
+void EQ::Net::WebsocketServer::DispatchEvent(WebsocketSubscriptionEvent evt, Json::Value data, int required_status)
+{
+	try {
+		Json::Value event_obj;
+		event_obj["type"] = "event";
+		event_obj["event"] = (int)evt;
+		event_obj["data"] = data;
+
+		std::stringstream payload;
+		payload << event_obj;
+
+		for (auto &iter : _impl->connections) {
+			auto &c = iter.second;
+
+			if (c->GetStatus() >= required_status && IsSubscribed(c.get(), evt)) {
+				c->GetWebsocketConnection()->send(payload.str());
+			}
+		}
+	}
+	catch (std::exception) {
+	}
+}
+
+Json::Value EQ::Net::WebsocketServer::Login(WebsocketServerConnection *connection, const Json::Value &params)
+{
+	Json::Value ret;
+
+	try {
+		Json::Value ret;
+
+		auto user = params[0].asString();
+		auto pass = params[1].asString();
+		
+		auto r = _impl->login_handler(connection, user, pass);
+
+		if (r.logged_in) {
+			connection->SetAuthorized(true, r.account_name, r.account_id, 255);
+			ret["status"] = "Ok";
+		}
+		else if (user == "admin" && (connection->RemoteIP() == "127.0.0.1" || connection->RemoteIP() == "::")) {
+			r.logged_in = true;
+			r.account_id = 0;
+			connection->SetAuthorized(true, r.account_name, r.account_id, 255);
+			ret["status"] = "Ok";
+		}
+		else {
+			connection->SetAuthorized(false, "", 0, 0);
+			ret["status"] = "Not Authorized";
+		}
+
+		return ret;
+	}
+	catch (std::exception) {
+		throw WebsocketException("Unable to process login request");
+	}
+}
+
+Json::Value EQ::Net::WebsocketServer::Subscribe(WebsocketServerConnection *connection, const Json::Value &params)
+{
+	Json::Value ret;
+
+	try {
+		auto evt = params[0].asInt();
+		if (evt < 0 || evt >= SubscriptionEventMax) {
+			throw WebsocketException("Not a valid subscription");
+		}
+
+		DoSubscribe(connection, (WebsocketSubscriptionEvent)evt);
+		ret["status"] = "Ok";
+		return ret;
+	}
+	catch (WebsocketException &ex) {
+		throw ex;
+	}
+	catch (std::exception) {
+		throw WebsocketException("Unable to process unsubscribe request");
+	}
+}
+
+Json::Value EQ::Net::WebsocketServer::Unsubscribe(WebsocketServerConnection *connection, const Json::Value &params)
+{
+	Json::Value ret;
+
+	try {
+		auto evt = params[0].asInt();
+		if (evt < 0 || evt >= SubscriptionEventMax) {
+			throw WebsocketException("Not a valid subscription");
+		}
+
+		DoUnsubscribe(connection, (WebsocketSubscriptionEvent)evt);
+		ret["status"] = "Ok";
+		return ret;
+	}
+	catch (WebsocketException &ex) {
+		throw ex;
+	}
+	catch (std::exception) {
+		throw WebsocketException("Unable to process unsubscribe request");
+	}
+}
+
+void EQ::Net::WebsocketServer::DoSubscribe(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub) {
+	auto &s = _impl->subscriptions[sub];
+
+	auto iter = s.find(connection);
+	if (iter == s.end()) {
+		s.insert(connection);
+	}
+}
+
+void EQ::Net::WebsocketServer::DoUnsubscribe(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub) {
+	auto &s = _impl->subscriptions[sub];
+	s.erase(connection);
+}
+
+bool EQ::Net::WebsocketServer::IsSubscribed(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub) {
+	auto &s = _impl->subscriptions[sub];
+	return s.count(connection) == 1;
+}
+
+void EQ::Net::WebsocketServer::UnsubscribeAll(WebsocketServerConnection *connection) {
+	for (auto i = 0; i < SubscriptionEventMax; ++i) {
+		DoUnsubscribe(connection, (WebsocketSubscriptionEvent)i);
+	}
+}
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "websocket_server_connection.h"
+
+#include "../json/json.h"
+#include <memory>
+#include <functional>
+#include <exception>
+
+namespace EQ
+{
+	namespace Net
+	{
+		enum WebsocketSubscriptionEvent : int
+		{
+			SubscriptionEventNone,
+			SubscriptionEventLog,
+			SubscriptionEventMax
+		};
+
+		struct WebsocketLoginStatus
+		{
+			bool logged_in;
+			std::string account_name;
+			uint32 account_id;
+			int status;
+		};
+
+		class WebsocketException : public std::exception
+		{
+		public:
+			WebsocketException(const std::string &msg)
+				: _msg(msg.empty() ? "Unknown Error" : msg) { }
+
+			~WebsocketException() throw() {}
+
+			virtual char const *what() const throw() {
+				return _msg.c_str();
+			}
+		private:
+			const std::string _msg;
+		};
+
+		class WebsocketServer
+		{
+		public:
+			typedef std::function<Json::Value(WebsocketServerConnection*, const Json::Value&)> MethodHandler;
+			typedef std::function<WebsocketLoginStatus(WebsocketServerConnection*, const std::string&, const std::string&)> LoginHandler;
+
+			WebsocketServer(const std::string &addr, int port);
+			~WebsocketServer();
+			
+			void SetMethodHandler(const std::string& method, MethodHandler handler, int required_status);
+			void SetLoginHandler(LoginHandler handler);
+			void DispatchEvent(WebsocketSubscriptionEvent evt, Json::Value data = Json::Value(), int required_status = 0);
+		private:
+			void ReleaseConnection(WebsocketServerConnection *connection);
+			Json::Value HandleRequest(WebsocketServerConnection *connection, const std::string& method, const Json::Value &params);
+
+			Json::Value Login(WebsocketServerConnection *connection, const Json::Value &params);
+			Json::Value Subscribe(WebsocketServerConnection *connection, const Json::Value &params);
+			Json::Value Unsubscribe(WebsocketServerConnection *connection, const Json::Value &params);
+			void DoSubscribe(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub);
+			void DoUnsubscribe(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub);
+			bool IsSubscribed(WebsocketServerConnection *connection, WebsocketSubscriptionEvent sub);
+			void UnsubscribeAll(WebsocketServerConnection *connection);
+
+			struct Impl;
+			std::unique_ptr<Impl> _impl;
+
+			friend class WebsocketServerConnection;
+		};
+	}
+}
@@ -0,0 +1,153 @@
+#include "websocket_server_connection.h"
+#include "websocket_server.h"
+#include "../timer.h"
+#include "../util/uuid.h"
+#include <sstream>
+#include <fmt/format.h>
+
+struct EQ::Net::WebsocketServerConnection::Impl {
+	WebsocketServer *parent;
+	std::shared_ptr<TCPConnection> connection;
+	std::shared_ptr<websocket_connection> ws_connection;
+	std::string id;
+	bool authorized;
+	std::string account_name;
+	uint32 account_id;
+	int status;
+};
+
+EQ::Net::WebsocketServerConnection::WebsocketServerConnection(WebsocketServer *parent, 
+	std::shared_ptr<TCPConnection> connection,
+	std::shared_ptr<websocket_connection> ws_connection)
+{
+	_impl.reset(new Impl());
+	_impl->parent = parent;
+	_impl->connection = connection;
+	_impl->id = EQ::Util::UUID::Generate().ToString();
+	_impl->authorized = false;
+	_impl->account_id = 0;
+	_impl->status = 0;
+	_impl->ws_connection = ws_connection;
+	_impl->ws_connection->set_message_handler(std::bind(&WebsocketServerConnection::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
+	_impl->ws_connection->start();
+
+	connection->OnDisconnect([this](EQ::Net::TCPConnection *connection) {
+		_impl->parent->ReleaseConnection(this);
+	});
+	
+	connection->OnRead([this](EQ::Net::TCPConnection *c, const unsigned char *buffer, size_t buffer_size) {
+		_impl->ws_connection->read_all((const char*)buffer, buffer_size);
+	});
+
+	connection->Start();
+}
+
+EQ::Net::WebsocketServerConnection::~WebsocketServerConnection()
+{
+}
+
+std::string EQ::Net::WebsocketServerConnection::GetID() const
+{
+	return _impl->id;
+}
+
+bool EQ::Net::WebsocketServerConnection::IsAuthorized() const
+{
+	return _impl->authorized;
+}
+
+std::string EQ::Net::WebsocketServerConnection::GetAccountName() const
+{
+	return _impl->account_name;
+}
+
+uint32 EQ::Net::WebsocketServerConnection::GetAccountID() const
+{
+	return _impl->account_id;
+}
+
+int EQ::Net::WebsocketServerConnection::GetStatus() const
+{
+	return _impl->status;
+}
+
+std::string EQ::Net::WebsocketServerConnection::RemoteIP() const
+{
+	return _impl->connection->RemoteIP();
+}
+
+int EQ::Net::WebsocketServerConnection::RemotePort() const
+{
+	return _impl->connection->RemotePort();
+}
+
+std::shared_ptr<EQ::Net::websocket_connection> EQ::Net::WebsocketServerConnection::GetWebsocketConnection()
+{
+	return _impl->ws_connection;
+}
+
+std::shared_ptr<EQ::Net::TCPConnection> EQ::Net::WebsocketServerConnection::GetTCPConnection()
+{
+	return _impl->connection;
+}
+
+void EQ::Net::WebsocketServerConnection::OnMessage(websocketpp::connection_hdl hdl, websocket_message_ptr msg)
+{
+	BenchTimer timer;
+	timer.reset();
+
+	if (msg->get_opcode() == websocketpp::frame::opcode::text) {
+		try {
+			auto &payload = msg->get_payload();
+
+			std::stringstream ss(payload);
+			Json::Value root;
+
+			ss >> root;
+
+			auto method = root["method"].asString();
+			auto params = root["params"];
+			std::string id = "";
+
+			auto idNode = root["id"];
+			if (!idNode.isNull() && idNode.isString()) {
+				id = idNode.asString();
+			}
+
+			Json::Value response;
+			response["type"] = "method";
+			response["data"] = _impl->parent->HandleRequest(this, method, params);
+			response["method"] = method;
+			if(id != "") {
+				response["id"] = id;
+			}
+
+			SendResponse(response, timer.elapsed());
+		}
+		catch (std::exception &ex) {
+			Json::Value error;
+			error["type"] = "method";
+			error["error"] = fmt::format("{0}", ex.what());
+			SendResponse(error, timer.elapsed());
+		}
+	}
+}
+
+void EQ::Net::WebsocketServerConnection::SendResponse(const Json::Value &response, double time_elapsed)
+{
+	Json::Value root = response;
+	root["execution_time"] = std::to_string(time_elapsed);
+
+	std::stringstream payload;
+	payload << root;
+
+	_impl->ws_connection->send(payload.str());
+}
+
+void EQ::Net::WebsocketServerConnection::SetAuthorized(bool v, const std::string account_name, uint32 account_id, int status)
+{
+	_impl->authorized = v;
+	_impl->account_name = account_name;
+	_impl->account_id = account_id;
+	_impl->status = status;
+}
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "tcp_server.h"
+#include "../types.h"
+#include "../json/json-forwards.h"
+#include <websocketpp/config/core.hpp>
+#include <websocketpp/server.hpp>
+
+namespace EQ
+{
+	namespace Net
+	{
+		typedef websocketpp::server<websocketpp::config::core> websocket_server;
+		typedef websocketpp::connection<websocketpp::config::core> websocket_connection;
+		typedef websocket_server::message_ptr websocket_message_ptr;
+
+		class WebsocketServer;
+		class WebsocketServerConnection
+		{
+		public:
+			WebsocketServerConnection(WebsocketServer *parent, 
+				std::shared_ptr<TCPConnection> connection, 
+				std::shared_ptr<websocket_connection> ws_connection);
+			~WebsocketServerConnection();
+
+			std::string GetID() const;
+			bool IsAuthorized() const;
+			std::string GetAccountName() const;
+			uint32 GetAccountID() const;
+			int GetStatus() const;
+			std::string RemoteIP() const;
+			int RemotePort() const;
+		private:
+			std::shared_ptr<websocket_connection> GetWebsocketConnection();
+			std::shared_ptr<TCPConnection> GetTCPConnection();
+			void OnMessage(websocketpp::connection_hdl hdl, websocket_message_ptr msg);
+			void SendResponse(const Json::Value &response, double time_elapsed);
+			void SetAuthorized(bool v, const std::string account_name, uint32 account_id, int status);
+
+			struct Impl;
+			std::unique_ptr<Impl> _impl;
+
+			friend class WebsocketServer;
+		};
+	}
+}
@@ -16,6 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

+#include "eqemu_logsys.h"
 #include "emu_opcodes.h"
 #include "opcodemgr.h"

@@ -31,7 +32,7 @@ OpcodeManager::OpcodeManager() {
 bool OpcodeManager::LoadOpcodesFile(const char *filename, OpcodeSetStrategy *s, bool report_errors) {
 	FILE *opf = fopen(filename, "r");
 	if(opf == nullptr) {
-		fprintf(stderr, "Unable to open opcodes file '%s'. Thats bad.\n", filename);
+		LogError("Unable to open opcodes file [{}]", filename);
 		return(false);
 	}

@@ -85,7 +85,7 @@ namespace RoF
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -108,7 +108,7 @@ namespace RoF
 		signature.first_length = sizeof(structs::ClientZoneEntry_Struct);
 		signature.first_eq_opcode = opcodes->EmuToEQ(OP_ZoneEntry);
 		into.RegisterPatch(signature, pname.c_str(), &opcodes, &struct_strategy);
-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -125,10 +125,10 @@ namespace RoF
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -350,7 +350,7 @@ namespace RoF

 		if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
 			delete in;
 			return;
 		}
@@ -589,7 +589,7 @@ namespace RoF
 		for (int index = 0; index < item_count; ++index, ++eq) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0, ItemPacketCharInventory);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "RoF::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("RoF::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);

 			last_pos = ob.tellp();
 		}
@@ -624,6 +624,7 @@ namespace RoF
 		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);

 		OUT(spawn_id);
+		OUT(vehicle_id);
 		OUT(x_pos);
 		OUT(delta_x);
 		OUT(delta_y);
@@ -1521,7 +1522,7 @@ namespace RoF

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0, old_item_pkt->PacketType);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "RoF::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("RoF::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -2602,7 +2603,7 @@ namespace RoF

 		outapp->WriteUInt8(0);				// Unknown

-		Log(Logs::General, Logs::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition());
+		LogNetcode("[STRUCTS] Player Profile Packet is [{}] bytes", outapp->GetWritePosition());

 		auto NewBuffer = new unsigned char[outapp->GetWritePosition()];
 		memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition());
@@ -3199,47 +3200,35 @@ namespace RoF
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name); // NPC names max out at 63 chars

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToRoFSayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_Stun)
@@ -3465,7 +3454,7 @@ namespace RoF

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -3816,7 +3805,7 @@ namespace RoF
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -4064,7 +4053,7 @@ namespace RoF
 			Buffer += 29;
 			if (Buffer != (BufferStart + PacketSize))
 			{
-				Log(Logs::General, Logs::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize));
+				LogNetcode("[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now [{}] from end", Buffer - (BufferStart + PacketSize));
 			}
 			//Log.LogDebugType(Logs::General, Logs::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size);
 			//Log.Hex(Logs::Netcode, outapp->pBuffer, outapp->size);
@@ -4326,6 +4315,7 @@ namespace RoF
 		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);

 		IN(spawn_id);
+		IN(vehicle_id);
 		IN(sequence);
 		IN(x_pos);
 		IN(y_pos);
@@ -4633,7 +4623,7 @@ namespace RoF
 			return;
 		}
 		default:
-			Log(Logs::Detail, Logs::Netcode, "Unhandled OP_GuildBank action");
+			LogNetcode("Unhandled OP_GuildBank action");
 			__packet->SetOpcode(OP_Unknown); /* invalidate the packet */
 			return;
 		}
@@ -5690,7 +5680,7 @@ namespace RoF
 			RoFSlot = server_corpse_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to RoF Corpse Main Slot %i", server_corpse_slot, RoFSlot);
+		LogNetcode("Convert Server Corpse Slot [{}] to RoF Corpse Main Slot [{}]", server_corpse_slot, RoFSlot);

 		return RoFSlot;
 	}
@@ -85,7 +85,7 @@ namespace RoF2
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -111,7 +111,7 @@ namespace RoF2



-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -128,10 +128,10 @@ namespace RoF2
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -419,7 +419,7 @@ namespace RoF2

 		if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
 			delete in;
 			return;
 		}
@@ -657,7 +657,7 @@ namespace RoF2
 		for (int index = 0; index < item_count; ++index, ++eq) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0, ItemPacketCharInventory);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "RoF2::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("RoF2::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);

 			last_pos = ob.tellp();
 		}
@@ -686,25 +686,6 @@ namespace RoF2
 		FINISH_ENCODE();
 	}

-	ENCODE(OP_ClientUpdate)
-	{
-		ENCODE_LENGTH_EXACT(PlayerPositionUpdateServer_Struct);
-		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);
-
-		OUT(spawn_id);
-		OUT(x_pos);
-		OUT(delta_x);
-		OUT(delta_y);
-		OUT(z_pos);
-		OUT(delta_heading);
-		OUT(y_pos);
-		OUT(delta_z);
-		OUT(animation);
-		OUT(heading);
-
-		FINISH_ENCODE();
-	}
-
 	ENCODE(OP_Consider)
 	{
 		ENCODE_LENGTH_EXACT(Consider_Struct);
@@ -1589,7 +1570,7 @@ namespace RoF2

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0, old_item_pkt->PacketType);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "RoF2::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("RoF2::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -2688,7 +2669,7 @@ namespace RoF2
 		// Think we need 1 byte of padding at the end
 		outapp->WriteUInt8(0);				// Unknown

-		Log(Logs::General, Logs::Netcode, "[STRUCTS] Player Profile Packet is %i bytes", outapp->GetWritePosition());
+		LogNetcode("[STRUCTS] Player Profile Packet is [{}] bytes", outapp->GetWritePosition());

 		auto NewBuffer = new unsigned char[outapp->GetWritePosition()];
 		memcpy(NewBuffer, outapp->pBuffer, outapp->GetWritePosition());
@@ -3266,47 +3247,35 @@ namespace RoF2
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name); // NPC names max out at 63 chars

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToRoF2SayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_Stun)
@@ -3532,7 +3501,7 @@ namespace RoF2

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -3642,7 +3611,7 @@ namespace RoF2

 		OUT(TraderID);
 		snprintf(eq->SerialNumber, sizeof(eq->SerialNumber), "%016d", emu->ItemID);
-		Log(Logs::Detail, Logs::Trading, "ENCODE(OP_TraderDelItem): TraderID %d, SerialNumber: %d", emu->TraderID, emu->ItemID);
+		LogTrading("ENCODE(OP_TraderDelItem): TraderID [{}], SerialNumber: [{}]", emu->TraderID, emu->ItemID);

 		FINISH_ENCODE();
 	}
@@ -3673,7 +3642,7 @@ namespace RoF2
 			eq->Traders2 = emu->Traders;
 			eq->Items2 = emu->Items;

-			Log(Logs::Detail, Logs::Trading, "ENCODE(OP_TraderShop): BazaarWelcome_Struct Code %d, Traders %d, Items %d",
+			LogTrading("ENCODE(OP_TraderShop): BazaarWelcome_Struct Code [{}], Traders [{}], Items [{}]",
 				eq->Code, eq->Traders, eq->Items);

 			FINISH_ENCODE();
@@ -3696,14 +3665,14 @@ namespace RoF2
 			OUT(Quantity);
 			snprintf(eq->SerialNumber, sizeof(eq->SerialNumber), "%016d", emu->ItemID);

-			Log(Logs::Detail, Logs::Trading, "ENCODE(OP_TraderShop): Buy Action %d, Price %d, Trader %d, ItemID %d, Quantity %d, ItemName, %s",
+			LogTrading("ENCODE(OP_TraderShop): Buy Action [{}], Price [{}], Trader [{}], ItemID [{}], Quantity [{}], ItemName, [{}]",
 				eq->Action, eq->Price, eq->TraderID, eq->ItemID, eq->Quantity, emu->ItemName);

 			FINISH_ENCODE();
 		}
 		else
 		{
-			Log(Logs::Detail, Logs::Trading, "ENCODE(OP_TraderShop): Encode Size Unknown (%d)", psize);
+			LogTrading("ENCODE(OP_TraderShop): Encode Size Unknown ([{}])", psize);
 		}
 	}

@@ -3958,7 +3927,7 @@ namespace RoF2
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -4290,7 +4259,7 @@ namespace RoF2
 			Buffer += 29;
 			if (Buffer != (BufferStart + PacketSize))
 			{
-				Log(Logs::General, Logs::Netcode, "[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now %i from end", Buffer - (BufferStart + PacketSize));
+				LogNetcode("[ERROR] SPAWN ENCODE LOGIC PROBLEM: Buffer pointer is now [{}] from end", Buffer - (BufferStart + PacketSize));
 			}
 			//Log.LogDebugType(Logs::General, Logs::Netcode, "[ERROR] Sending zone spawn for %s packet is %i bytes", emu->name, outapp->size);
 			//Log.Hex(Logs::Netcode, outapp->pBuffer, outapp->size);
@@ -4557,27 +4526,6 @@ namespace RoF2
 		FINISH_DIRECT_DECODE();
 	}

-	DECODE(OP_ClientUpdate)
-	{
-		// for some odd reason, there is an extra byte on the end of this on occasion..
-		DECODE_LENGTH_ATLEAST(structs::PlayerPositionUpdateClient_Struct);
-		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);
-
-		IN(spawn_id);
-		IN(sequence);
-		IN(x_pos);
-		IN(y_pos);
-		IN(z_pos);
-		IN(heading);
-		IN(delta_x);
-		IN(delta_y);
-		IN(delta_z);
-		IN(delta_heading);
-		IN(animation);
-
-		FINISH_DIRECT_DECODE();
-	}
-
 	DECODE(OP_Consider)
 	{
 		DECODE_LENGTH_EXACT(structs::Consider_Struct);
@@ -4871,7 +4819,7 @@ namespace RoF2
 			return;
 		}
 		default:
-			Log(Logs::Detail, Logs::Netcode, "Unhandled OP_GuildBank action");
+			LogNetcode("Unhandled OP_GuildBank action");
 			__packet->SetOpcode(OP_Unknown); /* invalidate the packet */
 			return;
 		}
@@ -5024,7 +4972,7 @@ namespace RoF2
 		emu->to_slot = RoF2ToServerSlot(eq->to_slot);
 		IN(number_in_stack);
 		
-		//Log(Logs::General, Logs::Netcode, "[RoF2] MoveItem Slot from %u to %u, Number %u", emu->from_slot, emu->to_slot, emu->number_in_stack);
+		//LogNetcode("[RoF2] MoveItem Slot from [{}] to [{}], Number [{}]", emu->from_slot, emu->to_slot, emu->number_in_stack);

 		FINISH_DIRECT_DECODE();
 	}
@@ -5257,7 +5205,7 @@ namespace RoF2
 			IN(Code);
 			IN(TraderID);
 			IN(Approval);
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): TraderClick_Struct Code %d, TraderID %d, Approval %d",
+			LogTrading("DECODE(OP_TraderShop): TraderClick_Struct Code [{}], TraderID [{}], Approval [{}]",
 				eq->Code, eq->TraderID, eq->Approval);

 			FINISH_DIRECT_DECODE();
@@ -5271,7 +5219,7 @@ namespace RoF2
 			emu->Beginning.Action = eq->Code;
 			IN(Traders);
 			IN(Items);
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): BazaarWelcome_Struct Code %d, Traders %d, Items %d",
+			LogTrading("DECODE(OP_TraderShop): BazaarWelcome_Struct Code [{}], Traders [{}], Items [{}]",
 				eq->Code, eq->Traders, eq->Items);

 			FINISH_DIRECT_DECODE();
@@ -5288,20 +5236,20 @@ namespace RoF2
 			memcpy(emu->ItemName, eq->ItemName, sizeof(emu->ItemName));
 			IN(ItemID);
 			IN(Quantity);
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): TraderBuy_Struct (Unknowns) Unknown004 %d, Unknown008 %d, Unknown012 %d, Unknown076 %d, Unknown276 %d",
+			LogTrading("DECODE(OP_TraderShop): TraderBuy_Struct (Unknowns) Unknown004 [{}], Unknown008 [{}], Unknown012 [{}], Unknown076 [{}], Unknown276 [{}]",
 				eq->Unknown004, eq->Unknown008, eq->Unknown012, eq->Unknown076, eq->Unknown276);
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): TraderBuy_Struct Buy Action %d, Price %d, Trader %d, ItemID %d, Quantity %d, ItemName, %s",
+			LogTrading("DECODE(OP_TraderShop): TraderBuy_Struct Buy Action [{}], Price [{}], Trader [{}], ItemID [{}], Quantity [{}], ItemName, [{}]",
 				eq->Action, eq->Price, eq->TraderID, eq->ItemID, eq->Quantity, eq->ItemName);

 			FINISH_DIRECT_DECODE();
 		}
 		else if (psize == 4)
 		{
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): Forwarding packet as-is with size 4");
+			LogTrading("DECODE(OP_TraderShop): Forwarding packet as-is with size 4");
 		}
 		else
 		{
-			Log(Logs::Detail, Logs::Trading, "DECODE(OP_TraderShop): Decode Size Unknown (%d)", psize);
+			LogTrading("DECODE(OP_TraderShop): Decode Size Unknown ([{}])", psize);
 		}
 	}

@@ -5978,7 +5926,7 @@ namespace RoF2
 			RoF2Slot = server_corpse_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to RoF2 Corpse Main Slot %i", server_corpse_slot, RoF2Slot);
+		LogNetcode("Convert Server Corpse Slot [{}] to RoF2 Corpse Main Slot [{}]", server_corpse_slot, RoF2Slot);

 		return RoF2Slot;
 	}
@@ -6161,7 +6109,7 @@ namespace RoF2
 			ServerSlot = rof2_corpse_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert RoF2 Corpse Main Slot %i to Server Corpse Slot %i", rof2_corpse_slot, ServerSlot);
+		LogNetcode("Convert RoF2 Corpse Main Slot [{}] to Server Corpse Slot [{}]", rof2_corpse_slot, ServerSlot);

 		return ServerSlot;
 	}
@@ -52,7 +52,6 @@ E(OP_CastSpell)
 E(OP_ChannelMessage)
 E(OP_CharInventory)
 E(OP_ClickObjectAction)
-E(OP_ClientUpdate)
 E(OP_Consider)
 E(OP_Damage)
 E(OP_DeleteCharge)
@@ -155,7 +154,6 @@ D(OP_BuffRemoveRequest)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)
-D(OP_ClientUpdate)
 D(OP_Consider)
 D(OP_ConsiderCorpse)
 D(OP_Consume)
@@ -1620,24 +1620,24 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-	/*0000*/	uint16	spawn_id;
-	/*0002*/	uint16	spawnId2;
-	/*0004*/	signed	padding0004 : 12;
-				signed	y_pos : 19;			// y coord
-				unsigned padding : 1;
-	/*0008*/	signed	delta_z : 13;			// change in z
-				signed	delta_x : 13;			// change in x
-				signed	padding0008 : 6;
-	/*0012*/	signed	x_pos : 19;			// x coord
-				unsigned heading : 12;		// heading
-				signed	padding0016 : 1;
-	/*0016*/	signed	delta_heading : 10;	// change in heading
-				signed	z_pos : 19;			// z coord
-				signed	padding0020 : 3;
-	/*0020*/	signed	animation : 10;		// animation
-				signed	delta_y : 13;			// change in y
-				signed	padding0024 : 9;
-	/*0024*/
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_z : 13;		// change in z
+			signed		delta_x : 13;		// change in x
+			signed		padding0008 : 6;
+/*0012*/	signed		x_pos : 19;			// x coord
+			unsigned	heading : 12;		// heading
+			signed		padding0016 : 1;
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			signed		z_pos : 19;			// z coord
+			signed		padding0020 : 3;
+/*0020*/	signed		animation : 10;		// animation
+			signed		delta_y : 13;		// change in y
+			signed		padding0024 : 9;
+/*0024*/
 };

 /*
@@ -1648,22 +1648,23 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-	/*0000*/	uint16		sequence;			// increments one each packet - Verified
-	/*0002*/	uint16		spawn_id;			// Player's spawn id
-	/*0004*/	uint8		unknown0004[6];		// ***Placeholder
-	/*0010*/	float		delta_x;			// Change in x
-	/*0014*/	unsigned	heading : 12;			// Directional heading
-				unsigned	padding0040 : 20;		// ***Placeholder
-	/*0018*/	float		x_pos;				// x coord (2nd loc value)
-	/*0022*/	float		delta_z;			// Change in z
-	/*0026*/	float		z_pos;				// z coord (3rd loc value)
-	/*0030*/	float		y_pos;				// y coord (1st loc value)
-	/*0034*/	unsigned	animation : 10;		// ***Placeholder
-				unsigned	padding0024 : 22;		// animation
-	/*0038*/	float		delta_y;			// Change in y
-	/*0042*/	signed		delta_heading : 10;	// change in heading
-				unsigned	padding0041 : 22;		// ***Placeholder
-	/*0046*/
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_x;			// Change in x
+/*0014*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 20;	// ***Placeholder
+/*0018*/	float		x_pos;				// x coord (2nd loc value)
+/*0022*/	float		delta_z;			// Change in z
+/*0026*/	float		z_pos;				// z coord (3rd loc value)
+/*0030*/	float		y_pos;				// y coord (1st loc value)
+/*0034*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 22;	// animation
+/*0038*/	float		delta_y;			// Change in y
+/*0042*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0041 : 22;	// ***Placeholder
+/*0046*/
 };

 /*
@@ -1608,22 +1608,22 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16	spawn_id;
-/*0002*/ uint16	spawnId2;
-/*0004*/ signed	padding0004:12;
-         signed	y_pos:19;           // y coord
-	 unsigned padding:1;
-/*0008*/ signed	delta_x:13;      // change in x
-         signed	delta_heading:10;// change in heading
-         signed	padding0008:9;
-/*0012*/ signed	delta_y:13;      // change in y
-         signed	z_pos:19;           // z coord
-/*0016*/ signed	x_pos:19;           // x coord
-         signed	animation:10;   // animation
-         signed	padding0016:3;
-/*0020*/ unsigned heading:12;     // heading
-         signed	delta_z:13;      // change in z
-         signed	padding0020:7;
+/*0000*/	uint16		spawn_id;
+/*0002*/	uint16		vehicle_id;
+/*0004*/	signed		padding0004 : 12;
+			signed		y_pos : 19;			// y coord
+			unsigned	padding : 1;
+/*0008*/	signed		delta_x : 13;		// change in x
+			signed		delta_heading : 10;	// change in heading
+			signed		padding0008 : 9;
+/*0012*/	signed		delta_y : 13;		// change in y
+			signed		z_pos : 19;			// z coord
+/*0016*/	signed		x_pos : 19;			// x coord
+			signed		animation : 10;		// animation
+			signed		padding0016 : 3;
+/*0020*/	unsigned	heading : 12;		// heading
+			signed		delta_z : 13;		// change in z
+			signed		padding0020 : 7;
 /*0024*/
 };

@@ -1636,21 +1636,22 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		sequence;			// increments one each packet - Verified
-/*0002*/ uint16		spawn_id;			// Player's spawn id
-/*0004*/ uint8		unknown0004[6];		// ***Placeholder
-/*0010*/ float		delta_y;			// Change in y
-/*0014*/ float		x_pos;				// x coord (2nd loc value)
-/*0018*/ float		y_pos;				// y coord (1st loc value)
-/*0022*/ signed		delta_heading:10;	// change in heading
-	 unsigned	animation:10;		// ***Placeholder
-         unsigned	padding0024:12;		// animation
-/*0026*/ float		delta_z;			// Change in z
-/*0030*/ float		delta_x;			// Change in x
-/*0034*/ float		z_pos;				// z coord (3rd loc value)
-/*0038*/ unsigned	heading:12;			// Directional heading
-         unsigned	padding0040:10;		// ***Placeholder
-         unsigned	padding0041:10;		// ***Placeholder
+/*0000*/	uint16		sequence;			// increments one each packet - Verified
+/*0002*/	uint16		spawn_id;			// Player's spawn id
+/*0004*/	uint16		vehicle_id;			// Player's vehicle spawn id
+/*0006*/	uint8		unknown0004[4];		// ***Placeholder
+/*0010*/	float		delta_y;			// Change in y
+/*0014*/	float		x_pos;				// x coord (2nd loc value)
+/*0018*/	float		y_pos;				// y coord (1st loc value)
+/*0022*/	signed		delta_heading : 10;	// change in heading
+			unsigned	animation : 10;		// ***Placeholder
+			unsigned	padding0024 : 12;	// animation
+/*0026*/	float		delta_z;			// Change in z
+/*0030*/	float		delta_x;			// Change in x
+/*0034*/	float		z_pos;				// z coord (3rd loc value)
+/*0038*/	unsigned	heading : 12;		// Directional heading
+			unsigned	padding0040 : 10;	// ***Placeholder
+			unsigned	padding0041 : 10;	// ***Placeholder
 /*0042*/
 };

@@ -79,7 +79,7 @@ namespace SoD
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -105,7 +105,7 @@ namespace SoD



-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -122,10 +122,10 @@ namespace SoD
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -277,7 +277,7 @@ namespace SoD

 		if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
 			delete in;
 			return;
 		}
@@ -400,7 +400,7 @@ namespace SoD
 		for (int index = 0; index < item_count; ++index, ++eq) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "SoD::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("SoD::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);

 			last_pos = ob.tellp();
 		}
@@ -1069,7 +1069,7 @@ namespace SoD

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "SoD::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("SoD::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -2069,47 +2069,35 @@ namespace SoD
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name); // NPC names max out at 63 chars

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToSoDSayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_Stun)
@@ -2210,7 +2198,7 @@ namespace SoD

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -2447,7 +2435,7 @@ namespace SoD
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -2938,6 +2926,7 @@ namespace SoD
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;

 		FINISH_DIRECT_DECODE();
 	}
@@ -3860,7 +3849,7 @@ namespace SoD
 			SoDSlot = serverSlot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to SoD Slot %i", serverSlot, SoDSlot);
+		LogNetcode("Convert Server Slot [{}] to SoD Slot [{}]", serverSlot, SoDSlot);

 		return SoDSlot;
 	}
@@ -3877,7 +3866,7 @@ namespace SoD
 			SoDSlot = server_corpse_slot - 2;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to SoD Corpse Slot %i", server_corpse_slot, SoDSlot);
+		LogNetcode("Convert Server Corpse Slot [{}] to SoD Corpse Slot [{}]", server_corpse_slot, SoDSlot);

 		return SoDSlot;
 	}
@@ -3942,7 +3931,7 @@ namespace SoD
 			server_slot = sod_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert SoD Slot %i to Server Slot %i", sod_slot, server_slot);
+		LogNetcode("Convert SoD Slot [{}] to Server Slot [{}]", sod_slot, server_slot);

 		return server_slot;
 	}
@@ -3959,7 +3948,7 @@ namespace SoD
 			server_slot = sod_corpse_slot + 2;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert SoD Corpse Slot %i to Server Corpse Slot %i", sod_corpse_slot, server_slot);
+		LogNetcode("Convert SoD Corpse Slot [{}] to Server Corpse Slot [{}]", sod_corpse_slot, server_slot);

 		return server_slot;
 	}
@@ -1372,21 +1372,21 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ signed		padding0000:12; // ***Placeholder
-         signed		delta_x:13;      // change in x
-         signed		padding0005:7;  // ***Placeholder
-/*0006*/ signed		delta_heading:10;// change in heading
-         signed		delta_y:13;      // change in y
-         signed		padding0006:9;  // ***Placeholder
-/*0010*/ signed		y_pos:19;           // y coord
-         signed		animation:10;   // animation
-         signed		padding0010:3;  // ***Placeholder
-/*0014*/ unsigned	heading:12;     // heading
-         signed		x_pos:19;           // x coord
-         signed		padding0014:1;  // ***Placeholder
-/*0018*/ signed		z_pos:19;           // z coord
-         signed		delta_z:13;      // change in z
+/*0000*/	uint16		spawn_id;
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		delta_x : 13;		// change in x
+			signed		padding0005 : 7;	// ***Placeholder
+/*0006*/	signed		delta_heading : 10;	// change in heading
+			signed		delta_y : 13;		// change in y
+			signed		padding0006 : 9;	// ***Placeholder
+/*0010*/	signed		y_pos : 19;			// y coord
+			signed		animation : 10;		// animation
+			signed		padding0010 : 3;	// ***Placeholder
+/*0014*/	unsigned	heading : 12;		// heading
+			signed		x_pos : 19;			// x coord
+			signed		padding0014 : 1;	// ***Placeholder
+/*0018*/	signed		z_pos : 19;			// z coord
+			signed		delta_z : 13;		// change in z
 /*0022*/
 };

@@ -1399,21 +1399,21 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		spawn_id;			// Player's spawn id
-/*0002*/ uint16		sequence;			// increments one each packet - Verified
-/*0004*/ uint8		unknown0004[4];		// ***Placeholder
-/*0008*/ float		x_pos;				// x coord (2nd loc value)
-/*0012*/ float		y_pos;				// y coord (1st loc value)
-/*0016*/ signed		delta_heading:10;	// change in heading
-         unsigned	padding0036:10;		// animation
-         unsigned	padding0016:12;		// ***Placeholder
-/*0020*/ float		delta_x;			// Change in x
-/*0024*/ float		delta_y;			// Change in y
-/*0028*/ float		z_pos;				// z coord (3rd loc value)
-/*0032*/ float		delta_z;			// Change in z
-/*0036*/ unsigned	animation:10;		// ***Placeholder
-         unsigned	heading:12;			// Directional heading
-         unsigned	padding0037:10;		// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Player's spawn id
+/*0002*/	uint16		sequence;			// increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		x_pos;				// x coord (2nd loc value)
+/*0012*/	float		y_pos;				// y coord (1st loc value)
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0036 : 10;	// animation
+			unsigned	padding0016 : 12;	// ***Placeholder
+/*0020*/	float		delta_x;			// Change in x
+/*0024*/	float		delta_y;			// Change in y
+/*0028*/	float		z_pos;				// z coord (3rd loc value)
+/*0032*/	float		delta_z;			// Change in z
+/*0036*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	heading : 12;		// Directional heading
+			unsigned	padding0037 : 10;	// ***Placeholder
 /*0040*/
 };

@@ -79,7 +79,7 @@ namespace SoF
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -103,7 +103,7 @@ namespace SoF
 		signature.first_eq_opcode = opcodes->EmuToEQ(OP_ZoneEntry);
 		into.RegisterPatch(signature, pname.c_str(), &opcodes, &struct_strategy);

-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -120,10 +120,10 @@ namespace SoF
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -380,7 +380,7 @@ namespace SoF
 		for (int index = 0; index < item_count; ++index, ++eq) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "SoF::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("SoF::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);

 			last_pos = ob.tellp();
 		}
@@ -864,7 +864,7 @@ namespace SoF

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "SoF::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("SoF::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -1116,7 +1116,10 @@ namespace SoF
 		}
 		OUT(deity);
 		OUT(intoxication);
+
 		OUT_array(spellSlotRefresh, spells::SPELL_GEM_COUNT);
+		eq->spellSlotRefresh[9] = 0; // 10th slot is not valid in this release
+
 		OUT(abilitySlotRefresh);
 		OUT(points); // Relocation Test
 		//	OUT(unknown0166[4]);
@@ -1177,7 +1180,10 @@ namespace SoF
 		}

 		//	OUT(unknown4184[128]);
+
 		OUT_array(mem_spells, spells::SPELL_GEM_COUNT);
+		eq->mem_spells[9] = 0xFFFFFFFFU; // 10th slot is not valid in this release
+
 		//	OUT(unknown04396[32]);
 		OUT(platinum);
 		OUT(gold);
@@ -1720,47 +1726,35 @@ namespace SoF
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name);

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToSoFSayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_Stun)
@@ -1833,7 +1827,7 @@ namespace SoF

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -1995,7 +1989,7 @@ namespace SoF
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -2393,6 +2387,7 @@ namespace SoF
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;

 		FINISH_DIRECT_DECODE();
 	}
@@ -3250,7 +3245,7 @@ namespace SoF
 			sof_slot = server_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to SoF Slot %i", server_slot, sof_slot);
+		LogNetcode("Convert Server Slot [{}] to SoF Slot [{}]", server_slot, sof_slot);

 		return sof_slot;
 	}
@@ -3336,7 +3331,7 @@ namespace SoF
 			server_slot = sof_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert SoF Slot %i to Server Slot %i", sof_slot, server_slot);
+		LogNetcode("Convert SoF Slot [{}] to Server Slot [{}]", sof_slot, server_slot);

 		return server_slot;
 	}
@@ -328,7 +328,11 @@ namespace SoF

 		const int SPELL_ID_MAX = 15999;
 		const int SPELLBOOK_SIZE = 480;
+		// Be careful not to confuse these two..SoF disc release has a special requirement...
+		// - The number of available spell gems HAS NOT increased from 9 at this point
+		// - The profile allocation HAS increased to 10 at this point
 		const int SPELL_GEM_COUNT = static_cast<uint32>(CastingSlot::MaxGems);
+		const int SPELL_GEM_PROFILE_SIZE = 10; // special case declaration
 		
 		const int LONG_BUFFS = 25;
 		const int SHORT_BUFFS = 15;
@@ -885,7 +885,7 @@ struct PlayerProfile_Struct //23576 Octets
 /*00060*/ BindStruct binds[5];			// Bind points (primary is first)
 /*00160*/ uint32  deity;				// deity
 /*00164*/ uint32  intoxication;			// Alcohol level (in ticks till sober?)
-/*00168*/ uint32  spellSlotRefresh[spells::SPELL_GEM_COUNT]; // Refresh time (millis) - 4 Octets Each
+/*00168*/ uint32  spellSlotRefresh[spells::SPELL_GEM_PROFILE_SIZE]; // Refresh time (millis) - 4 Octets Each
 /*00208*/ uint32  abilitySlotRefresh;
 /*00212*/ uint8   haircolor;			// Player hair color
 /*00213*/ uint8   beardcolor;			// Player beard color
@@ -912,7 +912,7 @@ struct PlayerProfile_Struct //23576 Octets
 /*04173*/ uint8 unknown02264[147];		// was [139]
 /*04312*/ uint32   spell_book[spells::SPELLBOOK_SIZE];	// List of the Spells in spellbook 480 = 60 pages
 /*06232*/ uint8   unknown4184[128];		// was [136]
-/*06396*/ uint32   mem_spells[spells::SPELL_GEM_COUNT]; // List of spells memorized
+/*06396*/ uint32   mem_spells[spells::SPELL_GEM_PROFILE_SIZE]; // List of spells memorized
 /*06436*/ uint8 unknown04396[28];		//#### uint8 unknown04396[32]; in Titanium ####[28]
 /*06464*/ uint32  platinum;				// Platinum Pieces on player
 /*06468*/ uint32  gold;					// Gold Pieces on player
@@ -1373,21 +1373,21 @@ struct RespawnWindow_Struct {

 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16   spawn_id;			// Entity ID of the Spawn/Player
-/*0002*/ signed   padding0000:12;	// ***Placeholder
-		 signed   x_pos:19;			// x coord
-		 signed   padding0290:1;	// ***Placeholder
-/*0006*/ signed   delta_x:13;		// change in x
-		 signed   delta_y:13;		// change in y
-		 signed   padding0294:6;	// ***Placeholder
-/*0010*/ signed   z_pos:19;			// z coord
-		 signed   delta_heading:10;	// change in heading
-		 signed   padding0298:3;	// ***Placeholder
-/*0014*/ signed   y_pos:19;			// y coord
-		 signed   delta_z:13;		// change in z
-/*0022*/ signed   animation:10;		// animation
-		 unsigned heading:12;		// heading
-		 signed   padding0302:10;	// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Entity ID of the Spawn/Player
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		x_pos : 19;			// x coord
+			signed		padding0290 : 1;	// ***Placeholder
+/*0006*/	signed		delta_x : 13;		// change in x
+			signed		delta_y : 13;		// change in y
+			signed		padding0294 : 6;	// ***Placeholder
+/*0010*/	signed		z_pos : 19;			// z coord
+			signed		delta_heading : 10;	// change in heading
+			signed		padding0298 : 3;	// ***Placeholder
+/*0014*/	signed		y_pos : 19;			// y coord
+			signed		delta_z : 13;		// change in z
+/*0022*/	signed		animation : 10;		// animation
+			unsigned	heading : 12;		// heading
+			signed		padding0302 : 10;	// ***Placeholder
 /*0026*/
 };

@@ -1399,20 +1399,20 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16 spawn_id;			// Player's Entity ID - Verified
-/*0002*/ uint16	sequence;			//increments one each packet - Verified
-/*0004*/ uint8 unknown0004[4];		// ***Placeholder
-/*0008*/ float delta_z;				// Change in z
-/*0012*/ float x_pos;				// x coord - Verified
-/*0016*/ signed delta_heading:10;	// Change in heading
-		 signed animation:10;		// Animation
-         unsigned padding0028:12;	// Seems to always be 0
-/*0020*/ float y_pos;				// y coord - Verified
-/*0024*/ float delta_x;				// Change in x
-/*0028*/ unsigned heading:12;		// Directional heading - Verified
-         unsigned padding0032:20;	// ***Placeholder - Some Static Number
-/*0032*/ float delta_y;				// Change in y
-/*0036*/ float z_pos;				// z coord - Verified
+/*0000*/	uint16		spawn_id;			// Player's Entity ID - Verified
+/*0002*/	uint16		sequence;			//increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		delta_z;			// Change in z
+/*0012*/	float		x_pos;				// x coord - Verified
+/*0016*/	signed		delta_heading : 10;	// Change in heading
+			signed		animation : 10;		// Animation
+			unsigned	padding0028 : 12;	// Seems to always be 0
+/*0020*/	float		y_pos;				// y coord - Verified
+/*0024*/	float		delta_x;			// Change in x
+/*0028*/	unsigned	heading : 12;		// Directional heading - Verified
+			unsigned	padding0032 : 20;	// ***Placeholder - Some Static Number
+/*0032*/	float		delta_y;			// Change in y
+/*0036*/	float		z_pos;				// z coord - Verified
 /*0040*/
 };

@@ -3768,7 +3768,7 @@ struct AnnoyingZoneUnknown_Struct {
 };

 struct LoadSpellSet_Struct {
-	uint32 spell[spells::SPELL_GEM_COUNT];
+	uint32 spell[spells::SPELL_GEM_PROFILE_SIZE];
 	uint32 unknown;
 };

@@ -87,14 +87,14 @@
 //check length of packet before decoding. Call before setup.
 #define ENCODE_LENGTH_EXACT(struct_) \
 	if((*p)->size != sizeof(struct_)) { \
-		Log(Logs::Detail, Logs::Netcode, "Wrong size on outbound %s (" #struct_ "): Got %d, expected %d", opcodes->EmuToName((*p)->GetOpcode()), (*p)->size, sizeof(struct_)); \
+		LogNetcode("Wrong size on outbound [{}] (" #struct_ "): Got [{}], expected [{}]", opcodes->EmuToName((*p)->GetOpcode()), (*p)->size, sizeof(struct_)); \
 		delete *p; \
 		*p = nullptr; \
 		return; \
 	}
 #define ENCODE_LENGTH_ATLEAST(struct_) \
 	if((*p)->size < sizeof(struct_)) { \
-		Log(Logs::Detail, Logs::Netcode, "Wrong size on outbound %s (" #struct_ "): Got %d, expected at least %d", opcodes->EmuToName((*p)->GetOpcode()), (*p)->size, sizeof(struct_)); \
+		LogNetcode("Wrong size on outbound [{}] (" #struct_ "): Got [{}], expected at least [{}]", opcodes->EmuToName((*p)->GetOpcode()), (*p)->size, sizeof(struct_)); \
 		delete *p; \
 		*p = nullptr; \
 		return; \
@@ -153,13 +153,13 @@
 //check length of packet before decoding. Call before setup.
 #define DECODE_LENGTH_EXACT(struct_) \
 	if(__packet->size != sizeof(struct_)) { \
-		Log(Logs::Detail, Logs::Netcode, "Wrong size on incoming %s (" #struct_ "): Got %d, expected %d", opcodes->EmuToName(__packet->GetOpcode()), __packet->size, sizeof(struct_)); \
+		LogNetcode("Wrong size on incoming [{}] (" #struct_ "): Got [{}], expected [{}]", opcodes->EmuToName(__packet->GetOpcode()), __packet->size, sizeof(struct_)); \
 		__packet->SetOpcode(OP_Unknown); /* invalidate the packet */ \
 		return; \
 	}
 #define DECODE_LENGTH_ATLEAST(struct_) \
 	if(__packet->size < sizeof(struct_)) { \
-		Log(Logs::Detail, Logs::Netcode, "Wrong size on incoming %s (" #struct_ "): Got %d, expected at least %d", opcodes->EmuToName(__packet->GetOpcode()), __packet->size, sizeof(struct_)); \
+		LogNetcode("Wrong size on incoming [{}] (" #struct_ "): Got [{}], expected at least [{}]", opcodes->EmuToName(__packet->GetOpcode()), __packet->size, sizeof(struct_)); \
 		__packet->SetOpcode(OP_Unknown); /* invalidate the packet */ \
 		return; \
 	}
@@ -78,7 +78,7 @@ namespace Titanium
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -104,7 +104,7 @@ namespace Titanium



-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -121,10 +121,10 @@ namespace Titanium
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -337,7 +337,7 @@ namespace Titanium
 		for (int r = 0; r < itemcount; r++, eq++) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, ServerToTitaniumSlot(eq->slot_id), 0);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "Titanium::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("Titanium::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);
 			
 			last_pos = ob.tellp();
 		}
@@ -350,6 +350,25 @@ namespace Titanium
 		dest->FastQueuePacket(&in, ack_req);
 	}

+	ENCODE(OP_ClientUpdate)
+	{
+		ENCODE_LENGTH_EXACT(PlayerPositionUpdateServer_Struct);
+		SETUP_DIRECT_ENCODE(PlayerPositionUpdateServer_Struct, structs::PlayerPositionUpdateServer_Struct);
+
+		OUT(spawn_id);
+		OUT(x_pos);
+		OUT(delta_x);
+		OUT(delta_y);
+		OUT(z_pos);
+		OUT(delta_heading);
+		OUT(y_pos);
+		OUT(delta_z);
+		OUT(animation);
+		OUT(heading);
+
+		FINISH_ENCODE();
+	}
+
 	ENCODE(OP_Damage)
 	{
 		ENCODE_LENGTH_EXACT(CombatDamage_Struct);
@@ -822,7 +841,7 @@ namespace Titanium

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, ServerToTitaniumSlot(int_struct->slot_id), 0);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "Titanium::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("Titanium::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -1420,47 +1439,35 @@ namespace Titanium
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name); // NPC names max out at 63 chars

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToTitaniumSayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_TaskDescription)
@@ -1522,7 +1529,7 @@ namespace Titanium

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -1640,7 +1647,7 @@ namespace Titanium
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -1890,6 +1897,28 @@ namespace Titanium
 		FINISH_DIRECT_DECODE();
 	}

+	DECODE(OP_ClientUpdate)
+	{
+		// for some odd reason, there is an extra byte on the end of this on occasion.. (copied from SoF..not sure if applies to Ti - TODO: check)
+		DECODE_LENGTH_ATLEAST(structs::PlayerPositionUpdateClient_Struct);
+		SETUP_DIRECT_DECODE(PlayerPositionUpdateClient_Struct, structs::PlayerPositionUpdateClient_Struct);
+
+		IN(spawn_id);
+		IN(sequence);
+		IN(x_pos);
+		IN(y_pos);
+		IN(z_pos);
+		IN(heading);
+		IN(delta_x);
+		IN(delta_y);
+		IN(delta_z);
+		IN(delta_heading);
+		IN(animation);
+		emu->vehicle_id = 0;
+
+		FINISH_DIRECT_DECODE();
+	}
+
 	DECODE(OP_Consume)
 	{
 		DECODE_LENGTH_EXACT(structs::Consume_Struct);
@@ -2315,7 +2344,10 @@ namespace Titanium
 		ob << '|' << itoa(item->SkillModType);

 		ob << '|' << itoa(item->BaneDmgRace);
-		ob << '|' << itoa(item->BaneDmgAmt);
+		if (item->BaneDmgAmt > 255)
+			ob << '|' << "255";
+		else
+			ob << '|' << itoa(item->BaneDmgAmt);
 		ob << '|' << itoa(item->BaneDmgBody);

 		ob << '|' << itoa(item->Magic);
@@ -2549,7 +2581,7 @@ namespace Titanium
 			titanium_slot = server_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to Titanium Slot %i", server_slot, titanium_slot);
+		LogNetcode("Convert Server Slot [{}] to Titanium Slot [{}]", server_slot, titanium_slot);

 		return titanium_slot;
 	}
@@ -2636,7 +2668,7 @@ namespace Titanium
 			server_slot = titanium_slot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Titanium Slot %i to Server Slot %i", titanium_slot, server_slot);
+		LogNetcode("Convert Titanium Slot [{}] to Server Slot [{}]", titanium_slot, server_slot);

 		return server_slot;
 	}
@@ -2657,7 +2689,7 @@ namespace Titanium
 			server_slot = titanium_corpse_slot + 4;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Titanium Corpse Slot %i to Server Corpse Slot %i", titanium_corpse_slot, server_slot);
+		LogNetcode("Convert Titanium Corpse Slot [{}] to Server Corpse Slot [{}]", titanium_corpse_slot, server_slot);

 		return server_slot;
 	}
@@ -27,6 +27,7 @@ E(OP_BecomeTrader)
 E(OP_Buff)
 E(OP_ChannelMessage)
 E(OP_CharInventory)
+E(OP_ClientUpdate)
 E(OP_Damage)
 E(OP_DeleteCharge)
 E(OP_DeleteItem)
@@ -82,6 +83,7 @@ D(OP_Bug)
 D(OP_CastSpell)
 D(OP_ChannelMessage)
 D(OP_CharacterCreate)
+D(OP_ClientUpdate)
 D(OP_Consume)
 D(OP_DeleteItem)
 D(OP_Emote)
@@ -1197,20 +1197,20 @@ struct BecomeCorpse_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ int32		delta_heading:10,  // change in heading
-         			x_pos:19,             // x coord
-         			padding0002:3;    // ***Placeholder
-/*0006*/ int32		y_pos:19,             // y coord
-         			animation:10,     // animation
-         			padding0006:3;    // ***Placeholder
-/*0010*/ int32		z_pos:19,             // z coord
-         			delta_y:13;        // change in y
-/*0014*/ int32		delta_x:13,        // change in x
-        			heading:12,       // heading
-         			padding0014:7;    // ***Placeholder
-/*0018*/ int32		delta_z:13,        // change in z
-         			padding0018:19;   // ***Placeholder
+/*0000*/	uint16	spawn_id;
+/*0002*/	int32	delta_heading : 10,	// change in heading
+					x_pos : 19,			// x coord
+					padding0002 : 3;	// ***Placeholder
+/*0006*/	int32	y_pos : 19,			// y coord
+					animation : 10,		// animation
+					padding0006 : 3;	// ***Placeholder
+/*0010*/	int32	z_pos : 19,			// z coord
+					delta_y : 13;		// change in y
+/*0014*/	int32	delta_x : 13,		// change in x
+					heading : 12,		// heading
+					padding0014 : 7;	// ***Placeholder
+/*0018*/	int32	delta_z : 13,		// change in z
+					padding0018 : 19;	// ***Placeholder
 /*0022*/
 };

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

@@ -79,7 +79,7 @@ namespace UF
 			//TODO: figure out how to support shared memory with multiple patches...
 			opcodes = new RegularOpcodeManager();
 			if (!opcodes->LoadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error loading opcodes file %s. Not registering patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error loading opcodes file [{}]. Not registering patch [{}]", opfile.c_str(), name);
 				return;
 			}
 		}
@@ -105,7 +105,7 @@ namespace UF



-		Log(Logs::General, Logs::Netcode, "[IDENTIFY] Registered patch %s", name);
+		LogNetcode("[StreamIdentify] Registered patch [{}]", name);
 	}

 	void Reload()
@@ -122,10 +122,10 @@ namespace UF
 			opfile += name;
 			opfile += ".conf";
 			if (!opcodes->ReloadOpcodes(opfile.c_str())) {
-				Log(Logs::General, Logs::Netcode, "[OPCODES] Error reloading opcodes file %s for patch %s.", opfile.c_str(), name);
+				LogNetcode("[OPCODES] Error reloading opcodes file [{}] for patch [{}]", opfile.c_str(), name);
 				return;
 			}
-			Log(Logs::General, Logs::Netcode, "[OPCODES] Reloaded opcodes for patch %s", name);
+			LogNetcode("[OPCODES] Reloaded opcodes for patch [{}]", name);
 		}
 	}

@@ -330,7 +330,7 @@ namespace UF

 		if (EntryCount == 0 || (in->size % sizeof(BazaarSearchResults_Struct)) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(BazaarSearchResults_Struct));
 			delete in;
 			return;
 		}
@@ -520,7 +520,7 @@ namespace UF
 		for (int index = 0; index < item_count; ++index, ++eq) {
 			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
-				Log(Logs::General, Logs::Netcode, "UF::ENCODE(OP_CharInventory) Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
+				LogNetcode("UF::ENCODE(OP_CharInventory) Serialization failed on item slot [{}] during OP_CharInventory.  Item skipped", eq->slot_id);

 			last_pos = ob.tellp();
 		}
@@ -1277,7 +1277,7 @@ namespace UF

 		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
-			Log(Logs::General, Logs::Netcode, "UF::ENCODE(OP_ItemPacket) Serialization failed on item slot %d.", int_struct->slot_id);
+			LogNetcode("UF::ENCODE(OP_ItemPacket) Serialization failed on item slot [{}]", int_struct->slot_id);
 			delete in;
 			return;
 		}
@@ -2369,47 +2369,35 @@ namespace UF
 		EQApplicationPacket *in = *p;
 		*p = nullptr;

-		SpecialMesg_Struct *emu = (SpecialMesg_Struct *)in->pBuffer;
+		SerializeBuffer buf(in->size);
+		buf.WriteInt8(in->ReadUInt8()); // speak mode
+		buf.WriteInt8(in->ReadUInt8()); // journal mode
+		buf.WriteInt8(in->ReadUInt8()); // language
+		buf.WriteInt32(in->ReadUInt32()); // message type
+		buf.WriteInt32(in->ReadUInt32()); // target spawn id

-		unsigned char *__emu_buffer = in->pBuffer;
+		std::string name;
+		in->ReadString(name); // NPC names max out at 63 chars

-		std::string old_message = &emu->message[strlen(emu->sayer)];
+		buf.WriteString(name);
+
+		buf.WriteInt32(in->ReadUInt32()); // loc
+		buf.WriteInt32(in->ReadUInt32());
+		buf.WriteInt32(in->ReadUInt32());
+
+		std::string old_message;
 		std::string new_message;

+		in->ReadString(old_message);
+
 		ServerToUFSayLink(new_message, old_message);

-		//in->size = 3 + 4 + 4 + strlen(emu->sayer) + 1 + 12 + new_message.length() + 1;
-		in->size = strlen(emu->sayer) + new_message.length() + 25;
-		in->pBuffer = new unsigned char[in->size];
+		buf.WriteString(new_message);

-		char *OutBuffer = (char *)in->pBuffer;
+		auto outapp = new EQApplicationPacket(OP_SpecialMesg, buf);

-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->header[2]);
-
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->msg_type);
-		VARSTRUCT_ENCODE_TYPE(uint32, OutBuffer, emu->target_spawn_id);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, emu->sayer);
-
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[0]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[1]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[2]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[3]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[4]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[5]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[6]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[7]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[8]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[9]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[10]);
-		VARSTRUCT_ENCODE_TYPE(uint8, OutBuffer, emu->unknown12[11]);
-
-		VARSTRUCT_ENCODE_STRING(OutBuffer, new_message.c_str());
-
-		delete[] __emu_buffer;
-		dest->FastQueuePacket(&in, ack_req);
+		dest->FastQueuePacket(&outapp, ack_req);
+		delete in;
 	}

 	ENCODE(OP_Stun)
@@ -2484,7 +2472,7 @@ namespace UF

 		if (EntryCount == 0 || ((in->size % sizeof(Track_Struct))) != 0)
 		{
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Track_Struct));
 			delete in;
 			return;
 		}
@@ -2716,7 +2704,7 @@ namespace UF
 		//determine and verify length
 		int entrycount = in->size / sizeof(Spawn_Struct);
 		if (entrycount == 0 || (in->size % sizeof(Spawn_Struct)) != 0) {
-			Log(Logs::General, Logs::Netcode, "[STRUCTS] Wrong size on outbound %s: Got %d, expected multiple of %d", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
+			LogNetcode("[STRUCTS] Wrong size on outbound [{}]: Got [{}], expected multiple of [{}]", opcodes->EmuToName(in->GetOpcode()), in->size, sizeof(Spawn_Struct));
 			delete in;
 			return;
 		}
@@ -3264,6 +3252,7 @@ namespace UF
 		IN(delta_z);
 		IN(delta_heading);
 		IN(animation);
+		emu->vehicle_id = 0;

 		FINISH_DIRECT_DECODE();
 	}
@@ -4218,7 +4207,7 @@ namespace UF
 			UFSlot = serverSlot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Slot %i to UF Slot %i", serverSlot, UFSlot);
+		LogNetcode("Convert Server Slot [{}] to UF Slot [{}]", serverSlot, UFSlot);

 		return UFSlot;
 	}
@@ -4235,7 +4224,7 @@ namespace UF
 			UFSlot = serverCorpseSlot - 2;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert Server Corpse Slot %i to UF Corpse Slot %i", serverCorpseSlot, UFSlot);
+		LogNetcode("Convert Server Corpse Slot [{}] to UF Corpse Slot [{}]", serverCorpseSlot, UFSlot);

 		return UFSlot;
 	}
@@ -4300,7 +4289,7 @@ namespace UF
 			ServerSlot = ufSlot;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert UF Slot %i to Server Slot %i", ufSlot, ServerSlot);
+		LogNetcode("Convert UF Slot [{}] to Server Slot [{}]", ufSlot, ServerSlot);

 		return ServerSlot;
 	}
@@ -4317,7 +4306,7 @@ namespace UF
 			ServerSlot = ufCorpseSlot + 2;
 		}

-		Log(Logs::Detail, Logs::Netcode, "Convert UF Corpse Slot %i to Server Corpse Slot %i", ufCorpseSlot, ServerSlot);
+		LogNetcode("Convert UF Corpse Slot [{}] to Server Corpse Slot [{}]", ufCorpseSlot, ServerSlot);

 		return ServerSlot;
 	}
@@ -1413,21 +1413,21 @@ struct RespawnWindow_Struct {
 */
 struct PlayerPositionUpdateServer_Struct
 {
-/*0000*/ uint16		spawn_id;
-/*0002*/ signed		padding0000:12; // ***Placeholder
-         signed		delta_x:13;      // change in x
-         signed		padding0005:7;  // ***Placeholder
-/*0006*/ signed		delta_heading:10;// change in heading
-         signed		delta_y:13;      // change in y
-         signed		padding0006:9;  // ***Placeholder
-/*0010*/ signed		y_pos:19;           // y coord
-         signed		animation:10;   // animation
-         signed		padding0010:3;  // ***Placeholder
-/*0014*/ unsigned	heading:12;     // heading
-         signed		x_pos:19;           // x coord
-         signed		padding0014:1;  // ***Placeholder
-/*0018*/ signed		z_pos:19;           // z coord
-         signed		delta_z:13;      // change in z
+/*0000*/	uint16		spawn_id;
+/*0002*/	signed		padding0000 : 12;	// ***Placeholder
+			signed		delta_x : 13;		// change in x
+			signed		padding0005 : 7;	// ***Placeholder
+/*0006*/	signed		delta_heading : 10;	// change in heading
+			signed		delta_y : 13;		// change in y
+			signed		padding0006 : 9;	// ***Placeholder
+/*0010*/	signed		y_pos : 19;			// y coord
+			signed		animation : 10;		// animation
+			signed		padding0010 : 3;	// ***Placeholder
+/*0014*/	unsigned	heading : 12;		// heading
+			signed		x_pos : 19;			// x coord
+			signed		padding0014 : 1;	// ***Placeholder
+/*0018*/	signed		z_pos : 19;			// z coord
+			signed		delta_z : 13;		// change in z
 /*0022*/
 };

@@ -1440,21 +1440,21 @@ struct PlayerPositionUpdateServer_Struct
 */
 struct PlayerPositionUpdateClient_Struct
 {
-/*0000*/ uint16		spawn_id;			// Player's spawn id
-/*0002*/ uint16		sequence;			// increments one each packet - Verified
-/*0004*/ uint8		unknown0004[4];		// ***Placeholder
-/*0008*/ float		x_pos;				// x coord (2nd loc value)
-/*0012*/ float		y_pos;				// y coord (1st loc value)
-/*0016*/ signed		delta_heading:10;	// change in heading
-         unsigned	padding0036:10;		// animation
-         unsigned	padding0016:12;		// ***Placeholder
-/*0020*/ float		delta_x;			// Change in x
-/*0024*/ float		delta_y;			// Change in y
-/*0028*/ float		z_pos;				// z coord (3rd loc value)
-/*0032*/ float		delta_z;			// Change in z
-/*0036*/ unsigned	animation:10;		// ***Placeholder
-         unsigned	heading:12;			// Directional heading
-         unsigned	padding0037:10;		// ***Placeholder
+/*0000*/	uint16		spawn_id;			// Player's spawn id
+/*0002*/	uint16		sequence;			// increments one each packet - Verified
+/*0004*/	uint8		unknown0004[4];		// ***Placeholder
+/*0008*/	float		x_pos;				// x coord (2nd loc value)
+/*0012*/	float		y_pos;				// y coord (1st loc value)
+/*0016*/	signed		delta_heading : 10;	// change in heading
+			unsigned	padding0036 : 10;	// animation
+			unsigned	padding0016 : 12;	// ***Placeholder
+/*0020*/	float		delta_x;			// Change in x
+/*0024*/	float		delta_y;			// Change in y
+/*0028*/	float		z_pos;				// z coord (3rd loc value)
+/*0032*/	float		delta_z;			// Change in z
+/*0036*/	unsigned	animation : 10;		// ***Placeholder
+			unsigned	heading : 12;		// Directional heading
+			unsigned	padding0037 : 10;	// ***Placeholder
 /*0040*/
 };

@@ -1,15 +0,0 @@
-#include "platform.h"
-
-EQEmuExePlatform exe_platform = ExePlatformNone;
-
-void RegisterExecutablePlatform(EQEmuExePlatform p) {
-	exe_platform = p;
-}
-
-const EQEmuExePlatform& GetExecutablePlatform() {
-	return exe_platform;
-}
-
-int GetExecutablePlatformInt(){
-	return exe_platform;
-}
@@ -1,24 +0,0 @@
-#ifndef EQEMU_PLATFORM_H
-#define EQEMU_PLATFORM_H
-
-enum EQEmuExePlatform
-{
-	ExePlatformNone = 0,
-	ExePlatformZone,
-	ExePlatformWorld,
-	ExePlatformLogin,
-	ExePlatformQueryServ,
-	ExePlatformSocket_Server,
-	ExePlatformUCS,
-	ExePlatformLaunch,
-	ExePlatformSharedMemory,
-	ExePlatformClientImport,
-	ExePlatformClientExport,
-	ExePlatformHC
-};
-
-void RegisterExecutablePlatform(EQEmuExePlatform p);
-const EQEmuExePlatform& GetExecutablePlatform();
-int GetExecutablePlatformInt();
-
-#endif
@@ -134,7 +134,6 @@ bool PersistentTimer::Load(Database *db) {
                                    (unsigned long)_char_id, _type);
    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-		Log(Logs::General, Logs::Error, "Error in PersistentTimer::Load, error: %s", results.ErrorMessage().c_str());
 		return false;
 	}

@@ -165,9 +164,6 @@ bool PersistentTimer::Store(Database *db) {
 #endif
    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-#if EQDEBUG > 5
-		Log(Logs::General, Logs::Error, "Error in PersistentTimer::Store, error: %s", results.ErrorMessage().c_str());
-#endif
 		return false;
 	}

@@ -185,9 +181,6 @@ bool PersistentTimer::Clear(Database *db) {

    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-#if EQDEBUG > 5
-		Log(Logs::General, Logs::Error, "Error in PersistentTimer::Clear, error: %s", results.ErrorMessage().c_str());
-#endif
 		return false;
 	}

@@ -198,7 +191,7 @@ bool PersistentTimer::Clear(Database *db) {
 /* This function checks if the timer triggered */
 bool PersistentTimer::Expired(Database *db, bool iReset) {
 	if (this == nullptr) {
-		Log(Logs::General, Logs::Error, "Null timer during ->Check()!?\n");
+		LogError("Null timer during ->Check()!?\n");
 		return(true);
 	}
 	uint32 current_time = get_current_time();
@@ -289,9 +282,6 @@ bool PTimerList::Load(Database *db) {
                                    (unsigned long)_char_id);
    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-#if EQDEBUG > 5
-		Log(Logs::General, Logs::Error, "Error in PersistentTimer::Load, error: %s", results.ErrorMessage().c_str());
-#endif
 		return false;
 	}

@@ -348,9 +338,6 @@ bool PTimerList::Clear(Database *db) {
 #endif
    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-#if EQDEBUG > 5
-		Log(Logs::General, Logs::Error, "Error in PersistentTimer::Clear, error: %s", results.ErrorMessage().c_str());
-#endif
 		return false;
 	}

@@ -440,9 +427,6 @@ bool PTimerList::ClearOffline(Database *db, uint32 char_id, pTimerType type) {
 #endif
    auto results = db->QueryDatabase(query);
 	if (!results.Success()) {
-#if EQDEBUG > 5
-		Log(Logs::General, Logs::Error, "Error in PTimerList::ClearOffline, error: %s", results.ErrorMessage().c_str());
-#endif
 		return false;
 	}

@@ -21,6 +21,7 @@
 #include "string_util.h"
 #include <cstdlib>
 #include <cstring>
+#include <fmt/format.h>

 /*
 	Commands:
@@ -45,14 +46,14 @@ const char *RuleManager::s_categoryNames[_CatCount+1] = {

 const RuleManager::RuleInfo RuleManager::s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount+1] = {
 	/* this is done in three steps so we can reliably get to them by index*/
-	#define RULE_INT(cat, rule, default_value) \
-		{ #cat ":" #rule, Category__##cat, IntRule, Int__##rule },
+	#define RULE_INT(cat, rule, default_value, notes) \
+		{ #cat ":" #rule, Category__##cat, IntRule, Int__##rule, notes },
 	#include "ruletypes.h"
-	#define RULE_REAL(cat, rule, default_value) \
-		{ #cat ":" #rule, Category__##cat, RealRule, Real__##rule },
+	#define RULE_REAL(cat, rule, default_value, notes) \
+		{ #cat ":" #rule, Category__##cat, RealRule, Real__##rule, notes },
 	#include "ruletypes.h"
-	#define RULE_BOOL(cat, rule, default_value) \
-		{ #cat ":" #rule, Category__##cat, BoolRule, Bool__##rule },
+	#define RULE_BOOL(cat, rule, default_value, notes) \
+		{ #cat ":" #rule, Category__##cat, BoolRule, Bool__##rule, notes },
 	#include "ruletypes.h"
 	{ "Invalid Rule", _CatCount, IntRule }
 };
@@ -145,11 +146,11 @@ bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Databas
 	switch(type) {
 		case IntRule:
 			m_RuleIntValues[index] = atoi(rule_value);
-			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %d", rule_name, m_RuleIntValues[index]);
+			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleIntValues[index]);
 			break;
 		case RealRule:
 			m_RuleRealValues[index] = atof(rule_value);
-			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %.13f", rule_name, m_RuleRealValues[index]);
+			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleRealValues[index]);
 			break;
 		case BoolRule:
 			uint32 val = 0;
@@ -157,7 +158,7 @@ bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Databas
 				val = 1;

 			m_RuleBoolValues[index] = val;
-			Log(Logs::Detail, Logs::Rules, "Set rule %s to value %s", rule_name, m_RuleBoolValues[index] == 1 ? "true" : "false");
+			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleBoolValues[index] == 1 ? "true" : "false");
 			break;
 	}

@@ -178,11 +179,11 @@ void RuleManager::ResetRules(bool reload) {
 	}

 	Log(Logs::Detail, Logs::Rules, "Resetting running rules to default values");
-	#define RULE_INT(cat, rule, default_value) \
+	#define RULE_INT(cat, rule, default_value, notes) \
 		m_RuleIntValues[ Int__##rule ] = default_value;
-	#define RULE_REAL(cat, rule, default_value) \
+	#define RULE_REAL(cat, rule, default_value, notes) \
 		m_RuleRealValues[ Real__##rule ] = default_value;
-	#define RULE_BOOL(cat, rule, default_value) \
+	#define RULE_BOOL(cat, rule, default_value, notes) \
 		m_RuleBoolValues[ Bool__##rule ] = default_value;
 	#include "ruletypes.h"

@@ -214,19 +215,101 @@ bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 &
 //assumes index is valid!
 const char *RuleManager::_GetRuleName(RuleType type, uint16 index) {
 	switch (type) {
-		case IntRule:
-			return(s_RuleInfo[index].name);
-		case RealRule:
-			return(s_RuleInfo[index + _IntRuleCount].name);
-		case BoolRule:
-			return(s_RuleInfo[index + _IntRuleCount + _RealRuleCount].name);
+	case IntRule:
+		return(s_RuleInfo[index].name);
+	case RealRule:
+		return(s_RuleInfo[index+_IntRuleCount].name);
+	case BoolRule:
+		return(s_RuleInfo[index+_IntRuleCount+_RealRuleCount].name);
+	default:
+		break;
 	}
 	//should never happen
-	return("InvalidRule??");
+	return(s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount].name); // no need to create a string when one already exists...
+}
+
+//assumes index is valid!
+const std::string &RuleManager::_GetRuleNotes(RuleType type, uint16 index) {
+	switch (type) {
+	case IntRule:
+		return(s_RuleInfo[index].notes);
+	case RealRule:
+		return(s_RuleInfo[index+_IntRuleCount].notes);
+	case BoolRule:
+		return(s_RuleInfo[index+_IntRuleCount+_RealRuleCount].notes);
+	default:
+		break;
+	}
+	//should never happen
+	return(s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount].notes);
+}
+
+bool RuleManager::LoadRules(Database *database, const char *ruleset_name, bool reload) {
+
+	int ruleset_id = this->GetRulesetID(database, ruleset_name);
+	if (ruleset_id < 0) {
+		Log(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
+		return (false);
+	}
+
+	m_activeRuleset = ruleset_id;
+	m_activeName = ruleset_name;
+
+	/* Load default ruleset values first if we're loading something other than default */
+	if (strcasecmp(ruleset_name, "default") != 0) {
+
+		std::string default_ruleset_name = "default";
+		int         default_ruleset_id = GetRulesetID(database, default_ruleset_name.c_str());
+
+		if (default_ruleset_id < 0) {
+			Log(Logs::Detail,
+				Logs::Rules,
+				"Failed to find default ruleset '%s' for load operation. Canceling.",
+				default_ruleset_name.c_str()
+			);
+
+			return (false);
+		}
+
+		Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", default_ruleset_name.c_str(), default_ruleset_id);
+
+		std::string query = StringFormat(
+			"SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = '%d'",
+			default_ruleset_id
+		);
+
+		auto results = database->QueryDatabase(query);
+		if (!results.Success()) {
+			return false;
+		}
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			if (!SetRule(row[0], row[1], nullptr, false, reload)) {
+				Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
+			}
+		}
+	}
+
+	Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", ruleset_name, ruleset_id);
+
+	std::string query = StringFormat("SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = '%d'", ruleset_id);
+
+	auto results = database->QueryDatabase(query);
+	if (!results.Success()) {
+		return false;
+	}
+
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		if (!SetRule(row[0], row[1], nullptr, false, reload)) {
+			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
+		}
+	}
+
+	return true;
 }

 void RuleManager::SaveRules(Database *database, const char *ruleset_name) {
-
+	
 	if (ruleset_name != nullptr) {
 		//saving to a specific name
 		if (m_activeName != ruleset_name) {
@@ -257,56 +340,6 @@ void RuleManager::SaveRules(Database *database, const char *ruleset_name) {
 	}
 }

-bool RuleManager::LoadRules(Database *database, const char *ruleset_name, bool reload) {
-
-	int ruleset_id = this->GetRulesetID(database, ruleset_name);
-	if (ruleset_id < 0) {
-		Log(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
-		return (false);
-	}
-
-	Log(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset_name, ruleset_id);
-
-	m_activeRuleset = ruleset_id;
-	m_activeName    = ruleset_name;
-
-	/* Load default ruleset values first if we're loading something other than default */
-	if (strcasecmp(ruleset_name, "default") != 0) {
-		std::string default_ruleset_name = "default";
-		int         default_ruleset_id   = GetRulesetID(database, default_ruleset_name.c_str());
-		if (default_ruleset_id < 0) {
-			Log(Logs::Detail, Logs::Rules, "Failed to find default ruleset '%s' for load operation. Canceling.",
-			    default_ruleset_name.c_str());
-			return (false);
-		}
-		Log(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", default_ruleset_name.c_str(), default_ruleset_id);
-
-		std::string query = StringFormat(
-				"SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id = %d",
-				default_ruleset_id
-		);
-
-		auto results = database->QueryDatabase(query);
-		if (!results.Success())
-			return false;
-
-		for (auto row = results.begin(); row != results.end(); ++row)
-			if (!SetRule(row[0], row[1], nullptr, false, reload))
-				Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
-	}
-
-	std::string query   = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id);
-	auto        results = database->QueryDatabase(query);
-	if (!results.Success())
-		return false;
-
-	for (auto row = results.begin(); row != results.end(); ++row)
-		if (!SetRule(row[0], row[1], nullptr, false, reload))
-			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
-
-	return true;
-}
-
 void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
 	char value_string[100];

@@ -328,17 +361,241 @@ void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
 	}

 	std::string query = StringFormat(
-			"REPLACE INTO rule_values "
-			"(ruleset_id, rule_name, rule_value) "
-			" VALUES(%d, '%s', '%s')",
+			"REPLACE INTO `rule_values`"
+			"(`ruleset_id`, `rule_name`, `rule_value`, `notes`)"
+			" VALUES('%d', '%s', '%s', '%s')",
 			m_activeRuleset,
 			_GetRuleName(type, index),
-			value_string
+			value_string,
+			EscapeString(_GetRuleNotes(type, index)).c_str()
 	);

 	database->QueryDatabase(query);
 }

+bool RuleManager::UpdateInjectedRules(Database *db, const char *ruleset_name, bool quiet_update)
+{
+	std::vector<std::string> database_data;
+	std::map<std::string, std::pair<std::string, const std::string *>> rule_data;
+	std::vector<std::tuple<int, std::string, std::string, std::string>> injected_rule_entries;
+
+	if (ruleset_name == nullptr) {
+		return false;
+	}
+
+	int ruleset_id = GetRulesetID(db, ruleset_name);
+	if (ruleset_id < 0) {
+		return false;
+	}
+
+	// load database rule names
+	std::string query(StringFormat("SELECT `rule_name` FROM `rule_values` WHERE `ruleset_id` = '%i'", ruleset_id));
+
+	auto results = db->QueryDatabase(query);
+	if (!results.Success()) {
+		return false;
+	}
+
+	// build database data entries
+	for (auto row : results) {
+		database_data.push_back(std::string(row[0]));
+	}
+
+	// build rule data entries
+	for (const auto &ri_iter : s_RuleInfo) {
+		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
+			continue;
+		}
+
+		char buffer[100];
+
+		switch (ri_iter.type) {
+		case IntRule:
+			sprintf(buffer, "%d", m_RuleIntValues[ri_iter.rule_index]);
+			rule_data[ri_iter.name].first = buffer;
+			rule_data[ri_iter.name].second = &ri_iter.notes;
+			break;
+		case RealRule:
+			sprintf(buffer, "%.13f", m_RuleRealValues[ri_iter.rule_index]);
+			rule_data[ri_iter.name].first = buffer;
+			rule_data[ri_iter.name].second = &ri_iter.notes;
+			break;
+		case BoolRule:
+			sprintf(buffer, "%s", (m_RuleBoolValues[ri_iter.rule_index] ? "true" : "false"));
+			rule_data[ri_iter.name].first = buffer;
+			rule_data[ri_iter.name].second = &ri_iter.notes;
+			break;
+		default:
+			break;
+		}
+	}
+
+	// build injected entries
+	for (const auto &rd_iter : rule_data) {
+		
+		const auto &dd_iter = std::find(database_data.begin(), database_data.end(), rd_iter.first);
+		if (dd_iter == database_data.end()) {
+
+			injected_rule_entries.push_back(
+				std::tuple<int, std::string, std::string, std::string>(
+					ruleset_id,								// `ruleset_id`
+					rd_iter.first,							// `rule_name`
+					rd_iter.second.first,					// `rule_value`	
+					EscapeString(*rd_iter.second.second)	// `notes`
+				)
+			);
+
+			if (!quiet_update) {
+				LogInfo(
+					"Adding new rule [{}] ruleset [{}] ({}) value [{}]",
+					rd_iter.first.c_str(),
+					ruleset_name,
+					ruleset_id,
+					rd_iter.second.first.c_str()
+				);
+			}
+		}
+	}
+
+	if (injected_rule_entries.size()) {
+
+		std::string query(
+			fmt::format(
+				"REPLACE INTO `rule_values`(`ruleset_id`, `rule_name`, `rule_value`, `notes`) VALUES {}",
+				implode(
+					",",
+					std::pair<char, char>('(', ')'),
+					join_tuple(",", std::pair<char, char>('\'', '\''), injected_rule_entries)
+				)
+			)
+		);
+
+		if (!db->QueryDatabase(query).Success()) {
+			return false;
+		}
+
+		LogInfo(
+			"[{}] New rule(s) added to ruleset [{}] [{}]",
+			injected_rule_entries.size(),
+			ruleset_name,
+			ruleset_id
+		);
+	}
+	
+	return true;
+}
+
+bool RuleManager::UpdateOrphanedRules(Database *db, bool quiet_update)
+{
+	std::vector<std::string> rule_data;
+	std::vector<std::string> orphaned_rule_entries;
+
+	// load database rule names
+	std::string query("SELECT `rule_name` FROM `rule_values` GROUP BY `rule_name`");
+
+	auto results = db->QueryDatabase(query);
+	if (!results.Success()) {
+		return false;
+	}
+
+	// build rule data entries
+	for (const auto &ri_iter : s_RuleInfo) {
+		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
+			continue;
+		}
+
+		rule_data.push_back(ri_iter.name);
+	}
+
+	// build orphaned entries
+	for (auto row : results) {
+		
+		const auto &rd_iter = std::find(rule_data.begin(), rule_data.end(), row[0]);
+		if (rd_iter == rule_data.end()) {
+
+			orphaned_rule_entries.push_back(std::string(row[0]));
+
+			if (!quiet_update) {
+				LogInfo(
+					"Rule [{}] no longer exists... Deleting orphaned entry from `rule_values` table...",
+					row[0]
+				);
+			}
+		}
+	}
+
+	if (orphaned_rule_entries.size()) {
+
+		std::string query (
+			fmt::format(
+				"DELETE FROM `rule_values` WHERE `rule_name` IN ({})",
+				implode(",", std::pair<char, char>('\'', '\''), orphaned_rule_entries)
+			)
+		);
+
+		if (!db->QueryDatabase(query).Success()) {
+			return false;
+		}
+
+		LogInfo("[{}] Orphaned Rule(s) Deleted from [All Rulesets] (-1)", orphaned_rule_entries.size());
+	}
+	
+	return true;
+}
+
+bool RuleManager::RestoreRuleNotes(Database *db)
+{
+	std::string query("SELECT `ruleset_id`, `rule_name`, `notes` FROM `rule_values`");
+
+	auto results = db->QueryDatabase(query);
+	if (!results.Success()) {
+		return false;
+	}
+
+	int update_count = 0;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+
+		auto rule = [](const char *rule_name) {
+
+			for (auto rule_iter : s_RuleInfo) {
+				if (strcasecmp(rule_iter.name, rule_name) == 0) {
+					return rule_iter;
+				}
+			}
+
+			return s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount];
+		}(row[1]);
+
+		if (strcasecmp(rule.name, row[1]) != 0) {
+			continue;
+		}
+
+		if (row[2] != nullptr && rule.notes.compare(row[2]) == 0) {
+			continue;
+		}
+
+		std::string query(
+			fmt::format(
+				"UPDATE `rule_values` SET `notes` = '{}' WHERE `ruleset_id` = '{}' AND `rule_name` = '{}'",
+				EscapeString(rule.notes),
+				row[0],
+				row[1]
+			)
+		);
+
+		if (!db->QueryDatabase(query).Success()) {
+			continue;
+		}
+		
+		++update_count;
+	}
+
+	if (update_count > 0) {
+		LogInfo("[{}] Rule Note [{}] Restored", update_count, (update_count == 1 ? "" : "s"));
+	}
+
+	return true;
+}

 int RuleManager::GetRulesetID(Database *database, const char *ruleset_name) {

@@ -49,21 +49,21 @@ class RuleManager {
 public:
 	//generate our rule enums:
 	typedef enum {
-	#define RULE_INT(cat, rule, default_value) \
+	#define RULE_INT(cat, rule, default_value, notes) \
 		Int__##rule,
 	#include "ruletypes.h"
 		_IntRuleCount
 	} IntType;

 	typedef enum {
-	#define RULE_REAL(cat, rule, default_value) \
+	#define RULE_REAL(cat, rule, default_value, notes) \
 		Real__##rule,
 	#include "ruletypes.h"
 		_RealRuleCount
 	} RealType;

 	typedef enum {
-	#define RULE_BOOL(cat, rule, default_value) \
+	#define RULE_BOOL(cat, rule, default_value, notes) \
 		Bool__##rule,
 	#include "ruletypes.h"
 		_BoolRuleCount
@@ -97,6 +97,9 @@ public:
 	static const char *GetRuleName(IntType t) { return(s_RuleInfo[t].name); }
 	static const char *GetRuleName(RealType t) { return(s_RuleInfo[t+_IntRuleCount].name); }
 	static const char *GetRuleName(BoolType t) { return(s_RuleInfo[t+_IntRuleCount+_RealRuleCount].name); }
+	static const std::string &GetRuleNotes(IntType t) { return(s_RuleInfo[t].notes); }
+	static const std::string &GetRuleNotes(RealType t) { return(s_RuleInfo[t+_IntRuleCount].notes); }
+	static const std::string &GetRuleNotes(BoolType t) { return(s_RuleInfo[t+_IntRuleCount+_RealRuleCount].notes); }
 	static uint32 CountRules() { return(_RulesCount); }
 	static CategoryType FindCategory(const char *catname);
 	bool ListRules(const char *catname, std::vector<const char *> &into);
@@ -113,6 +116,9 @@ public:
 	void ResetRules(bool reload = false);
 	bool LoadRules(Database *db, const char *ruleset = nullptr, bool reload = false);
 	void SaveRules(Database *db, const char *ruleset = nullptr);
+	bool UpdateInjectedRules(Database *db, const char *ruleset_name, bool quiet_update = false);
+	bool UpdateOrphanedRules(Database *db, bool quiet_update = false);
+	bool RestoreRuleNotes(Database *db);

 private:
 	RuleManager();
@@ -137,15 +143,17 @@ private:

 	static bool _FindRule(const char *rule_name, RuleType &type_into, uint16 &index_into);
 	static const char *_GetRuleName(RuleType type, uint16 index);
+	static const std::string &_GetRuleNotes(RuleType type, uint16 index);
 	static int _FindOrCreateRuleset(Database *db, const char *ruleset);
 	void _SaveRule(Database *db, RuleType type, uint16 index);
-
+	
 	static const char *s_categoryNames[];
 	typedef struct {
 		const char *name;
 		CategoryType category;
 		RuleType type;
 		uint16 rule_index;	//index into its 'type' array
+		const std::string notes;
 	} RuleInfo;
 	static const RuleInfo s_RuleInfo[];

@@ -100,8 +100,8 @@ const std::string &EQEmu::SayLinkEngine::GenerateLink()
 	if ((m_Link.length() == 0) || (m_Link.length() > (EQEmu::constants::SAY_LINK_MAXIMUM_SIZE))) {
 		m_Error = true;
 		m_Link  = "<LINKER ERROR>";
-		Log(Logs::General, Logs::Error, "SayLinkEngine::GenerateLink() failed to generate a useable say link");
-		Log(Logs::General, Logs::Error, ">> LinkType: %i, Lengths: {link: %u(%u), body: %u(%u), text: %u(%u)}",
+		LogError("SayLinkEngine::GenerateLink() failed to generate a useable say link");
+		LogError(">> LinkType: {}, Lengths: {link: {}({}), body: {}({}), text: {}({})}",
 			m_LinkType,
 			m_Link.length(),
 			EQEmu::constants::SAY_LINK_MAXIMUM_SIZE,
@@ -110,8 +110,8 @@ const std::string &EQEmu::SayLinkEngine::GenerateLink()
 			m_LinkText.length(),
 			EQEmu::constants::SAY_LINK_TEXT_SIZE
 		);
-		Log(Logs::General, Logs::Error, ">> LinkBody: %s", m_LinkBody.c_str());
-		Log(Logs::General, Logs::Error, ">> LinkText: %s", m_LinkText.c_str());
+		LogError(">> LinkBody: {}", m_LinkBody.c_str());
+		LogError(">> LinkText: {}", m_LinkText.c_str());
 	}

 	return m_Link;
@@ -316,7 +316,7 @@ std::string EQEmu::SayLinkEngine::GenerateQuestSaylink(std::string saylink_text,

 			results = database.QueryDatabase(insert_query);
 			if (!results.Success()) {
-				Log(Logs::General, Logs::Error, "Error in saylink phrase queries %s", results.ErrorMessage().c_str());
+				LogError("Error in saylink phrase queries {}", results.ErrorMessage().c_str());
 			}
 			else {
 				saylink_id = results.LastInsertedID();
@@ -143,7 +143,7 @@ public:
 	void WriteString(const char *str)
 	{
 		assert(str != nullptr);
-		auto len = strlen(str) + 1;
+		auto len = std::char_traits<char>::length(str) + 1;
 		if (m_pos + len > m_capacity)
 			Grow(m_capacity + len);
 		memcpy(m_buffer + m_pos, str, len);
@@ -15,109 +15,80 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-// Serverinfo.cpp - Server information gathering functions, used in #serverinfo - Windows specific
-// I'm not sure quite how to get this exact information in *nix, hopefully someone can fill that in
-// -T7g
-// Implement preliminary support for *nix variants
-// misanthropicfiend

-#ifdef _WINDOWS
-#include <windows.h>
+#include "serverinfo.h"
+#include <uv.h>

-char Ver_name[100];
-DWORD Ver_build, Ver_min, Ver_maj, Ver_pid;
+size_t EQ::GetRSS()
+{
+	size_t rss = 0;

-int GetOS()	{
-
-	strcpy(Ver_name, "Unknown operating system");
-
-	OSVERSIONINFO Ver_os;
-	Ver_os.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-
-	if(!(GetVersionEx(&Ver_os))) return 1;
-
-	Ver_build = Ver_os.dwBuildNumber & 0xFFFF;
-	Ver_min = Ver_os.dwMinorVersion;
-	Ver_maj = Ver_os.dwMajorVersion;
-	Ver_pid = Ver_os.dwPlatformId;
-
-	if ((Ver_pid == 1) && (Ver_maj == 4))
-	{
-		if ((Ver_min < 10) && (Ver_build == 950))
-		{
-			strcpy(Ver_name, "Microsoft Windows 95");
-		}
-		else if ((Ver_min < 10) &&
-				((Ver_build > 950) && (Ver_build <= 1080)))
-		{
-			strcpy(Ver_name, "Microsoft Windows 95 SP1");
-		}
-		else if ((Ver_min < 10) && (Ver_build > 1080))
-		{
-			strcpy(Ver_name, "Microsoft Windows 95 OSR2");
-		}
-		else if ((Ver_min == 10) && (Ver_build == 1998))
-		{
-			strcpy(Ver_name, "Microsoft Windows 98");
-		}
-		else if ((Ver_min == 10) &&
-				((Ver_build > 1998) && (Ver_build < 2183)))
-		{
-			strcpy(Ver_name, "Microsoft Windows 98, Service Pack 1");
-		}
-		else if ((Ver_min == 10) && (Ver_build >= 2183))
-		{
-			strcpy(Ver_name, "Microsoft Windows 98 Second Edition");
-		}
-		else if (Ver_min == 90)
-		{
-			strcpy(Ver_name, "Microsoft Windows ME");
-		}
-	}
-	else if (Ver_pid == 2)
-	{
-		if ((Ver_maj == 3) && (Ver_min == 51))
-		{
-			strcpy(Ver_name, "Microsoft Windows NT 3.51");
-		}
-		else if ((Ver_maj == 4) && (Ver_min == 0))
-		{
-			strcpy(Ver_name, "Microsoft Windows NT 4");
-		}
-		else if ((Ver_maj == 5) && (Ver_min == 0))
-		{
-			strcpy(Ver_name, "Microsoft Windows 2000");
-		}
-		else if ((Ver_maj == 5) && (Ver_min == 1))
-		{
-			strcpy(Ver_name, "Microsoft Windows XP");
-		}
-		else if ((Ver_maj == 5) && (Ver_min == 2))
-		{
-			strcpy(Ver_name, "Microsoft Windows 2003");
-		}
+	if (0 != uv_resident_set_memory(&rss)) {
+		return 0;
 	}

-	return 0;
+	return rss;
 }

-#else
+double EQ::GetUptime()
+{
+	double uptime = 0.0;

-#include <sys/utsname.h>
-#include <stdio.h>
-#include <string.h>
-
-char* GetOS(char* os_string) {
-	utsname info;
-
-	if(uname(&info)==0) {
-		snprintf(os_string, 99, "%s %s %s %s %s", info.sysname, info.nodename, info.release, info.version, info.machine);
-	} else {
-		strncpy(os_string, "Error determining OS & version!", 25);
+	if (0 != uv_uptime(&uptime)) {
+		return 0.0;
 	}

-	return os_string;
-
+	return uptime;
 }

-#endif
+size_t EQ::GetPID()
+{
+	return uv_os_getpid();
+}
+
+std::vector<eq_cpu_info_t> EQ::GetCPUs()
+{
+	std::vector<eq_cpu_info_t> ret;
+	uv_cpu_info_t *cpu_info = nullptr;
+	int count = 0;
+
+	if (0 != uv_cpu_info(&cpu_info, &count)) {
+		return ret;
+	}
+
+	ret.reserve(count);
+	for (int i = 0; i < count; ++i) {
+		eq_cpu_info_t r;
+		auto &entry = cpu_info[i];
+
+		r.model = entry.model;
+		r.speed = entry.speed / 1000.0;
+		r.time_user = entry.cpu_times.user;
+		r.time_sys = entry.cpu_times.sys;
+		r.time_idle = entry.cpu_times.idle;
+		r.time_nice = entry.cpu_times.nice;
+		r.time_irq = entry.cpu_times.irq;
+
+		ret.push_back(r);
+	}
+
+	uv_free_cpu_info(cpu_info, count);
+	return ret;
+}
+
+eq_utsname_t EQ::GetOS()
+{
+	eq_utsname_t ret;
+	uv_utsname_t name;
+
+	if (0 != uv_os_uname(&name)) {
+		return ret;
+	}
+
+	ret.machine = name.machine;
+	ret.release = name.release;
+	ret.sysname = name.sysname;
+	ret.version = name.version;
+
+	return ret;
+}
@@ -15,15 +15,33 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#ifndef SERVERINFO_H
-#define SERVERINFO_H
+#pragma once

-#ifdef _WINDOWS
-	extern char Ver_name[36];
-	extern DWORD Ver_build, Ver_min, Ver_maj, Ver_pid;
-	int GetOS();
-#else
-	char* GetOS(char* os_string);
-#endif
+#include <string>
+#include <vector>

-#endif
+typedef struct eq_cpu_info_s {
+	std::string model;
+	double speed;
+	uint64_t time_user;
+	uint64_t time_nice;
+	uint64_t time_sys;
+	uint64_t time_idle;
+	uint64_t time_irq;
+} eq_cpu_info_t;
+
+typedef struct eq_utsname_s {
+	std::string sysname;
+	std::string release;
+	std::string version;
+	std::string machine;
+} eq_utsname_t;
+
+namespace EQ
+{
+	size_t GetRSS();
+	double GetUptime();
+	size_t GetPID();
+	std::vector<eq_cpu_info_t> GetCPUs();
+	eq_utsname_t GetOS();
+}
@@ -80,6 +80,7 @@
 #define ServerOP_GroupJoin			0x003e //for joining ooz folks
 #define ServerOP_UpdateSpawn		0x003f
 #define ServerOP_SpawnStatusChange	0x0040
+#define ServerOP_DropClient         0x0041	// DropClient
 #define ServerOP_ReloadTasks		0x0060
 #define ServerOP_DepopAllPlayersCorpses	0x0061
 #define ServerOP_ReloadTitles		0x0062
@@ -142,14 +143,15 @@
 #define ServerOP_ClientVersionSummary 0x0215
 #define ServerOP_LSInfo				0x1000
 #define ServerOP_LSStatus			0x1001
-#define ServerOP_LSClientAuth		0x1002
+#define ServerOP_LSClientAuthLeg	0x1002
 #define ServerOP_LSFatalError		0x1003
 #define ServerOP_SystemwideMessage	0x1005
 #define ServerOP_ListWorlds			0x1006
 #define ServerOP_PeerConnect		0x1007
 #define ServerOP_NewLSInfo			0x1008
 #define ServerOP_LSRemoteAddr		0x1009
-#define ServerOP_LSAccountUpdate		0x100A
+#define ServerOP_LSAccountUpdate	0x100A
+#define ServerOP_LSClientAuth		0x100B

 #define ServerOP_EncapPacket		0x2007	// Packet within a packet
 #define ServerOP_WorldListUpdate	0x2008
@@ -170,8 +172,10 @@
 #define ServerOP_LSPlayerJoinWorld	0x3007
 #define ServerOP_LSPlayerZoneChange	0x3008

-#define	ServerOP_UsertoWorldReq		0xAB00
-#define	ServerOP_UsertoWorldResp	0xAB01
+#define	ServerOP_UsertoWorldReqLeg	0xAB00
+#define	ServerOP_UsertoWorldRespLeg	0xAB01
+#define	ServerOP_UsertoWorldReq		0xAB02
+#define	ServerOP_UsertoWorldResp	0xAB03

 #define ServerOP_LauncherConnectInfo	0x3000
 #define ServerOP_LauncherZoneRequest	0x3001
@@ -213,6 +217,15 @@ enum {	QSG_LFGuild_PlayerMatches = 0, QSG_LFGuild_UpdatePlayerInfo, QSG_LFGuild_

 #define ServerOP_Speech			0x4513

+enum {
+	UserToWorldStatusWorldUnavail = 0,
+	UserToWorldStatusSuccess = 1,
+	UserToWorldStatusSuspended = -1,
+	UserToWorldStatusBanned = -2,
+	UserToWorldStatusWorldAtCapacity = -3,
+	UserToWorldStatusAlreadyOnline = -4
+};
+
 /************ PACKET RELATED STRUCT ************/
 class ServerPacket
 {
@@ -308,11 +321,17 @@ struct ServerZoneIncomingClient_Struct {
 	uint32	accid;
 	int16	admin;
 	uint32	charid;
+	uint32  lsid;
 	bool	tellsoff;
 	char	charname[64];
 	char	lskey[30];
 };

+struct ServerZoneDropClient_Struct
+{
+	uint32 lsid;
+};
+
 struct ServerChangeWID_Struct {
 	uint32	charid;
 	uint32	newwid;
@@ -343,7 +362,8 @@ struct ServerChannelMessage_Struct {
 	bool noreply;
 	uint16 chan_num;
 	uint32 guilddbid;
-	uint16 language;
+	uint8 language;
+	uint8 lang_skill;
 	uint8 queued; // 0 = not queued, 1 = queued, 2 = queue full, 3 = offline
 	char message[0];
 };
@@ -452,15 +472,15 @@ struct ServerLSInfo_Struct {
 };

 struct ServerNewLSInfo_Struct {
-	char	name[201];				// name the worldserver wants
-	char	shortname[50];				// shortname the worldserver wants
-	char	remote_address[125];			// DNS address of the server
-	char	local_address[125];			// DNS address of the server
-	char	account[31];			// account name for the worldserver
-	char	password[31];			// password for the name
-	char	protocolversion[25];	// Major protocol version number
-	char	serverversion[64];		// minor server software version number
-	uint8	servertype;				// 0=world, 1=chat, 2=login, 3=MeshLogin
+	char	server_long_name[201];				// name the worldserver wants
+	char	server_short_name[50];				// shortname the worldserver wants
+	char	remote_ip_address[125];			// DNS address of the server
+	char	local_ip_address[125];			// DNS address of the server
+	char	account_name[31];			// account name for the worldserver
+	char	account_password[31];			// password for the name
+	char	protocol_version[25];	// Major protocol version number
+	char	server_version[64];		// minor server software version number
+	uint8	server_process_type;				// 0=world, 1=chat, 2=login, 3=MeshLogin
 };

 struct ServerLSAccountUpdate_Struct {			// for updating info on login server
@@ -469,7 +489,7 @@ struct ServerLSAccountUpdate_Struct {			// for updating info on login server
 	uint32	useraccountid;				// player account ID
 	char	useraccount[31];			// player account name
 	char	userpassword[51];			// player account password
-	char	useremail[101];				// player account email address
+	char	user_email[101];				// player account email address
 };

 struct ServerLSStatus_Struct {
@@ -516,18 +536,35 @@ struct ServerLSPlayerZoneChange_Struct {
 };

 struct ClientAuth_Struct {
-	uint32 lsaccount_id; // ID# in login server's db
-	char name[30]; // username in login server's db
+	uint32 loginserver_account_id; // ID# in login server's db
+	char loginserver_name[64];
+	char account_name[30]; // username in login server's db
 	char key[30]; // the Key the client will present
 	uint8 lsadmin; // login server admin level
-	int16 worldadmin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
+	int16 is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
 	uint32 ip;
-	uint8 local; // 1 if the client is from the local network
+	uint8 is_client_from_local_network; // 1 if the client is from the local network

 	template <class Archive>
 	void serialize(Archive &ar)
 	{
-		ar(lsaccount_id, name, key, lsadmin, worldadmin, ip, local);
+		ar(loginserver_account_id, loginserver_name, account_name, key, lsadmin, is_world_admin, ip, is_client_from_local_network);
+	}
+};
+
+struct ClientAuthLegacy_Struct {
+	uint32 loginserver_account_id; // ID# in login server's db
+	char loginserver_account_name[30]; // username in login server's db
+	char key[30]; // the Key the client will present
+	uint8 loginserver_admin_level; // login server admin level
+	int16 is_world_admin; // login's suggested worldadmin level setting for this user, up to the world if they want to obey it
+	uint32 ip;
+	uint8 is_client_from_local_network; // 1 if the client is from the local network
+
+	template <class Archive>
+	void serialize(Archive &ar)
+	{
+		ar(loginserver_account_id, loginserver_account_name, key, loginserver_admin_level, is_world_admin, ip, is_client_from_local_network);
 	}
 };

@@ -655,7 +692,7 @@ struct ServerSyncWorldList_Struct {
 	bool	placeholder;
 };

-struct UsertoWorldRequest_Struct {
+struct UsertoWorldRequestLegacy_Struct {
 	uint32	lsaccountid;
 	uint32	worldid;
 	uint32	FromID;
@@ -663,12 +700,30 @@ struct UsertoWorldRequest_Struct {
 	char	IPAddr[64];
 };

-struct UsertoWorldResponse_Struct {
+struct UsertoWorldRequest_Struct {
 	uint32	lsaccountid;
 	uint32	worldid;
-	int8	response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
 	uint32	FromID;
 	uint32	ToID;
+	char	IPAddr[64];
+	char	login[64];
+};
+
+struct UsertoWorldResponseLegacy_Struct {
+	uint32 lsaccountid;
+	uint32 worldid;
+	int8   response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
+	uint32 FromID;
+	uint32 ToID;
+};
+
+struct UsertoWorldResponse_Struct {
+	uint32 lsaccountid;
+	uint32 worldid;
+	int8   response; // -3) World Full, -2) Banned, -1) Suspended, 0) Denied, 1) Allowed
+	uint32 FromID;
+	uint32 ToID;
+	char   login[64];
 };

 // generic struct to be used for alot of simple zone->world questions
@@ -856,6 +911,8 @@ struct ServerRaidGroupAction_Struct { //add / remove depends on opcode.
 struct ServerRaidMessage_Struct {
 	uint32 rid;
 	uint32 gid;
+	uint8 language;
+	uint8 lang_skill;
 	char from[64];
 	char message[0];
 };
--- a/Show More
+++ b/Show More