Inventory V2 - Added ItemSlot Structures

Added MapKrono entry to RoF2::InventoryMaps enumeration
Added Shroud ops for UF
2026-05-23 09:02:29 +00:00 · 2014-12-05 19:35:30 -05:00 · 2014-12-05 19:33:25 -05:00 · 2014-12-05 16:26:55 -05:00 · 2014-12-05 15:59:03 -05:00 · 2014-12-05 14:40:41 -05:00
1359 changed files with 255992 additions and 133080 deletions
@@ -0,0 +1,18 @@
+language: cpp
+compiler: gcc
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y libmysqlclient-dev libperl-dev libboost-dev liblua5.1-0-dev zlib1g-dev
+script:
+  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
+  - make
+  - ./bin/tests
+branches:
+  only:
+    - master
+    - stable
+notifications:
+  email: false
+  irc:
+    channels: "irc.eqemulator.net#eqemucoders"
+os: linux
@@ -1,4 +1,36 @@
-#EQEmu Cmake
+#EQEmu CMake
+#Variables used:
+#EQEMU_DISABLE_CRT_SECURE_WARNINGS
+#EQEMU_FAST_FLOATINGPOINT
+#EQEMU_ENABLE_CRASH_LOGGING
+#EQEMU_DISABLE_SAFESEH
+#EQEMU_BUILD_MSVC_MP
+#EQEMU_DEBUG_LEVEL
+#EQEMU_LOG_LEVEL_STATUS
+#EQEMU_LOG_LEVEL_NORMAL
+#EQEMU_LOG_LEVEL_ERROR
+#EQEMU_LOG_LEVEL_DEBUG
+#EQEMU_LOG_LEVEL_QUEST
+#EQEMU_LOG_LEVEL_COMMANDS
+#EQEMU_LOG_LEVEL_CRASH
+#EQEMU_STREAM_SEND_RATE
+#EQEMU_STREAM_DECAY_RATE
+#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL
+#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX
+#EQEMU_STREAM_AVERAGE_DELTA_MAX
+#EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS
+#EQEMU_DEPOP_INVALIDATES_CACHE
+#EQEMU_ENABLE_BOTS
+#EQEMU_DISABLE_LOGSYS
+#EQEMU_COMMANDS_LOGGING
+#EQEMU_BUILD_SERVER
+#EQEMU_BUILD_LOGIN
+#EQEMU_BUILD_TESTS
+#EQEMU_BUILD_PERL
+#EQEMU_BUILD_LUA
+#EQEMU_SANITIZE_LUA_LIBS
+#EQEMU_BUILD_CLIENT_FILES
+#EQEMU_MAP_DIR

 #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
 #Can change this if you really want but you should upgrade!
@@ -7,158 +39,317 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 #FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})

-#For checking includes
-INCLUDE (CheckIncludeFiles)
-
 #Our project name is EQEmu
 PROJECT(EQEmu)

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

 #Add our various windows definitions
 IF(MSVC OR MINGW)
-    ADD_DEFINITIONS(-D_WINDOWS)
-    IF(CMAKE_CL_64)
-        ADD_DEFINITIONS(-DWIN64)
-    ELSE(CMAKE_CL_64)
-        ADD_DEFINITIONS(-DWIN32)
-    ENDIF(CMAKE_CL_64)
+	ADD_DEFINITIONS(-D_WINDOWS)
+	IF(CMAKE_CL_64)
+		ADD_DEFINITIONS(-DWIN64)
+	ELSE(CMAKE_CL_64)
+		ADD_DEFINITIONS(-DWIN32)
+	ENDIF(CMAKE_CL_64)
 ENDIF(MSVC OR MINGW)

 IF(MSVC)
-    #Set our default locations for zlib/mysql based on x86/x64
-    IF(CMAKE_CL_64)
-        SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
-        SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
-    ELSE(CMAKE_CL_64)
-        SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
-        SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
-    ENDIF(CMAKE_CL_64)
-    
-    #disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
-    OPTION(EQEMU_DISABLE_CRT_SECURE_WARNINGS "Disable Secure CRT Warnings" ON)
-    IF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-        ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
-    ENDIF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-    
-    #fast FP if you'd like it
-    OPTION(EQEMU_FAST_FLOATINGPOINT "Use MSVC /fp:fast option" ON)
-    IF(EQEMU_FAST_FLOATINGPOINT)
+	#Set our default locations for zlib/mysql based on x86/x64
+	IF(CMAKE_CL_64)
+		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
+		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
+		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x64")
+	ELSE(CMAKE_CL_64)
+		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
+		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
+		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
+	ENDIF(CMAKE_CL_64)
+
+	#disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
+	OPTION(EQEMU_DISABLE_CRT_SECURE_WARNINGS "Disable Secure CRT Warnings" ON)
+	IF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
+		ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
+	ENDIF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
+
+	#fast FP if you'd like it
+	OPTION(EQEMU_FAST_FLOATINGPOINT "Use MSVC /fp:fast option" ON)
+	IF(EQEMU_FAST_FLOATINGPOINT)
 		ADD_DEFINITIONS(/fp:fast)
 	ENDIF(EQEMU_FAST_FLOATINGPOINT)
-    
-    #crash logging currently only works on windows x86/x64
-    OPTION(EQEMU_ENABLE_CRASH_LOGGING "Enable crash logging" ON)
-    IF(EQEMU_ENABLE_CRASH_LOGGING)
-        ADD_DEFINITIONS(-DCRASH_LOGGING)
-    ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
-    
-    #Disable safe SEH or not?
-    OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
-    IF(EQEMU_DISABLE_SAFESEH)
-        SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-        SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-        SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-        SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-        SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-        SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-        SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-        SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-        SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-        SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-        SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-        SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-    ENDIF(EQEMU_DISABLE_SAFESEH)
-    
-    #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)
+
+	#crash logging currently only works on windows x86/x64
+	OPTION(EQEMU_ENABLE_CRASH_LOGGING "Enable crash logging" ON)
+	IF(EQEMU_ENABLE_CRASH_LOGGING)
+		ADD_DEFINITIONS(-DCRASH_LOGGING)
+	ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
+
+	#Disable safe SEH or not?
+	OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
+	IF(EQEMU_DISABLE_SAFESEH)
+		SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
+		SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
+		SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
+		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
+		SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
+		SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
+		SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
+		SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
+		SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
+		SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
+		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
+		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
+	ENDIF(EQEMU_DISABLE_SAFESEH)
+
+	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
+	IF(EQEMU_BUILD_MSVC_MP)
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+	ENDIF(EQEMU_BUILD_MSVC_MP)
+
+	#We want to compile /MT not /MD so we change that
+	FOREACH(flag_var CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
+		IF(${flag_var} MATCHES "/MD")
+			STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+		ENDIF(${flag_var} MATCHES "/MD")
+	ENDFOREACH(flag_var)
+
+	ADD_DEFINITIONS(-DNOMINMAX)
 ELSE(MSVC)
-    #Normally set by perl but we don't use the perl flags anymore so we set it.
-    ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
+	#Normally set by perl but we don't use the perl flags anymore so we set it.
+	ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
 ENDIF(MSVC)

-#use stdint.h types if they exist for this platform (we have to guess otherwise)
-CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
-IF(HAVE_STDINT_H)
-    ADD_DEFINITIONS(-DEQEMU_USE_STDINT)
-ENDIF(HAVE_STDINT_H)
+#FreeBSD support
+IF(UNIX)
+	IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+		ADD_DEFINITIONS(-DFREEBSD)
+		ADD_DEFINITIONS(-D_GLIBCXX_USE_C99)
+		SET(FREEBSD TRUE)
+	ENDIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+	IF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+		ADD_DEFINITIONS(-DDARWIN)
+		SET(DARWIN TRUE)
+	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
+#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"
+	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"
 )

+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"
+)
+
+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"
+)
+
+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"
+)
+
+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"
+)
+
+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"
+)
+
+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"
+)
+
+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"
+)
+
+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)
+
+SET(EQEMU_STREAM_SEND_RATE 1048576 CACHE STRING "Advanced: Base amount of data stream can send before throttle.")
+SET(EQEMU_STREAM_DECAY_RATE 78642 CACHE STRING "Advanced: Base amount of data stream recovers per tic.")
+SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL 3.0 CACHE STRING "Advanced: Multiplier on retransmit timeout.")
+SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX 5000 CACHE STRING "Advanced: Max in ms for retransmit timeout timer.")
+SET(EQEMU_STREAM_AVERAGE_DELTA_MAX 2500 CACHE STRING "Advanced: The maximum average delta in ms allowed.")
+SET(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS TRUE CACHE BOOL "Advanced: Whether or not acked packets can be retransmitted")
+MARK_AS_ADVANCED(EQEMU_STREAM_SEND_RATE EQEMU_STREAM_DECAY_RATE EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX EQEMU_STREAM_AVERAGE_DELTA_MAX EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
+
+#NPC Types Cache Behavior
+OPTION(EQEMU_DEPOP_INVALIDATES_CACHE "#repop invalidates the npc_types cache (will cause a larger database hit on #repop but is more convienent)." ON)
+
 #Bots are a compile time option so on/off
 OPTION(EQEMU_ENABLE_BOTS "Enable Bots" OFF)
+
+#Disable entire _mlog system (excludes trade/command logs)
+OPTION(EQEMU_DISABLE_LOGSYS "Disable Logging INI System" ON)
+
+#Enable GM Command log system
+OPTION(EQEMU_COMMANDS_LOGGING "Enable GM Command logs" ON)
+
+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)
+	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_AZONE "Build azone utility." 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)

-IF(UNIX)
-    #Whether to build cleanipc or not (probably a good idea if you build server)
-    OPTION(EQEMU_BUILD_CLEANIPC "Build cleanipc." ON)
-    
-    #Use C++11 stuff, support for this is still it infancy
-    OPTION(EQEMU_CPP_ELEVEN "Enable C++11 extentions in g++" OFF)
-    IF(EQEMU_CPP_ELEVEN)
-        ADD_DEFINITIONS(-std=c++0x)
-    ENDIF(EQEMU_CPP_ELEVEN)
-ENDIF(UNIX)
+#C++11 stuff
+IF(NOT MSVC)
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+	IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal")
+	ENDIF()
+ENDIF(NOT MSVC)

 #Various definitions
-ADD_DEFINITIONS(-DEMBPERL)
-ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
+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)
+
+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(-DSHAREMEM)
 ADD_DEFINITIONS(-DINVERSEXY)
 ADD_DEFINITIONS(-DFIELD_ITEMS)
-ADD_DEFINITIONS(-DMAP_DIR="./Maps")
+ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
+ADD_DEFINITIONS(-DRATEBASE=${EQEMU_STREAM_SEND_RATE})
+ADD_DEFINITIONS(-DDECAYBASE=${EQEMU_STREAM_DECAY_RATE})
+ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MULT=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL})
+ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MAX=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX})
+ADD_DEFINITIONS(-DAVERAGE_DELTA_MAX=${EQEMU_STREAM_AVERAGE_DELTA_MAX})
+ADD_DEFINITIONS(-DLOG_LEVEL_STATUS=${EQEMU_LOG_LEVEL_STATUS})
+ADD_DEFINITIONS(-DLOG_LEVEL_NORMAL=${EQEMU_LOG_LEVEL_NORMAL})
+ADD_DEFINITIONS(-DLOG_LEVEL_ERROR=${EQEMU_LOG_LEVEL_ERROR})
+ADD_DEFINITIONS(-DLOG_LEVEL_DEBUG=${EQEMU_LOG_LEVEL_DEBUG})
+ADD_DEFINITIONS(-DLOG_LEVEL_QUEST=${EQEMU_LOG_LEVEL_QUEST})
+ADD_DEFINITIONS(-DLOG_LEVEL_COMMANDS=${EQEMU_LOG_LEVEL_COMMANDS})
+ADD_DEFINITIONS(-DLOG_LEVEL_CRASH=${EQEMU_LOG_LEVEL_CRASH})
+ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
+
+IF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
+	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=true)
+ELSE(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
+	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=false)
+ENDIF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)

 #Find everything we need
 FIND_PACKAGE(ZLIB REQUIRED)
 FIND_PACKAGE(MySQL REQUIRED)
-FIND_PACKAGE(PerlLibs REQUIRED)
-INCLUDE_DIRECTORIES("${ZLIB_INCLUDE_DIRS}" "${PERL_INCLUDE_PATH}" "${MySQL_INCLUDE_DIR}")
+IF(EQEMU_BUILD_PERL)
+	FIND_PACKAGE(PerlLibs REQUIRED)
+	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
+ENDIF(EQEMU_BUILD_PERL)
+
+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")
+
+	FIND_PACKAGE(Boost REQUIRED)
+	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "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}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm/glm")
+
+IF(EQEMU_BUILD_LUA)
+    ADD_SUBDIRECTORY(luabind)
+ENDIF(EQEMU_BUILD_LUA)

 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
-    ADD_SUBDIRECTORY(common)
+	ADD_SUBDIRECTORY(common)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 IF(EQEMU_BUILD_SERVER)
-    ADD_SUBDIRECTORY(EMuShareMem)
-    ADD_SUBDIRECTORY(world)
-    ADD_SUBDIRECTORY(zone)
-    ADD_SUBDIRECTORY(ucs)
-    ADD_SUBDIRECTORY(queryserv)
-    ADD_SUBDIRECTORY(eqlaunch)
+	ADD_SUBDIRECTORY(shared_memory)
+	ADD_SUBDIRECTORY(world)
+	ADD_SUBDIRECTORY(zone)
+	ADD_SUBDIRECTORY(ucs)
+	ADD_SUBDIRECTORY(queryserv)
+	ADD_SUBDIRECTORY(eqlaunch)
 ENDIF(EQEMU_BUILD_SERVER)
 IF(EQEMU_BUILD_LOGIN)
-    ADD_SUBDIRECTORY(loginserver)
+	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)

-IF(EQEMU_BUILD_AZONE OR EQEMU_BUILD_CLEANIPC)
-    ADD_SUBDIRECTORY(utils)
-ENDIF(EQEMU_BUILD_AZONE OR EQEMU_BUILD_CLEANIPC)
-
 IF(EQEMU_BUILD_TESTS)
-# Testing framework not quite ready for prime time.
-#    ADD_SUBDIRECTORY(tests)
+	ADD_SUBDIRECTORY(tests)
 ENDIF(EQEMU_BUILD_TESTS)
+
+IF(EQEMU_BUILD_CLIENT_FILES)
+	ADD_SUBDIRECTORY(client_files)
+ENDIF(EQEMU_BUILD_CLIENT_FILES)
@@ -1,46 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-
-SET(sharedmem_src
-    DLLMain.cpp
-    Doors.cpp
-    Items.cpp
-    Loot.cpp
-    MMF.cpp
-    MMFMutex.cpp
-    NPCFactionLists.cpp
-    Opcodes.cpp
-    SkillCaps.cpp
-    Spells.cpp
-)
-
-SET(sharedmem_headers
-    Doors.h
-    Items.h
-    Loot.h
-    MMF.h
-    MMFMutex.h
-    NPCFactionLists.h
-    Opcodes.h
-    SkillCaps.h
-    Spells.h
-)
-
-SET(EQEMU_MAX_ITEMS 300000 CACHE STRING "Maxium number of items to load into memory. Make sure this is bigger than the total number of items in the server database")
-SET(EQEMU_MAX_DOORS 30000 CACHE STRING "Maxium number of doors to load into memory. Make sure this is bigger than the total number of doors in the server database")
-SET(EQEMU_MAX_FACTIONLIST_IDS 50000 CACHE STRING "Maxium number of FactionList IDs to load into memory. Make sure this is bigger than the total number of FactionList IDs in the server database")
-
-ADD_DEFINITIONS(-DMMF_EQMAX_ITEMS=${EQEMU_MAX_ITEMS})
-ADD_DEFINITIONS(-DMMF_MAX_Door_ID=${EQEMU_MAX_DOORS})
-ADD_DEFINITIONS(-DMMF_MAX_NPCFactionList_ID=${EQEMU_MAX_FACTIONLIST_IDS})
-
-ADD_LIBRARY(EMuShareMem SHARED ${sharedmem_src} ${sharedmem_headers})
-TARGET_LINK_LIBRARIES(EMuShareMem Common)
-
-IF(UNIX)
-    TARGET_LINK_LIBRARIES(EMuShareMem "dl")
-    TARGET_LINK_LIBRARIES(EMuShareMem "m")
-    TARGET_LINK_LIBRARIES(EMuShareMem "rt")
-    TARGET_LINK_LIBRARIES(EMuShareMem "pthread")
-ENDIF(UNIX)
-
-SET(LIBRARY_OUTPUT_PATH ../Bin)
@@ -1,37 +0,0 @@
-/*
-  EMuShareMem.dll
-  by Quagmire
-  Released under GPL
-
-  This DLL's purpose it to hold a single shared copy of items, npctypes, spells, and other
-  stuff that's normally cached in memory, thus allowing all processes on the server to share
-  one copy of the data, greatly reducing the amount of RAM used.
-*/
-#ifdef _WINDOWS
-
-#include <windows.h>
-void CloseMemShare();
-
-BOOL WINAPI DllMain(
-    HINSTANCE hinstDLL,  // handle to DLL module
-    DWORD fdwReason,     // reason for calling function
-    LPVOID lpReserved )  // reserved
-{
-    // Perform actions based on the reason for calling.
-    switch( fdwReason ) 
-    { 
-        case DLL_PROCESS_ATTACH:
-        case DLL_THREAD_ATTACH: {
-            break;
-		}
-        case DLL_THREAD_DETACH: {
-            break;
-		}
-        case DLL_PROCESS_DETACH: {
-            break;
-		}
-    }
-    return TRUE;  // Successful DLL_PROCESS_ATTACH.
-}
-
-#endif //WIN32
@@ -1,136 +0,0 @@
-#include "../common/debug.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "Doors.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF DoorsMMF;
-const MMFDoors_Struct* MMFDoorsData = 0;
-MMFDoors_Struct* MMFDoorsData_Writable = 0;
-
-#ifdef _WINDOWS
-extern "C" __declspec(dllexport) const Door* GetDoor(uint32 id) {
-	return pGetDoor(id);
-};
-
-extern "C" __declspec(dllexport) bool AddDoor(uint32 id, const Door* door) {
-	return pAddDoor(id, door);
-};
-
-extern "C" __declspec(dllexport) bool DLLLoadDoors(CALLBACK_DBLoadDoors cbDBLoadDoors, uint32 iDoorstructSize, int32* iDoorsCount, uint32* iMaxDoorID) {
-	return pDLLLoadDoors(cbDBLoadDoors, iDoorstructSize, iDoorsCount, iMaxDoorID);
-};
-#else
-extern "C" const Door* GetDoor(uint32 id) {
-	return pGetDoor(id);
-};
-
-extern "C" bool AddDoor(uint32 id, const Door* door) {
-	return pAddDoor(id, door);
-};
-
-extern "C" bool DLLLoadDoors(CALLBACK_DBLoadDoors cbDBLoadDoors, uint32 iDoorstructSize, int32* iDoorsCount, uint32* iMaxDoorID) {
-	return pDLLLoadDoors(cbDBLoadDoors, iDoorstructSize, iDoorsCount, iMaxDoorID);
-};
-
-#endif
-
-bool pAddDoor(uint32 id, const Door* door) {
-	if (!MMFDoorsData_Writable)
-		return false;
-	if (id > MMF_MAX_Door_ID || MMFDoorsData_Writable->NextFreeIndex >= MMFDoorsData_Writable->DoorCount)
-		return false;
-	if (MMFDoorsData_Writable->DoorIndex[id] != 0xFFFFFFFF)
-		return false;
-
-	MMFDoorsData_Writable->DoorIndex[id] = MMFDoorsData_Writable->NextFreeIndex++;
-	memcpy(&MMFDoorsData_Writable->Doors[MMFDoorsData_Writable->DoorIndex[id]], door, sizeof(Door));
-
-	return true;
-}
-
-bool pDLLLoadDoors(CALLBACK_DBLoadDoors cbDBLoadDoors, uint32 iDoorstructSize, int32* iDoorsCount, uint32* iMaxDoorID) {
-	if (iDoorstructSize != sizeof(Door)) {
-		cout << "Error: EMuShareMem: DLLLoadDoors: iDoorstructSize != sizeof(Door)" << endl;
-		cout << "Door struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (*iMaxDoorID > MMF_MAX_Door_ID) {
-		cout << "Error: EMuShareMem: pDLLLoadDoors: iMaxDoorID > MMF_MAX_Door_ID" << endl;
-		cout << "You need to increase the define in Doors.h." << endl;
-		return false;
-	}
-	uint32 tmpMemSize = sizeof(MMFDoors_Struct) + 256 + (sizeof(Door) * (*iDoorsCount));
-	if (DoorsMMF.Open("EQEMuDoors", tmpMemSize)) {
-		if (DoorsMMF.CanWrite()) {
-			MMFDoorsData_Writable = (MMFDoors_Struct*) DoorsMMF.GetWriteableHandle();
-			if (!MMFDoorsData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadDoors: !MMFDoorsData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFDoorsData_Writable, 0, tmpMemSize);
-			for(int i=0; i<MMF_MAX_Door_ID; i++)
-				MMFDoorsData_Writable->DoorIndex[i] = 0xFFFFFFFF;
-			MMFDoorsData_Writable->MaxDoorID = *iMaxDoorID;
-			MMFDoorsData_Writable->DoorCount = *iDoorsCount;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cbDBLoadDoors(*iDoorsCount, *iMaxDoorID)) {
-				cout << "Error: EMuShareMem: DLLLoadDoors: !cbDBLoadDoors" << endl;
-				return false;
-			}
-
-			MMFDoorsData_Writable = 0;
-			DoorsMMF.SetLoaded();
-			MMFDoorsData = (const MMFDoors_Struct*) DoorsMMF.GetHandle();
-			if (!MMFDoorsData) {
-				cout << "Error: EMuShareMem: DLLLoadDoors: !MMFDoorsData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		}
-		else {
-			if (!DoorsMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!DoorsMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(10);
-					Timer::SetCurrentTime();
-				}
-				if (!DoorsMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadDoors: !DoorsMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFDoorsData = (const MMFDoors_Struct*) DoorsMMF.GetHandle();
-			if (!MMFDoorsData) {
-				cout << "Error: EMuShareMem: DLLLoadDoors: !MMFDoorsData (CanWrite=false)" << endl;
-				return false;
-			}
-			*iMaxDoorID = MMFDoorsData->MaxDoorID;
-			*iDoorsCount = MMFDoorsData->DoorCount;
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading Doors: Doors.cpp: pDLLLoadDoors: ret == 0" << endl;
-		return false;
-	}
-	return false;
-};
-
-const Door* pGetDoor(uint32 id) {
-	if (MMFDoorsData == 0 || (!DoorsMMF.IsLoaded()) || id > MMF_MAX_Door_ID || MMFDoorsData->DoorIndex[id] == 0xFFFFFFFF)
-		return 0;
-	return &MMFDoorsData->Doors[MMFDoorsData->DoorIndex[id]];
-}
@@ -1,22 +0,0 @@
-#include "../common/types.h"
-#include "../zone/zonedump.h"
-#include "../common/EMuShareMem.h"
-
-// MMF_MAX_Door_ID:  Make sure this is bigger than the highest Door ID#
-#ifndef MMF_MAX_Door_ID
-#define MMF_MAX_Door_ID		30000
-#endif
-// MMF_MAX_Door_MEM: Maxium number of Doors to load into memory. Make sure this is bigger
-//                      than the total number of Doors in the server's database!
-
-struct MMFDoors_Struct {
-	uint32		MaxDoorID;
-	uint32		NextFreeIndex;
-	uint32		DoorCount;
-	uint32		DoorIndex[MMF_MAX_Door_ID+1];
-	Door		Doors[0];
-};
-
-bool	pDLLLoadDoors(CALLBACK_DBLoadDoors cbDBLoadDoors, uint32 iDoorstructSize, int32* iDoorsCount, uint32* iMaxDoorID);
-bool	pAddDoor(uint32 id, const Door* door);
-const Door* pGetDoor(uint32 id);
@@ -1,152 +0,0 @@
-/*
-  Note: Do NOT change this to load items on an as-needed basis. Since this memory is
-  accessed from multiple threads, you'd need mutex's all over the place if it was
-  ever to be modified/updated/added to. The overhead of the mutexes would be alot more
-  in the long run than the delay in loading.
-
-  -Quagmire
-*/
-
-#ifdef _WINDOWS
-#include <winsock2.h>
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "Items.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF ItemsMMF;
-const MMFItems_Struct* MMFItemsData = 0;
-MMFItems_Struct* MMFItemsData_Writable = 0;
-
-DLLFUNC bool AddItem(uint32 id, const Item_Struct* item) {
-	if (!MMFItemsData_Writable) {
-		return false;
-	}
-	if (id > MMF_EQMAX_ITEMS || MMFItemsData_Writable->NextFreeIndex >= MMFItemsData_Writable->ItemCount) {
-		return false;
-	}
-	if (MMFItemsData_Writable->ItemIndex[id] != 0xFFFF) {
-		return false;
-	}
-	
-	uint32 nextid = MMFItemsData_Writable->NextFreeIndex++;
-	MMFItemsData_Writable->ItemIndex[id] = nextid;
-	memcpy(&MMFItemsData_Writable->Items[nextid], item, sizeof(Item_Struct));
-
-	return true;
-}
-
-DLLFUNC bool DLLLoadItems(CALLBACK_DBLoadItems cbDBLoadItems, uint32 iItemStructSize, int32* iItemCount, uint32* iMaxItemID) {
-	if (iItemStructSize != sizeof(Item_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadItems: iItemStructSize != sizeof(Item_Struct)" << endl;
-		cout << "Item_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (*iMaxItemID > MMF_EQMAX_ITEMS) {
-		cout << "Error: EMuShareMem: pDLLLoadItems: iMaxItemID > MMF_EQMAX_ITEMS" << endl;
-		cout << "You need to increase the define in Items.h." << endl;
-		return false;
-	}
-	
-	MMFItemsData_Writable = 0;
-	//Allocate the shared memory for the item structures
-	uint32 tmpMemSize = sizeof(MMFItems_Struct) + 256 + (sizeof(Item_Struct) * (*iItemCount));
-	//cout << tmpMemSize << endl;
-	if (ItemsMMF.Open("EQEMuItems", tmpMemSize)) {
-		if (ItemsMMF.CanWrite()) {
-			MMFItemsData_Writable = (MMFItems_Struct*) ItemsMMF.GetWriteableHandle();
-			if (!MMFItemsData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadItems: !MMFItemsData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFItemsData_Writable, 0, tmpMemSize);
-			for(int i=0; i<MMF_EQMAX_ITEMS; i++)
-				MMFItemsData_Writable->ItemIndex[i] = 0xFFFF;
-			MMFItemsData_Writable->MaxItemID = *iMaxItemID;
-			MMFItemsData_Writable->ItemCount = *iItemCount;
-			//the writable handle has been created, do the load below after we have the 
-			//serialization handle as well.
-		} else {
-			if (!ItemsMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!ItemsMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(10);
-					Timer::SetCurrentTime();
-				}
-				if (!ItemsMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadItems: !ItemsMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFItemsData = (const MMFItems_Struct*) ItemsMMF.GetHandle();
-			if (!MMFItemsData) {
-				cout << "Error: EMuShareMem: DLLLoadItems: !MMFItemsData (CanWrite=false)" << endl;
-				return false;
-			}
-			*iMaxItemID = MMFItemsData->MaxItemID;
-			*iItemCount = MMFItemsData->ItemCount;
-
-			return true;
-		}
-	} else {
-		cout << "Error Loading Items: Items.cpp: pDLLLoadItems: Open() == false" << endl;
-		return false;
-	}
-	/*
-	
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cbDBLoadItems(*iItemCount, *iMaxItemID)) {
-				cout << "Error: EMuShareMem: DLLLoadItems: !cbDBLoadItems" << endl;
-				return false;
-			}
-
-	*/
-	
-	// use a callback so the DB functions are done in the main exe
-	// this way the DLL doesnt have to open a connection to mysql
-	if (!cbDBLoadItems(*iItemCount, *iMaxItemID)) {
-		cout << "Error: EMuShareMem: DLLLoadItems: !cbDBLoadItems" << endl;
-		return false;
-	}
-	
-	
-	//Now, Disable the write handle and get the read handle.
-	//do this for both item struct and serialization data
-	
-	MMFItemsData_Writable = 0;
-	ItemsMMF.SetLoaded();
-	MMFItemsData = (const MMFItems_Struct*) ItemsMMF.GetHandle();
-	if (!MMFItemsData) {
-		cout << "Error: EMuShareMem: DLLLoadItems: !MMFItemsData (CanWrite=true)" << endl;
-		return false;
-	}
-	
-	return true;
-};
-
-DLLFUNC const Item_Struct* GetItem(uint32 id) {
-	if (MMFItemsData == 0 || (!ItemsMMF.IsLoaded()) || id > MMF_EQMAX_ITEMS || MMFItemsData->ItemIndex[id] == 0xFFFF)
-		return 0;
-	return &MMFItemsData->Items[MMFItemsData->ItemIndex[id]];
-}
-
-DLLFUNC const Item_Struct* IterateItems(uint32* NextIndex) {
-	if (MMFItemsData == 0 || (!ItemsMMF.IsLoaded()) || (*NextIndex) > MMF_EQMAX_ITEMS)
-		return 0;
-	do {
-		if (MMFItemsData->ItemIndex[*NextIndex] != 0xFFFF)
-			return &MMFItemsData->Items[MMFItemsData->ItemIndex[(*NextIndex)++]];
-	} while (++(*NextIndex) < MMF_EQMAX_ITEMS);
-	
-	return 0;
-}
@@ -1,23 +0,0 @@
-#include "../common/types.h"
-#include "../common/eq_packet_structs.h"
-#include "../common/EMuShareMem.h"
-
-// MMF_EQMAX_ITEMS:  Make sure this is bigger than the highest item ID#
-#ifndef MMF_EQMAX_ITEMS
-#define MMF_EQMAX_ITEMS		300000
-#endif
-// MMF_MEMMAX_ITEMS: Maxium number of items to load into memory. Make sure this is bigger
-//                   than the total number of items in the server's database!
-
-struct MMFItems_Struct {
-	uint32		MaxItemID;
-	uint32		NextFreeIndex;
-	uint32		ItemCount;
-	uint32		ItemIndex[MMF_EQMAX_ITEMS+1];
-	Item_Struct	Items[0];
-};
-
-//#define MMF_MAX_ITEMS_MEMSIZE	sizeof(MMFItems_Struct) + 256
-
-
-
@@ -1,214 +0,0 @@
-#include "../common/debug.h"
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "Loot.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF LootMMF;
-const MMFLoot_Struct* MMFLootData = 0;
-MMFLoot_Struct* MMFLootData_Writable = 0;
-uint32* LootTable;
-uint32* LootDrop;
-
-#ifdef _WINDOWS
-	#define exportfunc extern "C" __declspec(dllexport)
-#else
-	#define exportfunc extern "C"
-#endif
-
-exportfunc const LootTable_Struct* GetLootTable(uint32 id) {
-	return pGetLootTable(id);
-};
-exportfunc const LootDrop_Struct* GetLootDrop(uint32 id) {
-	return pGetLootDrop(id);
-};
-
-exportfunc bool AddLootTable(uint32 id, const LootTable_Struct* lts) {
-	return pAddLootTable(id, lts);
-};
-exportfunc bool AddLootDrop(uint32 id, const LootDrop_Struct* lds) {
-	return pAddLootDrop(id, lds);
-};
-
-exportfunc bool DLLLoadLoot(CALLBACK_DBLoadLoot cbDBLoadLoot, 
-					 uint32 iLootTableStructsize, uint32 iLootTableCount, uint32 iMaxLootTable,
-					 uint32 iLootTableEntryStructsize, uint32 iLootTableEntryCount,
-					 uint32 iLootDropStructsize, uint32 iLootDropCount, uint32 iMaxLootDrop,
-					 uint32 iLootDropEntryStructsize, uint32 iLootDropEntryCount
-					 ) {
-	return pDLLLoadLoot(cbDBLoadLoot, 
-					 iLootTableStructsize, iLootTableCount, iMaxLootTable,
-					 iLootTableEntryStructsize, iLootTableEntryCount,
-					 iLootDropStructsize, iLootDropCount, iMaxLootDrop,
-					 iLootDropEntryStructsize, iLootDropEntryCount);
-};
-
-
-bool pAddLootTable(uint32 id, const LootTable_Struct* lts) {
-	if (!MMFLootData_Writable)
-		return false;
-	if (id > MMFLootData_Writable->MaxLootTableID)
-		return false;
-	if (!LootTable || LootTable[id] != 0)
-		return false;
-	
-	uint32 tmp = sizeof(LootTable_Struct) + (sizeof(LootTableEntries_Struct) * lts->NumEntries);
-	if (MMFLootData_Writable->dataindex + tmp >= MMFLootData_Writable->datamax)
-		return false;
-	LootTable[id] = MMFLootData_Writable->dataindex;
-	memcpy(&MMFLootData_Writable->data[MMFLootData_Writable->dataindex], lts, tmp);
-	MMFLootData_Writable->dataindex += tmp;
-
-	return true;
-}
-
-bool pAddLootDrop(uint32 id, const LootDrop_Struct* lds) {
-	if (!MMFLootData_Writable)
-		return false;
-	if (id > MMFLootData_Writable->MaxLootDropID)
-		return false;
-	if (!LootDrop || LootDrop[id] != 0)
-		return false;
-	
-	uint32 tmp = sizeof(LootDrop_Struct) + (sizeof(LootDropEntries_Struct) * lds->NumEntries);
-	if (MMFLootData_Writable->dataindex + tmp >= MMFLootData_Writable->datamax)
-		return false;
-	LootDrop[id] = MMFLootData_Writable->dataindex;
-	memcpy(&MMFLootData_Writable->data[MMFLootData_Writable->dataindex], lds, tmp);
-	MMFLootData_Writable->dataindex += tmp;
-
-	return true;
-}
-
-bool pDLLLoadLoot(CALLBACK_DBLoadLoot cbDBLoadLoot, 
-					 uint32 iLootTableStructsize, uint32 iLootTableCount, uint32 iMaxLootTable,
-					 uint32 iLootTableEntryStructsize, uint32 iLootTableEntryCount,
-					 uint32 iLootDropStructsize, uint32 iLootDropCount, uint32 iMaxLootDrop,
-					 uint32 iLootDropEntryStructsize, uint32 iLootDropEntryCount
-					 ) {
-#if 0
-cout << "iLootTableCount: " << iLootTableCount << endl;
-cout << "iMaxLootTable: " << iMaxLootTable << endl;
-cout << "iLootTableEntryCount: " << iLootTableEntryCount << endl;
-cout << "iLootDropCount: " << iLootDropCount << endl;
-cout << "iMaxLootDrop: " << iMaxLootDrop << endl;
-cout << "iLootDropEntryCount: " << iLootDropEntryCount << endl;
-#endif
-	if (iLootTableStructsize != sizeof(LootTable_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: iLootTableStructsize != sizeof(LootTable_Struct)" << endl;
-		cout << "Item_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (iLootTableEntryStructsize != sizeof(LootTableEntries_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: iLootTableEntryStructsize != sizeof(LootTableEntries_Struct)" << endl;
-		cout << "Item_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (iLootDropStructsize != sizeof(LootDrop_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: iLootDropStructsize != sizeof(LootDrop_Struct)" << endl;
-		cout << "Item_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (iLootDropEntryStructsize != sizeof(LootDropEntries_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: iLootDropEntryStructsize != sizeof(LootDropEntries_Struct)" << endl;
-		cout << "Item_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-
-	uint32 tmpMemSize = sizeof(MMFLoot_Struct) + 256
-		+ (sizeof(uint32) * (iMaxLootTable+1))
-		+ (sizeof(LootTable_Struct) * iLootTableCount) + (sizeof(LootTableEntries_Struct) * iLootTableEntryCount)
-		+ (sizeof(uint32) * (iMaxLootDrop+1))
-		+ (sizeof(LootDrop_Struct) * iLootDropCount) + (sizeof(LootDropEntries_Struct) * iLootDropEntryCount)
-		;
-	if (LootMMF.Open("EQEMuLoot", tmpMemSize)) {
-		if (LootMMF.CanWrite()) {
-			MMFLootData_Writable = (MMFLoot_Struct*) LootMMF.GetWriteableHandle();
-			if (!MMFLootData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadLoot: !MMFLootData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFLootData_Writable, 0, tmpMemSize);
-			MMFLootData_Writable->LootTableCount = iLootTableCount;
-			MMFLootData_Writable->MaxLootTableID = iMaxLootTable;
-			MMFLootData_Writable->LootDropCount = iLootDropCount;
-			MMFLootData_Writable->MaxLootDropID = iMaxLootDrop;
-			MMFLootData_Writable->datamax = tmpMemSize - sizeof(MMFLoot_Struct);
-
-			MMFLootData_Writable->dataindex = 0;
-			MMFLootData_Writable->LootTableOffset = MMFLootData_Writable->dataindex;
-			MMFLootData_Writable->dataindex += (sizeof(uint32) * (iMaxLootTable+1));
-			MMFLootData_Writable->LootDropOffset = MMFLootData_Writable->dataindex;
-			MMFLootData_Writable->dataindex += (sizeof(uint32) * (iMaxLootDrop+1));
-
-			LootTable = (uint32*) &MMFLootData_Writable->data[MMFLootData_Writable->LootTableOffset];
-			LootDrop = (uint32*) &MMFLootData_Writable->data[MMFLootData_Writable->LootDropOffset];
-
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cbDBLoadLoot()) {
-				cout << "Error: EMuShareMem: DLLLoadLoot: !cbDBLoadLoot" << endl;
-				return false;
-			}
-
-			MMFLootData_Writable = 0;
-			LootMMF.SetLoaded();
-		}
-		else {
-			if (!LootMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!LootMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(10);
-					Timer::SetCurrentTime();
-				}
-				if (!LootMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadLoot: !LootMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-		}
-	}
-	else {
-		cout << "Error Loading Loot: Loot.cpp: pDLLLoadLoot: Open() == false" << endl;
-		return false;
-	}
-	MMFLootData = (const MMFLoot_Struct*) LootMMF.GetHandle();
-	if (!MMFLootData) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: !MMFLootData" << endl;
-		MMFLootData = 0;
-		return false;
-	}
-	if (MMFLootData->LootTableCount != iLootTableCount
-		|| MMFLootData->MaxLootTableID != iMaxLootTable
-		|| MMFLootData->LootDropCount != iLootDropCount
-		|| MMFLootData->MaxLootDropID != iMaxLootDrop) {
-		cout << "Error: EMuShareMem: DLLLoadLoot: Count/Max mismatch" << endl;
-		MMFLootData = 0;
-		return false;
-	}
-	LootTable = (uint32*) &MMFLootData->data[MMFLootData->LootTableOffset];
-	LootDrop = (uint32*) &MMFLootData->data[MMFLootData->LootDropOffset];
-	return true;
-};
-
-const LootTable_Struct* pGetLootTable(uint32 id) {
-	if (MMFLootData == 0 || !LootMMF.IsLoaded())
-		return 0;
-	if (id > MMFLootData->MaxLootTableID || LootTable[id] == 0)
-		return 0;
-	return (LootTable_Struct*) &MMFLootData->data[LootTable[id]];
-}
-
-const LootDrop_Struct* pGetLootDrop(uint32 id) {
-	if (MMFLootData == 0 || !LootMMF.IsLoaded())
-		return 0;
-	if (id > MMFLootData->MaxLootDropID || LootDrop[id] == 0)
-		return 0;
-	return (LootDrop_Struct*) &MMFLootData->data[LootDrop[id]];
-}
-
-
@@ -1,29 +0,0 @@
-#include "../common/types.h"
-#include "../common/eq_packet_structs.h"
-#include "../common/EMuShareMem.h"
-
-#pragma pack(1)
-struct MMFLoot_Struct {
-	bool				Loaded;
-	uint32				MaxLootTableID;
-	uint32				LootTableCount;
-	uint32				LootTableOffset;
-	uint32				MaxLootDropID;
-	uint32				LootDropCount;
-	uint32				LootDropOffset;
-	uint32				datamax;
-	uint32				dataindex;
-	uint8				data[0];
-};
-#pragma pack()
-
-bool	pDLLLoadLoot(CALLBACK_DBLoadLoot cbDBLoadLoot, 
-					 uint32 iLootTableStructsize, uint32 iLootTableCount, uint32 iMaxLootTable,
-					 uint32 iLootTableEntryStructsize, uint32 iLootTableEntryCount,
-					 uint32 iLootDropStructsize, uint32 iLootDropCount, uint32 iMaxLootDrop,
-					 uint32 iLootDropEntryStructsize, uint32 iLootDropEntryCount
-					 );
-bool	pAddLootTable(uint32 id, const LootTable_Struct* lts);
-bool	pAddLootDrop(uint32, const LootDrop_Struct* lds);
-const LootTable_Struct*		pGetLootTable(uint32 id);
-const LootDrop_Struct*		pGetLootDrop(uint32 id);
@@ -1,353 +0,0 @@
-// start mingw
-#ifdef __MINGW32__
-#define __try
-#define __finally
-#endif
-// end mingw
-
-#include "MMF.h"
-#include <iostream>
-using namespace std;
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#ifdef _WINDOWS
-	#define snprintf	_snprintf
-	#define vsnprintf	_vsnprintf
-	#define strncasecmp	_strnicmp
-	#define strcasecmp  _stricmp
-#else
-    #include "MMFMutex.h"
-    #include "../common/unix.h"    
-#endif
-
-MMF::MMF() {
-	SharedMemory = 0;
-	pCanWrite = false;
-	#ifdef _WINDOWS
-		hMapObject = NULL;
-		lpvMem = 0;
-	#else
-		lpvMem = 0;
-		pMMFMutex = 0;
-		m_alloc = false;
-	#endif
-}
-
-MMF::~MMF() {
-	Close();
-}
-
-bool MMF::Open(const char* iName, uint32 iSize) {
-	if (iSize < 1) {
-		cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: iSize < 1" << endl;
-		return false;
-	}
-	if (strlen(iName) < 2) {
-		cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: strlen(iName) < 2" << endl;
-		return false;
-	}
-	char MMFname[200];
-	memset(MMFname, 0, sizeof(MMFname));
-	snprintf(MMFname, sizeof(MMFname), "memfilemap_%s", iName);
-	uint32 tmpSize = sizeof(MMF_Struct) + iSize;
-	
-#ifdef _WINDOWS
-	char MMFMutexName[200];
-	memset(MMFMutexName, 0, sizeof(MMFMutexName));
-	snprintf(MMFMutexName, sizeof(MMFMutexName), "MutexToProtectOpenMMF_%s", iName);
-	
-	HANDLE hMutex;
-	hMutex = CreateMutex( 
-	NULL,                       // no security attributes
-	FALSE,                      // initially not owned
-	MMFMutexName);  // name of mutex
-
-	if (hMutex == NULL) {
-		cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: hMutex == Null" << endl;
-		return false;
-	}
-
-	DWORD dwWaitResult;
-    // Request ownership of mutex.
-	dwWaitResult = WaitForSingleObject( 
-		hMutex,   // handle to mutex
-		2000L);   // two-second time-out interval
-
-	if (dwWaitResult != WAIT_OBJECT_0) {
-		// Mutex not aquired, crap out
-		cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: dwWaitResult != WAIT_OBJECT_0" << endl;
-		return false;
-	}
-
-	// Finally, ready to rock.
-	bool fInit = false;
-	__try {
-		hMapObject = CreateFileMapping( 
-			INVALID_HANDLE_VALUE,		// use paging file
-			NULL,						// default security attributes
-			PAGE_READWRITE,				// read/write access
-			0,							// size: high 32-bits
-			tmpSize,					// size: low 32-bits
-			MMFname);					// name of map object
-		if (hMapObject == NULL) {
-			cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: hMapObject == Null" << endl;
-			return false;
-		}
-
-		// The first process to attach initializes memory.
-
-		fInit = (bool) (GetLastError() != ERROR_ALREADY_EXISTS); 
-
-		// Get a pointer to the file-mapped shared memory.
-
-		lpvMem = MapViewOfFile( 
-			hMapObject,					// object to map view of
-			FILE_MAP_WRITE,				// read/write access
-			0,							// high offset:  map from
-			0,							// low offset:   beginning
-			0);							// default: map entire file
-		if (lpvMem == NULL) {
-			cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: lpvMem == Null" << endl;
-			Close();
-			return false;
-		}
- 
-		SharedMemory = (MMF_Struct*) lpvMem;
-		// Initialize memory if this is the first process.
-		if (fInit) {
-			memset(lpvMem, 0, sizeof(MMF_Struct));
-			pCanWrite = true;
-			SharedMemory->Loaded = false;
-			SharedMemory->datasize = iSize;
-		}
-		else {
-			pCanWrite = false;
-			if (SharedMemory->datasize != iSize) {
-				cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: SharedMemory->datasize != iSize" << endl;
-				Close();
-				return false;
-			}
-		}
-	} // end of try block
-
-	__finally {
-		// Clean up the Mutex stuff
-		if (!ReleaseMutex(hMutex)) {
-			cout << "Error Loading MMF: " << __FILE__ << ":" << __LINE__ << " OpenMMF: !ReleaseMutex(hMutex)" << endl;
-			Close();
-			return false;
-		}
-	}
-	CloseHandle(hMutex);
-
-	return true;
-#else //else, NOT WINDOWS
-	int load_share;
-	//int max_share = 7;
-	key_t share_key;
-	switch (MMFname[16]) {
-		case 'I': load_share = 0;  break;
-		case 'N': load_share = 1;  break;
-		case 'D': load_share = 2;  break;
-		case 'S': load_share = 3;  break;
-		case 'F': load_share = 4;  break;
-		case 'L': load_share = 5;  break;
-		case 'M': load_share = 6;  break;
-		case 'O': load_share = 7;  break;
-		case 'Z': load_share = 8;  break;
-		case 'K': load_share = 9;  break;
-#ifdef CATCH_CRASH
-		default:
-		    cerr<<"Failed to load shared memory segment="<<MMFname<<" ("<<MMFname[16]<<")"<<endl;
-		    // malloc some memory here or something fancy
-		    return false; // and make this return true
-		break;
-#else
-		default: cerr<<"FATAL="<<(char)MMFname[16]<<endl; return false; break;
-#endif
-	}
-	switch (load_share) {
-		// Item
-		case 0: share_key = ftok(".", 'I'); break;
-		// Npctype
-		case 1: share_key = ftok(".", 'N'); break;
-		// Door
-		case 2: share_key = ftok(".", 'D'); break;
-		// Spell
-		case 3: share_key = ftok(".", 'S'); break;
-		// Faction
-		case 4: share_key = ftok(".", 'F'); break;
-		// Loot
-		case 5: share_key = ftok(".", 'L'); break;
-		// ??
-		case 6: share_key = ftok(".", 'M'); break;
-		// Opcodes
-		case 7: share_key = ftok(".", 'O'); break;
-		// Item Serialization
-		case 8: share_key = ftok(".", 'Z'); break;
-		// Skills
-		case 9: share_key = ftok(".", 'K'); break;
-		// ERROR Fatal
-		default: cerr<<"Opps!"<<endl; share_key = 0xFF; break;
-	}
-	pMMFMutex = new MMFMutex(share_key);
-	if (!pMMFMutex){
-		assert(false);
-	}
-	//if (!tmpSize) {
-		int share_id = shmget(share_key, tmpSize, IPC_CREAT|IPC_EXCL|SHM_R|SHM_W);
-		if ( share_id <= 0) {
-			share_id = shmget(share_key, tmpSize, IPC_CREAT|IPC_NOWAIT);
-			if (share_id <= 0) {
-			    shmid_ds mem_size;
-			    share_id = shmget(share_key, 1, IPC_CREAT|IPC_NOWAIT|SHM_R|SHM_W);
-			    if(share_id == -1) {
-				    cerr << "failed to get 0-length shared mem: " << strerror(errno) << endl;
-			    }
-			    if ((lpvMem = shmat(share_id, NULL,SHM_RDONLY)) == (void *)-1) {
-				    cerr << "shmat failed! " << strerror(errno) << endl;
-			    }
-			    if( (shmctl(share_id, IPC_STAT, &mem_size)) == 0){
-				  if (mem_size.shm_segsz != int(tmpSize)){	//comparison between signed and unsigned integer expressions
-					cout<<"[Warning] requested shared memory of size:"<<tmpSize<<" but that Key is already in use with size:"<< mem_size.shm_segsz<<endl;
-					shmid_ds mem_users;
-					if( (shmctl(share_id, IPC_STAT, &mem_users)) == 0 && mem_users.shm_nattch == 1){
-					    cout<<"[Warning] Attempting resize"<<endl;
-					    shmctl(share_id, IPC_RMID, 0);
-					    shmdt(lpvMem);
-					    if ((share_id = shmget(share_key, tmpSize, IPC_CREAT|IPC_EXCL|SHM_R|SHM_W)) <= 0) {
-						// Failed proceed on malloc
-					    	cerr<<"[Error] Failed to resize" << strerror(errno) <<endl;
-					    }
-					    else{
-					    	cerr<<"[Error] Resize successful." << endl;
-							// Success
-							lpvMem = shmat(share_id, NULL, SHM_R|SHM_W);
-							memset(lpvMem, 0, sizeof(MMF_Struct));
-							pCanWrite = true;
-							SharedMemory = (MMF_Struct*) lpvMem;
-							SharedMemory->Loaded = false;
-							SharedMemory->datasize = iSize;
-							pMMFMutex->Release(this);
-							delete pMMFMutex;
-							return true;
-					    }
-					}
-					else{
-					    cout<<"[Warning] Resize not possible"<<endl;
-					}
-				  }
-			    }
-			    // Can not attatch to shared memory we'll malloc it here
-				if ((lpvMem == 0 || lpvMem == (void *)-1) && (lpvMem = malloc(tmpSize))) {
-					cout<<"[Warning] Could not attach to shared memory proceeding on isolated memory (share_id <= 0)"<<endl;
-					// Success!
-					m_alloc = true;
-					memset(lpvMem, 0, sizeof(MMF_Struct));
-					pCanWrite = true;
-					SharedMemory = (MMF_Struct*) lpvMem;
-					SharedMemory->datasize = iSize;
-					SharedMemory->Loaded = false;
-					pMMFMutex->Release(this);
-					delete pMMFMutex;
-					return true;
-				}  else if (!lpvMem){
-					//LogFile->write(EQEMuLog::Error, "Could not connect to shared memory and allocation of isolated memory failed.");
-					cout<<"Could not connect to shared memory and allocation of isolated memory failed."<<endl;
-					pMMFMutex->Release(this);
-					delete pMMFMutex;
-					exit(1);
-				}
-				pCanWrite = false;
-				SharedMemory = (MMF_Struct*) lpvMem;
-				if (SharedMemory->datasize != iSize) {
-					cerr<<"SharedMemory->datasize("<<SharedMemory->datasize<<") != iSize("<<iSize<<"), We can rebuild him faster better STRONGER!"<<endl;
-					cerr<<"Or not.. restart all servers on this machine"<<endl;
-					shmctl(share_id, IPC_RMID, 0);
-					pMMFMutex->Release(this);
-					exit(1);
-				}
-				pMMFMutex->Release(this);
-				delete pMMFMutex;
-				return true;
-			}
-			shmid_ds mem_users;
-			if ((shmctl(share_id, IPC_STAT, &mem_users)) != 0) {
-				if ((lpvMem = malloc(tmpSize))) {
-					// Success!
-					cout<<"[Warning] Could not attach to shared memory proceeding on isolated memory"<<endl;
-					m_alloc = true;
-					memset(lpvMem, 0, sizeof(MMF_Struct));
-					pCanWrite = true;
-					SharedMemory = (MMF_Struct*) lpvMem;
-					SharedMemory->datasize = iSize;
-					SharedMemory->Loaded = false;
-					pMMFMutex->Release(this);
-					delete pMMFMutex;
-					return true;
-				}  else {
-					//LogFile->write(EQEMuLog::Error, "Could not connect to shared memory and allocation of isolated memory failed.");
-					cout<<"Could not connect to shared memory and allocation of isolated memory failed."<<endl;
-					pMMFMutex->Release(this);
-					delete pMMFMutex;
-					exit(1);
-				}
-			}
-			lpvMem = shmat(share_id, NULL,SHM_RDONLY);
-			pCanWrite = false;
-			SharedMemory = (MMF_Struct*) lpvMem;
-			//cerr << "lpvMem=" << (int)lpvMem << endl;
-			if (lpvMem==(void *)-1 || SharedMemory->datasize != iSize) {
-			    cerr<<"SharedMemory->datasize("<<SharedMemory->datasize<<") != iSize("<<iSize<<"), or "<<((void *)lpvMem)<<"==-1, We can rebuild him faster better STRONGER!"<<endl;
-			    cerr<<"Or not.. restart all servers on this machine"<<endl;
-			    shmctl(share_id, IPC_RMID, 0);
-			    pMMFMutex->Release(this);
-			    exit(1);
-			}
-			pMMFMutex->Release(this);
-			delete pMMFMutex;
-			return true;
-		}
-		lpvMem = shmat(share_id, NULL, SHM_R|SHM_W);
-		memset(lpvMem, 0, sizeof(MMF_Struct));
-		pCanWrite = true;
-		SharedMemory = (MMF_Struct*) lpvMem;
-		SharedMemory->Loaded = false;
-		SharedMemory->datasize = iSize;
-	//}
-	pMMFMutex->Release(this);
-	delete pMMFMutex;
-	return true;
-
-#endif //end NOT WINDOWS
-}
-
-void MMF::Close() {
-	SharedMemory = 0;
-	pCanWrite = false;
-#ifdef _WINDOWS
-		if (lpvMem) {
-			// Unmap shared memory from the process's address space.
-			UnmapViewOfFile(lpvMem); 
-			lpvMem = 0;
-		}
-		if (hMapObject) {
-			// Close the process's handle to the file-mapping object.
-			CloseHandle(hMapObject);
-			hMapObject = NULL;
-		}
-#else
-		if (lpvMem) {
-			if (m_alloc == true)
-				free(lpvMem);
-			else
-				if (shmdt(lpvMem) == -1)
-					//LogFile->write(EQEMuLog::Error, "Warning something odd happened freeing shared memory");
-					cout<<"Warning something odd happened freeing shared memory"<<endl;
-			lpvMem = 0;
-		}
-#endif
-}
-
@@ -1,46 +0,0 @@
-#ifndef MMF_H
-#define MMF_H
-#include "../common/types.h"
-#ifdef _WINDOWS
-	#include <windows.h>
-#else
-	//#include "MMFMutex.h"
-	class MMFMutex;
-#endif
-
-class MMF {
-public:
-	struct MMF_Struct {
-		bool	Loaded;
-		uint32	datasize;
-		uint8	data[0];
-	};
-
-	MMF();
-	virtual ~MMF();
-
-			bool	Open(const char* iName, uint32 iSize);
-			void	Close();
-	const	void*	GetHandle() { if (IsLoaded()) { return SharedMemory->data; } return 0; }
-			void*	GetWriteableHandle() { if (!IsLoaded() && CanWrite()) { return SharedMemory->data; } return 0; }
-
-	inline	bool	IsOpen()		{ return (bool) (SharedMemory != 0); }
-	inline	bool	IsLoaded()		{ if (SharedMemory) { return SharedMemory->Loaded; } return false; }
-			bool	SetLoaded()		{ if (SharedMemory && CanWrite()) { SharedMemory->Loaded = true; return true; } return false; }
-	inline	bool	CanWrite()		{ if (SharedMemory) { return pCanWrite; } return false; }
-	
-#ifndef WIN32
-	bool	m_alloc;
-#endif
-private:
-	bool		pCanWrite;
-	MMF_Struct* SharedMemory;
-#ifdef _WINDOWS
-	HANDLE		hMapObject;
-	LPVOID		lpvMem;
-#else
-	void*		lpvMem;
-	MMFMutex*	pMMFMutex;
-#endif
-};
-#endif
@@ -1,126 +0,0 @@
-#include "MMFMutex.h"
-
-#ifndef WIN32
-
-MMFMutex::MMFMutex( int key )
- {
-    m_key = key;
-
-    if( m_key == 0 )
-    {
-        // initialize POSIX semaphore
-        sem_init( &m_semaphore, 0, 1);
-    }
-    else
-    {
-        // currently, this thread does not own the semaphore
-        m_owner = 0;
-        m_recursive_count = 0;
-
-        // try to get an existing semaphore. the access permissions are "full access for everyone"
-        m_id = semget(m_key, 1, 0x1b6); 
-        if( m_id == -1 )
-        {
-            // it doesn't exist yet, try to create a new one
-            m_id = semget(m_key, 1, IPC_CREAT | 0x1b6);
-            if( m_id != -1 )
-            {
-                // initialize it to 1
-                semun data;
-                data.val = 1;
-                semctl(m_id, 0, SETVAL, data);
-            }
-        }
-    }
-}
-
-MMFMutex::~MMFMutex()
-{
-    if( m_key == 0 )
-    {
-        sem_destroy(&m_semaphore);
-    }
-    else
-    {
-        semctl(m_id, 0, IPC_RMID, 0);
-    }
-}
-
-bool MMFMutex::Lock( uint32 dwTimeout )
- {
-    if( m_owner == pthread_self() )
-    {
-        m_recursive_count++;
-        return true;
-    }
-    bool bUseTimeout = (dwTimeout != 0);
-    while(true) {
-        bool bGotSemaphore = false;
-        if( m_key == 0 )
-        {
-            bGotSemaphore = (sem_trywait(&m_semaphore) == 0);
-        }
-        else
-        {
-            struct sembuf operations[1];
-            operations[0].sem_num = 0;
-            operations[0].sem_op = -1;
-            operations[0].sem_flg = SEM_UNDO|IPC_NOWAIT;
-            bGotSemaphore = (semop(m_id, operations, 1) >= 0);
-        }
-        if( bGotSemaphore )
-        {
-            m_owner = pthread_self();
-            m_recursive_count = 1;
-            return true;
-        }
-        sleep(1);
-        if( bUseTimeout )
-        {
-            if( dwTimeout > 1000 )
-                dwTimeout -= 1000;
-            else
-                dwTimeout = 0;
-
-            if( dwTimeout == 0 )
-                return false;
-        }
-    }
-}
-void MMFMutex::Release(const MMF* pMMF)
-{
-    if( m_owner != pthread_self() && pMMF->m_alloc != true  )
-    {
-        //We're supposed to explode here with an assert
-        //assert(false);
-    }
-    else if ( pMMF->m_alloc == true ){
-	// Just do it nothing is useing but us
-	return;
-    }
-    else if( m_recursive_count > 1 )
-    {
-        m_recursive_count--;
-    }
-    else
-    {
-        if( m_key == 0 )
-        {
-            sem_post(&m_semaphore);
-        }
-
-        else
-        {
-            struct sembuf operations[1];
-            operations[0].sem_num = 0;
-            operations[0].sem_op = 1;
-            operations[0].sem_flg = SEM_UNDO;
-            semop(m_id, operations, 1);
-        }
-        m_recursive_count = 0;
-        m_owner = 0;
-    }
-}
-#endif //!WIN32
-
-
@@ -1,43 +0,0 @@
-#ifndef MMFMUTEX_H
-#define MMFMUTEX_H
-#ifndef WIN32
-#include <sys/types.h> // moved before sys/shm.h for freeBSD
-#include <sys/shm.h>
-#include <sys/ipc.h>
-#include <sys/sem.h>
-#include <semaphore.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <assert.h>
-#include "../common/types.h"
-
-#include "MMF.h"
-
-// the manuals say you have to define this struct your self. 
-#if !defined FREEBSD || defined __NetBSD__  // for BSDs
-union semun
-{
-    int val;
-    struct semid_ds* buf;
-    unsigned short int *array;
-    struct seminfo *__buf;
-};
-#endif  // for freeBSD
-
-class MMFMutex
- {
-    public:
-        MMFMutex(int iIndex);
-        virtual ~MMFMutex();
-        bool Lock( uint32 dwTimeout = 0 );
-        void Release(const MMF*);
-    
-    protected:
-        int m_id; 
-        key_t m_key; 
-        pthread_t m_owner;
-        sem_t m_semaphore;
-        int m_recursive_count;
-};
-#endif //!WIN32
-#endif
@@ -1,178 +0,0 @@
-#include "../common/debug.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "NPCFactionLists.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF NPCFactionListsMMF;
-const MMFNPCFactionLists_Struct* MMFNPCFactionListsData = 0;
-MMFNPCFactionLists_Struct* MMFNPCFactionListsData_Writable = 0;
-
-#ifdef _WINDOWS
-extern "C" __declspec(dllexport) const NPCFactionList* GetNPCFactionList(uint32 id) {
-	return pGetNPCFactionList(id);
-};
-
-extern "C" __declspec(dllexport) bool AddNPCFactionList(uint32 id, const NPCFactionList* nfl) {
-	return pAddNPCFactionList(id, nfl);
-};
-
-extern "C" __declspec(dllexport) bool DLLLoadNPCFactionLists(CALLBACK_DBLoadNPCFactionLists cbDBLoadNPCFactionLists, uint32 iNPCFactionListStructSize, int32* iNPCFactionListsCount, uint32* iMaxNPCFactionListID, uint8 iMaxNPCFactions) {
-	return pDLLLoadNPCFactionLists(cbDBLoadNPCFactionLists, iNPCFactionListStructSize, iNPCFactionListsCount, iMaxNPCFactionListID, iMaxNPCFactions);
-};
-
-extern "C" __declspec(dllexport) bool SetNPCFaction(uint32 id, uint32* factionid, int32* factionvalue, int8 *factionnpcvalue, uint8 *factiontemp) {
-	return pSetNPCFaction(id, factionid, factionvalue, factionnpcvalue, factiontemp);
-}
-#else
-extern "C" const NPCFactionList* GetNPCFactionList(uint32 id) {
-	return pGetNPCFactionList(id);
-};
-
-extern "C" bool AddNPCFactionList(uint32 id, const NPCFactionList* nfl) {
-	return pAddNPCFactionList(id, nfl);
-};
-
-extern "C" bool DLLLoadNPCFactionLists(CALLBACK_DBLoadNPCFactionLists cbDBLoadNPCFactionLists, uint32 iNPCFactionListStructSize, int32* iNPCFactionListsCount, uint32* iMaxNPCFactionListID, uint8 iMaxNPCFactions) {
-	return pDLLLoadNPCFactionLists(cbDBLoadNPCFactionLists, iNPCFactionListStructSize, iNPCFactionListsCount, iMaxNPCFactionListID, iMaxNPCFactions);
-};
-
-extern "C" bool SetNPCFaction(uint32 id, uint32* factionid, int32* factionvalue, int8 *factionnpcvalue, uint8 *factiontemp) {
-	return pSetNPCFaction(id, factionid, factionvalue, factionnpcvalue, factiontemp);
-}
-#endif
-
-bool pAddNPCFactionList(uint32 id, const NPCFactionList* nfl) {
-	if (!MMFNPCFactionListsData_Writable){
-	    if (EQDEBUG>=1) cout<<"[Debug] !MMFNPCFactionListsData_Writable"<<endl;
-		return false;
-	}
-	if (id > MMF_MAX_NPCFactionList_ID || MMFNPCFactionListsData_Writable->NextFreeIndex >= MMFNPCFactionListsData_Writable->NPCFactionListCount){
-	    if (EQDEBUG>=1) cout<<"[Debug] id > MMF_MAX_NPCFactionList_ID || MMFNPCFactionListsData_Writable->NextFreeIndex >= MMFNPCFactionListsData_Writable->NPCFactionListCount"<<endl;
-		return false;
-	}
-	if (MMFNPCFactionListsData_Writable->NPCFactionListIndex[id] != 0xFFFFFFFF){
-	    if (EQDEBUG>=1) cout<<"[Debug] MMFNPCFactionListsData_Writable->NPCFactionListIndex[id] != 0xFFFFFFFF"<<endl;
-		return false;
-	}
-
-	MMFNPCFactionListsData_Writable->NPCFactionListIndex[id] = MMFNPCFactionListsData_Writable->NextFreeIndex++;
-	memcpy(&MMFNPCFactionListsData_Writable->NPCFactionLists[MMFNPCFactionListsData_Writable->NPCFactionListIndex[id]], nfl, sizeof(NPCFactionList));
-
-	return true;
-}
-
-bool pSetNPCFaction(uint32 id, uint32* factionid, int32* factionvalue, int8 *factionnpcvalue, uint8 *factiontemp) {
-	if (!MMFNPCFactionListsData_Writable) {
-	    if(EQDEBUG>=1) cout<<"[Debug] !MMFNPCFactionListsData_Writable"<<endl;
-		return false;
-	}
-	if (id > MMF_MAX_NPCFactionList_ID) {
-	    if(EQDEBUG>=1) cout<<"[Debug] id > MMF_MAX_NPCFactionList_ID"<<endl;
-		return false;
-	}
-	if (MMFNPCFactionListsData_Writable->NPCFactionListIndex[id] == 0xFFFFFFFF) {
-	    if(EQDEBUG>=1) cout<<"[Debug] MMFNPCFactionListsData_Writable->NPCFactionListIndex[id="<<id<<"] == 0xFFFFFFFF"<<endl;
-		return false;
-	}
-	
-	for (int i=0; i<MAX_NPC_FACTIONS; i++) {
-		MMFNPCFactionListsData_Writable->NPCFactionLists[MMFNPCFactionListsData_Writable->NPCFactionListIndex[id]].factionid[i] = factionid[i];
-		MMFNPCFactionListsData_Writable->NPCFactionLists[MMFNPCFactionListsData_Writable->NPCFactionListIndex[id]].factionvalue[i] = factionvalue[i];
-		MMFNPCFactionListsData_Writable->NPCFactionLists[MMFNPCFactionListsData_Writable->NPCFactionListIndex[id]].factionnpcvalue[i] = factionnpcvalue[i];
-		MMFNPCFactionListsData_Writable->NPCFactionLists[MMFNPCFactionListsData_Writable->NPCFactionListIndex[id]].factiontemp[i] = factiontemp[i];
-	}
-	return true;
-}
-
-bool pDLLLoadNPCFactionLists(CALLBACK_DBLoadNPCFactionLists cbDBLoadNPCFactionLists, uint32 iNPCFactionListStructSize, int32* iNPCFactionListsCount, uint32* iMaxNPCFactionListID, uint8 iMaxNPCFactions) {
-	if (iNPCFactionListStructSize != sizeof(NPCFactionList)) {
-		cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: iNPCFactionListStructSize != sizeof(NPCFactionList)" << endl;
-		cout << "NPCFactionList struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (iMaxNPCFactions != MAX_NPC_FACTIONS) {
-		cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: iMaxNPCFactions != MAX_NPC_FACTIONS" << endl;
-		cout << "NPCFactionList struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (*iMaxNPCFactionListID > MMF_MAX_NPCFactionList_ID) {
-		cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: iMaxNPCFactions > MMF_MAX_NPCFactionList_ID" << endl;
-		cout << "You need to increase the define in NPCFactionList.h." << endl;
-		return false;
-	}
-	uint32 tmpMemSize = sizeof(MMFNPCFactionLists_Struct) + 256 + (sizeof(NPCFactionList) * (*iNPCFactionListsCount));
-	if (NPCFactionListsMMF.Open("EQEMuFactionLists", tmpMemSize)) {
-//		MMFNPCFactionListsData = (const MMFNPCFactionLists_Struct*) NPCFactionListsMMF.GetHandle();
-		if (NPCFactionListsMMF.CanWrite()) {
-			MMFNPCFactionListsData_Writable = (MMFNPCFactionLists_Struct*) NPCFactionListsMMF.GetWriteableHandle();
-			if (!MMFNPCFactionListsData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: !MMFNPCFactionListsData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFNPCFactionListsData_Writable, 0, tmpMemSize);
-			for(int i=0; i<MMF_MAX_NPCFactionList_ID; i++)
-				MMFNPCFactionListsData_Writable->NPCFactionListIndex[i] = 0xFFFFFFFF;
-			MMFNPCFactionListsData_Writable->MaxNPCFactionListID = *iMaxNPCFactionListID;
-			MMFNPCFactionListsData_Writable->NPCFactionListCount = *iNPCFactionListsCount;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cbDBLoadNPCFactionLists(MMFNPCFactionListsData_Writable->NPCFactionListCount, MMFNPCFactionListsData_Writable->MaxNPCFactionListID)) {
-				cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: !cbDBLoadNPCFactionLists" << endl;
-				return false;
-			}
-
-			MMFNPCFactionListsData_Writable = 0;
-			NPCFactionListsMMF.SetLoaded();
-			MMFNPCFactionListsData = (const MMFNPCFactionLists_Struct*) NPCFactionListsMMF.GetHandle();
-			if (!MMFNPCFactionListsData) {
-				cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: !MMFNPCFactionListsData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		}
-		else {
-			if (!NPCFactionListsMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!NPCFactionListsMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(100);
-					Timer::SetCurrentTime();
-				}
-				if (!NPCFactionListsMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: !NPCFactionListsMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFNPCFactionListsData = (const MMFNPCFactionLists_Struct*) NPCFactionListsMMF.GetHandle();
-			if (!MMFNPCFactionListsData) {
-				cout << "Error: EMuShareMem: DLLLoadNPCFactionLists: !MMFNPCFactionListsData (CanWrite=false)" << endl;
-				return false;
-			}
-			*iMaxNPCFactionListID = MMFNPCFactionListsData->MaxNPCFactionListID;
-			*iNPCFactionListsCount = MMFNPCFactionListsData->NPCFactionListCount;
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading NPCFactionLists: NPCFactionLists.cpp: pDLLLoadNPCFactionLists: Open() == false" << endl;
-		return false;
-	}
-	return false;
-};
-
-const NPCFactionList* pGetNPCFactionList(uint32 id) {
-	if (MMFNPCFactionListsData == 0 || (!NPCFactionListsMMF.IsLoaded()) || id > MMF_MAX_NPCFactionList_ID || MMFNPCFactionListsData->NPCFactionListIndex[id] == 0xFFFFFFFF)
-		return 0;
-	return &MMFNPCFactionListsData->NPCFactionLists[MMFNPCFactionListsData->NPCFactionListIndex[id]];
-}
@@ -1,22 +0,0 @@
-#include "../common/types.h"
-#include "../zone/features.h"
-#include "../zone/faction.h"
-#include "../common/EMuShareMem.h"
-
-// MMF_MAX_NPCFactionList_ID:  Make sure this is bigger than the highest NPCFactionList ID#
-#ifndef MMF_MAX_NPCFactionList_ID
-#define MMF_MAX_NPCFactionList_ID		50000
-#endif
-
-struct MMFNPCFactionLists_Struct {
-	uint32			MaxNPCFactionListID;
-	uint32			NextFreeIndex;
-	uint32			NPCFactionListCount;
-	uint32			NPCFactionListIndex[MMF_MAX_NPCFactionList_ID+1];
-	NPCFactionList	NPCFactionLists[0];
-};
-
-bool	pDLLLoadNPCFactionLists(CALLBACK_DBLoadNPCFactionLists cbDBLoadNPCFactionLists, uint32 iNPCFactionListStructSize, int32* iNPCFactionListCount, uint32* iMaxNPCFactionListID, uint8 iMaxNPCFactions);
-bool	pAddNPCFactionList(uint32 id, const NPCFactionList* nfl);
-bool	pSetNPCFaction(uint32 id, uint32* factionid, int32* factionvalue, int8 *factionnpcvalue, uint8 *factiontemp);
-const NPCFactionList* pGetNPCFactionList(uint32 id);
@@ -1,137 +0,0 @@
-#include "../common/debug.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "NPCTypes.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF NPCTypesMMF;
-const MMFNPCTypes_Struct* MMFNPCTypesData = 0;
-MMFNPCTypes_Struct* MMFNPCTypesData_Writable = 0;
-
-#ifdef _WINDOWS
-extern "C" __declspec(dllexport) const NPCType* GetNPCType(uint32 id) {
-	return pGetNPCType(id);
-};
-
-extern "C" __declspec(dllexport) bool AddNPCType(uint32 id, const NPCType* npctype) {
-	return pAddNPCType(id, npctype);
-};
-
-/*extern "C" __declspec(dllexport) bool DLLLoadNPCTypes(CALLBACK_DBLoadNPCTypes cbDBLoadNPCTypes, uint32 iNPCTypeStructSize, int32* iNPCTypesCount, uint32* iMaxNPCTypeID) {
-	return pDLLLoadNPCTypes(cbDBLoadNPCTypes, iNPCTypeStructSize, iNPCTypesCount, iMaxNPCTypeID);
-};*/
-
-#else
-extern "C" const NPCType* GetNPCType(uint32 id) {
-	return pGetNPCType(id);
-};
-
-extern "C" bool AddNPCType(uint32 id, const NPCType* npctype) {
-	return pAddNPCType(id, npctype);
-};
-
-extern "C" bool DLLLoadNPCTypes(CALLBACK_DBLoadNPCTypes cbDBLoadNPCTypes, uint32 iNPCTypeStructSize, int32* iNPCTypesCount, uint32* iMaxNPCTypeID) {
-	return pDLLLoadNPCTypes(cbDBLoadNPCTypes, iNPCTypeStructSize, iNPCTypesCount, iMaxNPCTypeID);
-};
-#endif
-
-bool pAddNPCType(uint32 id, const NPCType* npctype) {
-	if (!MMFNPCTypesData_Writable)
-		return false;
-	if (id > MMF_MAX_NPCTYPE_ID || MMFNPCTypesData_Writable->NextFreeIndex >= MMFNPCTypesData_Writable->NPCTypeCount)
-		return false;
-	if (MMFNPCTypesData_Writable->NPCTypeIndex[id] != 0xFFFFFFFF)
-		return false;
-	
-	MMFNPCTypesData_Writable->NPCTypeIndex[id] = MMFNPCTypesData_Writable->NextFreeIndex++;
-	memcpy(&MMFNPCTypesData_Writable->NPCTypes[MMFNPCTypesData_Writable->NPCTypeIndex[id]], npctype, sizeof(NPCType));
-
-	return true;
-}
-
-/*bool pDLLLoadNPCTypes(CALLBACK_DBLoadNPCTypes cbDBLoadNPCTypes, uint32 iNPCTypeStructSize, int32* iNPCTypesCount, uint32* iMaxNPCTypeID) {
-	if (iNPCTypeStructSize != sizeof(NPCType)) {
-		cout << "Error: EMuShareMem: DLLLoadNPCTypes: iNPCTypeStructSize != sizeof(NPCType)" << endl;
-		cout << "NPCType struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	if (*iMaxNPCTypeID > MMF_MAX_NPCTYPE_ID) {
-		cout << "Error: EMuShareMem: pDLLLoadNPCTypes: iMaxNPCTypeID > MMF_MAX_NPCTYPE_ID" << endl;
-		cout << "You need to increase the define in NPCTypes.h." << endl;
-		return false;
-	}
-	uint32 tmpMemSize = sizeof(MMFNPCTypes_Struct) + 256 + (sizeof(NPCType) * (*iNPCTypesCount));
-	if (NPCTypesMMF.Open("EQEMuNPCTypes", tmpMemSize)) {
-//		MMFNPCTypesData = (const MMFNPCTypes_Struct*) NPCTypesMMF.GetHandle();
-		if (NPCTypesMMF.CanWrite()) {
-			MMFNPCTypesData_Writable = (MMFNPCTypes_Struct*) NPCTypesMMF.GetWriteableHandle();
-			if (!MMFNPCTypesData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadNPCTypes: !MMFNPCTypesData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFNPCTypesData_Writable, 0, tmpMemSize);
-			for(int i=0; i<MMF_MAX_NPCTYPE_ID; i++)
-				MMFNPCTypesData_Writable->NPCTypeIndex[i] = 0xFFFFFFFF;
-			MMFNPCTypesData_Writable->MaxNPCTypeID = *iMaxNPCTypeID;
-			MMFNPCTypesData_Writable->NPCTypeCount = *iNPCTypesCount;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cbDBLoadNPCTypes(MMFNPCTypesData_Writable->NPCTypeCount, MMFNPCTypesData_Writable->MaxNPCTypeID)) {
-				cout << "Error: EMuShareMem: DLLLoadNPCTypes: !cbDBLoadNPCTypes" << endl;
-				return false;
-			}
-
-			MMFNPCTypesData_Writable = 0;
-			NPCTypesMMF.SetLoaded();
-			MMFNPCTypesData = (const MMFNPCTypes_Struct*) NPCTypesMMF.GetHandle();
-			if (!MMFNPCTypesData) {
-				cout << "Error: EMuShareMem: DLLLoadNPCTypes: !MMFNPCTypesData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		}
-		else {
-			if (!NPCTypesMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!NPCTypesMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(100);
-					Timer::SetCurrentTime();
-				}
-				if (!NPCTypesMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadNPCTypes: !NPCTypesMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFNPCTypesData = (const MMFNPCTypes_Struct*) NPCTypesMMF.GetHandle();
-			if (!MMFNPCTypesData) {
-				cout << "Error: EMuShareMem: DLLLoadNPCTypes: !MMFNPCTypesData (CanWrite=false)" << endl;
-				return false;
-			}
-			*iMaxNPCTypeID = MMFNPCTypesData->MaxNPCTypeID;
-			*iNPCTypesCount = MMFNPCTypesData->NPCTypeCount;
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading NPCTypes: NPCTypes.cpp: pDLLLoadNPCTypes: Open() == false" << endl;
-		return false;
-	}
-	return false;
-};*/
-
-const NPCType* pGetNPCType(uint32 id) {
-	if (MMFNPCTypesData == 0 || (!NPCTypesMMF.IsLoaded()) || id > MMF_MAX_NPCTYPE_ID || MMFNPCTypesData->NPCTypeIndex[id] == 0xFFFFFFFF)
-		return 0;
-	return &MMFNPCTypesData->NPCTypes[MMFNPCTypesData->NPCTypeIndex[id]];
-}
@@ -1,18 +0,0 @@
-#include "../common/types.h"
-#include "../zone/zonedump.h"
-#include "../common/EMuShareMem.h"
-
-// MMF_MAX_NPCTYPE_ID:  Make sure this is bigger than the highest NPCType ID#
-#define MMF_MAX_NPCTYPE_ID		400000
-
-struct MMFNPCTypes_Struct {
-	uint32		MaxNPCTypeID;
-	uint32		NextFreeIndex;
-	uint32		NPCTypeCount;
-	uint32		NPCTypeIndex[MMF_MAX_NPCTYPE_ID+1];
-	NPCType		NPCTypes[0];
-};
-
-//bool	pDLLLoadNPCTypes(CALLBACK_DBLoadNPCTypes cbDBLoadNPCTypes, uint32 iNPCTypeStructSize, int32* iNPCTypesCount, uint32* iMaxNPCTypeID);
-bool	pAddNPCType(uint32 id, const NPCType* npctype);
-const NPCType* pGetNPCType(uint32 id);
@@ -1,140 +0,0 @@
-#include "../common/debug.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "Opcodes.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF OpcodesMMF;
-const MMFOpcodes_Struct* MMFOpcodesData = 0;
-MMFOpcodes_Struct* MMFOpcodesData_Writable = 0;
-const uint16 *MMFOpcodesData_emu_to_eq = NULL;
-uint16 *MMFOpcodesData_emu_to_eq_write = NULL;
-
-//we choose to store all opcodes as 16 bits, so if they are a different
-//size in emu, they are gunna get casted to 16 bits... prolly will never
-//be a problem, but I figured it was noteworthy
-
-
-DLLFUNC uint16 GetEQOpcode(uint16 emu_op) {
-	if (MMFOpcodesData == 0 || (!OpcodesMMF.IsLoaded()) || emu_op >= MMFOpcodesData->EmuOpcodeCount )
-		return 0;
-	return MMFOpcodesData_emu_to_eq[emu_op];
-}
-
-DLLFUNC uint16 GetEmuOpcode(uint16 eq_op) {
-	if (MMFOpcodesData == 0 || (!OpcodesMMF.IsLoaded()) || eq_op >= MMFOpcodesData->EQOpcodeCount )
-		return 0;
-	return MMFOpcodesData->eq_to_emu[eq_op];
-}
-
-DLLFUNC bool SetOpcodePair(uint16 emu_op, uint16 eq_op) {
-	if (!MMFOpcodesData_Writable || !MMFOpcodesData_emu_to_eq_write)
-		return false;
-	if (emu_op >= MMFOpcodesData_Writable->EmuOpcodeCount || eq_op >= MMFOpcodesData_Writable->EQOpcodeCount)
-		return false;
-	
-	MMFOpcodesData_emu_to_eq_write[emu_op] = eq_op;
-	MMFOpcodesData_Writable->eq_to_emu[eq_op] = emu_op;
-	
-	return true;
-}
-
-DLLFUNC void ClearEQOpcodes() {
-	if (!MMFOpcodesData_Writable)
-		return;
-	
-	memset(MMFOpcodesData_Writable->eq_to_emu, 0, sizeof(uint16)*MMFOpcodesData->EQOpcodeCount);
-	
-}
-
-DLLFUNC bool DLLLoadOpcodes(CALLBACK_DBLoadOpcodes cb, uint32 opsize, uint32 eq_count, uint32 emu_count, const char *filename) {
-	if(opsize != sizeof(uint16)) {
-		cout << "Error: EMuShareMem: DLLLoadOpcodes: opsize != sizeof(uint16)" << endl;
-		cout << "Opcode size has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	uint32 tmpMemSize = sizeof(MMFOpcodes_Struct) + opsize * (eq_count+emu_count);
-	if (OpcodesMMF.Open("EQEMuOpcodes", tmpMemSize)) {
-		if (OpcodesMMF.CanWrite()) {
-			MMFOpcodesData_Writable = (MMFOpcodes_Struct*) OpcodesMMF.GetWriteableHandle();
-			if (!MMFOpcodesData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadOpcodes: !MMFOpcodesData_Writable" << endl;
-				return false;
-			}
-			
-			//emu_to_eq is right after eq_to_emu
-			MMFOpcodesData_emu_to_eq = MMFOpcodesData_Writable->eq_to_emu + eq_count;
-			MMFOpcodesData_emu_to_eq_write = MMFOpcodesData_Writable->eq_to_emu + eq_count;
-			
-			//we need to memset the eq opcodes
-			memset(MMFOpcodesData_Writable->eq_to_emu, 0, sizeof(uint16)*eq_count);
-			
-			MMFOpcodesData_Writable->EQOpcodeCount = eq_count;
-			MMFOpcodesData_Writable->EmuOpcodeCount = emu_count;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cb(filename)) {
-				cout << "Error: EMuShareMem: DLLLoadOpcodes: !cbDBLoadOpcodes" << endl;
-				return false;
-			}
-			
-			//we dont disable the write handle here, so we can reload them
-			//MMFOpcodesData_Writable = 0;
-			
-			OpcodesMMF.SetLoaded();
-			MMFOpcodesData = (const MMFOpcodes_Struct*) OpcodesMMF.GetHandle();
-			if (!MMFOpcodesData) {
-				cout << "Error: EMuShareMem: DLLLoadOpcodes: !MMFOpcodesData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		} else {
-			if (!OpcodesMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!OpcodesMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(10);
-					Timer::SetCurrentTime();
-				}
-				if (!OpcodesMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadOpcodes: !OpcodesMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFOpcodesData = (const MMFOpcodes_Struct*) OpcodesMMF.GetHandle();
-			if (!MMFOpcodesData) {
-				cout << "Error: EMuShareMem: DLLLoadOpcodes: !MMFOpcodesData (CanWrite=false)" << endl;
-				return false;
-			}
-			
-			//emu_to_eq is right after eq_to_emu
-			MMFOpcodesData_emu_to_eq = MMFOpcodesData->eq_to_emu + MMFOpcodesData->EQOpcodeCount;
-			
-			//cheat a little so we can retain writeable handles for reloading
-			MMFOpcodesData_Writable = const_cast<MMFOpcodes_Struct*>(MMFOpcodesData);
-			MMFOpcodesData_emu_to_eq_write = MMFOpcodesData_Writable->eq_to_emu + eq_count;
-			
-			
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading Opcodes: Opcodes.cpp: pDLLLoadOpcodes: ret == 0, size = " << tmpMemSize << endl;
-		return false;
-	}
-	return false;
-}
-
-
-
-
-
@@ -1,10 +0,0 @@
-#include "../common/types.h"
-#include "../common/EMuShareMem.h"
-
-struct MMFOpcodes_Struct {
-	uint32		EQOpcodeCount;
-	uint32		EmuOpcodeCount;
-	uint16		eq_to_emu[0];
-	//uint16	emu_to_eq[0];	//logical, not really here... EQOpcodeCount indexes in
-};
-
@@ -1,142 +0,0 @@
-#include "../common/debug.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "SkillCaps.h"
-#include "../common/timer.h"
-#include "MMF.h"
-
-MMF SkillCapsMMF;
-const MMFSkillCaps_Struct* MMFSkillCapsData = 0;
-MMFSkillCaps_Struct* MMFSkillCapsData_Writable = 0;
-
-
-DLLFUNC uint16 GetSkillCap(uint8 Class_, uint8 Skill, uint8 Level) {
-	if (MMFSkillCapsData == 0 || (!SkillCapsMMF.IsLoaded()))
-		return 0;
-	if (Class_ >= MMFSkillCapsData->ClassCount || Skill >= MMFSkillCapsData->SkillCount || Level >= MMFSkillCapsData->LevelCount)
-		return(0);
-
-	uint32 index = 
-		  (((Class_ * MMFSkillCapsData->SkillCount) + Skill) * MMFSkillCapsData->LevelCount)
-		+ Level;
-	
-	return MMFSkillCapsData->caps[index];
-}
-
-DLLFUNC bool SetSkillCap(uint8 Class_, uint8 Skill, uint8 Level, uint16 cap) {
-    if (!MMFSkillCapsData_Writable)
-		return false;
-	if (Class_ >= MMFSkillCapsData_Writable->ClassCount || Skill >= MMFSkillCapsData_Writable->SkillCount || Level >= MMFSkillCapsData_Writable->LevelCount)
-		return false;
-
-	uint32 index = 
-		  (((Class_ * MMFSkillCapsData_Writable->SkillCount) + Skill) * MMFSkillCapsData_Writable->LevelCount)
-		+ Level;
-    
-	MMFSkillCapsData_Writable->caps[index] = cap;
-	
-	return true;
-}
-
-DLLFUNC uint8 GetTrainLevel(uint8 Class_, uint8 Skill, uint8 Level){
-	if (MMFSkillCapsData == 0 || (!SkillCapsMMF.IsLoaded()))
-		return 0;
-	if (Class_ >= MMFSkillCapsData->ClassCount || Skill >= MMFSkillCapsData->SkillCount || Level >= MMFSkillCapsData->LevelCount)
-		return(0);
-
-	uint32 index = (((Class_ * MMFSkillCapsData->SkillCount) + Skill) * MMFSkillCapsData->LevelCount);
-	
-	for(int x = 0; x < Level; x++){
-		if(MMFSkillCapsData->caps[index + x]){
-			return (x);
-		}
-	}
-	return(0);
-}
-
-DLLFUNC void ClearSkillCaps() {
-	if (!MMFSkillCapsData_Writable)
-		return;
-	
-	memset(MMFSkillCapsData_Writable->caps, 0, 
-		sizeof(uint16)*(MMFSkillCapsData->ClassCount*MMFSkillCapsData->SkillCount*MMFSkillCapsData->LevelCount));
-	
-}
-
-DLLFUNC bool LoadSkillCaps(CALLBACK_DBLoadSkillCaps cb, uint32 opsize, uint8 ClassCount, uint8 SkillCount, uint8 LevelCount) {
-	if(opsize != sizeof(uint16)) {
-		cout << "Error: EMuShareMem: DLLLoadSkillCaps: opsize != sizeof(uint16)" << endl;
-		cout << "SkillCap size has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-	uint32 tmpMemSize = sizeof(MMFSkillCaps_Struct) + opsize * (ClassCount*SkillCount*LevelCount);
-	if (SkillCapsMMF.Open("EQEMuKSkillCaps", tmpMemSize)) {
-		if (SkillCapsMMF.CanWrite()) {
-			MMFSkillCapsData_Writable = (MMFSkillCaps_Struct*) SkillCapsMMF.GetWriteableHandle();
-			if (!MMFSkillCapsData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadSkillCaps: !MMFSkillCapsData_Writable" << endl;
-				return false;
-			}
-			//we need to memset the eq SkillCaps
-			memset(MMFSkillCapsData_Writable->caps, 0, sizeof(uint16)*(ClassCount*SkillCount*LevelCount));
-			
-			MMFSkillCapsData_Writable->ClassCount = ClassCount;
-			MMFSkillCapsData_Writable->SkillCount = SkillCount;
-			MMFSkillCapsData_Writable->LevelCount = LevelCount;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (!cb()) {
-				cout << "Error: EMuShareMem: DLLLoadSkillCaps: !cbDBLoadSkillCaps" << endl;
-				return false;
-			}
-			
-			MMFSkillCapsData_Writable = 0;
-			
-			SkillCapsMMF.SetLoaded();
-			MMFSkillCapsData = (const MMFSkillCaps_Struct*) SkillCapsMMF.GetHandle();
-			if (!MMFSkillCapsData) {
-				cout << "Error: EMuShareMem: DLLLoadSkillCaps: !MMFSkillCapsData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		} else {
-			if (!SkillCapsMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!SkillCapsMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(10);
-					Timer::SetCurrentTime();
-				}
-				if (!SkillCapsMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadSkillCaps: !SkillCapsMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFSkillCapsData = (const MMFSkillCaps_Struct*) SkillCapsMMF.GetHandle();
-			if (!MMFSkillCapsData) {
-				cout << "Error: EMuShareMem: DLLLoadSkillCaps: !MMFSkillCapsData (CanWrite=false)" << endl;
-				return false;
-			}
-			
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading SkillCaps: SkillCaps.cpp: pDLLLoadSkillCaps: ret == 0, size = " << tmpMemSize << endl;
-		return false;
-	}
-	return false;
-}
-
-
-
-
-
@@ -1,10 +0,0 @@
-#include "../common/types.h"
-#include "../common/EMuShareMem.h"
-
-struct MMFSkillCaps_Struct {
-	uint8		ClassCount;
-	uint8		SkillCount;
-	uint8		LevelCount;
-	uint16		caps[0];
-};
-
@@ -1,98 +0,0 @@
-#include "../common/debug.h"
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-
-#include <memory.h>
-#include <iostream>
-using namespace std;
-#include "Spells.h"
-#include "../common/timer.h"
-//#include "../zone/masterentity.h"
-#include "MMF.h"
-
-MMF SpellsMMF;
-const MMFSpells_Struct* MMFSpellsData = 0;
-MMFSpells_Struct* MMFSpellsData_Writable = 0;
-
-#ifdef _WINDOWS
-extern "C" __declspec(dllexport) bool DLLLoadSPDat(const CALLBACK_FileLoadSPDat cbFileLoadSPDat, const void** oSpellsPointer, int32* oSPDAT_RECORDS, uint32 iSPDat_Struct_Size) {
-	return pDLLLoadSPDat(cbFileLoadSPDat, oSpellsPointer, oSPDAT_RECORDS, iSPDat_Struct_Size);
-};
-#else
-extern "C" bool DLLLoadSPDat(const CALLBACK_FileLoadSPDat cbFileLoadSPDat, const void** oSpellsPointer, int32* oSPDAT_RECORDS, uint32 iSPDat_Struct_Size) {
-	return pDLLLoadSPDat(cbFileLoadSPDat, oSpellsPointer, oSPDAT_RECORDS, iSPDat_Struct_Size);
-};
-
-#endif
-
-bool pDLLLoadSPDat(const CALLBACK_FileLoadSPDat cbFileLoadSPDat, const void** oSpellsPointer, int32* oSPDAT_RECORDS, uint32 iSPDat_Struct_Size) {
-	if (iSPDat_Struct_Size != sizeof(SPDat_Spell_Struct)) {
-		cout << "Error: EMuShareMem: DLLLoadSPDat: iSPDat_Struct_Size != sizeof(SPDat_Spell_Struct)" << endl;
-		cout << "SPDat_Spell_Struct has changed, EMuShareMem.dll needs to be recompiled." << endl;
-		return false;
-	}
-
-	uint32 tmpMemSize = sizeof(MMFSpells_Struct) + 256 + (sizeof(SPDat_Spell_Struct) * (*oSPDAT_RECORDS));
-	if (SpellsMMF.Open("EQEMuSpells", tmpMemSize)) {
-		if (SpellsMMF.CanWrite()) {
-			MMFSpellsData_Writable = (MMFSpells_Struct*) SpellsMMF.GetWriteableHandle();
-			if (!MMFSpellsData_Writable) {
-				cout << "Error: EMuShareMem: DLLLoadSPDat: !MMFSpellsData_Writable" << endl;
-				return false;
-			}
-
-			memset(MMFSpellsData_Writable, 0, tmpMemSize);
-			MMFSpellsData_Writable->SPDAT_RECORDS = *oSPDAT_RECORDS;
-			// use a callback so the DB functions are done in the main exe
-			// this way the DLL doesnt have to open a connection to mysql
-			if (MMFSpellsData_Writable->SPDAT_RECORDS > 0) {
-				cbFileLoadSPDat(&MMFSpellsData_Writable->spells[0], MMFSpellsData_Writable->SPDAT_RECORDS-1);
-				*oSpellsPointer = &MMFSpellsData_Writable->spells[0];
-			}
-			else
-				*oSpellsPointer = 0;
-
-			MMFSpellsData_Writable = 0;
-			SpellsMMF.SetLoaded();
-			MMFSpellsData = (const MMFSpells_Struct*) SpellsMMF.GetHandle();
-			if (!MMFSpellsData) {
-				cout << "Error: EMuShareMem: DLLLoadSPDat: !MMFSpellsData (CanWrite=true)" << endl;
-				return false;
-			}
-			return true;
-		}
-		else {
-			if (!SpellsMMF.IsLoaded()) {
-				Timer::SetCurrentTime();
-				uint32 starttime = Timer::GetCurrentTime();
-				while ((!SpellsMMF.IsLoaded()) && ((Timer::GetCurrentTime() - starttime) < 300000)) {
-					Sleep(100);
-					Timer::SetCurrentTime();
-				}
-				if (!SpellsMMF.IsLoaded()) {
-					cout << "Error: EMuShareMem: DLLLoadSPDat: !SpellsMMF.IsLoaded() (timeout)" << endl;
-					return false;
-				}
-			}
-			MMFSpellsData = (const MMFSpells_Struct*) SpellsMMF.GetHandle();
-			if (!MMFSpellsData) {
-				cout << "Error: EMuShareMem: DLLLoadSPDat: !SpellsMMF (CanWrite=false)" << endl;
-				return false;
-			}
-			*oSPDAT_RECORDS = MMFSpellsData->SPDAT_RECORDS;
-			if (MMFSpellsData->SPDAT_RECORDS > 0)
-				*oSpellsPointer = &MMFSpellsData->spells[0];
-			else
-				*oSpellsPointer = 0;
-			return true;
-		}
-	}
-	else {
-		cout << "Error Loading SPDat: Spells.cpp: pDLLLoadSPDat: Open() == false" << endl;
-		return false;
-	}
-	return false;
-}
@@ -1,16 +0,0 @@
-#ifndef MEMSHARE_SPELLS_H
-#define MEMSHARE_SPELLS_H
-
-#include "../common/types.h"
-#include "../zone/spdat.h"
-#include "../common/EMuShareMem.h"
-
-struct MMFSpells_Struct {
-	uint32		SPDAT_RECORDS;	// maxspellid + 1, size of array
-	SPDat_Spell_Struct spells[0];
-};
-
-bool	pDLLLoadSPDat(const CALLBACK_FileLoadSPDat cbFileLoadSPDat, const void** oSpellsPointer, int32* oSPDAT_RECORDS, uint32 iSPDat_Struct_Size);
-
-#endif
-
@@ -1,4 +1,4 @@
-The server code and utilities are released under GPL.
+The server code and utilities are released under GPLv3.

 We also include some small libraries for convienence that may be under different licensing:

@@ -8,3 +8,5 @@ StackWalker - New BSD License
 ZLib - ZLib License
 MySQL - GPL
 Perl - GPL / ActiveState (under the assumption that this is a free project).
+CPPUnit - GLP
+StringUtilities - Apache
@@ -1,2 +1,53 @@
-EQEmu - Custom Game Implementation for EverQuest
+EQEmu
+===
+
+[![Build Status](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)
+
+Overview
+---
+
+EQEmu is a custom server implementation for EverQuest
+
+Dependencies
+---
+
+For Windows: http://eqemu.github.io
+
+Login Server dependencies for Windows/Linux/OSX: http://eqemu.github.io
+
+For Debian based distros (adjust to your local flavor):
+
+- libmysqlclient-dev
+- libperl-dev
+- liblua5.1-0-dev (5.2 should work as well)
+- libboost-dev
+
+Further instructions on building the source can be found on the
+[wiki](http://wiki.eqemulator.org/i?M=Wiki).
+
+Bug reports
+---
+
+Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
+reports or feature requests.
+
+The [EQEmu Forums](http://www.eqemulator.org/forums/) also have forums to submit
+bugs/get help with bugs.
+
+Contributions
+---
+
+The preferred way to contribute is to fork the repo and submit a pull request on
+GitHub. If you need help with your changes, you can always post on the forums or
+try IRC. You can also post unified diffs (`git diff` should do the trick) on the
+[Server Code Submissions](http://www.eqemulator.org/forums/forumdisplay.php?f=669)
+forum, although pull requests will be much quicker and easier on all parties.
+
+Contact
+---
+ - **User IRC Channel**: `#eqemu` on `irc.eqemulator.net`
+ - **Developer IRC Channel**: `#eqemucoders` on `irc.eqemulator.net`
+
+- [EQEmulator Forums](http://www.eqemulator.org/forums)
+- [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)

@@ -0,0 +1,4 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+add_subdirectory(import)
+add_subdirectory(export)
@@ -0,0 +1,36 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+SET(export_sources
+	main.cpp
+)
+
+SET(export_headers
+)
+
+ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
+
+INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+
+TARGET_LINK_LIBRARIES(export_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+
+IF(MSVC)
+	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
+	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
+ENDIF(MSVC)
+
+IF(MINGW)
+	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
+ENDIF(MINGW)
+
+IF(UNIX)
+	TARGET_LINK_LIBRARIES(export_client_files "${CMAKE_DL_LIBS}")
+	TARGET_LINK_LIBRARIES(export_client_files "z")
+	TARGET_LINK_LIBRARIES(export_client_files "m")
+	IF(NOT DARWIN)
+		TARGET_LINK_LIBRARIES(export_client_files "rt")
+	ENDIF(NOT DARWIN)
+	TARGET_LINK_LIBRARIES(export_client_files "pthread")
+	ADD_DEFINITIONS(-fPIC)
+ENDIF(UNIX)
+
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -0,0 +1,198 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdio.h>
+#include "../../common/debug.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"
+
+void ExportSpells(SharedDatabase *db);
+void ExportSkillCaps(SharedDatabase *db);
+void ExportBaseData(SharedDatabase *db);
+
+int main(int argc, char **argv) {
+	RegisterExecutablePlatform(ExePlatformClientExport);
+	set_exception_handler();
+
+	LogFile->write(EQEMuLog::Status, "Client Files Export Utility");
+	if(!EQEmuConfig::LoadConfig()) {
+		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		return 1;
+	}
+
+	const EQEmuConfig *config = EQEmuConfig::get();
+	if(!load_log_settings(config->LogSettingsFile.c_str())) {
+		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
+	}
+
+	SharedDatabase database;
+	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+			"database connection");
+		return 1;
+	}
+
+	ExportSpells(&database);
+	ExportSkillCaps(&database);
+	ExportBaseData(&database);
+
+	return 0;
+}
+
+void ExportSpells(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Exporting Spells...");
+
+	FILE *f = fopen("export/spells_us.txt", "w");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		return;
+	}
+
+	const std::string query = "SELECT * FROM spells_new ORDER BY id";
+	auto results = db->QueryDatabase(query);
+
+	if(results.Success()) {
+        for (auto row = results.begin(); row != results.end(); ++row) {
+			std::string line;
+			unsigned int fields = results.ColumnCount();
+			for(unsigned int i = 0; i < fields; ++i) {
+				if(i != 0) {
+					line.push_back('^');
+				}
+
+				if(row[i] != nullptr) {
+					line += row[i];
+				}
+			}
+
+			fprintf(f, "%s\n", line.c_str());
+		}
+	} else {
+		LogFile->write(EQEMuLog::Error, "Error in ExportSpells query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+	}
+
+	fclose(f);
+}
+
+bool SkillUsable(SharedDatabase *db, int skill_id, int class_id) {
+
+	bool res = false;
+
+	std::string query = StringFormat("SELECT max(cap) FROM skill_caps WHERE class=%d AND skillID=%d",
+                                    class_id, skill_id);
+	auto results = db->QueryDatabase(query);
+	if(!results.Success()) {
+        LogFile->write(EQEMuLog::Error, "Error in skill_usable query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        return false;
+    }
+
+    if (results.RowCount() == 0)
+        return false;
+
+    auto row = results.begin();
+    if(row[0] && atoi(row[0]) > 0)
+        return true;
+
+    return false;
+}
+
+int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
+
+	std::string query = StringFormat("SELECT cap FROM skill_caps WHERE class=%d AND skillID=%d AND level=%d",
+                                    class_id, skill_id, level);
+    auto results = db->QueryDatabase(query);
+    if (!results.Success()) {
+        LogFile->write(EQEMuLog::Error, "Error in get_skill query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        return 0;
+    }
+
+    if (results.RowCount() == 0)
+        return 0;
+
+    auto row = results.begin();
+	return atoi(row[0]);
+}
+
+void ExportSkillCaps(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Exporting Skill Caps...");
+
+	FILE *f = fopen("export/SkillCaps.txt", "w");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		return;
+	}
+
+	for(int cl = 1; cl <= 16; ++cl) {
+		for(int skill = 0; skill <= 77; ++skill) {
+			if(SkillUsable(db, skill, cl)) {
+				int previous_cap = 0;
+				for(int level = 1; level <= 100; ++level) {
+					int cap = GetSkill(db, skill, cl, level);
+					if(cap < previous_cap) {
+						cap = previous_cap;
+					}
+
+					fprintf(f, "%d^%d^%d^%d^0\n", cl, skill, level, cap);
+					previous_cap = cap;
+				}
+			}
+		}
+	}
+
+	fclose(f);
+}
+
+void ExportBaseData(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Exporting Base Data...");
+
+	FILE *f = fopen("export/BaseData.txt", "w");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		return;
+	}
+
+	const std::string query = "SELECT * FROM base_data ORDER BY level, class";
+	auto results = db->QueryDatabase(query);
+	if(results.Success()) {
+        for (auto row = results.begin();row != results.end();++row) {
+			std::string line;
+			unsigned int fields = results.ColumnCount();
+			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
+				if(rowIndex != 0)
+					line.push_back('^');
+
+				if(row[rowIndex] != nullptr) {
+					line += row[rowIndex];
+				}
+			}
+
+			fprintf(f, "%s\n", line.c_str());
+		}
+	} else {
+		LogFile->write(EQEMuLog::Error, "Error in ExportBaseData query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+	}
+
+	fclose(f);
+}
+
@@ -0,0 +1,36 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+
+SET(import_sources
+	main.cpp
+)
+
+SET(import_headers
+)
+
+ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
+
+INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+
+TARGET_LINK_LIBRARIES(import_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+
+IF(MSVC)
+	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
+	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
+ENDIF(MSVC)
+
+IF(MINGW)
+	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
+ENDIF(MINGW)
+
+IF(UNIX)
+	TARGET_LINK_LIBRARIES(import_client_files "${CMAKE_DL_LIBS}")
+	TARGET_LINK_LIBRARIES(import_client_files "z")
+	TARGET_LINK_LIBRARIES(import_client_files "m")
+	IF(NOT DARWIN)
+		TARGET_LINK_LIBRARIES(import_client_files "rt")
+	ENDIF(NOT DARWIN)
+	TARGET_LINK_LIBRARIES(import_client_files "pthread")
+	ADD_DEFINITIONS(-fPIC)
+ENDIF(UNIX)
+
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -0,0 +1,231 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "../../common/debug.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"
+
+void ImportSpells(SharedDatabase *db);
+void ImportSkillCaps(SharedDatabase *db);
+void ImportBaseData(SharedDatabase *db);
+
+int main(int argc, char **argv) {
+	RegisterExecutablePlatform(ExePlatformClientImport);
+	set_exception_handler();
+
+	LogFile->write(EQEMuLog::Status, "Client Files Import Utility");
+	if(!EQEmuConfig::LoadConfig()) {
+		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		return 1;
+	}
+
+	const EQEmuConfig *config = EQEmuConfig::get();
+	if(!load_log_settings(config->LogSettingsFile.c_str())) {
+		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
+	}
+
+	SharedDatabase database;
+	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+			"database connection");
+		return 1;
+	}
+
+	ImportSpells(&database);
+	ImportSkillCaps(&database);
+	ImportBaseData(&database);
+
+	return 0;
+}
+
+int GetSpellColumns(SharedDatabase *db) {
+
+	const std::string query = "DESCRIBE spells_new";
+	auto results = db->QueryDatabase(query);
+	if(!results.Success()) {
+        LogFile->write(EQEMuLog::Error, "Error in GetSpellColumns query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
+        return 0;
+    }
+
+	return results.RowCount();
+}
+
+void ImportSpells(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Importing Spells...");
+	FILE *f = fopen("import/spells_us.txt", "r");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		return;
+	}
+
+	std::string query = "DELETE FROM spells_new";
+	db->QueryDatabase(query);
+
+	int columns = GetSpellColumns(db);
+	int spells_imported = 0;
+
+	char buffer[2048];
+	while(fgets(buffer, 2048, f)) {
+		for(int i = 0; i < 2048; ++i) {
+			if(buffer[i] == '\n') {
+				buffer[i] = 0;
+				break;
+			}
+		}
+
+		std::string escaped = ::EscapeString(buffer);
+		auto split = SplitString(escaped, '^');
+		int line_columns = (int)split.size();
+
+		std::string sql;
+		if(line_columns >= columns) {
+			sql = "INSERT INTO spells_new VALUES(";
+			for(int i = 0; i < columns; ++i) {
+				if(i != 0) {
+					sql += ", '";
+				} else {
+					sql += "'";
+				}
+
+				sql += split[i];
+				sql += "'";
+			}
+
+			sql += ");";
+		} else {
+			int i = 0;
+			sql = "INSERT INTO spells_new VALUES(";
+			for(; i < line_columns; ++i) {
+				if(i != 0) {
+					sql += ", '";
+				} else {
+					sql += "'";
+				}
+
+				sql += split[i];
+				sql += "'";
+			}
+
+			for(; i < columns; ++i) {
+				sql += ", '0'";
+			}
+
+			sql += ");";
+		}
+
+		db->QueryDatabase(sql);
+
+		spells_imported++;
+		if(spells_imported % 1000 == 0) {
+			LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+		}
+	}
+
+	if(spells_imported % 1000 != 0) {
+		LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+	}
+
+	fclose(f);
+}
+
+void ImportSkillCaps(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Importing Skill Caps...");
+
+	FILE *f = fopen("import/SkillCaps.txt", "r");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		return;
+	}
+
+	std::string delete_sql = "DELETE FROM skill_caps";
+	db->QueryDatabase(delete_sql);
+
+	char buffer[2048];
+	while(fgets(buffer, 2048, f)) {
+		auto split = SplitString(buffer, '^');
+
+		if(split.size() < 4) {
+			continue;
+		}
+
+
+		int class_id, skill_id, level, cap;
+		class_id = atoi(split[0].c_str());
+		skill_id = atoi(split[1].c_str());
+		level = atoi(split[2].c_str());
+		cap = atoi(split[3].c_str());
+
+		std::string sql = StringFormat("INSERT INTO skill_caps(class, skillID, level, cap) VALUES(%d, %d, %d, %d)",
+			class_id, skill_id, level, cap);
+
+		db->QueryDatabase(sql);
+	}
+
+	fclose(f);
+}
+
+void ImportBaseData(SharedDatabase *db) {
+	LogFile->write(EQEMuLog::Status, "Importing Base Data...");
+
+	FILE *f = fopen("import/BaseData.txt", "r");
+	if(!f) {
+		LogFile->write(EQEMuLog::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		return;
+	}
+
+	std::string delete_sql = "DELETE FROM base_data";
+	db->QueryDatabase(delete_sql);
+
+	char buffer[2048];
+	while(fgets(buffer, 2048, f)) {
+		auto split = SplitString(buffer, '^');
+
+		if(split.size() < 10) {
+			continue;
+		}
+
+		std::string sql;
+		int level, class_id;
+		double hp, mana, end, unk1, unk2, hp_fac, mana_fac, end_fac;
+
+		level = atoi(split[0].c_str());
+		class_id = atoi(split[1].c_str());
+		hp = atof(split[2].c_str());
+		mana = atof(split[3].c_str());
+		end = atof(split[4].c_str());
+		unk1 = atof(split[5].c_str());
+		unk2 = atof(split[6].c_str());
+		hp_fac = atof(split[7].c_str());
+		mana_fac = atof(split[8].c_str());
+		end_fac = atof(split[9].c_str());
+
+		sql = StringFormat("INSERT INTO base_data(level, class, hp, mana, end, unk1, unk2, hp_fac, "
+			"mana_fac, end_fac) VALUES(%d, %d, %f, %f, %f, %f, %f, %f, %f, %f)",
+			level, class_id, hp, mana, end, unk1, unk2, hp_fac, mana_fac, end_fac);
+
+		db->QueryDatabase(sql);
+	}
+
+	fclose(f);
+}
@@ -0,0 +1,124 @@
+#CMake - Cross Platform Makefile Generator
+#Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
+#All rights reserved.
+#
+#Redistribution and use in source and binary forms, with or without
+#modification, are permitted provided that the following conditions
+#are met:
+#
+#* Redistributions of source code must retain the above copyright
+#  notice, this list of conditions and the following disclaimer.
+#
+#* Redistributions in binary form must reproduce the above copyright
+#  notice, this list of conditions and the following disclaimer in the
+#  documentation and/or other materials provided with the distribution.
+#
+#* Neither the names of Kitware, Inc., the Insight Software Consortium,
+#  nor the names of their contributors may be used to endorse or promote
+#  products derived from this software without specific prior written
+#  permission.
+#
+#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# This module defines
+#  LUA51_FOUND, if false, do not try to link to Lua
+#  LUA_LIBRARIES
+#  LUA_INCLUDE_DIR, where to find lua.h
+#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+
+IF(LUA_ROOT)
+	FIND_PATH(LUA_INCLUDE_DIR
+		NAMES lua.h
+		HINTS
+			ENV LUA_DIR
+		PATHS
+		${LUA_ROOT}
+		~/Library/Frameworks
+		/Library/Frameworks
+		/sw
+		/opt/local
+		/opt/csw
+		/opt
+		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include src
+	)
+	
+	FIND_LIBRARY(LUA_LIBRARY
+		NAMES lua51 lua5.1 lua-5.1 lua
+		HINTS
+			ENV LUA_DIR
+		PATHS
+		${LUA_ROOT}
+		~/Library/Frameworks
+		/Library/Frameworks
+		/sw
+		/opt/local
+		/opt/csw
+		/opt
+		PATH_SUFFIXES lib bin
+	)
+ELSE(LUA_ROOT)
+	FIND_PATH(LUA_INCLUDE_DIR
+		NAMES lua.h
+		HINTS
+			ENV LUA_DIR
+		PATHS
+		~/Library/Frameworks
+		/Library/Frameworks
+		/sw
+		/opt/local
+		/opt/csw
+		/opt
+		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include
+	)
+	
+	FIND_LIBRARY(LUA_LIBRARY
+		NAMES lua51 lua5.1 lua-5.1 lua
+		HINTS
+			ENV LUA_DIR
+		PATHS
+		~/Library/Frameworks
+		/Library/Frameworks
+		/sw
+		/opt/local
+		/opt/csw
+		/opt
+		PATH_SUFFIXES lib bin
+	)
+ENDIF(LUA_ROOT)
+
+IF(LUA_LIBRARY)
+	# include the math library for Unix
+	IF(UNIX AND NOT APPLE)
+		FIND_LIBRARY(LUA_MATH_LIBRARY m)
+	SET(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+	# For Windows and Mac, don't need to explicitly include the math library
+	ELSE()
+		SET( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+	ENDIF()
+ENDIF()
+
+IF(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
+	FILE(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
+
+	STRING(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
+	UNSET(lua_version_str)
+ENDIF()
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+MARK_AS_ADVANCED(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
+
+
@@ -4,65 +4,65 @@
 #
 # Find the native MySQL includes and library
 #
-#  MySQL_INCLUDE_DIR - where to find mysql.h, etc.
-#  MySQL_LIBRARIES   - List of libraries when using MySQL.
-#  MySQL_FOUND       - True if MySQL found.
-#  The following can be used as a hint as to where to search:
-#  MYSQL_ROOT
+#	MySQL_INCLUDE_DIR	- where to find mysql.h, etc.
+#	MySQL_LIBRARIES		- List of libraries when using MySQL.
+#	MySQL_FOUND			- True if MySQL found.
+#	The following can be used as a hint as to where to search:
+#	MYSQL_ROOT

 IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARIES)
-  # Already in cache, be silent
-  SET(MySQL_FIND_QUIETLY TRUE)
+	# Already in cache, be silent
+	SET(MySQL_FIND_QUIETLY TRUE)
 ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARIES)

 # Include dir
 IF(MYSQL_ROOT)
-    FIND_PATH(MySQL_INCLUDE_DIR
-      NAMES mysql.h
-      PATHS ${MYSQL_ROOT}/include
-      PATH_SUFFIXES mysql
-    )
+	FIND_PATH(MySQL_INCLUDE_DIR
+		NAMES mysql.h
+		PATHS ${MYSQL_ROOT}/include
+		PATH_SUFFIXES mysql
+	)
 ELSE(MYSQL_ROOT)
-    FIND_PATH(MySQL_INCLUDE_DIR
-      NAMES mysql.h
-      PATH_SUFFIXES mysql
-    )
+	FIND_PATH(MySQL_INCLUDE_DIR
+		NAMES mysql.h
+		PATH_SUFFIXES mysql
+	)
 ENDIF(MYSQL_ROOT)

 # Library
 SET(MySQL_NAMES mysqlclient_r mysqlclient)
 IF(MYSQL_ROOT)
-    FIND_LIBRARY(MySQL_LIBRARY_DEBUG
-      NAMES ${MySQL_NAMES}
-      PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
-      PATH_SUFFIXES mysql
-    )
-    
-    FIND_LIBRARY(MySQL_LIBRARY_RELEASE
-      NAMES ${MySQL_NAMES}
-      PATHS ${MYSQL_ROOT}/lib /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
-      PATH_SUFFIXES mysql
-    )
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
+		NAMES ${MySQL_NAMES}
+		PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
+		NAMES ${MySQL_NAMES}
+		PATHS ${MYSQL_ROOT}/lib /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
 ELSE(MYSQL_ROOT)
-    FIND_LIBRARY(MySQL_LIBRARY_DEBUG
-      NAMES ${MySQL_NAMES}
-      PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
-      PATH_SUFFIXES mysql
-    )
-    
-    FIND_LIBRARY(MySQL_LIBRARY_RELEASE
-      NAMES ${MySQL_NAMES}
-      PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
-      PATH_SUFFIXES mysql
-    )
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
+		NAMES ${MySQL_NAMES}
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
+		NAMES ${MySQL_NAMES}
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
 ENDIF(MYSQL_ROOT)

 IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
-  SET(MySQL_FOUND TRUE)
-  SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
+	SET(MySQL_FOUND TRUE)
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
 ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
-  SET(MySQL_FOUND FALSE)
-  SET( MySQL_LIBRARIES )
+	SET(MySQL_FOUND FALSE)
+	SET( MySQL_LIBRARIES )
 ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)


@@ -72,14 +72,13 @@ INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY_DEBUG MySQL_LIBRARY_RELEASE MySQL_INCLUDE_DIR)

 IF(MySQL_FOUND)
-  SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
 ELSE(MySQL_FOUND)
-  SET( MySQL_LIBRARIES )
+	SET( MySQL_LIBRARIES )
 ENDIF(MySQL_FOUND)

 MARK_AS_ADVANCED(
-  MySQL_LIBRARY_DEBUG
-  MySQL_LIBRARY_RELEASE
-  MySQL_INCLUDE_DIR
-  )
-  
+	MySQL_LIBRARY_DEBUG
+	MySQL_LIBRARY_RELEASE
+	MySQL_INCLUDE_DIR
+	)
@@ -1,313 +1,355 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)

 SET(common_sources
-    BasePacket.cpp
-    classes.cpp
-    Condition.cpp
-    crash.cpp
-    CRC16.cpp
-    crc32.cpp
-    database.cpp
-    dbasync.cpp
-    dbcore.cpp
-    DBMemLeak.cpp
-    debug.cpp
-    emu_opcodes.cpp
-    EMuShareMem.cpp
-    EmuTCPConnection.cpp
-    EmuTCPServer.cpp
-    EQDB.cpp
-    EQDBRes.cpp
-    EQEmuConfig.cpp
-    EQEMuError.cpp
-    EQPacket.cpp
-    EQStream.cpp
-    EQStreamFactory.cpp
-    EQStreamIdent.cpp
-    EQStreamProxy.cpp
-    eqtime.cpp
-    extprofile.cpp
-    guild_base.cpp
-    guilds.cpp
-    Item.cpp
-    logsys.cpp
-    logsys_eqemu.cpp
-    md5.cpp
-    misc.cpp
-    MiscFunctions.cpp
-    moremath.cpp
-    Mutex.cpp
-    opcode_map.cpp
-    opcodemgr.cpp
-    packet_dump.cpp
-    packet_dump_file.cpp
-    packet_functions.cpp
-    perl_EQDB.cpp
-    perl_EQDBRes.cpp
-    ProcLauncher.cpp
-    ptimer.cpp
-    races.cpp
-    rdtsc.cpp
-    rulesys.cpp
-    serverinfo.cpp
-    shareddb.cpp
-    SharedLibrary.cpp
-    StructStrategy.cpp
-    TCPConnection.cpp
-    TCPServer.cpp
-    timeoutmgr.cpp
-    timer.cpp
-    unix.cpp
-    worldconn.cpp
-    XMLParser.cpp
-    platform.cpp
-    patches/Client62.cpp
-    patches/patches.cpp
-    patches/SoD.cpp
-    patches/SoF.cpp
-    patches/RoF.cpp
-    patches/Titanium.cpp
-    patches/Underfoot.cpp
-    SocketLib/Base64.cpp
-    SocketLib/File.cpp
-    SocketLib/HttpdCookies.cpp
-    SocketLib/HttpdForm.cpp
-    SocketLib/HttpdSocket.cpp
-    SocketLib/HTTPSocket.cpp
-    SocketLib/MemFile.cpp
-    SocketLib/Mime.cpp
-    SocketLib/Parse.cpp
-    SocketLib/socket_include.cpp
-    SocketLib/Utility.cpp
-    StackWalker/StackWalker.cpp
-    tinyxml/tinystr.cpp
-    tinyxml/tinyxml.cpp
-    tinyxml/tinyxmlerror.cpp
-    tinyxml/tinyxmlparser.cpp
+	base_packet.cpp
+	classes.cpp
+	condition.cpp
+	crash.cpp
+	crc16.cpp
+	crc32.cpp
+	database.cpp
+	dbcore.cpp
+	debug.cpp
+	emu_opcodes.cpp
+	emu_tcp_connection.cpp
+	emu_tcp_server.cpp
+	eq_dictionary.cpp
+	eqdb.cpp
+	eqdb_res.cpp
+	eqemu_exception.cpp
+	eqemu_config.cpp
+	eqemu_error.cpp
+	eq_packet.cpp
+	eq_stream.cpp
+	eq_stream_factory.cpp
+	eq_stream_ident.cpp
+	eq_stream_proxy.cpp
+	eqtime.cpp
+	extprofile.cpp
+	faction.cpp
+	guild_base.cpp
+	guilds.cpp
+	ipc_mutex.cpp
+	item.cpp
+	logsys.cpp
+	logsys_eqemu.cpp
+	md5.cpp
+	memory_mapped_file.cpp
+	misc.cpp
+	misc_functions.cpp
+	moremath.cpp
+	mutex.cpp
+	mysql_request_result.cpp
+	mysql_request_row.cpp
+	opcode_map.cpp
+	opcodemgr.cpp
+	packet_dump.cpp
+	packet_dump_file.cpp
+	packet_functions.cpp
+	perl_eqdb.cpp
+	perl_eqdb_res.cpp
+	proc_launcher.cpp
+	ptimer.cpp
+	races.cpp
+	rdtsc.cpp
+	rulesys.cpp
+	serverinfo.cpp
+	shareddb.cpp
+	skills.cpp
+	spdat.cpp
+	string_util.cpp
+	struct_strategy.cpp
+	tcp_connection.cpp
+	tcp_server.cpp
+	timeoutmgr.cpp
+	timer.cpp
+	unix.cpp
+	worldconn.cpp
+	xml_parser.cpp
+	platform.cpp
+	patches/client62.cpp
+	patches/patches.cpp
+	patches/sod.cpp
+	patches/sof.cpp
+	patches/rof.cpp
+	patches/rof2.cpp
+	patches/titanium.cpp
+	patches/underfoot.cpp
+	SocketLib/Base64.cpp
+	SocketLib/File.cpp
+	SocketLib/HttpdCookies.cpp
+	SocketLib/HttpdForm.cpp
+	SocketLib/HttpdSocket.cpp
+	SocketLib/HTTPSocket.cpp
+	SocketLib/MemFile.cpp
+	SocketLib/Mime.cpp
+	SocketLib/Parse.cpp
+	SocketLib/socket_include.cpp
+	SocketLib/Utility.cpp
+	StackWalker/StackWalker.cpp
+	tinyxml/tinystr.cpp
+	tinyxml/tinyxml.cpp
+	tinyxml/tinyxmlerror.cpp
+	tinyxml/tinyxmlparser.cpp
 )

 SET(common_headers
-    BasePacket.h
-    bodytypes.h
-    breakdowns.h
-    classes.h
-    common_profile.h
-    Condition.h
-    crash.h
-    CRC16.h
-    crc32.h
-    database.h
-    dbasync.h
-    dbcore.h
-    DBMemLeak.h
-    debug.h
-    deity.h
-    emu_opcodes.h
-    emu_oplist.h
-    EMuShareMem.h
-    EmuTCPConnection.h
-    EmuTCPServer.h
-    eq_constants.h
-    eq_opcodes.h
-    eq_packet_structs.h
-    EQDB.h
-    EQDBRes.h
-    EQEmuConfig.h
-    EQEmuConfig_elements.h
-    EQEMuError.h
-    EQPacket.h
-    EQStream.h
-    EQStreamFactory.h
-    EQStreamIdent.h
-    EQStreamIntf.h
-    EQStreamLocator.h
-    EQStreamProxy.h
-    EQStreamType.h
-    eqtime.h
-    errmsg.h
-    extprofile.h
-    guild_base.h
-    guilds.h
-    Item.h
-    item_fieldlist.h
-    item_struct.h
-    languages.h
-    linked_list.h
-    logsys.h
-    logtypes.h
-    mail_oplist.h
-    md5.h
-    misc.h
-    MiscFunctions.h
-    moremath.h
-    Mutex.h
-    op_codes.h
-    opcode_dispatch.h
-    opcodemgr.h
-    packet_dump.h
-    packet_dump_file.h
-    packet_functions.h
-    ProcLauncher.h
-    profiler.h
-    ptimer.h
-    queue.h
-    races.h
-    rdtsc.h
-    rulesys.h
-    ruletypes.h
-    seperator.h
-    serverinfo.h
-    servertalk.h
-    shareddb.h
-    SharedLibrary.h
-    skills.h
-    StructStrategy.h
-    TCPBasicServer.h
-    TCPConnection.h
-    TCPServer.h
-    timeoutmgr.h
-    timer.h
-    types.h
-    unix.h
-    useperl.h
-    version.h
-    worldconn.h
-    XMLParser.h
-    ZoneNumbers.h
-    platform.h
-    patches/Client62.h
-    patches/Client62_itemfields.h
-    patches/Client62_ops.h
-    patches/Client62_structs.h
-    patches/patches.h
-    patches/SoD.h
-    patches/SoD_itemfields.h
-    patches/SoD_ops.h
-    patches/SoD_structs.h
-    patches/SoF.h
-    patches/SoF_itemfields.h
-    patches/SoF_opcode_list.h
-    patches/SoF_ops.h
-    patches/SoF_structs.h
-    patches/SSDeclare.h
-    patches/SSDefine.h
-    patches/SSRegister.h
-    patches/RoF.h
-    patches/RoF_itemfields.h
-    patches/RoF_ops.h
-    patches/RoF_structs.h
-    patches/Titanium.h
-    patches/Titanium_itemfields.h
-    patches/Titanium_ops.h
-    patches/Titanium_structs.h
-    patches/Underfoot.h
-    patches/Underfoot_itemfields.h
-    patches/Underfoot_ops.h
-    patches/Underfoot_structs.h
-    SocketLib/Base64.h
-    SocketLib/File.h
-    SocketLib/HttpdCookies.h
-    SocketLib/HttpdForm.h
-    SocketLib/HttpdSocket.h
-    SocketLib/HTTPSocket.h
-    SocketLib/IFile.h
-    SocketLib/MemFile.h
-    SocketLib/Mime.h
-    SocketLib/Parse.h
-    SocketLib/socket_include.h
-    SocketLib/Utility.h
-    StackWalker/StackWalker.h
-    tinyxml/tinystr.h
-    tinyxml/tinyxml.h
+	any.h
+	base_packet.h
+	base_data.h
+	bodytypes.h
+	breakdowns.h
+	classes.h
+	condition.h
+	crash.h
+	crc16.h
+	crc32.h
+	data_verification.h
+	database.h
+	dbcore.h
+	debug.h
+	deity.h
+	emu_opcodes.h
+	emu_oplist.h
+	emu_tcp_connection.h
+	emu_tcp_server.h
+	eq_constants.h
+	eq_dictionary.h
+	eq_packet_structs.h
+	eqdb.h
+	eqdb_res.h
+	eqemu_exception.h
+	eqemu_config.h
+	eqemu_config_elements.h
+	eqemu_error.h
+	eq_packet.h
+	eq_stream.h
+	eq_stream_factory.h
+	eq_stream_ident.h
+	eq_stream_intf.h
+	eq_stream_locator.h
+	eq_stream_proxy.h
+	eq_stream_type.h
+	eqtime.h
+	errmsg.h
+	extprofile.h
+	faction.h
+	features.h
+	fixed_memory_hash_set.h
+	fixed_memory_variable_hash_set.h
+	guild_base.h
+	guilds.h
+	ipc_mutex.h
+	item.h
+	item_fieldlist.h
+	item_struct.h
+	languages.h
+	linked_list.h
+	logsys.h
+	logtypes.h
+	loottable.h
+	mail_oplist.h
+	md5.h
+	memory_mapped_file.h
+	misc.h
+	misc_functions.h
+	moremath.h
+	mutex.h
+	mysql_request_result.h
+	mysql_request_row.h
+	op_codes.h
+	opcode_dispatch.h
+	opcodemgr.h
+	packet_dump.h
+	packet_dump_file.h
+	packet_functions.h
+	platform.h
+	proc_launcher.h
+	profiler.h
+	ptimer.h
+	queue.h
+	races.h
+	random.h
+	rdtsc.h
+	rulesys.h
+	ruletypes.h
+	seperator.h
+	serverinfo.h
+	servertalk.h
+	shareddb.h
+	skills.h
+	spdat.h
+    string_util.h
+	struct_strategy.h
+	tcp_basic_server.h
+	tcp_connection.h
+	tcp_server.h
+	timeoutmgr.h
+	timer.h
+	types.h
+	unix.h
+	useperl.h
+	version.h
+	worldconn.h
+	xml_parser.h
+	zone_numbers.h
+	patches/client62.h
+	patches/client62_constants.h
+	patches/client62_itemfields.h
+	patches/client62_ops.h
+	patches/client62_structs.h
+	patches/patches.h
+	patches/sod.h
+	patches/sod_constants.h
+	patches/sod_itemfields.h
+	patches/sod_ops.h
+	patches/sod_structs.h
+	patches/sof.h
+	patches/sof_constants.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
+	patches/sof_ops.h
+	patches/sof_structs.h
+	patches/ss_declare.h
+	patches/ss_define.h
+	patches/ss_register.h
+	patches/rof.h
+	patches/rof_constants.h
+	patches/rof_itemfields.h
+	patches/rof_ops.h
+	patches/rof_structs.h
+	patches/rof2.h
+	patches/rof2_constants.h
+	patches/rof2_itemfields.h
+	patches/rof2_ops.h
+	patches/rof2_structs.h
+	patches/titanium.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_structs.h
+	patches/underfoot.h
+	patches/underfoot_constants.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_structs.h
+	SocketLib/Base64.h
+	SocketLib/File.h
+	SocketLib/HttpdCookies.h
+	SocketLib/HttpdForm.h
+	SocketLib/HttpdSocket.h
+	SocketLib/HTTPSocket.h
+	SocketLib/IFile.h
+	SocketLib/MemFile.h
+	SocketLib/Mime.h
+	SocketLib/Parse.h
+	SocketLib/socket_include.h
+	SocketLib/Utility.h
+	StackWalker/StackWalker.h
+	tinyxml/tinystr.h
+	tinyxml/tinyxml.h
 )

 SOURCE_GROUP(Patches FILES
-    patches/Client62.h
-    patches/Client62_itemfields.h
-    patches/Client62_ops.h
-    patches/Client62_structs.h
-    patches/patches.h
-    patches/SoD.h
-    patches/SoD_itemfields.h
-    patches/SoD_ops.h
-    patches/SoD_structs.h
-    patches/SoF.h
-    patches/SoF_itemfields.h
-    patches/SoF_opcode_list.h
-    patches/SoF_ops.h
-    patches/SoF_structs.h
-    patches/SSDeclare.h
-    patches/SSDefine.h
-    patches/SSRegister.h
-    patches/RoF.h
-    patches/RoF_itemfields.h
-    patches/RoF_ops.h
-    patches/RoF_structs.h
-    patches/Titanium.h
-    patches/Titanium_itemfields.h
-    patches/Titanium_ops.h
-    patches/Titanium_structs.h
-    patches/Underfoot.h
-    patches/Underfoot_itemfields.h
-    patches/Underfoot_ops.h
-    patches/Underfoot_structs.h
-    patches/Client62.cpp
-    patches/patches.cpp
-    patches/SoD.cpp
-    patches/SoF.cpp
-    patches/RoF.cpp
-    patches/Titanium.cpp
-    patches/Underfoot.cpp
+	patches/client62.h
+	patches/client62_itemfields.h
+	patches/client62_ops.h
+	patches/client62_constants.h
+	patches/client62_structs.h
+	patches/patches.h
+	patches/sod.h
+	patches/sod_itemfields.h
+	patches/sod_ops.h
+	patches/sod_constants.h
+	patches/sod_structs.h
+	patches/sof.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
+	patches/sof_ops.h
+	patches/sof_constants.h
+	patches/sof_structs.h
+	patches/ss_declare.h
+	patches/ss_define.h
+	patches/ss_register.h
+	patches/rof.h
+	patches/rof_itemfields.h
+	patches/rof_ops.h
+	patches/rof_constants.h
+	patches/rof_structs.h
+	patches/rof2.h
+	patches/rof2_itemfields.h
+	patches/rof2_ops.h
+	patches/rof2_constants.h
+	patches/rof2_structs.h
+	patches/titanium.h
+	patches/titanium_itemfields.h
+	patches/titanium_ops.h
+	patches/titanium_constants.h
+	patches/titanium_structs.h
+	patches/underfoot.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_constants.h
+	patches/underfoot_structs.h
+	patches/client62.cpp
+	patches/patches.cpp
+	patches/sod.cpp
+	patches/sof.cpp
+	patches/rof.cpp
+	patches/rof2.cpp
+	patches/titanium.cpp
+	patches/underfoot.cpp
 )

 SOURCE_GROUP(SocketLib FILES
-    SocketLib/Base64.h
-    SocketLib/File.h
-    SocketLib/HttpdCookies.h
-    SocketLib/HttpdForm.h
-    SocketLib/HttpdSocket.h
-    SocketLib/HTTPSocket.h
-    SocketLib/IFile.h
-    SocketLib/MemFile.h
-    SocketLib/Mime.h
-    SocketLib/Parse.h
-    SocketLib/socket_include.h
-    SocketLib/Utility.h
-    SocketLib/Base64.cpp
-    SocketLib/File.cpp
-    SocketLib/HttpdCookies.cpp
-    SocketLib/HttpdForm.cpp
-    SocketLib/HttpdSocket.cpp
-    SocketLib/HTTPSocket.cpp
-    SocketLib/MemFile.cpp
-    SocketLib/Mime.cpp
-    SocketLib/Parse.cpp
-    SocketLib/socket_include.cpp
-    SocketLib/Utility.cpp
+	SocketLib/Base64.h
+	SocketLib/File.h
+	SocketLib/HttpdCookies.h
+	SocketLib/HttpdForm.h
+	SocketLib/HttpdSocket.h
+	SocketLib/HTTPSocket.h
+	SocketLib/IFile.h
+	SocketLib/MemFile.h
+	SocketLib/Mime.h
+	SocketLib/Parse.h
+	SocketLib/socket_include.h
+	SocketLib/Utility.h
+	SocketLib/Base64.cpp
+	SocketLib/File.cpp
+	SocketLib/HttpdCookies.cpp
+	SocketLib/HttpdForm.cpp
+	SocketLib/HttpdSocket.cpp
+	SocketLib/HTTPSocket.cpp
+	SocketLib/MemFile.cpp
+	SocketLib/Mime.cpp
+	SocketLib/Parse.cpp
+	SocketLib/socket_include.cpp
+	SocketLib/Utility.cpp
 )

 SOURCE_GROUP(StackWalker FILES
-    StackWalker/StackWalker.h
-    StackWalker/StackWalker.cpp
+	StackWalker/StackWalker.h
+	StackWalker/StackWalker.cpp
 )

 SOURCE_GROUP(TinyXML FILES
-    tinyxml/tinystr.h
-    tinyxml/tinyxml.h
-    tinyxml/tinystr.cpp
-    tinyxml/tinyxml.cpp
-    tinyxml/tinyxmlerror.cpp
-    tinyxml/tinyxmlparser.cpp
+	tinyxml/tinystr.h
+	tinyxml/tinyxml.h
+	tinyxml/tinystr.cpp
+	tinyxml/tinyxml.cpp
+	tinyxml/tinyxmlerror.cpp
+	tinyxml/tinyxmlparser.cpp
 )

 INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)

-ADD_LIBRARY(Common ${common_sources} ${common_headers})
-
+ADD_LIBRARY(common ${common_sources} ${common_headers})

 IF(UNIX)
-    ADD_DEFINITIONS(-fPIC)
-    SET_SOURCE_FILES_PROPERTIES("patches/SoD.cpp" "patches/SoF.cpp" "patches/RoF.cpp" "patches/Underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
+	ADD_DEFINITIONS(-fPIC)
+	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)
+	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp"  "patches/rof2.cpp" "patches/underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)

-SET(LIBRARY_OUTPUT_PATH ../Bin)
+
+SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -1,346 +0,0 @@
-#include <stdio.h>
-
-unsigned long IntArray[]={ 
-0x00000000, 
-0x77073096, 
-0xEE0E612C, 
-0x990951BA, 
-0x076DC419, 
-0x706AF48F, 
-0xE963A535, 
-0x9E6495A3, 
-0x0EDB8832, 
-0x79DCB8A4, 
-0xE0D5E91E, 
-0x97D2D988, 
-0x09B64C2B, 
-0x7EB17CBD, 
-0xE7B82D07, 
-0x90BF1D91, 
-0x1DB71064, 
-0x6AB020F2, 
-0xF3B97148, 
-0x84BE41DE, 
-0x1ADAD47D, 
-0x6DDDE4EB, 
-0xF4D4B551, 
-0x83D385C7, 
-0x136C9856, 
-0x646BA8C0, 
-0xFD62F97A, 
-0x8A65C9EC, 
-0x14015C4F, 
-0x63066CD9, 
-0xFA0F3D63, 
-0x8D080DF5, 
-0x3B6E20C8, 
-0x4C69105E, 
-0xD56041E4, 
-0xA2677172, 
-0x3C03E4D1, 
-0x4B04D447, 
-0xD20D85FD, 
-0xA50AB56B, 
-0x35B5A8FA, 
-0x42B2986C, 
-0xDBBBC9D6, 
-0xACBCF940, 
-0x32D86CE3, 
-0x45DF5C75, 
-0xDCD60DCF, 
-0xABD13D59, 
-0x26D930AC, 
-0x51DE003A, 
-0xC8D75180, 
-0xBFD06116, 
-0x21B4F4B5, 
-0x56B3C423, 
-0xCFBA9599, 
-0xB8BDA50F, 
-0x2802B89E, 
-0x5F058808, 
-0xC60CD9B2, 
-0xB10BE924, 
-0x2F6F7C87, 
-0x58684C11, 
-0xC1611DAB, 
-0xB6662D3D, 
-0x76DC4190, 
-0x01DB7106, 
-0x98D220BC, 
-0xEFD5102A, 
-0x71B18589, 
-0x06B6B51F, 
-0x9FBFE4A5, 
-0xE8B8D433, 
-0x7807C9A2, 
-0x0F00F934, 
-0x9609A88E, 
-0xE10E9818, 
-0x7F6A0DBB, 
-0x086D3D2D, 
-0x91646C97, 
-0xE6635C01, 
-0x6B6B51F4, 
-0x1C6C6162, 
-0x856530D8, 
-0xF262004E, 
-0x6C0695ED, 
-0x1B01A57B, 
-0x8208F4C1, 
-0xF50FC457, 
-0x65B0D9C6, 
-0x12B7E950, 
-0x8BBEB8EA, 
-0xFCB9887C, 
-0x62DD1DDF, 
-0x15DA2D49, 
-0x8CD37CF3, 
-0xFBD44C65, 
-0x4DB26158, 
-0x3AB551CE, 
-0xA3BC0074, 
-0xD4BB30E2, 
-0x4ADFA541, 
-0x3DD895D7, 
-0xA4D1C46D, 
-0xD3D6F4FB, 
-0x4369E96A, 
-0x346ED9FC, 
-0xAD678846, 
-0xDA60B8D0, 
-0x44042D73, 
-0x33031DE5, 
-0xAA0A4C5F, 
-0xDD0D7CC9, 
-0x5005713C, 
-0x270241AA, 
-0xBE0B1010, 
-0xC90C2086, 
-0x5768B525, 
-0x206F85B3, 
-0xB966D409, 
-0xCE61E49F, 
-0x5EDEF90E, 
-0x29D9C998, 
-0xB0D09822, 
-0xC7D7A8B4, 
-0x59B33D17, 
-0x2EB40D81, 
-0xB7BD5C3B, 
-0xC0BA6CAD, 
-0xEDB88320, 
-0x9ABFB3B6, 
-0x03B6E20C, 
-0x74B1D29A, 
-0xEAD54739, 
-0x9DD277AF, 
-0x04DB2615, 
-0x73DC1683, 
-0xE3630B12, 
-0x94643B84, 
-0x0D6D6A3E, 
-0x7A6A5AA8, 
-0xE40ECF0B, 
-0x9309FF9D, 
-0x0A00AE27, 
-0x7D079EB1, 
-0xF00F9344, 
-0x8708A3D2, 
-0x1E01F268, 
-0x6906C2FE, 
-0xF762575D, 
-0x806567CB, 
-0x196C3671, 
-0x6E6B06E7, 
-0xFED41B76, 
-0x89D32BE0, 
-0x10DA7A5A, 
-0x67DD4ACC, 
-0xF9B9DF6F, 
-0x8EBEEFF9, 
-0x17B7BE43, 
-0x60B08ED5, 
-0xD6D6A3E8, 
-0xA1D1937E, 
-0x38D8C2C4, 
-0x4FDFF252, 
-0xD1BB67F1, 
-0xA6BC5767, 
-0x3FB506DD, 
-0x48B2364B, 
-0xD80D2BDA, 
-0xAF0A1B4C, 
-0x36034AF6, 
-0x41047A60, 
-0xDF60EFC3, 
-0xA867DF55, 
-0x316E8EEF, 
-0x4669BE79, 
-0xCB61B38C, 
-0xBC66831A, 
-0x256FD2A0, 
-0x5268E236, 
-0xCC0C7795, 
-0xBB0B4703, 
-0x220216B9, 
-0x5505262F, 
-0xC5BA3BBE, 
-0xB2BD0B28, 
-0x2BB45A92, 
-0x5CB36A04, 
-0xC2D7FFA7, 
-0xB5D0CF31, 
-0x2CD99E8B, 
-0x5BDEAE1D, 
-0x9B64C2B0, 
-0xEC63F226, 
-0x756AA39C, 
-0x026D930A, 
-0x9C0906A9, 
-0xEB0E363F, 
-0x72076785, 
-0x05005713, 
-0x95BF4A82, 
-0xE2B87A14, 
-0x7BB12BAE, 
-0x0CB61B38, 
-0x92D28E9B, 
-0xE5D5BE0D, 
-0x7CDCEFB7, 
-0x0BDBDF21, 
-0x86D3D2D4, 
-0xF1D4E242, 
-0x68DDB3F8, 
-0x1FDA836E, 
-0x81BE16CD, 
-0xF6B9265B, 
-0x6FB077E1, 
-0x18B74777, 
-0x88085AE6, 
-0xFF0F6A70, 
-0x66063BCA, 
-0x11010B5C, 
-0x8F659EFF, 
-0xF862AE69, 
-0x616BFFD3, 
-0x166CCF45, 
-0xA00AE278, 
-0xD70DD2EE, 
-0x4E048354, 
-0x3903B3C2, 
-0xA7672661, 
-0xD06016F7, 
-0x4969474D, 
-0x3E6E77DB, 
-0xAED16A4A, 
-0xD9D65ADC, 
-0x40DF0B66, 
-0x37D83BF0, 
-0xA9BCAE53, 
-0xDEBB9EC5, 
-0x47B2CF7F, 
-0x30B5FFE9, 
-0xBDBDF21C, 
-0xCABAC28A, 
-0x53B39330, 
-0x24B4A3A6, 
-0xBAD03605, 
-0xCDD70693, 
-0x54DE5729, 
-0x23D967BF, 
-0xB3667A2E, 
-0xC4614AB8, 
-0x5D681B02, 
-0x2A6F2B94, 
-0xB40BBE37, 
-0xC30C8EA1, 
-0x5A05DF1B, 
-0x2D02EF8D, 
-}; 
- 
-unsigned long CRC16(const unsigned char *buf, int size, int key) 
-{
- 
-	//printf("CRC16() key=%d\n",key);
-/* 
-sub_0_10020760  proc near               ; CODE XREF: sub_0_10008620+AEp 
-                                        ; sub_0_10022A90+14Fp ... 
- 
-arg_0           = dword ptr  4 
-arg_4           = dword ptr  8 
-arg_8           = dword ptr  0Ch 
-*/ 
- 
-   //int *pecx = buf; 
-   unsigned long ecx = key;            //mov     ecx, [esp+arg_8] 
-   unsigned long eax = ecx;            //mov     eax, ecx 
-   unsigned long edi;
-/*   int ecx = key;            //mov     ecx, [esp+arg_8] 
-   int eax = ecx;            //mov     eax, ecx 
-   int edi;
-*/
-   eax = ~ eax;               //not     eax 
-    eax&=0xFF;               //and     eax, 0FFh 
-    eax=IntArray[eax];         //mov     eax, dword_0_10115D38[eax*4] IntArray 
-    eax ^= 0x00FFFFFF;         //xor     eax, 0FFFFFFh 
-     int edx = ecx;            //mov     edx, ecx 
-   edx = edx >> 8;            //sar     edx, 8 
-    edx = edx ^ eax;         //xor     edx, eax 
-    eax = eax >> 8;            //sar     eax, 8 
-    edx &= 0xFF;            //and     edx, 0FFh 
-    eax &= 0x00FFFFFF;         //and     eax, 0FFFFFFh 
-                        //push    esi 
-    eax ^= IntArray[edx];      //xor     eax, dword_0_10115D38[edx*4] 
-    edx = ecx;               //mov     edx, ecx 
-    edx = edx >> 0x10;         //sar     edx, 10h 
-    edx ^= eax;               //xor     edx, eax 
-    eax = eax >> 8;            //sar     eax, 8 
-    edx &= 0xFF;            //and     edx, 0FFh 
-    int esi = IntArray[edx];   //mov     esi, dword_0_10115D38[edx*4] 
-    edx = size;            //mov     edx, [esp+4+arg_4] 
-    eax &= 0x00FFFFFF;         //and     eax, 0FFFFFFh 
-    eax ^= esi;               //xor     eax, esi 
-    ecx = ecx >> 0x18;         //sar     ecx, 18h 
-    ecx ^= eax;               //xor     ecx, eax 
-    ecx &= 0xFF;            //and     ecx, 0FFh 
-    esi = IntArray[ecx];      //mov     esi, dword_0_10115D38[ecx*4] 
-    /*ecx = (int) buf;   not used */           //mov     ecx, [esp+4+arg_0] 
-    eax = eax >> 8;            //sar     eax, 8 
-    eax &= 0x00FFFFFF;         //and     eax, 0FFFFFFh 
-    eax ^= esi;               //xor     eax, esi 
-    /* int* esi = ecx+edx //??*///lea     esi, [ecx+edx] 
-    for(int x = 0; x < size; x++) 
-   {                     //eax is the crc, ecx is the current part of the buffer 
-      int edx = 0;         //xor     edx, edx 
-      edx = buf[x] & 0x00FF;   //mov     dl, [ecx] 
- 
-   /*if(pos > size)         //cmp     ecx, esi 
-      return ~eax;         //jnb     short loc_0_10020803 
-   */ 
-                        //push    edi 
- 
-//loc_0_100207E0:                         ; CODE XREF: sub_0_10020760+A0j 
-//LOOP 
-        edx ^= eax;            //xor     edx, eax 
-        eax = eax >> 8;         //sar     eax, 8 
-        edx &= 0xFF;         //and     edx, 0FFh 
-        edi = IntArray[edx];   //mov     edi, dword_0_10115D38[edx*4] 
-        eax &= 0x00FFFFFF;      //and     eax, 0FFFFFFh 
-        eax ^= edi;            //xor     eax, edi 
-                       //inc     ecx 
-                        //cmp     ecx, esi 
-                        // jb      short loc_0_100207E0 
-                        //pop     edi 
-   } 
- 
-   return ~eax; 
-} 
- 
-/*loc_0_10020803:                         ; CODE XREF: sub_0_10020760+7Dj 
-                not     eax 
-                pop     esi 
-                retn 
-sub_0_10020760  endp 
- 
-*/
@@ -1,6 +0,0 @@
-#ifndef _CRC16_H
-#define _CRC16_H
-
-unsigned long CRC16(const unsigned char *buf, int size, int key);
-
-#endif
@@ -1,153 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "debug.h"
-#include "Condition.h"
-
-#ifdef _WINDOWS
-#else
-#include <pthread.h>
-#include <sys/time.h>
-#include <errno.h>
-#endif
-
-#ifdef _WINDOWS
-
-
-Condition::Condition() 
-{
-	m_events[SignalEvent] = CreateEvent (NULL,  // security
-                                     FALSE, // is auto-reset event?
-                                     FALSE, // is signaled initially?
-                                     NULL); // name
-	m_events[BroadcastEvent] = CreateEvent (NULL,  // security
-                                     TRUE, // is auto-reset event?
-                                     FALSE, // is signaled initially?
-                                     NULL); // name
-	m_waiters = 0;
-	InitializeCriticalSection(&CSMutex);
-}
-
-Condition::~Condition()
-{
-	DeleteCriticalSection(&CSMutex);
-	CloseHandle(m_events[SignalEvent]);
-	CloseHandle(m_events[BroadcastEvent]);
-}
-
-void Condition::Signal()
-{
-	EnterCriticalSection(&CSMutex);
-	if(m_waiters > 0)
-		SetEvent(m_events[SignalEvent]);
-	LeaveCriticalSection(&CSMutex);
-}
-
-void Condition::SignalAll()
-{
-	EnterCriticalSection(&CSMutex);
-	if(m_waiters > 0)
-		SetEvent(m_events[BroadcastEvent]);
-	LeaveCriticalSection(&CSMutex);
-}
-
-void Condition::Wait()
-{
-	EnterCriticalSection(&CSMutex);
-	
-	m_waiters++;
-	
-	
-	LeaveCriticalSection(&CSMutex);
-	int result = WaitForMultipleObjects (_eventCount, m_events, FALSE, INFINITE);
-	EnterCriticalSection(&CSMutex);
-	
-	m_waiters--;
-	
-	//see if we are the last person waiting on the condition, and there was a broadcast
-	//if so, we need to reset the broadcast event.
-	if(m_waiters == 0 && result == (WAIT_OBJECT_0+BroadcastEvent))
-		ResetEvent(m_events[BroadcastEvent]);
-	
-	LeaveCriticalSection(&CSMutex);
-}
-
-
-#else	//!WIN32
-
-Condition::Condition() 
-{
-	pthread_cond_init(&cond,NULL);
-	pthread_mutex_init(&mutex,NULL);
-}
-
-void Condition::Signal()
-{
-	pthread_mutex_lock(&mutex);
-	pthread_cond_signal(&cond);
-	pthread_mutex_unlock(&mutex);
-}
-
-void Condition::SignalAll()
-{
-	pthread_mutex_lock(&mutex);
-	pthread_cond_broadcast(&cond);
-	pthread_mutex_unlock(&mutex);
-}
-
-void Condition::Wait()
-{
-	pthread_mutex_lock(&mutex);
-	pthread_cond_wait(&cond,&mutex);
-	pthread_mutex_unlock(&mutex);
-}
-
-/*
-I commented this specifically because I think it might be very
-difficult to write a windows counterpart to it, so I would like
-to discourage its use until we can confirm that it can be reasonably
-implemented on windows.
-
-bool Condition::TimedWait(unsigned long usec)
-{
-struct timeval now;
-struct timespec timeout;
-int retcode=0;
-	pthread_mutex_lock(&mutex);
-	gettimeofday(&now,NULL);
-	now.tv_usec+=usec;
-	timeout.tv_sec = now.tv_sec + (now.tv_usec/1000000);
-	timeout.tv_nsec = (now.tv_usec%1000000) *1000;
-	//cout << "now=" << now.tv_sec << "."<<now.tv_usec << endl;
-	//cout << "timeout=" << timeout.tv_sec << "."<<timeout.tv_nsec << endl;
-	retcode=pthread_cond_timedwait(&cond,&mutex,&timeout);
-	pthread_mutex_unlock(&mutex);
-
-	return retcode!=ETIMEDOUT;
-}
-*/
-
-Condition::~Condition()
-{
-	pthread_mutex_lock(&mutex);
-	pthread_cond_destroy(&cond);
-	pthread_mutex_unlock(&mutex);
-	pthread_mutex_destroy(&mutex);
-}
-
-#endif
@@ -1,56 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef __CONDITION_H
-#define __CONDITION_H
-
-#include "debug.h"
-#ifndef WIN32
-#include <pthread.h>
-#endif
-
-//Sombody, someday needs to figure out how to implement a condition
-//system on windows...
-
-
-class Condition {
-	private:
-#ifdef WIN32
-		enum {
-			SignalEvent = 0,
-			BroadcastEvent,
-			_eventCount
-		};
-
-		HANDLE m_events[_eventCount];
-		uint32 m_waiters;
-		CRITICAL_SECTION CSMutex;
-#else
-		pthread_cond_t cond;
-		pthread_mutex_t mutex;
-#endif
-	public:
-		Condition();
-		void Signal();
-		void SignalAll();
-		void Wait();
-//		bool TimedWait(unsigned long usec);
-		~Condition();
-};
-
-#endif
-
@@ -1,62 +0,0 @@
-#ifdef _EQDEBUG
-#include "../common/debug.h"
-#include <windows.h>
-#include <stdio.h>
-#include <string.h>
-#include "../common/Mutex.h"
-#include "DBMemLeak.h"
-
-#include <crtdbg.h>
-
-#ifdef _WINDOWS
-#define snprintf	_snprintf
-#define strncasecmp	_strnicmp
-#define strcasecmp	_stricmp
-#endif
-
-DBMemLeak dbmemleak;
-LinkedList<DBMemLeakStruct*>* list = 0;
-Mutex MDBMemLeak;
-
-DBMemLeak::DBMemLeak() {
-	list = new LinkedList<DBMemLeakStruct*>;
-}
-
-DBMemLeak::~DBMemLeak() {
-	LinkedListIterator<DBMemLeakStruct*> iterator(*list);
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		char tmp[200];
-		snprintf(tmp, sizeof(tmp) - 3, "DB Mem Leak: Block=%6d, Query=%s", iterator.GetData()->memblock, iterator.GetData()->query);
-		snprintf(tmp, sizeof(tmp), "%s\n", tmp);
-		OutputDebugString(tmp);
-		iterator.Advance();
-	}
-	safe_delete(list);
-}
-
-void DBMemLeak::Alloc(const void* result, const char* query) {
-	LockMutex lock(&MDBMemLeak);
-	long requestNumber;
-	uint8* tmp2 = new uint8;
-	_CrtIsMemoryBlock( tmp2, 1, &requestNumber, 0, 0 );
-	safe_delete(tmp2);
-	DBMemLeakStruct* tmp = (DBMemLeakStruct*) new uchar[sizeof(DBMemLeakStruct) + strlen(query) + 1];
-	tmp->result = result;
-	tmp->memblock = requestNumber;
-	strcpy(tmp->query, query);
-	list->Append(tmp);
-}
-
-void DBMemLeak::Free(const void* result) {
-	LockMutex lock(&MDBMemLeak);
-	LinkedListIterator<DBMemLeakStruct*> iterator(*list);
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (result == iterator.GetData()->result)
-			iterator.RemoveCurrent();
-		else
-			iterator.Advance();
-	}
-}
-#endif
@@ -1,25 +0,0 @@
-#ifdef _EQDEBUG
-#ifndef DBMemLeak_H
-#define DBMemLeak_H
-#include "../common/types.h"
-#include "../common/linked_list.h"
-
-#define mysql_free_result(r)	{ DBMemLeak::Free(r); mysql_free_result(r); }
-
-struct DBMemLeakStruct {
-	const void* result;
-	uint32 memblock;
-	char query[0];
-};
-
-class DBMemLeak {
-public:
-	DBMemLeak();
-	~DBMemLeak();
-
-	static void Alloc(const void* result, const char* query);
-	static void Free(const void* result);
-};
-
-#endif
-#endif
@@ -1,300 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#include "../common/debug.h"
-#include <iostream>
-using namespace std;
-#include "../common/types.h"
-#include "EMuShareMem.h"
-
-#ifdef _WINDOWS
-	#define snprintf	_snprintf
-#if (_MSC_VER < 1500)
-	#define vsnprintf	_vsnprintf
-#endif
-	#define strncasecmp	_strnicmp
-	#define strcasecmp  _stricmp
-
-	#define EmuLibName "EMuShareMem"
-#else
-	#define EmuLibName "libEMuShareMem.so"
-#endif
-
-LoadEMuShareMemDLL EMuShareMemDLL;
-
-#ifndef WIN32
-uint32 LoadEMuShareMemDLL::refCount = 0;
-#endif
-
-LoadEMuShareMemDLL::LoadEMuShareMemDLL() {
-	ClearFunc();
-#ifndef WIN32
-    refCountU();
-#endif
-}
-
-LoadEMuShareMemDLL::~LoadEMuShareMemDLL() {
-#ifndef WIN32
-    if (refCountD() <= 0) {
-#endif
-	Unload();
-#ifndef WIN32
-    }
-#endif
-}
-
-bool LoadEMuShareMemDLL::Load() {
-	if(loaded)
-		return(true);
-	
-	if(!SharedLibrary::Load(EmuLibName))
-		return(false);
-	
-	if (Loaded()) {
-		Items.GetItem = (DLLFUNC_GetItem) GetSym("GetItem");
-		Items.IterateItems = (DLLFUNC_IterateItems) GetSym("IterateItems");
-		Items.cbAddItem = (DLLFUNC_AddItem) GetSym("AddItem");
-		Items.DLLLoadItems = (DLLFUNC_DLLLoadItems) GetSym("DLLLoadItems");
-		Doors.GetDoor = (DLLFUNC_GetDoor) GetSym("GetDoor");
-		Doors.cbAddDoor = (DLLFUNC_AddDoor) GetSym("AddDoor");
-		Doors.DLLLoadDoors = (DLLFUNC_DLLLoadDoors) GetSym("DLLLoadDoors");
-		Spells.DLLLoadSPDat = (DLLFUNC_DLLLoadSPDat) GetSym("DLLLoadSPDat");
-		NPCFactionList.DLLLoadNPCFactionLists = (DLLFUNC_DLLLoadNPCFactionLists) GetSym("DLLLoadNPCFactionLists");
-		NPCFactionList.GetNPCFactionList = (DLLFUNC_GetNPCFactionList) GetSym("GetNPCFactionList");
-		NPCFactionList.cbAddNPCFactionList = (DLLFUNC_AddNPCFactionList) GetSym("AddNPCFactionList");
-		NPCFactionList.cbSetFaction = (DLLFUNC_SetFaction) GetSym("SetNPCFaction");
-		Loot.DLLLoadLoot = (DLLFUNC_DLLLoadLoot) GetSym("DLLLoadLoot");
-		Loot.cbAddLootTable = (DLLFUNC_AddLootTable) GetSym("AddLootTable");
-		Loot.cbAddLootDrop = (DLLFUNC_AddLootDrop) GetSym("AddLootDrop");
-		Loot.GetLootTable = (DLLFUNC_GetLootTable) GetSym("GetLootTable");
-		Loot.GetLootDrop = (DLLFUNC_GetLootDrop) GetSym("GetLootDrop");
-		Opcodes.GetEQOpcode = (DLLFUNC_GetEQOpcode) GetSym("GetEQOpcode");
-		Opcodes.GetEmuOpcode = (DLLFUNC_GetEmuOpcode) GetSym("GetEmuOpcode");
-		Opcodes.SetOpcodePair = (DLLFUNC_SetOpcodePair) GetSym("SetOpcodePair");
-		Opcodes.DLLLoadOpcodes = (DLLFUNC_DLLLoadOpcodes) GetSym("DLLLoadOpcodes");
-		Opcodes.ClearEQOpcodes = (DLLFUNC_ClearEQOpcodes) GetSym("ClearEQOpcodes");
-		SkillCaps.LoadSkillCaps = (DLLFUNC_DLLLoadSkillCaps) GetSym("LoadSkillCaps");
-		SkillCaps.GetSkillCap = (DLLFUNC_GetSkillCap) GetSym("GetSkillCap");
-		SkillCaps.SetSkillCap = (DLLFUNC_SetSkillCap) GetSym("SetSkillCap");
-		SkillCaps.ClearSkillCaps = (DLLFUNC_ClearSkillCaps) GetSym("ClearSkillCaps");
-		SkillCaps.GetTrainLevel = (DLLFUNC_GetTrainLevel) GetSym("GetTrainLevel");	
-		if(Items.GetItem == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Items.GetItem");
-			return(false);
-		}
-
-		if(Items.IterateItems == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Items.IterateItems");
-			return(false);
-		}
-
-		if(Items.cbAddItem == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Items.cbAddItem");
-			return(false);
-		}
-
-		if(Items.DLLLoadItems == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Items.DLLLoadItems");
-			return(false);
-		}
-
-		if(Doors.GetDoor == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Doors.GetDoor");
-			return(false);
-		}
-
-		if(Doors.cbAddDoor == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Doors.cbAddDoor");
-			return(false);
-		}
-
-		if(Doors.DLLLoadDoors == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Doors.DLLLoadDoors");
-			return(false);
-		}
-
-		if(Spells.DLLLoadSPDat == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Spells.DLLLoadSPDat");
-			return(false);
-		}
-
-		if(NPCFactionList.DLLLoadNPCFactionLists == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach NPCFactionList.DLLLoadNPCFactionLists");
-			return(false);
-		}
-
-		if(NPCFactionList.GetNPCFactionList == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach NPCFactionList.GetNPCFactionList");
-			return(false);
-		}
-
-		if(NPCFactionList.cbAddNPCFactionList == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach NPCFactionList.cbAddNPCFactionList");
-			return(false);
-		}
-
-		if(NPCFactionList.cbSetFaction == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach NPCFactionList.cbSetFaction");
-			return(false);
-		}
-
-		if(Loot.DLLLoadLoot == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Loot.DLLLoadLoot");
-			return(false);
-		}
-
-		if(Loot.cbAddLootTable == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Loot.cbAddLootTable");
-			return(false);
-		}
-
-		if(Loot.cbAddLootDrop == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Loot.cbAddLootDrop");
-			return(false);
-		}
-
-		if(Loot.GetLootTable == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Loot.GetLootTable");
-			return(false);
-		}
-
-		if(Loot.GetLootDrop == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Loot.GetLootDrop");
-			return(false);
-		}
-
-		if(Opcodes.GetEQOpcode == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Opcodes.GetEQOpcode");
-			return(false);
-		}
-
-		if(Opcodes.GetEmuOpcode == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Opcodes.GetEmuOpcode");
-			return(false);
-		}
-
-		if(Opcodes.SetOpcodePair == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Opcodes.SetOpcodePair");
-			return(false);
-		}
-
-		if(Opcodes.DLLLoadOpcodes == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Opcodes.DLLLoadOpcodes");
-			return(false);
-		}
-
-		if(Opcodes.ClearEQOpcodes == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach Opcodes.ClearEQOpcodes");
-			return(false);
-		}
-
-		if(SkillCaps.LoadSkillCaps == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach SkillCaps.LoadSkillCaps");
-			return(false);
-		}
-
-		if(SkillCaps.GetSkillCap == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach SkillCaps.GetSkillCap");
-			return(false);
-		}
-
-		if(SkillCaps.SetSkillCap == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach SkillCaps.SetSkillCap");
-			return(false);
-		}
-
-		if(SkillCaps.ClearSkillCaps == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach SkillCaps.ClearSkillCaps");
-			return(false);
-		}
-		
-		if(SkillCaps.GetTrainLevel == NULL) {
-			Unload();
-			LogFile->write(EQEMuLog::Error, "LoadEMuShareMemDLL::Load() failed to attach SkillCaps.GetTrainLevel");
-			return(false);
-		}
-				
-		LogFile->write(EQEMuLog::Status, "%s loaded", EmuLibName);
-		loaded = true;
-		return true;
-	}
-	else {
-		LogFile->write(EQEMuLog::Error, "%s was not loaded, but did not report an error.", EmuLibName);
-	}
-	return false;
-}
-
-void LoadEMuShareMemDLL::Unload() {
-	ClearFunc();
-	SharedLibrary::Unload();
-}
-
-void LoadEMuShareMemDLL::ClearFunc() {
-	Items.GetItem = 0;
-	Items.IterateItems = 0;
-	Items.cbAddItem = 0;
-	Items.DLLLoadItems = 0;
-	Doors.GetDoor = 0;
-	Doors.cbAddDoor = 0;
-	Doors.DLLLoadDoors = 0;
-	NPCFactionList.DLLLoadNPCFactionLists = 0;
-	NPCFactionList.GetNPCFactionList = 0;
-	NPCFactionList.cbAddNPCFactionList = 0;
-	NPCFactionList.cbSetFaction = 0;
-	Loot.DLLLoadLoot = 0;
-	Loot.cbAddLootTable = 0;
-	Loot.cbAddLootDrop = 0;
-	Loot.GetLootTable = 0;
-	Loot.GetLootDrop = 0;
-	Opcodes.GetEQOpcode = NULL;
-	Opcodes.GetEmuOpcode = NULL;
-	Opcodes.SetOpcodePair = NULL;
-	Opcodes.DLLLoadOpcodes = NULL;
-	Opcodes.ClearEQOpcodes = NULL;
-	SkillCaps.LoadSkillCaps = NULL;
-	SkillCaps.GetSkillCap = NULL;
-	SkillCaps.SetSkillCap = NULL;
-	SkillCaps.ClearSkillCaps = NULL;
-	SkillCaps.GetTrainLevel = NULL;
-	loaded = false;
-}
@@ -1,187 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef EMuShareMem_H
-#define EMuShareMem_H
-#ifdef _WINDOWS
-#include <windows.h>
-#else
-#include "../common/unix.h"
-#endif
-#include "../common/eq_packet_structs.h"
-#include "../zone/zonedump.h"
-#include "../zone/loottable.h"
-#include "SharedLibrary.h"
-
-////////////
-// Items //
-///////////
-typedef bool(*CALLBACK_DBLoadItems)(int32, uint32);
-
-typedef bool(*DLLFUNC_DLLLoadItems)(const CALLBACK_DBLoadItems, uint32, int32*, uint32*);
-typedef const Item_Struct*(*DLLFUNC_GetItem)(uint32);
-typedef const Item_Struct*(*DLLFUNC_IterateItems)(uint32*);
-typedef bool(*DLLFUNC_AddItem)(uint32, const Item_Struct*);
-
-struct ItemsDLLFunc_Struct {
-	DLLFUNC_DLLLoadItems DLLLoadItems;
-	DLLFUNC_GetItem GetItem;
-	DLLFUNC_IterateItems IterateItems;
-	DLLFUNC_AddItem cbAddItem;
-};
-/*
-typedef bool(*CALLBACK_DBLoadNPCTypes)(int32, uint32);
-
-typedef bool(*DLLFUNC_DLLLoadNPCTypes)(const CALLBACK_DBLoadNPCTypes, uint32, int32*, uint32*);
-typedef const NPCType*(*DLLFUNC_GetNPCType)(uint32);
-typedef bool(*DLLFUNC_AddNPCType)(uint32, const NPCType*);
-struct NPCTypesDLLFunc_Struct {
-	DLLFUNC_DLLLoadNPCTypes DLLLoadNPCTypes;
-	DLLFUNC_GetNPCType GetNPCType;
-	DLLFUNC_AddNPCType cbAddNPCType;
-};
-*/
-
-
-////////////
-// Doors ///
-////////////
-typedef bool(*CALLBACK_DBLoadDoors)(int32, uint32);
-
-typedef bool(*DLLFUNC_DLLLoadDoors)(const CALLBACK_DBLoadDoors, uint32, int32*, uint32*);
-typedef const Door*(*DLLFUNC_GetDoor)(uint32);
-typedef bool(*DLLFUNC_AddDoor)(uint32, const Door*);
-struct DoorsDLLFunc_Struct {
-	DLLFUNC_DLLLoadDoors DLLLoadDoors;
-	DLLFUNC_GetDoor GetDoor;
-	DLLFUNC_AddDoor cbAddDoor;
-};
-
-////////////
-// Spells //
-////////////
-typedef bool(*CALLBACK_FileLoadSPDat)(void*, int32);
-
-typedef bool(*DLLFUNC_DLLLoadSPDat)(const CALLBACK_FileLoadSPDat, const void**, int32*, uint32);
-struct SpellsDLLFunc_Struct {
-	DLLFUNC_DLLLoadSPDat DLLLoadSPDat;
-};
-
-//////////////
-// Factions //
-//////////////
-
-typedef bool(*CALLBACK_DBLoadNPCFactionLists)(int32, uint32);
-
-typedef bool(*DLLFUNC_DLLLoadNPCFactionLists)(const CALLBACK_DBLoadNPCFactionLists, uint32, int32*, uint32*, uint8);
-typedef const NPCFactionList*(*DLLFUNC_GetNPCFactionList)(uint32);
-typedef bool(*DLLFUNC_AddNPCFactionList)(uint32, const NPCFactionList*);
-typedef bool(*DLLFUNC_SetFaction)(uint32, uint32*, int32*, int8*, uint8*);
-struct NPCFactionListDLLFunc_Struct {
-	DLLFUNC_DLLLoadNPCFactionLists DLLLoadNPCFactionLists;
-	DLLFUNC_GetNPCFactionList GetNPCFactionList;
-	DLLFUNC_AddNPCFactionList cbAddNPCFactionList;
-	DLLFUNC_SetFaction cbSetFaction;
-};
-
-////////////
-// Loot   //
-///////////
-
-typedef bool(*CALLBACK_DBLoadLoot)();
-
-typedef bool(*DLLFUNC_DLLLoadLoot)(const CALLBACK_DBLoadLoot, uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32, uint32);
-typedef bool(*DLLFUNC_AddLootTable)(uint32, const LootTable_Struct*);
-typedef bool(*DLLFUNC_AddLootDrop)(uint32, const LootDrop_Struct*);
-typedef const LootTable_Struct*(*DLLFUNC_GetLootTable)(uint32);
-typedef const LootDrop_Struct*(*DLLFUNC_GetLootDrop)(uint32);
-struct LootDLLFunc_Struct {
-	DLLFUNC_DLLLoadLoot DLLLoadLoot;
-	DLLFUNC_AddLootTable cbAddLootTable;
-	DLLFUNC_AddLootDrop cbAddLootDrop;
-	DLLFUNC_GetLootTable GetLootTable;
-	DLLFUNC_GetLootDrop GetLootDrop;
-};
-
-/////////////
-// Opcodes //
-/////////////
-
-typedef bool(*CALLBACK_DBLoadOpcodes)(const char *filename);
-
-typedef bool(*DLLFUNC_DLLLoadOpcodes)(const CALLBACK_DBLoadOpcodes, uint32 opsize, uint32 eq_count, uint32 emu_count, const char *filename);
-typedef uint16 (*DLLFUNC_GetEQOpcode)(uint16 emu_op);
-typedef uint16 (*DLLFUNC_GetEmuOpcode)(uint16 eq_op);
-typedef void (*DLLFUNC_ClearEQOpcodes)();
-typedef bool(*DLLFUNC_SetOpcodePair)(uint16 emu_op, uint16 eq_op);
-struct OpcodeDLLFunc_Struct {
-	DLLFUNC_DLLLoadOpcodes DLLLoadOpcodes;
-	DLLFUNC_GetEQOpcode GetEQOpcode;
-	DLLFUNC_GetEmuOpcode GetEmuOpcode;
-	DLLFUNC_SetOpcodePair SetOpcodePair;
-	DLLFUNC_ClearEQOpcodes ClearEQOpcodes;
-};
-
-////////////////
-// Skill Caps //
-////////////////
-
-typedef bool(*CALLBACK_DBLoadSkillCaps)();
-
-typedef bool(*DLLFUNC_DLLLoadSkillCaps)(const CALLBACK_DBLoadSkillCaps, uint32 opsize, uint8 ClassCount, uint8 SkillCount, uint8 LevelCount);
-typedef uint16 (*DLLFUNC_GetSkillCap)(uint8 Class_, uint8 Skill, uint8 Level);
-typedef void (*DLLFUNC_ClearSkillCaps)();
-typedef bool(*DLLFUNC_SetSkillCap)(uint8 Class_, uint8 Skill, uint8 Level, uint16 cap);
-typedef uint8 (*DLLFUNC_GetTrainLevel)(uint8 Class_, uint8 Skill, uint8 Level);
-struct SkillCapDLLFunc_Struct {
-	DLLFUNC_DLLLoadSkillCaps LoadSkillCaps;
-	DLLFUNC_GetSkillCap GetSkillCap;
-	DLLFUNC_SetSkillCap SetSkillCap;
-	DLLFUNC_ClearSkillCaps ClearSkillCaps;
-	DLLFUNC_GetTrainLevel GetTrainLevel;
-};
-
-
-class LoadEMuShareMemDLL : public SharedLibrary {
-public:
-	LoadEMuShareMemDLL();
-	~LoadEMuShareMemDLL();
-
-	bool Load();
-	void Unload();
-	
-	ItemsDLLFunc_Struct				Items;
-	//NPCTypesDLLFunc_Struct			NPCTypes;
-	DoorsDLLFunc_Struct				Doors;
-	SpellsDLLFunc_Struct			Spells;
-	NPCFactionListDLLFunc_Struct	NPCFactionList;
-	LootDLLFunc_Struct				Loot;
-	OpcodeDLLFunc_Struct			Opcodes;
-	SkillCapDLLFunc_Struct			SkillCaps;
-private:
-	void ClearFunc();
-	
-	bool loaded;
-	
-#ifdef _WINDOWS
-#else
-	static uint32  refCount;
-	static uint32  refCountU() { return ++refCount; };
-	static uint32  refCountD() { return --refCount; };
-#endif
-};
-#endif
@@ -1,51 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#include "debug.h"
-#include "EQDBRes.h"
-#include <mysql.h>
-
-vector<string> EQDBRes::fetch_row_array() {
-	vector<string> array;
-	if(res == NULL)
-		return(array);
-	
-	int count=mysql_num_fields(res);
-	MYSQL_ROW row=mysql_fetch_row(res);
-	for (int i=0;i<count;i++)
-		array.push_back(row[i]);
-
-	return array;
-}
-
-map<string,string> EQDBRes::fetch_row_hash() {
-	map<string,string> rowhash;
-	if(res == NULL)
-		return(rowhash);
-	
-	MYSQL_FIELD *fields;
-	MYSQL_ROW row;
-	unsigned long num_fields,i;
-
-	if (res && (num_fields=mysql_num_fields(res)) && (row = mysql_fetch_row(res))!=NULL && (fields = mysql_fetch_fields(res))!=NULL) {
-		for(i=0;i<num_fields;i++) {
-			rowhash[fields[i].name]=(row[i] ? row[i] : "");
-		}
-	}
-
-	return rowhash;
-}
@@ -1,48 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef EQDBRes_H_
-#define EQDBRes_H_
-
-#include <string>
-#include <vector>
-#include <map>
-#include "types.h"
-#include "database.h"
-#include <mysql.h>
-
-//this is the main object exported to perl.
-class EQDBRes {
-public:
-	EQDBRes(MYSQL_RES *r) { res=r; }
-	~EQDBRes()	{ finish(); }
-	
-//BEGIN PERL EXPORT
-	unsigned long	num_rows() { return (res) ? mysql_num_rows(res) : 0; }
-	unsigned long	num_fields() { return (res) ? mysql_num_fields(res) : 0; }
-	void		DESTROY() { }
-	void		finish() { if (res) mysql_free_result(res); res=NULL; };
-	vector<string>	fetch_row_array();
-	map<string,string> fetch_row_hash();
-	unsigned long *	fetch_lengths() { return (res) ? mysql_fetch_lengths(res) : 0; }
-//END PERL EXPORT
-
-private:
-	MYSQL_RES *res;
-};
-
-#endif /*EQDBRes_H_*/
@@ -1,36 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef EQEMuError_H
-#define EQEMuError_H
-
-#include "../common/types.h"
-
-enum eEQEMuError { EQEMuError_NoError, 
-	EQEMuError_Mysql_1405,
-	EQEMuError_Mysql_2003,
-	EQEMuError_Mysql_2005,
-	EQEMuError_Mysql_2007,
-	EQEMuError_MaxErrorID };
-
-void AddEQEMuError(eEQEMuError iError, bool iExitNow = false);
-void AddEQEMuError(char* iError, bool iExitNow = false);
-uint32 CheckEQEMuError();
-void CheckEQEMuErrorAndPause();
-
-#endif
-
@@ -1,414 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
-
-    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
-*/
-/* 
- * EQStream classes, by Quagmire
-*/
-
-#include "../common/debug.h"
-
-#include <iostream>
-#include <iomanip>
-#ifdef WIN32
-	#include <process.h>
-#else
-	#include <arpa/inet.h>
-	#include <unistd.h>
-	#include <sys/socket.h>
-	#include <netinet/in.h>
-	#include <fcntl.h>
-	#include <stdlib.h>
-	#include <string.h>
-	#include <pthread.h>
-	#include "../common/unix.h"
-	#define SOCKET_ERROR -1
-#endif
-#include "EQNetwork.h"
-#include "EQStream.h"
-#include "../common/packet_dump.h"
-#include "../common/packet_dump_file.h"
-#include "../common/packet_functions.h"
-#include "../common/MiscFunctions.h"
-#include "../common/crc32.h"
-#include "../common/eq_packet_structs.h"
-
-using namespace std;
-
-#define EQN_DEBUG			0
-#define EQN_DEBUG_Error		0
-#define EQN_DEBUG_Packet	0
-#define EQN_DEBUG_Fragment	0
-#define EQN_DEBUG_ACK		0
-#define EQN_DEBUG_Unknown	0
-#define EQN_DEBUG_NewStream	0
-#define LOG_PACKETS			0
-#define LOG_RAW_PACKETS_OUT	0
-#define LOG_RAW_PACKETS_IN	0
-//#define PRIORITYTEST
-
-template <typename type>                    // LO_BYTE
-type  LO_BYTE (type a) {return (a&=0xff);}  
-template <typename type>                    // HI_BYTE 
-type  HI_BYTE (type a) {return (a&=0xff00);} 
-template <typename type>                    // LO_WORD
-type  LO_WORD (type a) {return (a&=0xffff);}  
-template <typename type>                    // HI_WORD 
-type  HI_WORD (type a) {return (a&=0xffff0000);} 
-template <typename type>                    // HI_LOSWAPshort
-type  HI_LOSWAPshort (type a) {return (LO_BYTE(a)<<8) | (HI_BYTE(a)>>8);}  
-template <typename type>                    // HI_LOSWAPlong
-type  HI_LOSWAPlong (type x) {return (LO_WORD(a)<<16) | (HIWORD(a)>>16);}  
-
-EQStreamServer::EQStreamServer(uint16 iPort) {
-	RunLoop = false;
-	pPort = iPort;
-	pOpen = false;
-#ifdef WIN32
-	WORD version = MAKEWORD (1,1);
-	WSADATA wsadata;
-	WSAStartup (version, &wsadata);
-#endif
-	sock = 0;
-}
-
-EQStreamServer::~EQStreamServer() {
-	Close();
-	RunLoop = false;
-	MLoopRunning.lock();
-	MLoopRunning.unlock();
-#ifdef WIN32
-	WSACleanup();
-#endif
-	connection_list.clear();
-	while (!NewQueue.empty())
-		NewQueue.pop(); // they're deleted with the list, clear this queue so it doesnt try to delete them again
-}
-
-bool EQStreamServer::Open(uint16 iPort) {
-	LockMutex lock(&MOpen);
-	if (iPort && pPort != iPort) {
-		if (pOpen)
-			return false;
-		pPort = iPort;
-	}
-	if (!RunLoop) {
-		RunLoop = true;
-#ifdef WIN32
-		_beginthread(EQStreamServerLoop, 0, this);
-#else
-		pthread_t thread;
-		pthread_create(&thread, NULL, &EQStreamServerLoop, this);
-#endif
-	}
-	if (pOpen) {
-		return true;
-	}
-	else {
-		struct sockaddr_in address;
-//		int reuse_addr = 1;
-		int bufsize = 64 * 1024; // 64kbyte send/recieve buffers, up from default of 8k
-#ifdef WIN32
-		unsigned long nonblocking = 1;
-#endif
-
-	  /* Setup internet address information.  
-		 This is used with the bind() call */
-		memset((char *) &address, 0, sizeof(address));
-		address.sin_family = AF_INET;
-		address.sin_port = htons(pPort);
-		address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-		/* Setting up UDP port for new clients */
-		sock = socket(AF_INET, SOCK_DGRAM, 0);
-		if (sock < 0) {
-			return false;
-		}
-
-//#ifdef WIN32
-//		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse_addr, sizeof(reuse_addr));
-		setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize));
-		setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*) &bufsize, sizeof(bufsize));
-//#else
-//		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, sizeof(reuse_addr));
-//		setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
-//		setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
-//#endif
-
-		if (bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0) {
-#ifdef WIN32
-			closesocket(sock);
-#else
-			close(sock);
-#endif
-			return false;
-		}
-
-#ifdef WIN32
-		ioctlsocket (sock, FIONBIO, &nonblocking);
-#else
-		fcntl(sock, F_SETFL, O_NONBLOCK);
-#endif
-		pOpen = true;
-		return true;
-	}
-}
-
-void EQStreamServer::Close() {
-	SetOpen(false);
-	if (sock) {
-#ifdef WIN32
-		closesocket(sock);
-#else
-		close(sock);
-#endif
-	}
-	sock = 0;
-}
-
-bool EQStreamServer::IsOpen() {
-	MOpen.lock();
-	bool ret = pOpen;
-	MOpen.unlock();
-	return ret;
-}
-
-void EQStreamServer::SetOpen(bool iOpen) {
-	MOpen.lock();
-	pOpen = iOpen;
-	MOpen.unlock();
-}
-
-void EQStreamServer::Process() {
-	_CP(EQStreamServer_Process);
-	if (!IsOpen()) {
-		if (sock) {
-#ifdef WIN32
-			closesocket(sock);
-#else
-			close(sock);
-#endif
-			sock = 0;
-		}
-		return;
-	}
-
-    uchar		buffer[1518];
-	
-    int			status;
-    struct sockaddr_in	from;
-    unsigned int	fromlen;
-
-    from.sin_family = AF_INET;
-    fromlen = sizeof(from);
-
-	while (1) {
-#ifdef WIN32
-		status = recvfrom(sock, (char *) buffer, sizeof(buffer), 0,(struct sockaddr*) &from, (int *) &fromlen);
-#else
-		status = recvfrom(sock, buffer, sizeof(buffer), 0,(struct sockaddr*) &from, &fromlen);
-#endif
-		if (status >= 1) {
-			cout << "Got data from recvfrom" << endl;
-			RecvData(buffer, status, from.sin_addr.s_addr, from.sin_port);
-		}
-		else {
-			break;
-		}
-	}
-
-	map <string, EQStream*>::iterator connection;
-	for (connection = connection_list.begin( ); connection != connection_list.end( );)
-	{
-		if(!connection->second)
-		{
-			map <string, EQStream*>::iterator tmp=connection;
-			connection++;
-			connection_list.erase(tmp);
-			continue;
-		}
-		EQStream* eqs_data = connection->second; 
-		if (eqs_data->IsFree() && (!eqs_data->CheckNetActive())) { 
-			map <string, EQStream*>::iterator tmp=connection;
-			connection++;
-			safe_delete(eqs_data);
-			connection_list.erase(tmp);
-		} 
-		else if(!eqs_data->RunLoop) {
-			eqs_data->Process(sock);
-			connection++;
-		}
-	}
-}
-
-void EQStreamServer::RecvData(uchar* data, uint32 size, uint32 irIP, uint16 irPort) {
-/*
-	CHANGE HISTORY
-
-	Version		Author		Date		Comment
-	1			Unknown		Unknown		Initial Revision
-	2			Joolz		05-Jan-2003	Optimised
-	3			Quagmire	05-Feb-2003	Changed so 2 connection objects wouldnt be created for the same ip/port pair, often happened
-*/
-
-	// Check for invalid data
-	if (!data || size <= 4) return;
-	//if (CRC32::Generate(data, size-4) != ntohl(*((uint32*) &data[size-4]))) {
-#if EQN_DEBUG_Error >= 1
-		//cout << "Incomming Packet failed checksum" << endl;
-#endif
-		//return;
-	//}
-
-	char temp[25];
-	sprintf(temp,"%lu:%u",(unsigned long)irIP,irPort);
-	cout << "Data from " << temp << endl;
-	EQStream* tmp = NULL;
-	map <string, EQStream*>::iterator connection;
-	if ((connection=connection_list.find(temp))!=connection_list.end())
-		tmp=connection->second;
-	if(tmp != NULL && tmp->GetrPort() == irPort)
-	{
-		tmp->RecvData(data, size);
-		return;
-	}
-	else if(tmp != NULL  && tmp->GetrPort() != irPort)
-	{
-		printf("Conflicting IPs & Ports: IP %i and Port %i is conflicting with IP %i and Port %i\n",irIP,irPort,tmp->GetrIP(),tmp->GetrPort());
-		return;
-	}
-
-	if (data[1]==0x01) { 
-		cout << "New EQStream Connection." << endl;
-		EQStream* tmp = new EQStream(irIP, irPort);
-		tmp->RecvData(data, size);
-		connection_list[temp]=tmp;
-		if (connection_list.find(temp)==connection_list.end()) {
-			cerr <<"Could not find new connection we just added!" << endl;
-		}
-		MNewQueue.lock();
-		NewQueue.push(tmp);
-		MNewQueue.unlock();
-		return;
-	}
-#if EQN_DEBUG >= 4
-	struct in_addr	in;
-	in.s_addr = irIP;
-	cout << "WARNING: Stray packet? " << inet_ntoa(in) << ":" << irPort << endl;
-#endif
-}
-
-EQStream* EQStreamServer::NewQueuePop() {
-	EQStream* ret = 0;
-	MNewQueue.lock();
-	if (!NewQueue.empty()) {
-		ret = NewQueue.front();
-		NewQueue.pop();
-	}
-	MNewQueue.unlock();
-	return ret;
-}
-
-#ifdef WIN32
-	void EQStreamServerLoop(void* tmp)
-#else
-	void* EQStreamServerLoop(void* tmp)
-#endif
-{
-#ifdef WIN32
-	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
-#endif
-	EQStreamServer* eqns = (EQStreamServer*) tmp;
-	eqns->MLoopRunning.lock();
-	while (eqns->RunLoop) {
-		{
-			_CP(EQStreamServerLoop);
-			eqns->Process();
-		}
-		Sleep(1);
-	}
-	eqns->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-
-#ifdef WIN32
-	void EQStreamInLoop(void* tmp)
-#else
-	void* EQStreamInLoop(void* tmp)
-#endif
-{
-	EQStream* eqs = (EQStream*) tmp;
-#ifdef _DEBUG
-	if (eqs->ConnectionType != Outgoing) {
-		ThrowError("EQStreamInLoop: eqs->ConnectionType != Outgoing");
-	}
-#endif
-	eqs->MLoopRunning.lock();
-	Timer* tmp_timer = new Timer(100);
-	tmp_timer->Start();
-	while (eqs->RunLoop) {
-		{
-			_CP(EQStreamInLoop);
-			if(tmp_timer->Check())
-				eqs->DoRecvData();
-		}
-		Sleep(1);
-	}
-	safe_delete(tmp_timer);
-	eqs->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-
-#ifdef WIN32
-	void EQStreamOutLoop(void* tmp)
-#else
-	void* EQStreamOutLoop(void* tmp)
-#endif
-{
-	EQStream* eqs = (EQStream*) tmp;
-#ifdef _DEBUG
-	if (eqs->ConnectionType != Outgoing) {
-		ThrowError("EQStreamOutLoop: eqs->ConnectionType != Outgoing");
-	}
-#endif
-	eqs->MLoopRunning.lock();
-	Timer* tmp_timer = new Timer(100);
-	tmp_timer->Start();
-	while (eqs->RunLoop) {
-		{
-			_CP(EQStreamOutLoop);
-			if(tmp_timer->Check())
-				eqs->Process(eqs->outsock);
-		}
-		Sleep(1);
-	}
-	safe_delete(tmp_timer);
-	eqs->MLoopRunning.unlock();
-#ifdef WIN32
-	_endthread();
-#else
-	return 0;
-#endif
-}
-
@@ -1,121 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
-
-    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 EQNETWORK_H
-#define EQNETWORK_H
-
-#include "../common/debug.h"
-
-//uncomment this to enable the packet profiler. Counts the number
-//of each type of packet sent or received on a connection.
-#ifdef ZONE
-//#define PACKET_PROFILER 1
-#endif
-
-#include <string.h>
-#include <map>
-#include <list>
-#include <queue>
-using namespace std;
-
-#include "../common/types.h"
-#include "../common/timer.h"
-#include "../common/linked_list.h"
-#include "../common/queue.h"
-#include "../common/Mutex.h"
-#include "../common/packet_functions.h"
-#include "EQStream.h"
-#ifdef PACKET_PROFILER
-#include "../common/rdtsc.h"
-#endif
-
-#define EQNC_TIMEOUT	60000
-#define NAS_TIMER	100
-#define KA_TIMER	400 /* keeps the lag bar constant */
-#define MAX_HEADER_SIZE	39 // Quag: 39 is the max header + opcode + crc32 + unknowns size
-
-class EQStreamServer;
-class EQStream;
-class EQStreamPacket;
-class EQStreamFragmentGroupList;
-class EQStreamFragmentGroup;
-typedef EQStreamServer				EQNServer;
-typedef EQStream			EQNConnection;
-typedef EQStreamPacket				EQNPacket;
-typedef EQStreamFragmentGroupList	EQNFragmentGroupList;
-typedef EQStreamFragmentGroup		EQNFragmentGroup;
-
-#define	FLAG_COMPRESSED 0x1000
-#define	FLAG_COMBINED	0x2000
-#define	FLAG_ENCRYPTED	0x4000
-#define	FLAG_IMPLICIT	0x8000
-#define FLAG_ALL		0xF000
-#define StripFlags(x)	(x & ~FLAG_ALL)
-
-// Optimistic compression, used for guessing pre-alloc size on debug output
-#define BEST_COMPR_RATIO 300
-
-enum eappCompressed { appNormal, appInflated, appDeflated };
-
-#ifdef WIN32
-	void EQStreamServerLoop(void* tmp);
-	void EQStreamInLoop(void* tmp);
-	void EQStreamOutLoop(void* tmp);
-#else
-	void* EQStreamServerLoop(void* tmp);
-	void* EQStreamInLoop(void* tmp);
-	void* EQStreamOutLoop(void* tmp);
-#endif
-class EQStreamServer {
-public:
-	EQStreamServer(uint16 iPort = 0);
-	virtual ~EQStreamServer();
-
-	bool	Open(uint16 iPort = 0);			// opens the port
-	void	Close();	// closes the port
-	void	KillAll();						// kills all clients
-	inline uint16	GetPort()		{ return pPort; }
-
-	EQStream* NewQueuePop();
-protected:
-#ifdef WIN32
-	friend void EQStreamServerLoop(void* tmp);
-#else
-	friend void* EQStreamServerLoop(void* tmp);
-#endif
-	void		Process();
-	bool		IsOpen();
-	void		SetOpen(bool iOpen);
-	bool		RunLoop;
-	Mutex		MLoopRunning;
-private:
-	void		RecvData(uchar* data, uint32 size, uint32 irIP, uint16 irPort);
-#ifdef WIN32
-	SOCKET	sock;
-#else
-	int		sock;
-#endif
-	uint16	pPort;
-	bool	pOpen;
-	Mutex	MNewQueue;
-	Mutex	MOpen;
-
-	map<string,EQStream*> connection_list;
-	queue<EQStream *>		NewQueue;
-};
-
-#endif
@@ -1,650 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
-
-    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 "../common/debug.h"
-#include "MiscFunctions.h"
-#include <string.h>
-#include <time.h>
-#include <math.h>
-#ifndef WIN32
-#include <netinet/in.h>
-#include <sys/socket.h>
-#endif
-#include <iostream>
-#include <iomanip>
-#ifdef _WINDOWS
-	#include <io.h>
-#endif
-#include "../common/timer.h"
-#include "../common/seperator.h"
-
-using namespace std;
-
-#ifdef _WINDOWS
-	#include <windows.h>
-
-	#define snprintf	_snprintf
-#if (_MSC_VER < 1500)
-	#define vsnprintf	_vsnprintf
-#endif
-	#define strncasecmp	_strnicmp
-	#define strcasecmp  _stricmp
-#else
-	#include <stdlib.h>
-	#include <ctype.h>
-	#include <stdarg.h>
-	#include <sys/types.h>
-	#include <sys/time.h>
-#ifdef FREEBSD //Timothy Whitman - January 7, 2003
-       #include <sys/socket.h>
-       #include <netinet/in.h>
- #endif
-	#include <sys/stat.h>
-	#include <unistd.h>
-	#include <netdb.h>
-	#include <errno.h>
-#endif
-
-#ifndef va_copy
-	#define va_copy(d,s) ((d) = (s))
-#endif
-
-static bool WELLRNG_init = false;
-static int state_i = 0;
-static unsigned int STATE[R];
-static unsigned int z0, z1, z2;
-unsigned int (*WELLRNG19937)(void);
-static unsigned int case_1 (void);
-static unsigned int case_2 (void);
-static unsigned int case_3 (void);
-static unsigned int case_4 (void);
-static unsigned int case_5 (void);
-static unsigned int case_6 (void);
-uint32 rnd_hash(time_t t, clock_t c);
-void oneseed(const uint32 seed);
-
-void CoutTimestamp(bool ms) {
-	time_t rawtime;
-	struct tm* gmt_t;
-	time(&rawtime);
-	gmt_t = gmtime(&rawtime);
-
-    struct timeval read_time;	
-    gettimeofday(&read_time,0);
-
-	cout << (gmt_t->tm_year + 1900) << "/" << setw(2) << setfill('0') << (gmt_t->tm_mon + 1) << "/" << setw(2) << setfill('0') << gmt_t->tm_mday << " " << setw(2) << setfill('0') << gmt_t->tm_hour << ":" << setw(2) << setfill('0') << gmt_t->tm_min << ":" << setw(2) << setfill('0') << gmt_t->tm_sec;
-	if (ms)
-		cout << "." << setw(3) << setfill('0') << (read_time.tv_usec / 1000);
-	cout << " GMT";
-}
-
-// normal strncpy doesnt put a null term on copied strings, this one does
-// ref: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcecrt/htm/_wcecrt_strncpy_wcsncpy.asp
-char* strn0cpy(char* dest, const char* source, uint32 size) {
-	if (!dest)
-		return 0;
-	if (size == 0 || source == 0) {
-		dest[0] = 0;
-		return dest;
-	}
-	strncpy(dest, source, size);
-	dest[size - 1] = 0;
-	return dest;
-}
-
-// String N w/null Copy Truncated?
-// return value =true if entire string(source) fit, false if it was truncated
-bool strn0cpyt(char* dest, const char* source, uint32 size) {
-	if (!dest)
-		return 0;
-	if (size == 0 || source == 0) {
-		dest[0] = 0;
-		return false;
-	}
-	strncpy(dest, source, size);
-	dest[size - 1] = 0;
-	return (bool) (source[strlen(dest)] == 0);
-}
-
-const char *MakeUpperString(const char *source) {
-    static char str[128];
-    if (!source)
-	    return NULL;
-    MakeUpperString(source, str);
-    return str;
-}
-
-void MakeUpperString(const char *source, char *target) {
-    if (!source || !target) {
-	*target=0;
-        return;
-    }
-    while (*source)
-    {
-        *target = toupper(*source);
-        target++;source++;
-    }
-    *target = 0;
-}
-
-const char *MakeLowerString(const char *source) {
-    static char str[128];
-    if (!source)
-	    return NULL;
-    MakeLowerString(source, str);
-    return str;
-}
-
-void MakeLowerString(const char *source, char *target) {
-    if (!source || !target) {
-	*target=0;
-        return;
-    }
-    while (*source)
-    {
-        *target = tolower(*source);
-        target++;source++;
-    }
-    *target = 0;
-}
-
-int MakeAnyLenString(char** ret, const char* format, ...) {
-	int buf_len = 128;
-    int chars = -1;
-	va_list argptr, tmpargptr;
-	va_start(argptr, format);
-	while (chars == -1 || chars >= buf_len) {
-		safe_delete_array(*ret);
-		if (chars == -1)
-			buf_len *= 2;
-		else
-			buf_len = chars + 1;
-		*ret = new char[buf_len];
-		va_copy(tmpargptr, argptr);
-		chars = vsnprintf(*ret, buf_len, format, tmpargptr);
-	}
-	va_end(argptr);
-	return chars;
-}
-
-uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...) {
-	if (*bufsize == 0)
-		*bufsize = 256;
-	if (*ret == 0)
-		*strlen = 0;
-    int chars = -1;
-	char* oldret = 0;
-	va_list argptr, tmpargptr;
-	va_start(argptr, format);
-	while (chars == -1 || chars >= (int32)(*bufsize-*strlen)) {
-		if (chars == -1)
-			*bufsize += 256;
-		else
-			*bufsize += chars + 25;
-		oldret = *ret;
-		*ret = new char[*bufsize];
-		if (oldret) {
-			if (*strlen)
-				memcpy(*ret, oldret, *strlen);
-			safe_delete_array(oldret);
-		}
-		va_copy(tmpargptr, argptr);
-		chars = vsnprintf(&(*ret)[*strlen], (*bufsize-*strlen), format, tmpargptr);
-	}
-	va_end(argptr);
-	*strlen += chars;
-	return *strlen;
-}
-
-uint32 hextoi(char* num) {
-	int len = strlen(num);
-	if (len < 3)
-		return 0;
-
-	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
-		return 0;
-
-	uint32 ret = 0;
-	int mul = 1;
-	for (int i=len-1; i>=2; i--) {
-		if (num[i] >= 'A' && num[i] <= 'F')
-			ret += ((num[i] - 'A') + 10) * mul;
-		else if (num[i] >= 'a' && num[i] <= 'f')
-			ret += ((num[i] - 'a') + 10) * mul;
-		else if (num[i] >= '0' && num[i] <= '9')
-			ret += (num[i] - '0') * mul;
-		else
-			return 0;
-		mul *= 16;
-	}
-	return ret;
-}
-
-uint64 hextoi64(char* num) {
-	int len = strlen(num);
-	if (len < 3)
-		return 0;
-
-	if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X'))
-		return 0;
-
-	uint64 ret = 0;
-	int mul = 1;
-	for (int i=len-1; i>=2; i--) {
-		if (num[i] >= 'A' && num[i] <= 'F')
-			ret += ((num[i] - 'A') + 10) * mul;
-		else if (num[i] >= 'a' && num[i] <= 'f')
-			ret += ((num[i] - 'a') + 10) * mul;
-		else if (num[i] >= '0' && num[i] <= '9')
-			ret += (num[i] - '0') * mul;
-		else
-			return 0;
-		mul *= 16;
-	}
-	return ret;
-}
-
-bool atobool(char* iBool) {
-	if (!strcasecmp(iBool, "true"))
-		return true;
-	if (!strcasecmp(iBool, "false"))
-		return false;
-	if (!strcasecmp(iBool, "yes"))
-		return true;
-	if (!strcasecmp(iBool, "no"))
-		return false;
-	if (!strcasecmp(iBool, "on"))
-		return true;
-	if (!strcasecmp(iBool, "off"))
-		return false;
-	if (!strcasecmp(iBool, "enable"))
-		return true;
-	if (!strcasecmp(iBool, "disable"))
-		return false;
-	if (!strcasecmp(iBool, "enabled"))
-		return true;
-	if (!strcasecmp(iBool, "disabled"))
-		return false;
-	if (!strcasecmp(iBool, "y"))
-		return true;
-	if (!strcasecmp(iBool, "n"))
-		return false;
-	if (atoi(iBool))
-		return true;
-	return false;
-}
-
-int32 filesize(FILE* fp) {
-#ifdef _WINDOWS
-	return _filelength(_fileno(fp));
-#else
-	struct stat file_stat;
-	fstat(fileno(fp), &file_stat);
-	return (int32) file_stat.st_size;
-/*	uint32 tmp = 0;
-	while (!feof(fp)) {
-		fseek(fp, tmp++, SEEK_SET);
-	}
-	return tmp;*/
-#endif
-}
-
-uint32 ResolveIP(const char* hostname, char* errbuf) {
-#ifdef _WINDOWS
-	static InitWinsock ws;
-#endif
-	if (errbuf)
-		errbuf[0] = 0;
-	if (hostname == 0) {
-		if (errbuf)
-			snprintf(errbuf, ERRBUF_SIZE, "ResolveIP(): hostname == 0");
-		return 0;
-	}
-    struct sockaddr_in	server_sin;
-#ifdef _WINDOWS
-	PHOSTENT phostent = NULL;
-#else
-	struct hostent *phostent = NULL;
-#endif
-	server_sin.sin_family = AF_INET;
-	if ((phostent = gethostbyname(hostname)) == NULL) {
-#ifdef _WINDOWS
-		if (errbuf)
-			snprintf(errbuf, ERRBUF_SIZE, "Unable to get the host name. Error: %i", WSAGetLastError());
-#else
-		if (errbuf)
-			snprintf(errbuf, ERRBUF_SIZE, "Unable to get the host name. Error: %s", strerror(errno));
-#endif
-		return 0;
-	}
-#ifdef _WINDOWS
-	memcpy ((char FAR *)&(server_sin.sin_addr), phostent->h_addr, phostent->h_length);
-#else
-	memcpy ((char*)&(server_sin.sin_addr), phostent->h_addr, phostent->h_length);
-#endif
-	return server_sin.sin_addr.s_addr;
-}
-
-bool ParseAddress(const char* iAddress, uint32* oIP, uint16* oPort, char* errbuf) {
-	Seperator sep(iAddress, ':', 2, 250, false, 0, 0);
-	if (sep.argnum == 1 && sep.IsNumber(1)) {
-		*oIP = ResolveIP(sep.arg[0], errbuf);
-		if (*oIP == 0)
-			return false;
-		if (oPort)
-			*oPort = atoi(sep.arg[1]);
-		return true;
-	}
-	return false;
-}
-
-#ifdef _WINDOWS
-InitWinsock::InitWinsock() {
-	WORD version = MAKEWORD (1,1);
-	WSADATA wsadata;
-	WSAStartup (version, &wsadata);
-}
-
-InitWinsock::~InitWinsock() {
-	WSACleanup();
-}
-
-#endif
-
-
-const char * itoa(int num) {
-		static char temp[_ITOA_BUFLEN];
-		memset(temp,0,_ITOA_BUFLEN);
-		snprintf(temp,_ITOA_BUFLEN,"%d",num);
-		return temp;
-}
-
-#ifndef WIN32
-const char * itoa(int num, char* a,int b) {
-		static char temp[_ITOA_BUFLEN];
-		memset(temp,0,_ITOA_BUFLEN);
-		snprintf(temp,_ITOA_BUFLEN,"%d",num);
-		return temp;
-		return temp;
-}
-#endif
-
-/* 
- * generate a random integer in the range low-high this
- * should be used instead of the rand()%limit method
- */
-int MakeRandomInt(int low, int high)
-{
-	_CP(MakeRandomInt);
-	if(low >= high)
-		return(low);
-
-	//return (rand()%(high-low+1) + (low));
-        if(!WELLRNG_init) {
-		WELLRNG_init = true;
-		oneseed( rnd_hash( time(NULL), clock() ) );
-		WELLRNG19937 = case_1;
-	}
-	unsigned int randomnum = ((WELLRNG19937)());
-	if(randomnum == 0xffffffffUL)
-		return high;
-	return int ((randomnum / (double)0xffffffffUL) * (high - low + 1) + low);
-}
-
-double MakeRandomFloat(double low, double high)
-{
-	_CP(MakeRandomFloat);
-	if(low >= high)
-		return(low);
-
-	//return (rand() / (double)RAND_MAX * (high - low) + low);
-        if(!WELLRNG_init) {
-		WELLRNG_init = true;
-		oneseed( rnd_hash( time(NULL), clock() ) );
-		WELLRNG19937 = case_1;
-	}
-	return ((WELLRNG19937)() / (double)0xffffffffUL * (high - low) + low);
-}
-
-uint32 rnd_hash( time_t t, clock_t c )
-{
-        // Get a uint32 from t and c
-        // Better than uint32(x) in case x is floating point in [0,1]
-        // Based on code by Lawrence Kirby (fred@genesis.demon.co.uk)
-        
-        static uint32 differ = 0;  // guarantee time-based seeds will change
-        
-        uint32 h1 = 0;
-        unsigned char *p = (unsigned char *) &t;
-        for( size_t i = 0; i < sizeof(t); ++i )
-        {
-                h1 *= 255 + 2U;
-                h1 += p[i];
-        }
-        uint32 h2 = 0;
-        p = (unsigned char *) &c;
-        for( size_t j = 0; j < sizeof(c); ++j )
-        {
-                h2 *= 255 + 2U;
-                h2 += p[j];
-        }
-        return ( h1 + differ++ ) ^ h2;
-}
-
-void oneseed( const uint32 seed )
-{
-        // Initialize generator state with seed
-        // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
-        // In previous versions, most significant bits (MSBs) of the seed affect
-        // only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
-        register int j = 0;
-        STATE[j] = seed & 0xffffffffUL;
-	for (j = 1; j < R; j++)
-        {
-                STATE[j] = ( 1812433253UL * ( STATE[j-1] ^ (STATE[j-1] >> 30) ) + j ) & 0xffffffffUL;
-        }
-}
-
-// WELL RNG code
-
-/* ***************************************************************************** */
-/* Copyright:      Francois Panneton and Pierre L'Ecuyer, University of Montreal */
-/*                 Makoto Matsumoto, Hiroshima University                        */
-/* Notice:         This code can be used freely for personal, academic,          */
-/*                 or non-commercial purposes. For commercial purposes,          */
-/*                 please contact P. L'Ecuyer at: lecuyer@iro.UMontreal.ca       */
-/*                 A modified "maximally equidistributed" implementation         */
-/*                 by Shin Harase, Hiroshima University.                         */
-/* ***************************************************************************** */
-
-unsigned int case_1 (void){
-   // state_i == 0
-   z0 = (VRm1Under & MASKL) | (VRm2Under & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1);
-   z2 = MAT3POS (9, VM2) ^ MAT0POS (1, VM3);
-   newV1      = z1 ^ z2;
-   newV0Under = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i = R - 1;
-   WELLRNG19937 = case_3;
-   return (STATE[state_i] ^ (newVM2Over & BITMASK));
-}
-
-static unsigned int case_2 (void){
-   // state_i == 1
-   z0 = (VRm1 & MASKL) | (VRm2Under & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1);
-   z2 = MAT3POS (9, VM2) ^ MAT0POS (1, VM3);
-   newV1 = z1 ^ z2;
-   newV0 = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i = 0;
-   WELLRNG19937 = case_1;
-   return (STATE[state_i] ^ (newVM2 & BITMASK));
-}
-
-static unsigned int case_3 (void){
-   // state_i+M1 >= R
-   z0 = (VRm1 & MASKL) | (VRm2 & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1Over);
-   z2 = MAT3POS (9, VM2Over) ^ MAT0POS (1, VM3Over);
-   newV1 = z1 ^ z2;
-   newV0 = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i--;
-   if (state_i + M1 < R)
-      WELLRNG19937 = case_5;
-   return (STATE[state_i] ^ (newVM2Over & BITMASK));
-}
-
-static unsigned int case_4 (void){
-   // state_i+M3 >= R
-   z0 = (VRm1 & MASKL) | (VRm2 & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1);
-   z2 = MAT3POS (9, VM2) ^ MAT0POS (1, VM3Over);
-   newV1 = z1 ^ z2;
-   newV0 = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i--;
-   if (state_i + M3 < R)
-      WELLRNG19937 = case_6;
-   return (STATE[state_i] ^ (newVM2 & BITMASK));
-}
-
-static unsigned int case_5 (void){
-   // state_i+M2 >= R
-   z0 = (VRm1 & MASKL) | (VRm2 & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1);
-   z2 = MAT3POS (9, VM2Over) ^ MAT0POS (1, VM3Over);
-   newV1 = z1 ^ z2;
-   newV0 = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i--;
-   if (state_i + M2 < R)
-      WELLRNG19937 = case_4;
-	  return (STATE[state_i] ^ (newVM2Over & BITMASK));
-}
-
-static unsigned int case_6 (void){
-   // 2 <= state_i <= (R - M3 - 1)
-   z0 = (VRm1 & MASKL) | (VRm2 & MASKU);
-   z1 = MAT0NEG (-25, V0) ^ MAT0POS (27, VM1);
-   z2 = MAT3POS (9, VM2) ^ MAT0POS (1, VM3);
-   newV1 = z1 ^ z2;
-   newV0 = MAT1 (z0) ^ MAT0NEG (-9, z1) ^ MAT0NEG (-21, z2) ^ MAT0POS (21, newV1);
-   state_i--;
-   if (state_i == 1)
-      WELLRNG19937 = case_2;
-   return (STATE[state_i] ^ (newVM2 & BITMASK));
-}
-
-// end WELL RNG code
-
-// solar: removes the crap and turns the underscores into spaces.
-char *CleanMobName(const char *in, char *out)
-{
-	unsigned i, j;
-	
-	for(i = j = 0; i < strlen(in); i++)
-	{
-		// convert _ to space.. any other conversions like this?  I *think* this
-		// is the only non alpha char that's not stripped but converted.
-		if(in[i] == '_')
-		{
-			out[j++] = ' ';
-		}
-		else
-		{
-			if(isalpha(in[i]) || (in[i] == '`'))	// numbers, #, or any other crap just gets skipped
-				out[j++] = in[i];
-		}
-	}
-	out[j] = 0;	// terimnate the string before returning it
-	return out;
-}
-
-const char *ConvertArray(int input, char *returnchar)
-{
-	sprintf(returnchar, "%i" ,input);
-	return returnchar;
-}
-
-const char *ConvertArrayF(float input, char *returnchar)
-{
-	sprintf(returnchar, "%0.2f", input);
-	return returnchar;
-}
-
-float EQ13toFloat(int d)
-{
-	return ( float(d)/float(1<<2));
-}
-
-float NewEQ13toFloat(int d)
-{
-	return ( float(d)/float(1<<6));
-}
-
-float EQ19toFloat(int d)
-{
-	return ( float(d)/float(1<<3));
-}
-
-int FloatToEQ13(float d)
-{
-	return int(d*float(1<<2));
-}
-
-int NewFloatToEQ13(float d)
-{
-	return int(d*float(1<<6));
-}
-
-int FloatToEQ19(float d)
-{
-	return int(d*float(1<<3));
-}
-
-/*
-	Heading of 0 points in the pure positive Y direction
-
-*/
-int FloatToEQH(float d)
-{
-	return(int((360.0f - d) * float(1<<11)) / 360);
-}
-
-float EQHtoFloat(int d)
-{
-	return(360.0f - float((d * 360) >> 11));
-}
-
-void RemoveApostrophes(std::string &s)
-{
-	for(unsigned int i = 0; i < s.length(); ++i)
-		if(s[i] == '\'')
-			 s[i] = '_';
-}
-
-char *RemoveApostrophes(const char *s)
-{
-	char *NewString = new char[strlen(s) + 1];
-
-	strcpy(NewString, s);
-
-	for(unsigned int i = 0 ; i < strlen(NewString); ++i)
-		if(NewString[i] == '\'')
-			 NewString[i] = '_';
-
-	return NewString;
-}
-
@@ -1,171 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
-
-    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 MISCFUNCTIONS_H
-#define MISCFUNCTIONS_H
-
-#include "types.h"
-#include <stdio.h>
-#include <ctype.h>
-#include <string>
-#include <time.h>
-
-
-#ifndef ERRBUF_SIZE
-#define ERRBUF_SIZE		1024
-#endif
-
-// These are helper macros for dealing with packets of variable length, typically those that contain
-// variable length strings where it is not convenient to use a fixed length struct.
-//
-#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, String); Buffer += strlen(String) + 1; }
-#define VARSTRUCT_ENCODE_INTSTRING(Buffer, Number) { sprintf(Buffer, "%i", Number); Buffer += strlen(Buffer) + 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)) \
-	{ \
-		LogFile->write(EQEMuLog::Debug, "Size mismatch in " #OPCode " expected %i got %i", sizeof(StructName), Packet->size); \
-		DumpPacket(Packet); \
-		return; \
-	}
-
-// Definitions for WELLRNG
-//
-#define W 32
-#define R 624
-#define DISCARD 31
-#define MASKU (0xffffffffU>>(W-DISCARD))
-#define MASKL (~MASKU)
-#define M1 70
-#define M2 179
-#define M3 449
-
-#define MAT0POS(t,v) (v^(v>>t))
-#define MAT0NEG(t,v) (v^(v<<(-(t))))
-#define MAT1(v) v
-#define MAT3POS(t,v) (v>>t)
-
-#define V0            STATE[state_i]
-#define VM1Over       STATE[state_i+M1-R]
-#define VM1           STATE[state_i+M1]
-#define VM2Over       STATE[state_i+M2-R]
-#define VM2           STATE[state_i+M2]
-#define VM3Over       STATE[state_i+M3-R]
-#define VM3           STATE[state_i+M3]
-#define VRm1          STATE[state_i-1]
-#define VRm1Under     STATE[state_i+R-1]
-#define VRm2          STATE[state_i-2]
-#define VRm2Under     STATE[state_i+R-2]
-
-#define newV0         STATE[state_i-1]
-#define newV0Under    STATE[state_i-1+R]
-#define newV1         STATE[state_i]
-#define newVRm1       STATE[state_i-2]
-#define newVRm1Under  STATE[state_i-2+R]
-
-#define newVM2Over    STATE[state_i+M2-R+1]
-#define newVM2        STATE[state_i+M2+1]
-
-#define BITMASK 0x41180000
-
-//////////////////////////////////////////////////////////////////////
-//
-//  MakeUpperString
-//   i     : source - allocated null-terminated string
-//   return: pointer to static buffer with the target string
-const char *MakeUpperString(const char *source);
-const char *MakeLowerString(const char *source);
-//////////////////////////////////////////////////////////////////////
-//
-//  MakeUpperString
-//   i : source - allocated null-terminated string
-//   io: target - allocated buffer, at least of size strlen(source)+1
-void MakeUpperString(const char *source, char *target);
-void MakeLowerString(const char *source, char *target);
-
-
-int		MakeAnyLenString(char** ret, const char* format, ...);
-uint32	AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...);
-uint32	hextoi(char* num);
-uint64	hextoi64(char* num);
-bool	atobool(char* iBool);
-int32	filesize(FILE* fp);
-uint32	ResolveIP(const char* hostname, char* errbuf = 0);
-bool	ParseAddress(const char* iAddress, uint32* oIP, uint16* oPort, char* errbuf = 0);
-void	CoutTimestamp(bool ms = true);
-char*	strn0cpy(char* dest, const char* source, uint32 size);
-		// return value =true if entire string(source) fit, false if it was truncated
-bool	strn0cpyt(char* dest, const char* source, uint32 size);
-int	MakeRandomInt(int low, int high);
-double	MakeRandomFloat(double low, double high);
-char *CleanMobName(const char *in, char *out);
-const char *ConvertArray(int input, char *returnchar);
-const char *ConvertArrayF(float input, char *returnchar);
-float EQ13toFloat(int d);
-float NewEQ13toFloat(int d);
-float EQ19toFloat(int d);
-float EQHtoFloat(int d);
-int FloatToEQ13(float d);
-int NewFloatToEQ13(float d);
-int FloatToEQ19(float d);
-int FloatToEQH(float d);
-void RemoveApostrophes(std::string &s);
-char *RemoveApostrophes(const char *s);
-
-
-
-#define _ITOA_BUFLEN	25
-const char *itoa(int num);	//not thread safe
-#ifndef _WINDOWS
-const char *itoa(int num, char* a,int b);
-#endif
-
-class InitWinsock {
-public:
-	InitWinsock();
-	~InitWinsock();
-};
-
-template<class T> class AutoDelete {
-public:
-	AutoDelete(T** iVar, T* iSetTo = 0) {
-		init(iVar, iSetTo);
-	}
-	AutoDelete() { pVar = NULL; }
-	void init(T** iVar, T* iSetTo = 0)
-	{
-		pVar = iVar;
-		if (iSetTo)
-			*pVar = iSetTo;
-	}
-	~AutoDelete() {
-		if(pVar != NULL)
-			safe_delete(*pVar);
-	}
-	void ReallyClearIt() {
-		pVar = NULL;
-	}
-private:
-	T** pVar;
-};
-
-#endif
-
@@ -1,117 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#include "SharedLibrary.h"
-#include <stdio.h>
-
-#ifdef _WINDOWS
-	#define snprintf	_snprintf
-#if (_MSC_VER < 1500)
-	#define vsnprintf	_vsnprintf
-#endif
-	#define strncasecmp	_strnicmp
-	#define strcasecmp  _stricmp
-
-	#define EmuLibName "EMuShareMem"
-#else
-	#define EmuLibName "libEMuShareMem.so"
-
-	#include "../common/unix.h"
-	#include <dlfcn.h>
-    #define GetProcAddress(a,b) dlsym(a,b)
-	#define LoadLibrary(a) dlopen(a, RTLD_NOW) 
-	#define  FreeLibrary(a) dlclose(a)
-	#define GetLastError() dlerror()
-#endif
-
-SharedLibrary::SharedLibrary() {
-	hDLL = NULL;
-}
-
-SharedLibrary::~SharedLibrary() {
-	Unload();
-}
-
-bool SharedLibrary::Load(const char *name)
-{
-#ifdef _WINDOWS
-	SetLastError(0);
-#endif
-	
-	hDLL = LoadLibrary(name);
-	
-	if(!hDLL) {
-		const char *load_error = GetError();
-		fprintf(stderr, "[Error] Load Shared Library '%s' failed.  Error=%s\n", name, load_error?load_error:"Null Return, no error");
-		return false;
-	}
-#ifdef _WINDOWS
-    else { SetLastError(0); } // Clear the win9x error
-#endif
-	
-	return(true);
-}
-
-void SharedLibrary::Unload() {
-	if (hDLL != NULL) {
-		FreeLibrary(hDLL);
-#ifndef WIN32
-		const char* error;
-		if ((error = GetError()) != NULL)
-			fprintf(stderr, "FreeLibrary() error = %s", error);
-#endif
-		hDLL = NULL;
-	}
-}
-
-void *SharedLibrary::GetSym(const char *name) {
-	if (!Loaded())
-		return(NULL);
-	
-	void *r = GetProcAddress(hDLL, name);
-
-	if(GetError() != NULL)
-		r = NULL;
-
-	return(r);
-}
-
-bool SharedLibrary::GetSym(const char *name, void **sym)
-{
-	bool result=false;
-	if (Loaded()) {
-		*sym = GetProcAddress(hDLL, name);
-		result= (GetError() == NULL);
-	}
-
-	return result;
-}
-
-const char *SharedLibrary::GetError()
-{
-#ifdef _WINDOWS
-	//not thread safe, dont care.
-	static char ErrBuf[128];
-	unsigned long err = GetLastError();
-	if(err == 0)
-		return(NULL);
-	sprintf(ErrBuf, "Error #%lu", (unsigned long)err);
-	return(ErrBuf);
-#else
-	return GetLastError();
-#endif
-}
@@ -1,49 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef _SHAREDLIBRARY_H
-#define _SHAREDLIBRARY_H
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-class SharedLibrary {
-public:
-	SharedLibrary();
-	virtual ~SharedLibrary();
-	
-	//two call styles for GetSym, one returns bool, other NULL for fail
-	bool GetSym(const char *name, void **sym);
-	void *GetSym(const char *name);
-	
-	const char *GetError();
-	
-	virtual bool Load(const char *file);
-	virtual void Unload();
-	
-	inline bool	Loaded() { return (hDLL != 0); }
-	
-protected:
-#ifdef _WINDOWS
-	HINSTANCE hDLL;
-#else
-	void* hDLL;
-#endif
-};
-
-#endif
@@ -43,7 +43,7 @@ namespace SOCKETS_NAMESPACE {


 File::File()
-:m_fil(NULL)
+:m_fil(nullptr)
 {
 }

@@ -85,7 +85,7 @@ size_t File::fwrite(const char *ptr, size_t size, size_t nmemb)

 char *File::fgets(char *s, int size)
 {
-	return m_fil ? ::fgets(s, size, m_fil) : NULL;
+	return m_fil ? ::fgets(s, size, m_fil) : nullptr;
 }


@@ -46,7 +46,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include <stdarg.h>
 #include "Parse.h"
 #include "HTTPSocket.h"
-#include "../TCPConnection.h"
+#include "../tcp_connection.h"
 #include <cstdlib>
 #include <cstring>

@@ -42,7 +42,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 #include <map>
 #include <string>
-#include "../TCPConnection.h"
+#include "../tcp_connection.h"


 #ifdef SOCKETS_NAMESPACE
@@ -93,14 +93,14 @@ bool HttpdCookies::getvalue(const std::string& name,std::string& buffer) //char

 void HttpdCookies::replacevalue(const std::string& name,const std::string& value)
 {
-	COOKIE *c = NULL;
+	COOKIE *c = nullptr;
 	
 	for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
 	{
 		c = *it;
 		if (!strcasecmp(c -> name.c_str(),name.c_str()))
 			break;
-		c = NULL;
+		c = nullptr;
 	}

 	if (c)
@@ -126,14 +126,14 @@ void HttpdCookies::replacevalue(const std::string& name,int i)

 size_t HttpdCookies::getlength(const std::string& name)
 {
-	COOKIE *c = NULL;
+	COOKIE *c = nullptr;

 	for (cookie_v::iterator it = m_cookies.begin(); it != m_cookies.end(); it++)
 	{
 		c = *it;
 		if (!strcasecmp(c -> name.c_str(),name.c_str()))
 			break;
-		c = NULL;
+		c = nullptr;
 	}
 	return c ? c -> value.size() : 0;
 }
@@ -223,7 +223,7 @@ void HttpdCookies::setcookie(HTTPSocket *sock, const std::string& domain, const

 const std::string& HttpdCookies::expiredatetime()
 {
-	time_t t = time(NULL);
+	time_t t = time(nullptr);
 	struct tm * tp = gmtime(&t);
 	const char *days[7] = {"Sunday", "Monday",
 	 "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
@@ -47,7 +47,7 @@ namespace SOCKETS_NAMESPACE {

 HttpdForm::HttpdForm(IFile *infil) : raw(false)
 {
-	CGI *cgi = NULL;
+	CGI *cgi = nullptr;
 	char *c_t = getenv("CONTENT_TYPE");
 	char *c_l = getenv("CONTENT_LENGTH");
 	size_t extra = 2;
@@ -59,7 +59,7 @@ HttpdForm::HttpdForm(IFile *infil) : raw(false)
 	if (c_t && !strncmp(c_t, "multipart/form-data",19))
 	{
 		Parse pa(c_t,";=");
-		char *tempcmp = NULL;
+		char *tempcmp = nullptr;
 		size_t tc = 0;
 		size_t l = 0;
 		std::string str = pa.getword();
@@ -80,7 +80,7 @@ HttpdForm::HttpdForm(IFile *infil) : raw(false)
 			std::string content_type;
 			std::string current_name;
 			std::string current_filename;
-			char slask[200];
+			char slask[2000];
 			infil -> fgets(slask, 200);
 			while (!infil -> eof())
 			{
@@ -209,7 +209,7 @@ HttpdForm::HttpdForm(IFile *infil) : raw(false)
 #else
 						sprintf(fn,"/tmp/%s",current_filename.c_str());
 #endif
-						if ((fil = fopen(fn, "wb")) != NULL)
+						if ((fil = fopen(fn, "wb")) != nullptr)
 						{
 							infil -> fread(&c,1,1);
 							while (!infil -> eof())
@@ -353,7 +353,7 @@ HttpdForm::HttpdForm(IFile *infil) : raw(false)

 HttpdForm::HttpdForm(const std::string& buffer,size_t l) : raw(false)
 {
-	CGI *cgi = NULL;
+	CGI *cgi = nullptr;
 	char slask[8888];
 	char name[200];
 	int i = 0;
@@ -424,7 +424,7 @@ HttpdForm::HttpdForm(const std::string& buffer,size_t l) : raw(false)

 HttpdForm::~HttpdForm()
 {
-	CGI *cgi = NULL; //,*tmp;
+	CGI *cgi = nullptr; //,*tmp;

 	for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
 	{
@@ -525,7 +525,7 @@ bool HttpdForm::getnext(std::string& n,std::string& v) //char *n,size_t len,char

 int HttpdForm::getvalue(const std::string& n,std::string& v) //char *v,size_t len)
 {
-	CGI *cgi = NULL;
+	CGI *cgi = nullptr;
 	int r = 0;

 	for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
@@ -533,7 +533,7 @@ int HttpdForm::getvalue(const std::string& n,std::string& v) //char *v,size_t le
 		cgi = *it;
 		if (cgi -> name == n)
 			break;
-		cgi = NULL;
+		cgi = nullptr;
 	}
 	if (cgi)
 	{
@@ -572,7 +572,7 @@ std::string HttpdForm::getvalue(const std::string& n)

 size_t HttpdForm::getlength(const std::string& n)
 {
-	CGI *cgi = NULL;
+	CGI *cgi = nullptr;
 	size_t l;

 	for (cgi_v::iterator it = m_cgi.begin(); it != m_cgi.end(); it++)
@@ -580,7 +580,7 @@ size_t HttpdForm::getlength(const std::string& n)
 		cgi = *it;
 		if (cgi -> name == n)
 			break;
-		cgi = NULL;
+		cgi = nullptr;
 	}
 	l = cgi ? cgi -> value.size() : 0;
 	if (cgi && !raw)
@@ -64,11 +64,11 @@ std::string HttpdSocket::m_start = "";
 HttpdSocket::HttpdSocket(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
 : HTTPSocket(ID,in_socket,irIP,irPort)
 ,m_content_length(0)
-,m_file(NULL)
+,m_file(nullptr)
 ,m_received(0)
 ,m_request_id(++m_request_count)
-,m_cookies(NULL)
-,m_form(NULL)
+,m_cookies(nullptr)
+,m_form(nullptr)
 {
 	m_http_date = datetime2httpdate(GetDate());
 	if (!m_start.size())
@@ -289,7 +289,7 @@ std::string HttpdSocket::datetime2httpdate(const std::string& dt)

 std::string HttpdSocket::GetDate()
 {
-	time_t t = time(NULL);
+	time_t t = time(nullptr);
 	struct tm* tp = localtime(&t);
 	char slask[40];
 	if (tp)
@@ -315,16 +315,16 @@ void HttpdSocket::Reset()
 	if (m_file)
 	{
 		delete m_file;
-		m_file = NULL;
+		m_file = nullptr;
 	}
 	m_received = 0;
 	m_request_id = ++m_request_count;
 	if (m_cookies)
 		delete m_cookies;
-	m_cookies = NULL;
+	m_cookies = nullptr;
 	if (m_form)
 		delete m_form;
-	m_form = NULL;
+	m_form = nullptr;
 }


@@ -66,8 +66,8 @@ MemFile::MemFile(const std::string& path)
 :m_path(path)
 ,m_temporary(false)
 ,m_base(m_files[path])
-,m_current_read(NULL)
-,m_current_write(NULL)
+,m_current_read(nullptr)
+,m_current_write(nullptr)
 ,m_read_ptr(0)
 ,m_write_ptr(0)
 {
@@ -48,7 +48,7 @@ public:
 	/** File block structure. 
 		\ingroup file */
 	struct block_t {
-		block_t() : next(NULL) {}
+		block_t() : next(nullptr) {}
 		struct block_t *next;
 		char data[BLOCKSIZE];
 	};
@@ -37,7 +37,7 @@ Mime::Mime(const std::string& filename) {

 bool Mime::LoadMimeFile(const std::string& filename) {
 	FILE *fil;
-	if ((fil = fopen(filename.c_str(),"rt")) != NULL) {
+	if ((fil = fopen(filename.c_str(),"rt")) != nullptr) {
 		char * slask = new char[1000];
 		fgets(slask,1000,fil);
 		while (!feof(fil))
@@ -211,7 +211,7 @@ typedef unsigned short port_t;
 #endif

 #ifdef _THREADSAFE_SOCKETS
-#include "Mutex.h"
+#include "mutex.h"
 #include "Lock.h"
 #endif

@@ -104,7 +104,7 @@ typedef struct _tagSTACKFRAME64 {
    ADDRESS64   AddrFrame;            // frame pointer
    ADDRESS64   AddrStack;            // stack pointer
    ADDRESS64   AddrBStore;           // backing store pointer
-    PVOID       FuncTableEntry;       // pointer to pdata/fpo or NULL
+    PVOID       FuncTableEntry;       // pointer to pdata/fpo or nullptr
    DWORD64     Params[4];            // possible arguments to the function
    BOOL        Far;                  // WOW far call
    BOOL        Virtual;              // is this a virtual frame?
@@ -187,44 +187,44 @@ public:
  StackWalkerInternal(StackWalker *parent, HANDLE hProcess)
  {
    m_parent = parent;
-    m_hDbhHelp = NULL;
-    pSC = NULL;
+    m_hDbhHelp = nullptr;
+    pSC = nullptr;
    m_hProcess = hProcess;
-    m_szSymPath = NULL;
-    pSFTA = NULL;
-    pSGLFA = NULL;
-    pSGMB = NULL;
-    pSGMI = NULL;
-    pSGO = NULL;
-    pSGSFA = NULL;
-    pSI = NULL;
-    pSLM = NULL;
-    pSSO = NULL;
-    pSW = NULL;
-    pUDSN = NULL;
-    pSGSP = NULL;
+    m_szSymPath = nullptr;
+    pSFTA = nullptr;
+    pSGLFA = nullptr;
+    pSGMB = nullptr;
+    pSGMI = nullptr;
+    pSGO = nullptr;
+    pSGSFA = nullptr;
+    pSI = nullptr;
+    pSLM = nullptr;
+    pSSO = nullptr;
+    pSW = nullptr;
+    pUDSN = nullptr;
+    pSGSP = nullptr;
  }
  ~StackWalkerInternal()
  {
-    if (pSC != NULL)
+    if (pSC != nullptr)
      pSC(m_hProcess);  // SymCleanup
-    if (m_hDbhHelp != NULL)
+    if (m_hDbhHelp != nullptr)
      FreeLibrary(m_hDbhHelp);
-    m_hDbhHelp = NULL;
-    m_parent = NULL;
-    if(m_szSymPath != NULL)
+    m_hDbhHelp = nullptr;
+    m_parent = nullptr;
+    if(m_szSymPath != nullptr)
      free(m_szSymPath);
-    m_szSymPath = NULL;
+    m_szSymPath = nullptr;
  }
  BOOL Init(LPCSTR szSymPath)
  {
-    if (m_parent == NULL)
+    if (m_parent == nullptr)
      return FALSE;
    // Dynamically load the Entry-Points for dbghelp.dll:
    // First try to load the newsest one from
    TCHAR szTemp[4096];
    // But before wqe do this, we first check if the ".local" file exists
-    if (GetModuleFileName(NULL, szTemp, 4096) > 0)
+    if (GetModuleFileName(nullptr, szTemp, 4096) > 0)
    {
      _tcscat_s(szTemp, _T(".local"));
      if (GetFileAttributes(szTemp) == INVALID_FILE_ATTRIBUTES)
@@ -240,7 +240,7 @@ public:
          }
        }
          // Still not found? Then try to load the 64-Bit version:
-        if ( (m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0) )
+        if ( (m_hDbhHelp == nullptr) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0) )
        {
          _tcscat_s(szTemp, _T("\\Debugging Tools for Windows 64-Bit\\dbghelp.dll"));
          if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)
@@ -250,9 +250,9 @@ public:
        }
      }
    }
-    if (m_hDbhHelp == NULL)  // if not already loaded, try to load a default-one
+    if (m_hDbhHelp == nullptr)  // if not already loaded, try to load a default-one
      m_hDbhHelp = LoadLibrary( _T("dbghelp.dll") );
-    if (m_hDbhHelp == NULL)
+    if (m_hDbhHelp == nullptr)
      return FALSE;
    pSI = (tSI) GetProcAddress(m_hDbhHelp, "SymInitialize" );
    pSC = (tSC) GetProcAddress(m_hDbhHelp, "SymCleanup" );
@@ -271,18 +271,18 @@ public:
    pSLM = (tSLM) GetProcAddress(m_hDbhHelp, "SymLoadModule64" );
    pSGSP =(tSGSP) GetProcAddress(m_hDbhHelp, "SymGetSearchPath" );

-    if ( pSC == NULL || pSFTA == NULL || pSGMB == NULL || pSGMI == NULL ||
-      pSGO == NULL || pSGSFA == NULL || pSI == NULL || pSSO == NULL ||
-      pSW == NULL || pUDSN == NULL || pSLM == NULL )
+    if ( pSC == nullptr || pSFTA == nullptr || pSGMB == nullptr || pSGMI == nullptr ||
+      pSGO == nullptr || pSGSFA == nullptr || pSI == nullptr || pSSO == nullptr ||
+      pSW == nullptr || pUDSN == nullptr || pSLM == nullptr )
    {
      FreeLibrary(m_hDbhHelp);
-      m_hDbhHelp = NULL;
-      pSC = NULL;
+      m_hDbhHelp = nullptr;
+      pSC = nullptr;
      return FALSE;
    }

    // SymInitialize
-    if (szSymPath != NULL)
+    if (szSymPath != nullptr)
      m_szSymPath = _strdup(szSymPath);
    if (this->pSI(m_hProcess, m_szSymPath, FALSE) == FALSE)
      this->m_parent->OnDbgHelpErr("SymInitialize", GetLastError(), 0);
@@ -295,7 +295,7 @@ public:
    symOptions = this->pSSO(symOptions);

    char buf[StackWalker::STACKWALK_MAX_NAMELEN] = {0};
-    if (this->pSGSP != NULL)
+    if (this->pSGSP != nullptr)
    {
      if (this->pSGSP(m_hProcess, buf, StackWalker::STACKWALK_MAX_NAMELEN) == FALSE)
        this->m_parent->OnDbgHelpErr("SymGetSearchPath", GetLastError(), 0);
@@ -458,10 +458,10 @@ private:

    // try both dlls...
    const TCHAR *dllname[] = { _T("kernel32.dll"), _T("tlhelp32.dll") };
-    HINSTANCE hToolhelp = NULL;
-    tCT32S pCT32S = NULL;
-    tM32F pM32F = NULL;
-    tM32N pM32N = NULL;
+    HINSTANCE hToolhelp = nullptr;
+    tCT32S pCT32S = nullptr;
+    tM32F pM32F = nullptr;
+    tM32N pM32N = nullptr;

    HANDLE hSnap;
    MODULEENTRY32 me;
@@ -472,18 +472,18 @@ private:
    for (i = 0; i<(sizeof(dllname) / sizeof(dllname[0])); i++ )
    {
      hToolhelp = LoadLibrary( dllname[i] );
-      if (hToolhelp == NULL)
+      if (hToolhelp == nullptr)
        continue;
      pCT32S = (tCT32S) GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
      pM32F = (tM32F) GetProcAddress(hToolhelp, "Module32First");
      pM32N = (tM32N) GetProcAddress(hToolhelp, "Module32Next");
-      if ( (pCT32S != NULL) && (pM32F != NULL) && (pM32N != NULL) )
+      if ( (pCT32S != nullptr) && (pM32F != nullptr) && (pM32N != nullptr) )
        break; // found the functions!
      FreeLibrary(hToolhelp);
-      hToolhelp = NULL;
+      hToolhelp = nullptr;
    }

-    if (hToolhelp == NULL)
+    if (hToolhelp == nullptr)
      return FALSE;

    hSnap = pCT32S( TH32CS_SNAPMODULE, pid );
@@ -534,20 +534,20 @@ private:
    DWORD cbNeeded;
    MODULEINFO mi;
    HMODULE *hMods = 0;
-    char *tt = NULL;
-    char *tt2 = NULL;
+    char *tt = nullptr;
+    char *tt2 = nullptr;
    const SIZE_T TTBUFLEN = 8096;
    int cnt = 0;

    hPsapi = LoadLibrary( _T("psapi.dll") );
-    if (hPsapi == NULL)
+    if (hPsapi == nullptr)
      return FALSE;

    pEPM = (tEPM) GetProcAddress( hPsapi, "EnumProcessModules" );
    pGMFNE = (tGMFNE) GetProcAddress( hPsapi, "GetModuleFileNameExA" );
    pGMBN = (tGMFNE) GetProcAddress( hPsapi, "GetModuleBaseNameA" );
    pGMI = (tGMI) GetProcAddress( hPsapi, "GetModuleInformation" );
-    if ( (pEPM == NULL) || (pGMFNE == NULL) || (pGMBN == NULL) || (pGMI == NULL) )
+    if ( (pEPM == nullptr) || (pGMFNE == nullptr) || (pGMBN == nullptr) || (pGMI == nullptr) )
    {
      // we couldn?t find all functions
      FreeLibrary(hPsapi);
@@ -557,7 +557,7 @@ private:
    hMods = (HMODULE*) malloc(sizeof(HMODULE) * (TTBUFLEN / sizeof HMODULE));
    tt = (char*) malloc(sizeof(char) * TTBUFLEN);
    tt2 = (char*) malloc(sizeof(char) * TTBUFLEN);
-    if ( (hMods == NULL) || (tt == NULL) || (tt2 == NULL) )
+    if ( (hMods == nullptr) || (tt == nullptr) || (tt2 == nullptr) )
      goto cleanup;

    if ( ! pEPM( hProcess, hMods, TTBUFLEN, &cbNeeded ) )
@@ -590,10 +590,10 @@ private:
    }

  cleanup:
-    if (hPsapi != NULL) FreeLibrary(hPsapi);
-    if (tt2 != NULL) free(tt2);
-    if (tt != NULL) free(tt);
-    if (hMods != NULL) free(hMods);
+    if (hPsapi != nullptr) FreeLibrary(hPsapi);
+    if (tt2 != nullptr) free(tt2);
+    if (tt != nullptr) free(tt);
+    if (hMods != nullptr) free(hMods);

    return cnt != 0;
  }  // GetModuleListPSAPI
@@ -603,7 +603,7 @@ private:
    CHAR *szImg = _strdup(img);
    CHAR *szMod = _strdup(mod);
    DWORD result = ERROR_SUCCESS;
-    if ( (szImg == NULL) || (szMod == NULL) )
+    if ( (szImg == nullptr) || (szMod == nullptr) )
      result = ERROR_NOT_ENOUGH_MEMORY;
    else
    {
@@ -611,25 +611,25 @@ private:
        result = GetLastError();
    }
    ULONGLONG fileVersion = 0;
-    if ( (m_parent != NULL) && (szImg != NULL) )
+    if ( (m_parent != nullptr) && (szImg != nullptr) )
    {
      // try to retrive the file-version:
      if ( (this->m_parent->m_options & StackWalker::RetrieveFileVersion) != 0)
      {
-        VS_FIXEDFILEINFO *fInfo = NULL;
+        VS_FIXEDFILEINFO *fInfo = nullptr;
        DWORD dwHandle;
        DWORD dwSize = GetFileVersionInfoSizeA(szImg, &dwHandle);
        if (dwSize > 0)
        {
          LPVOID vData = malloc(dwSize);
-          if (vData != NULL)
+          if (vData != nullptr)
          {
            if (GetFileVersionInfoA(szImg, dwHandle, dwSize, vData) != 0)
            {
              UINT len;
              TCHAR szSubBlock[] = _T("\\");
              if (VerQueryValue(vData, szSubBlock, (LPVOID*) &fInfo, &len) == 0)
-                fInfo = NULL;
+                fInfo = nullptr;
              else
              {
                fileVersion = ((ULONGLONG)fInfo->dwFileVersionLS) + ((ULONGLONG)fInfo->dwFileVersionMS << 32);
@@ -678,8 +678,8 @@ private:
      }
      this->m_parent->OnLoadModule(img, mod, baseAddr, size, result, szSymType, Module.LoadedImageName, fileVersion);
    }
-    if (szImg != NULL) free(szImg);
-    if (szMod != NULL) free(szMod);
+    if (szImg != nullptr) free(szImg);
+    if (szMod != nullptr) free(szMod);
    return result;
  }
 public:
@@ -695,7 +695,7 @@ public:

  BOOL GetModuleInfo(HANDLE hProcess, DWORD64 baseAddr, IMAGEHLP_MODULE64_V2 *pModuleInfo)
  {
-    if(this->pSGMI == NULL)
+    if(this->pSGMI == nullptr)
    {
      SetLastError(ERROR_DLL_INIT_FAILED);
      return FALSE;
@@ -703,7 +703,7 @@ public:
    // First try to use the larger ModuleInfo-Structure
 //    memset(pModuleInfo, 0, sizeof(IMAGEHLP_MODULE64_V3));
 //    pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V3);
-//    if (this->pSGMI_V3 != NULL)
+//    if (this->pSGMI_V3 != nullptr)
 //    {
 //      if (this->pSGMI_V3(hProcess, baseAddr, pModuleInfo) != FALSE)
 //        return TRUE;
@@ -714,7 +714,7 @@ public:
    // could not retrive the bigger structure, try with the smaller one (as defined in VC7.1)...
    pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2);
    void *pData = malloc(4096); // reserve enough memory, so the bug in v6.3.5.1 does not lead to memory-overwrites...
-    if (pData == NULL)
+    if (pData == nullptr)
    {
      SetLastError(ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
@@ -742,7 +742,7 @@ StackWalker::StackWalker(DWORD dwProcessId, HANDLE hProcess)
  this->m_hProcess = hProcess;
  this->m_sw = new StackWalkerInternal(this, this->m_hProcess);
  this->m_dwProcessId = dwProcessId;
-  this->m_szSymPath = NULL;
+  this->m_szSymPath = nullptr;
 }
 StackWalker::StackWalker(int options, LPCSTR szSymPath, DWORD dwProcessId, HANDLE hProcess)
 {
@@ -751,28 +751,28 @@ StackWalker::StackWalker(int options, LPCSTR szSymPath, DWORD dwProcessId, HANDL
  this->m_hProcess = hProcess;
  this->m_sw = new StackWalkerInternal(this, this->m_hProcess);
  this->m_dwProcessId = dwProcessId;
-  if (szSymPath != NULL)
+  if (szSymPath != nullptr)
  {
    this->m_szSymPath = _strdup(szSymPath);
    this->m_options |= SymBuildPath;
  }
  else
-    this->m_szSymPath = NULL;
+    this->m_szSymPath = nullptr;
 }

 StackWalker::~StackWalker()
 {
-  if (m_szSymPath != NULL)
+  if (m_szSymPath != nullptr)
    free(m_szSymPath);
-  m_szSymPath = NULL;
-  if (this->m_sw != NULL)
+  m_szSymPath = nullptr;
+  if (this->m_sw != nullptr)
    delete this->m_sw;
-  this->m_sw = NULL;
+  this->m_sw = nullptr;
 }

 BOOL StackWalker::LoadModules()
 {
-  if (this->m_sw == NULL)
+  if (this->m_sw == nullptr)
  {
    SetLastError(ERROR_DLL_INIT_FAILED);
    return FALSE;
@@ -781,19 +781,19 @@ BOOL StackWalker::LoadModules()
    return TRUE;

  // Build the sym-path:
-  char *szSymPath = NULL;
+  char *szSymPath = nullptr;
  if ( (this->m_options & SymBuildPath) != 0)
  {
    const size_t nSymPathLen = 4096;
    szSymPath = (char*) malloc(nSymPathLen);
-    if (szSymPath == NULL)
+    if (szSymPath == nullptr)
    {
      SetLastError(ERROR_NOT_ENOUGH_MEMORY);
      return FALSE;
    }
    szSymPath[0] = 0;
    // Now first add the (optional) provided sympath:
-    if (this->m_szSymPath != NULL)
+    if (this->m_szSymPath != nullptr)
    {
      strcat_s(szSymPath, nSymPathLen, this->m_szSymPath);
      strcat_s(szSymPath, nSymPathLen, ";");
@@ -812,7 +812,7 @@ BOOL StackWalker::LoadModules()
    }

    // Now add the path for the main-module:
-    if (GetModuleFileNameA(NULL, szTemp, nTempLen) > 0)
+    if (GetModuleFileNameA(nullptr, szTemp, nTempLen) > 0)
    {
      szTemp[nTempLen-1] = 0;
      for (char *p = (szTemp+strlen(szTemp)-1); p >= szTemp; --p)
@@ -870,7 +870,7 @@ BOOL StackWalker::LoadModules()

  // First Init the whole stuff...
  BOOL bRet = this->m_sw->Init(szSymPath);
-  if (szSymPath != NULL) free(szSymPath); szSymPath = NULL;
+  if (szSymPath != nullptr) free(szSymPath); szSymPath = nullptr;
  if (bRet == FALSE)
  {
    this->OnDbgHelpErr("Error while initializing dbghelp.dll", 0, 0);
@@ -889,14 +889,14 @@ BOOL StackWalker::LoadModules()
 // This has to be done due to a problem with the "hProcess"-parameter in x64...
 // Because this class is in no case multi-threading-enabled (because of the limitations 
 // of dbghelp.dll) it is "safe" to use a static-variable
-static StackWalker::PReadProcessMemoryRoutine s_readMemoryFunction = NULL;
-static LPVOID s_readMemoryFunction_UserData = NULL;
+static StackWalker::PReadProcessMemoryRoutine s_readMemoryFunction = nullptr;
+static LPVOID s_readMemoryFunction_UserData = nullptr;

 BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadProcessMemoryRoutine readMemoryFunction, LPVOID pUserData)
 {
  CONTEXT c;;
  CallstackEntry csEntry;
-  IMAGEHLP_SYMBOL64 *pSym = NULL;
+  IMAGEHLP_SYMBOL64 *pSym = nullptr;
  StackWalkerInternal::IMAGEHLP_MODULE64_V2 Module;
  IMAGEHLP_LINE64 Line;
  int frameNum;
@@ -904,7 +904,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
  if (m_modulesLoaded == FALSE)
    this->LoadModules();  // ignore the result...

-  if (this->m_sw->m_hDbhHelp == NULL)
+  if (this->m_sw->m_hDbhHelp == nullptr)
  {
    SetLastError(ERROR_DLL_INIT_FAILED);
    return FALSE;
@@ -913,7 +913,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
  s_readMemoryFunction = readMemoryFunction;
  s_readMemoryFunction_UserData = pUserData;

-  if (context == NULL)
+  if (context == nullptr)
  {
    // If no context is provided, capture the context
    if (hThread == GetCurrentThread())
@@ -989,7 +989,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
    // assume that either you are done, or that the stack is so hosed that the next
    // deeper frame could not be found.
    // CONTEXT need not to be suplied if imageTyp is IMAGE_FILE_MACHINE_I386!
-    if ( ! this->m_sw->pSW(imageType, this->m_hProcess, hThread, &s, &c, myReadProcMem, this->m_sw->pSFTA, this->m_sw->pSGMB, NULL) )
+    if ( ! this->m_sw->pSW(imageType, this->m_hProcess, hThread, &s, &c, myReadProcMem, this->m_sw->pSFTA, this->m_sw->pSGMB, nullptr) )
    {
      this->OnDbgHelpErr("StackWalk64", GetLastError(), s.AddrPC.Offset);
      break;
@@ -1028,7 +1028,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
      }

      // show line number info, NT5.0-method (SymGetLineFromAddr64())
-      if (this->m_sw->pSGLFA != NULL )
+      if (this->m_sw->pSGLFA != nullptr )
      { // yes, we have SymGetLineFromAddr64()
        if (this->m_sw->pSGLFA(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromLine), &Line) != FALSE)
        {
@@ -1078,7 +1078,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
          break;
        default:
          //_snprintf( ty, sizeof ty, "symtype=%ld", (long) Module.SymType );
-          csEntry.symTypeString = NULL;
+          csEntry.symTypeString = nullptr;
          break;
        }

@@ -1109,7 +1109,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, const CONTEXT *context, PReadPro
  cleanup:
    if (pSym) free( pSym );

-  if (context == NULL)
+  if (context == nullptr)
    ResumeThread(hThread);

  return TRUE;
@@ -1123,7 +1123,7 @@ BOOL __stdcall StackWalker::myReadProcMem(
    LPDWORD     lpNumberOfBytesRead
    )
 {
-  if (s_readMemoryFunction == NULL)
+  if (s_readMemoryFunction == nullptr)
  {
    SIZE_T st;
    BOOL bRet = ReadProcessMemory(hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, &st);
@@ -66,7 +66,7 @@ public:

  StackWalker(
    int options = OptionsAll, // 'int' is by design, to combine the enum-flags
-    LPCSTR szSymPath = NULL, 
+    LPCSTR szSymPath = nullptr, 
    DWORD dwProcessId = GetCurrentProcessId(), 
    HANDLE hProcess = GetCurrentProcess()
    );
@@ -86,9 +86,9 @@ public:

  BOOL ShowCallstack(
    HANDLE hThread = GetCurrentThread(), 
-    const CONTEXT *context = NULL, 
-    PReadProcessMemoryRoutine readMemoryFunction = NULL,
-    LPVOID pUserData = NULL  // optional to identify some data in the 'readMemoryFunction'-callback
+    const CONTEXT *context = nullptr, 
+    PReadProcessMemoryRoutine readMemoryFunction = nullptr,
+    LPVOID pUserData = nullptr  // optional to identify some data in the 'readMemoryFunction'-callback
    );

 #if _MSC_VER >= 1300
@@ -157,11 +157,11 @@ protected:
 #define GET_CURRENT_CONTEXT(c, contextFlags) \
  do { \
    memset(&c, 0, sizeof(CONTEXT)); \
-    EXCEPTION_POINTERS *pExp = NULL; \
+    EXCEPTION_POINTERS *pExp = nullptr; \
    __try { \
      throw 0; \
    } __except( ( (pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_EXECUTE_HANDLER)) {} \
-    if (pExp != NULL) \
+    if (pExp != nullptr) \
      memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \
      c.ContextFlags = contextFlags; \
  } while(0);
@@ -1,59 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	  You should have received a copy of the GNU General Public License
-	  along with this program; if not, write to the Free Software
-	  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef XMLParser_H
-#define XMLParser_H
-
-#include "debug.h"
-#include "tinyxml/tinyxml.h"
-#include "../common/types.h"
-
-#include <string>
-#include <map>
-using namespace std;
-
-
-
-/*
- * See note in XMLParser::ParseFile() before inheriting this class.
- */
-class XMLParser {
-public:
-	typedef void (XMLParser::*ElementHandler)(TiXmlElement *ele);
-	
-	XMLParser();
-	virtual ~XMLParser() {}
-	
-	bool ParseFile(const char *file, const char *root_ele);
-	bool ParseStatus() const { return ParseOkay; }
-	
-protected:
-	const char *ParseTextBlock(TiXmlNode *within, const char *name, bool optional = false);
-	const char *GetText(TiXmlNode *within, bool optional = false);
-
-	map<string,ElementHandler> Handlers;
-
-	bool ParseOkay;
-	
-};
-
-
-#endif
-
-
-
-
@@ -0,0 +1,190 @@
+/*
+ *  Boost Software License - Version 1.0 - August 17th, 2003
+ *  
+ *  Permission is hereby granted, free of charge, to any person or organization
+ *  obtaining a copy of the software and accompanying documentation covered by
+ *  this license (the "Software") to use, reproduce, display, distribute,
+ *  execute, and transmit the Software, and to prepare derivative works of the
+ *  Software, and to permit third-parties to whom the Software is furnished to
+ *  do so, all subject to the following:
+ *  
+ *  The copyright notices in the Software and this entire statement, including
+ *  the above license grant, this restriction and the following disclaimer,
+ *  must be included in all copies of the Software, in whole or in part, and
+ *  all derivative works of the Software, unless such copies or derivative
+ *  works are solely in the form of machine-executable object code generated by
+ *  a source language processor.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+ *  SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+ *  FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+// EQEmu::Any is a modified version of Boost::Any and as such retains the Boost licensing.
+
+#ifndef EQEMU_COMMON_ANY_H
+#define EQEMU_COMMON_ANY_H
+
+#include <algorithm>
+#include <typeinfo>
+
+namespace EQEmu
+{
+	class Any
+	{
+	public:
+		Any()
+			: content(nullptr) 
+		{
+		}
+
+		template<typename ValueType>
+		Any(const ValueType &value)
+			: content(new Holder<ValueType>(value))
+		{
+		}
+
+		Any(const Any &other)
+			: content(other.content ? other.content->clone() : 0)
+		{
+		}
+		
+		~Any()
+		{
+			if(content)
+				delete content;
+		}
+
+		Any& swap(Any &rhs)
+		{
+			std::swap(content, rhs.content);
+			return *this;
+		}
+
+		template<typename ValueType>
+		Any& operator=(const ValueType &rhs)
+		{
+			Any(rhs).swap(*this);
+			return *this;
+		}
+
+		Any& operator=(Any rhs)
+		{
+			rhs.swap(*this);
+			return *this;
+		}
+
+		bool empty() const
+		{
+			return !content;
+		}
+
+		const std::type_info& type() const
+		{
+			return content ? content->type() : typeid(void);
+		}
+
+		class Placeholder
+		{
+		public:
+			virtual ~Placeholder()
+			{
+			}
+
+			virtual const std::type_info& type() const = 0;
+			virtual Placeholder* clone() const = 0;
+		};
+
+
+		template<typename ValueType>
+		class Holder : public Placeholder
+		{
+		public:
+			Holder(const ValueType &value)
+				: held(value)
+			{
+			}
+
+			virtual const std::type_info& type() const
+			{
+				return typeid(ValueType);
+			}
+
+			virtual Placeholder* clone() const
+			{
+				return new Holder(held);
+			}
+
+			 ValueType held;
+
+		private:
+			Holder& operator=(const Holder&);
+		};
+
+	private:
+		template<typename ValueType>
+		friend ValueType* any_cast(Any*);
+
+		template<typename ValueType>
+		friend ValueType* unsafe_any_cast(Any*);
+
+		Placeholder* content;
+	};
+
+	class bad_any_cast : public std::bad_cast
+	{
+	public:
+		virtual const char * what() const throw()
+		{
+			return "DBI::bad_any_cast: failed conversion using DBI::any_cast";
+		}
+	};
+
+	template<typename ValueType>
+	ValueType* any_cast(Any* operand)
+	{
+		return operand && 
+			operand->type() == typeid(ValueType) ? &static_cast<Any::Holder<ValueType>*>(operand->content)->held : nullptr;
+	}
+
+	template<typename ValueType>
+	inline const ValueType* any_cast(const Any* operand)
+	{
+		return any_cast<ValueType>(const_cast<Any*>(operand));
+	}
+
+	template<typename ValueType>
+	ValueType any_cast(Any& operand)
+	{
+		typedef typename std::remove_reference<ValueType>::type nonref;
+		nonref* result = any_cast<nonref>(&operand);
+		if(!result)
+			throw bad_any_cast();
+		return *result;
+	}
+	
+	template<typename ValueType>
+	inline ValueType any_cast(const Any& operand)
+	{
+		typedef typename std::remove_reference<ValueType>::type nonref;
+		return any_cast<const nonref&>(const_cast<Any&>(operand));
+	}
+
+	template<typename ValueType>
+	inline ValueType* unsafe_any_cast(Any* operand)
+	{
+		return &static_cast<Any::Holder<ValueType>*>(operand->content)->held;
+	}
+
+	template<typename ValueType>
+	inline const ValueType* unsafe_any_cast(const Any* operand)
+	{
+		return unsafe_any_cast<ValueType>(const_cast<Any*>(operand));
+	}
+}
+
+#endif
@@ -0,0 +1,34 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __EQEMU_COMMON_BASE_DATA_H
+#define __EQEMU_COMMON_BASE_DATA_H
+
+struct BaseDataStruct
+{
+	double base_hp;
+	double base_mana;
+	double base_end;
+	double unk1;
+	double unk2;
+	double hp_factor;
+	double mana_factor;
+	double endurance_factor;
+};
+
+#endif
@@ -1,22 +1,22 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)

-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
+	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
+	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 "debug.h"
-#include "BasePacket.h"
+#include "base_packet.h"
 #include "misc.h"
 #include "packet_dump.h"

@@ -24,16 +24,17 @@

 BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 {
-	this->pBuffer=NULL;
+	this->pBuffer=nullptr;
 	this->size=0;
 	this->_wpos = 0;
 	this->_rpos = 0;
+	this->timestamp.tv_sec = 0;
 	if (len>0) {
 		this->size=len;
 		pBuffer= new unsigned char[len];
 		if (buf) {
 			memcpy(this->pBuffer,buf,len);
-		}  else {
+		} else {
 			memset(this->pBuffer,0,len);
 		}
 	}
@@ -43,7 +44,7 @@ BasePacket::~BasePacket()
 {
 	if (pBuffer)
 		delete[] pBuffer;
-	pBuffer=NULL;
+	pBuffer=nullptr;
 }


@@ -55,7 +56,7 @@ void BasePacket::build_raw_header_dump(char *buffer, uint16 seq) const
 		buffer += sprintf(buffer, "%s.%06lu ",temp,timestamp.tv_usec);
 	}
 	if (src_ip) {
-		string sIP,dIP;;
+		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
 		dIP=long2ip(dst_ip);
 		buffer += sprintf(buffer, "[%s:%d->%s:%d]\n",sIP.c_str(),src_port,dIP.c_str(),dst_port);
@@ -79,7 +80,7 @@ void BasePacket::build_header_dump(char *buffer) const
 void BasePacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
 	if (src_ip) {
-		string sIP,dIP;;
+		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);
@@ -107,7 +108,7 @@ void BasePacket::ReadString(char *str, uint32 Offset, uint32 MaxLength) const
 	while((j < size) && (i < MaxLength) && (str[i - 1] != 0));

 	str[i - 1] = '\0';
-}	
+}

 void DumpPacketHex(const BasePacket* app)
 {
@@ -123,24 +124,3 @@ void DumpPacketBin(const BasePacket* app) {
 	DumpPacketBin(app->pBuffer, app->size);
 }

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)

-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
+	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
+	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 BASEPACKET_H_
 #define BASEPACKET_H_
@@ -50,7 +50,7 @@ public:
 	void setSrcInfo(uint32 sip, uint16 sport) { src_ip=sip; src_port=sport; }
 	void setDstInfo(uint32 dip, uint16 dport) { dst_ip=dip; dst_port=dport; }
 	void setTimeInfo(uint32 ts_sec, uint32 ts_usec) { timestamp.tv_sec=ts_sec; timestamp.tv_usec=ts_usec; }
-	void copyInfo(const BasePacket *p) { src_ip=p->src_ip; src_port=p->src_port;  dst_ip=p->dst_ip; dst_port=p->dst_port; timestamp.tv_sec=p->timestamp.tv_sec; timestamp.tv_usec=p->timestamp.tv_usec; }
+	void copyInfo(const BasePacket *p) { src_ip=p->src_ip; src_port=p->src_port; dst_ip=p->dst_ip; dst_port=p->dst_port; timestamp.tv_sec=p->timestamp.tv_sec; timestamp.tv_usec=p->timestamp.tv_usec; }

 	inline bool operator<(const BasePacket &rhs) {
 		return (timestamp.tv_sec < rhs.timestamp.tv_sec || (timestamp.tv_sec==rhs.timestamp.tv_sec && timestamp.tv_usec < rhs.timestamp.tv_usec));
@@ -71,7 +71,7 @@ public:
 	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(char *str, uint32 Offset, uint32 MaxLength) const;
-	
+
 	uint32 GetWritePosition() { return _wpos; }
 	uint32 GetReadPosition() { return _rpos; }
 	void SetWritePosition(uint32 Newwpos) { _wpos = Newwpos; }
@@ -79,7 +79,7 @@ public:

 protected:
 	virtual ~BasePacket();
-	BasePacket() { pBuffer=NULL; size=0; _wpos = 0; _rpos = 0; }
+	BasePacket() { pBuffer=nullptr; size=0; _wpos = 0; _rpos = 0; }
 	BasePacket(const unsigned char *buf, const uint32 len);
 };

@@ -89,5 +89,3 @@ extern void DumpPacketBin(const BasePacket* app);

 #endif /*BASEPACKET_H_*/

-
-
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)

-    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 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
+	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.
+	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
+	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 BODYTYPES_H
 #define BODYTYPES_H
@@ -25,7 +25,7 @@ typedef enum {
 	BT_Giant			= 4,
 	BT_Construct		= 5,
 	BT_Extraplanar		= 6,
-	BT_Magical			= 7,	//this name might be a bit off, 
+	BT_Magical			= 7,	//this name might be a bit off,
 	BT_SummonedUndead	= 8,
 	BT_RaidGiant		= 9,
 	//					...
@@ -45,7 +45,7 @@ typedef enum {
 	BT_Dragon			= 26,
 	BT_Summoned2		= 27,
 	BT_Summoned3		= 28,
-	//					  29
+						//29
 	BT_VeliousDragon	= 30,	//might not be a tight set
 	//					...
 	BT_Dragon3			= 32,
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)

-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; version 2 of the License.
-  
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
+	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
+	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 BREAKDOWNS_H_
 #define BREAKDOWNS_H_
@@ -1,279 +1,279 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)

-    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 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
+	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.
+	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
+	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 "../common/debug.h"
 #include "../common/classes.h"

 const char* GetEQClassName(uint8 class_, uint8 level) {
 	switch(class_) {
-      case WARRIOR: 
-		 if (level >= 70) 
-			return "Vanquisher"; 
-         else if (level >= 65) 
-            return "Overlord";   //Baron-Sprite: LEAVE MY CLASSES ALONE.
-         else if (level >= 60) 
-            return "Warlord"; 
-         else if (level >= 55) 
-            return "Myrmidon"; 
-         else if (level >= 51) 
-            return "Champion"; 
-         else 
-            return "Warrior"; 
-      case CLERIC:
-		 if (level >= 70) 
-			return "Prelate"; 
-         else if (level >= 65) 
-            return "Archon"; 
-         else if (level >= 60) 
-            return "High Priest"; 
-         else if (level >= 55) 
-            return "Templar"; 
-         else if (level >= 51) 
-            return "Vicar"; 
-         else 
-            return "Cleric"; 
-      case PALADIN: 
-		 if (level >= 70) 
-			return "Lord"; 
-         else if (level >= 65) 
-            return "Lord Protector"; 
-         else if (level >= 60) 
-            return "Crusader"; 
-         else if (level >= 55) 
-            return "Knight"; 
-         else if (level >= 51) 
-            return "Cavalier"; 
-         else 
-            return "Paladin"; 
-      case RANGER:
-		 if (level >= 70) 
-			return "Plainswalker"; 
-         else if (level >= 65) 
-            return "Forest Stalker"; 
-         else if (level >= 60) 
-            return "Warder"; 
-         else if (level >= 55) 
-            return "Outrider"; 
-         else if (level >= 51) 
-            return "Pathfinder"; 
-         else 
-            return "Ranger"; 
-      case SHADOWKNIGHT:
-		 if (level >= 70) 
-			return "Scourge Knight"; 
-         else if (level >= 65) 
-            return "Dread Lord"; 
-         else if (level >= 60) 
-            return "Grave Lord"; 
-         else if (level >= 55) 
-            return "Revenant"; 
-         else if (level >= 51) 
-            return "Reaver"; 
-         else 
-            return "Shadowknight"; 
-      case DRUID:
-		 if (level >= 70) 
-			return "Natureguard"; 
-         else if (level >= 65) 
-            return "Storm Warden"; 
-         else if (level >= 60) 
-            return "Hierophant"; 
-         else if (level >= 55) 
-            return "Preserver"; 
-         else if (level >= 51) 
-            return "Wanderer"; 
-         else 
-            return "Druid"; 
-      case MONK:
-		 if (level >= 70) 
-			return "Stone Fist"; 
-         else if (level >= 65) 
-            return "Transcendent"; 
-         else if (level >= 60) 
-            return "Grandmaster"; 
-         else if (level >= 55) 
-            return "Master"; 
-         else if (level >= 51) 
-            return "Disciple"; 
-         else 
-            return "Monk"; 
-      case BARD: 
-	     if (level >= 70) 
-			return "Performer";
-         else if (level >= 65) 
-            return "Maestro"; 
-         else if (level >= 60) 
-            return "Virtuoso"; 
-         else if (level >= 55) 
-            return "Troubadour"; 
-         else if (level >= 51) 
-            return "Minstrel"; 
-         else 
-            return "Bard"; 
-      case ROGUE: 
-		 if (level >= 70) 
-			return "Nemesis"; 
-         else if (level >= 65) 
-            return "Deceiver"; 
-         else if (level >= 60) 
-            return "Assassin"; 
-         else if (level >= 55) 
-            return "Blackguard"; 
-         else if (level >= 51) 
-            return "Rake"; 
-         else 
-            return "Rogue"; 
-      case SHAMAN: 
-		 if (level >= 70) 
-			return "Soothsayer";
-         else if (level >= 65) 
-            return "Prophet"; 
-         else if (level >= 60) 
-            return "Oracle"; 
-         else if (level >= 55) 
-            return "Luminary"; 
-         else if (level >= 51) 
-            return "Mystic"; 
-         else 
-            return "Shaman"; 
-      case NECROMANCER: 
-	     if (level >= 70) 
-			return "Wraith"; 
-         else if (level >= 65) 
-            return "Arch Lich"; 
-         else if (level >= 60) 
-            return "Warlock"; 
-         else if (level >= 55) 
-            return "Defiler"; 
-         else if (level >= 51) 
-            return "Heretic"; 
-         else 
-            return "Necromancer"; 
-      case WIZARD: 
-	     if (level >= 70) 
-			return "Grand Arcanist"; 
-         else if (level >= 65) 
-            return "Arcanist"; 
-         else if (level >= 60) 
-            return "Sorcerer"; 
-         else if (level >= 55) 
-            return "Evoker"; 
-         else if (level >= 51) 
-            return "Channeler"; 
-         else 
-            return "Wizard"; 
-      case MAGICIAN: 
-		 if (level >= 70) 
-			return "Arch Magus"; 
-         else if (level >= 65) 
-            return "Arch Convoker"; 
-         else if (level >= 60) 
-            return "Arch Mage"; 
-         else if (level >= 55) 
-            return "Conjurer"; 
-         if (level >= 51) 
-            return "Elementalist"; 
-         else 
-            return "Magician"; 
-      case ENCHANTER: 
-		 if (level >= 70) 
-			return "Bedazzler"; 
-         else if (level >= 65) 
-            return "Coercer"; 
-         else if (level >= 60) 
-            return "Phantasmist"; 
-         else if (level >= 55) 
-            return "Beguiler"; 
-         else if (level >= 51) 
-            return "Illusionist"; 
-         else 
-            return "Enchanter"; 
-      case BEASTLORD: 
-		 if (level >= 70) 
-			return "Wildblood"; 
-         else if (level >= 65) 
-            return "Feral Lord"; 
-         else if (level >= 60) 
-            return "Savage Lord"; 
-         else if (level >= 55) 
-            return "Animist"; 
-         else if (level >= 51) 
-            return "Primalist"; 
-         else 
-            return "Beastlord"; 
-	  case BERSERKER: 
-		 if (level >= 70) 
-			return "Ravager"; 
-         else if (level >= 65) 
-            return "Fury"; 
-         else if (level >= 60) 
-            return "Rager"; 
-         else if (level >= 55) 
-            return "Vehement"; 
-         else if (level >= 51) 
-            return "Brawler"; 
-         else 
-            return "Berserker"; 
-	  case BANKER: 
-		 if (level >= 70) 
-			return "Master Banker"; 
-         else if (level >= 65) 
-            return "Elder Banker"; 
-         else if (level >= 60) 
-            return "Oldest Banker"; 
-         else if (level >= 55) 
-            return "Older Banker"; 
-         else if (level >= 51) 
-            return "Old Banker"; 
-         else 
-            return "Banker";
-	  case WARRIORGM:
+		case WARRIOR:
+			if (level >= 70)
+				return "Vanquisher";
+			else if (level >= 65)
+				return "Overlord"; //Baron-Sprite: LEAVE MY CLASSES ALONE.
+			else if (level >= 60)
+				return "Warlord";
+			else if (level >= 55)
+				return "Myrmidon";
+			else if (level >= 51)
+				return "Champion";
+			else
+				return "Warrior";
+		case CLERIC:
+			if (level >= 70)
+				return "Prelate";
+			else if (level >= 65)
+				return "Archon";
+			else if (level >= 60)
+				return "High Priest";
+			else if (level >= 55)
+				return "Templar";
+			else if (level >= 51)
+				return "Vicar";
+			else
+				return "Cleric";
+		case PALADIN:
+			if (level >= 70)
+				return "Lord";
+			else if (level >= 65)
+				return "Lord Protector";
+			else if (level >= 60)
+				return "Crusader";
+			else if (level >= 55)
+				return "Knight";
+			else if (level >= 51)
+				return "Cavalier";
+			else
+				return "Paladin";
+		case RANGER:
+			if (level >= 70)
+				return "Plainswalker";
+			else if (level >= 65)
+				return "Forest Stalker";
+			else if (level >= 60)
+				return "Warder";
+			else if (level >= 55)
+				return "Outrider";
+			else if (level >= 51)
+				return "Pathfinder";
+			else
+				return "Ranger";
+		case SHADOWKNIGHT:
+			if (level >= 70)
+				return "Scourge Knight";
+			else if (level >= 65)
+				return "Dread Lord";
+			else if (level >= 60)
+				return "Grave Lord";
+			else if (level >= 55)
+				return "Revenant";
+			else if (level >= 51)
+				return "Reaver";
+			else
+				return "Shadowknight";
+		case DRUID:
+			if (level >= 70)
+				return "Natureguard";
+			else if (level >= 65)
+				return "Storm Warden";
+			else if (level >= 60)
+				return "Hierophant";
+			else if (level >= 55)
+				return "Preserver";
+			else if (level >= 51)
+				return "Wanderer";
+			else
+				return "Druid";
+		case MONK:
+			if (level >= 70)
+				return "Stone Fist";
+			else if (level >= 65)
+				return "Transcendent";
+			else if (level >= 60)
+				return "Grandmaster";
+			else if (level >= 55)
+				return "Master";
+			else if (level >= 51)
+				return "Disciple";
+			else
+				return "Monk";
+		case BARD:
+			if (level >= 70)
+				return "Performer";
+			else if (level >= 65)
+				return "Maestro";
+			else if (level >= 60)
+				return "Virtuoso";
+			else if (level >= 55)
+				return "Troubadour";
+			else if (level >= 51)
+				return "Minstrel";
+			else
+				return "Bard";
+		case ROGUE:
+			if (level >= 70)
+				return "Nemesis";
+			else if (level >= 65)
+				return "Deceiver";
+			else if (level >= 60)
+				return "Assassin";
+			else if (level >= 55)
+				return "Blackguard";
+			else if (level >= 51)
+				return "Rake";
+			else
+				return "Rogue";
+		case SHAMAN:
+			if (level >= 70)
+				return "Soothsayer";
+			else if (level >= 65)
+				return "Prophet";
+			else if (level >= 60)
+				return "Oracle";
+			else if (level >= 55)
+				return "Luminary";
+			else if (level >= 51)
+				return "Mystic";
+			else
+				return "Shaman";
+		case NECROMANCER:
+			if (level >= 70)
+				return "Wraith";
+			else if (level >= 65)
+				return "Arch Lich";
+			else if (level >= 60)
+				return "Warlock";
+			else if (level >= 55)
+				return "Defiler";
+			else if (level >= 51)
+				return "Heretic";
+			else
+				return "Necromancer";
+		case WIZARD:
+			if (level >= 70)
+				return "Grand Arcanist";
+			else if (level >= 65)
+				return "Arcanist";
+			else if (level >= 60)
+				return "Sorcerer";
+			else if (level >= 55)
+				return "Evoker";
+			else if (level >= 51)
+				return "Channeler";
+			else
+				return "Wizard";
+		case MAGICIAN:
+			if (level >= 70)
+				return "Arch Magus";
+			else if (level >= 65)
+				return "Arch Convoker";
+			else if (level >= 60)
+				return "Arch Mage";
+			else if (level >= 55)
+				return "Conjurer";
+			if (level >= 51)
+				return "Elementalist";
+			else
+				return "Magician";
+		case ENCHANTER:
+			if (level >= 70)
+				return "Bedazzler";
+			else if (level >= 65)
+				return "Coercer";
+			else if (level >= 60)
+				return "Phantasmist";
+			else if (level >= 55)
+				return "Beguiler";
+			else if (level >= 51)
+				return "Illusionist";
+			else
+				return "Enchanter";
+		case BEASTLORD:
+			if (level >= 70)
+				return "Wildblood";
+			else if (level >= 65)
+				return "Feral Lord";
+			else if (level >= 60)
+				return "Savage Lord";
+			else if (level >= 55)
+				return "Animist";
+			else if (level >= 51)
+				return "Primalist";
+			else
+				return "Beastlord";
+		case BERSERKER:
+			if (level >= 70)
+				return "Ravager";
+			else if (level >= 65)
+				return "Fury";
+			else if (level >= 60)
+				return "Rager";
+			else if (level >= 55)
+				return "Vehement";
+			else if (level >= 51)
+				return "Brawler";
+			else
+				return "Berserker";
+		case BANKER:
+			if (level >= 70)
+				return "Master Banker";
+			else if (level >= 65)
+				return "Elder Banker";
+			else if (level >= 60)
+				return "Oldest Banker";
+			else if (level >= 55)
+				return "Older Banker";
+			else if (level >= 51)
+				return "Old Banker";
+			else
+				return "Banker";
+		case WARRIORGM:
 			return "Warrior Guildmaster";
-	  case CLERICGM:
+		case CLERICGM:
 			return "Cleric Guildmaster";
-	  case PALADINGM:
+		case PALADINGM:
 			return "Paladin Guildmaster";
-	  case RANGERGM:
+		case RANGERGM:
 			return "Ranger Guildmaster";
-	  case SHADOWKNIGHTGM:
+		case SHADOWKNIGHTGM:
 			return "Shadowknight Guildmaster";
-	  case DRUIDGM:
-	  		return "Druid Guildmaster";
-	  case MONKGM:
+		case DRUIDGM:
+			return "Druid Guildmaster";
+		case MONKGM:
 			return "Monk Guildmaster";
-	  case BARDGM:
+		case BARDGM:
 			return "Bard Guildmaster";
-	  case ROGUEGM:
+		case ROGUEGM:
 			return "Rogue Guildmaster";
-	  case SHAMANGM:
+		case SHAMANGM:
 			return "Shaman Guildmaster";
-	  case NECROMANCERGM:
+		case NECROMANCERGM:
 			return "Necromancer Guildmaster";
-	  case WIZARDGM:
+		case WIZARDGM:
 			return "Wizard Guildmaster";
-	  case MAGICIANGM:
+		case MAGICIANGM:
 			return "Magician Guildmaster";
-	  case ENCHANTERGM:
+		case ENCHANTERGM:
 			return "Enchanter Guildmaster";
-	  case BEASTLORDGM:
+		case BEASTLORDGM:
 			return "Beastlord Guildmaster";
-	  case BERSERKERGM:
+		case BERSERKERGM:
 			return "Berserker Guildmaster";
-	  case MERCHANT:
+		case MERCHANT:
 			return "Merchant";
 		case ADVENTURERECRUITER:
 			return "Adventure Recruiter";
@@ -285,55 +285,8 @@ const char* GetEQClassName(uint8 class_, uint8 level) {
 			return "Tribute Master";
 		case GUILD_TRIBUTE_MASTER:
 			return "Guild Tribute Master";
-	  default:
+		default:
 			return "Unknown";
 	}
 }

-uint32 GetArrayEQClass(uint8 eqclass) {
-	switch (eqclass) {
-		case WARRIOR:
-			return WARRIOR;
-		case CLERIC:
-			return CLERIC;
-		case PALADIN:
-			return PALADIN;
-		case RANGER:
-			return RANGER;
-		case SHADOWKNIGHT:
-			return SHADOWKNIGHT;
-		case DRUID:
-			return DRUID;
-		case MONK:
-			return MONK;
-		case BARD:
-			return BARD;
-		case ROGUE:
-			return ROGUE;
-		case SHAMAN:
-			return SHAMAN;
-		case NECROMANCER:
-			return NECROMANCER;
-		case WIZARD:
-			return WIZARD;
-		case MAGICIAN:
-			return MAGICIAN;
-		case ENCHANTER:
-			return ENCHANTER;
-		case BEASTLORD:
-			return BEASTLORD;
-		case BERSERKER:
-			return BERSERKER;
-		default:
-			return 0;
-	}
-}
-
-uint8 GetEQArrayEQClass(uint8 eqclass) {
-	if (eqclass >= WARRIOR && eqclass <= BERSERKER)
-		return eqclass - WARRIOR;
-	if (eqclass >= WARRIORGM && eqclass <= BERSERKERGM)
-		return eqclass - WARRIORGM;
-	return WARRIOR;
-}
-
@@ -1,59 +1,59 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)

-    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 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
+	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.
+	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
+	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 CLASSES_CH
 #define CLASSES_CH
 #include "../common/types.h"

 #define Array_Class_UNKNOWN 0
-#define WARRIOR      1
-#define CLERIC       2
-#define PALADIN      3
-#define RANGER       4
-#define SHADOWKNIGHT 5
-#define DRUID        6
-#define MONK         7
-#define BARD         8
-#define ROGUE        9
-#define SHAMAN      10
-#define NECROMANCER 11
-#define WIZARD      12
-#define MAGICIAN    13
-#define ENCHANTER   14
-#define BEASTLORD   15
-#define BERSERKER   16
+#define WARRIOR			1
+#define CLERIC			2
+#define PALADIN			3
+#define RANGER			4
+#define SHADOWKNIGHT	5
+#define DRUID			6
+#define MONK			7
+#define BARD			8
+#define ROGUE			9
+#define SHAMAN			10
+#define NECROMANCER		11
+#define WIZARD			12
+#define MAGICIAN		13
+#define ENCHANTER		14
+#define BEASTLORD		15
+#define BERSERKER		16
 #define PLAYER_CLASS_COUNT	16 // used for array defines, must be the count of playable classes
-#define WARRIORGM 20 
-#define CLERICGM 21 
-#define PALADINGM 22 
-#define RANGERGM 23 
-#define SHADOWKNIGHTGM 24 
-#define DRUIDGM 25 
-#define MONKGM 26 
-#define BARDGM 27 
-#define ROGUEGM 28 
-#define SHAMANGM 29 
-#define NECROMANCERGM 30 
-#define WIZARDGM 31 
-#define MAGICIANGM 32 
-#define ENCHANTERGM 33 
+#define WARRIORGM 20
+#define CLERICGM 21
+#define PALADINGM 22
+#define RANGERGM 23
+#define SHADOWKNIGHTGM 24
+#define DRUIDGM 25
+#define MONKGM 26
+#define BARDGM 27
+#define ROGUEGM 28
+#define SHAMANGM 29
+#define NECROMANCERGM 30
+#define WIZARDGM 31
+#define MAGICIANGM 32
+#define ENCHANTERGM 33
 #define BEASTLORDGM 34
 #define BERSERKERGM 35
-#define BANKER 40 
+#define BANKER 40
 #define MERCHANT 41
 #define DISCORD_MERCHANT 59
 #define ADVENTURERECRUITER 60
@@ -86,7 +86,5 @@
 #define call_1 65536

 const char* GetEQClassName(uint8 class_, uint8 level = 0);
-uint32 GetArrayEQClass(uint8 eqclass);
-uint8 GetEQArrayEQClass(uint8 eqclass);
 #endif

@@ -1,27 +1,76 @@
 #ifndef CLIENTVERSIONS_H
 #define CLIENTVERSIONS_H

-static const uint32 BIT_Client62 = 1;
-static const uint32 BIT_Titanium = 2;
-static const uint32 BIT_SoF = 4;
-static const uint32 BIT_SoD = 8;
-static const uint32 BIT_Underfoot = 16;
-static const uint32 BIT_RoF = 32;
-static const uint32 BIT_TitaniumAndEarlier = 3;
-static const uint32 BIT_SoFAndLater = 0xFFFFFFFC;
-static const uint32 BIT_SoDAndLater = 0xFFFFFFF8;
-static const uint32 BIT_UnderfootAndLater = 0xFFFFFFF0;
-static const uint32 BIT_RoFAndLater = 0xFFFFFFE0;
-static const uint32 BIT_AllClients = 0xFFFFFFFF;
+static const uint32 BIT_Client62	= 1;
+static const uint32 BIT_Titanium	= 2;
+static const uint32 BIT_SoF			= 4;
+static const uint32 BIT_SoD			= 8;
+static const uint32 BIT_Underfoot	= 16;
+static const uint32 BIT_RoF			= 32;
+static const uint32 BIT_RoF2		= 64;

-typedef enum {
+static const uint32 BIT_TitaniumAndEarlier	= 0x00000003;
+static const uint32 BIT_SoFAndLater			= 0xFFFFFFFC;
+static const uint32 BIT_SoDAndLater			= 0xFFFFFFF8;
+static const uint32 BIT_UnderfootAndLater	= 0xFFFFFFF0;
+static const uint32 BIT_RoFAndLater			= 0xFFFFFFE0;
+static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0;
+static const uint32 BIT_AllClients			= 0xFFFFFFFF;
+
+typedef enum
+{
 	EQClientUnknown = 0,
-	EQClient62,
-	EQClientTitanium,
-	EQClientSoF,
-	EQClientSoD,
-	EQClientUnderfoot,
-	EQClientRoF
+	EQClient62,				// Build: 'Aug  4 2005 15:40:59'
+	EQClientTitanium,		// Build: 'Oct 31 2005 10:33:37'
+	EQClientSoF,			// Build: 'Sep  7 2007 09:11:49'
+	EQClientSoD,			// Build: 'Dec 19 2008 15:22:49'
+	EQClientUnderfoot,		// Build: 'Jun  8 2010 16:44:32'
+	EQClientRoF,			// Build: 'Dec 10 2012 17:35:44'
+	EQClientRoF2,			// Build: 'May 10 2013 23:30:08'
+
+	_EQClientCount,			// place new clients before this point (preferably, in release/attribute order)
+
+	// Values below are not implemented, as yet...
+
+	EmuNPC = _EQClientCount,
+	EmuMerc,
+	EmuBot,
+	EmuPet,
+
+	_EmuClientCount			// array size for EQLimits
 } EQClientVersion;

+static const char* EQClientVersionName(EQClientVersion version)
+{
+	switch (version)
+	{
+	case EQClientUnknown:
+		return "EQClientUnknown";
+	case EQClient62:
+		return "EQClient62";
+	case EQClientTitanium:
+		return "EQClientTitanium";
+	case EQClientSoF:
+		return "EQClientSoF";
+	case EQClientSoD:
+		return "EQClientSoD";
+	case EQClientUnderfoot:
+		return "EQClientUnderfoot";
+	case EQClientRoF:
+		return "EQClientRoF";
+	case EQClientRoF2:
+		return "EQClientRoF2";
+	case EmuNPC:
+		return "EmuNPC";
+	case EmuMerc:
+		return "EmuMerc";
+	case EmuBot:
+		return "EmuBot";
+	case EmuPet:
+		return "EmuPet";
+	default:
+		return "ERROR: Invalid EQClientVersion";
+	};
+}
+
 #endif /* CLIENTVERSIONS_H */
@@ -1,103 +0,0 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2004  EQEMu Development Team (http://eqemulator.net)
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; version 2 of the License.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-#ifndef COMMON_PROFILE_H
-#define COMMON_PROFILE_H
-
-#ifdef ZONE
-#include "../zone/features.h"
-
-#ifndef EQPROFILE
-#ifdef COMMON_PROFILE
-#undef COMMON_PROFILE
-#endif
-#endif
-
-#ifdef COMMON_PROFILE
-
-#include "../common/profiler.h"
-
-class CommonProfiler : public GeneralProfiler {
-public:
-	enum {
-		Database_SaveInventory = 0,
-		Database_StoreCharacter,
-		Database_GetCharacterInfoForLogin,
-		Database_GetCharacterInfoForLogin_result,
-		Database_GetPlayerProfile,
-		Database_GetInventory,
-		Database_GetInventory_name,
-		Database_SetPlayerProfile,
-		Database_DBLoadItems,
-		Database_GetWaypoints,
-		Database_DBLoadNPCFactionLists,
-		
-		DBcore_RunQuery,
-		
-		DBAsync_ProcessWork,
-		DBAsync_DispatchWork,
-		DBAsyncLoop_loop,
-		
-		EQStreamServer_Process,
-		
-		EQStream_Process,
-		
-		EQStreamServerLoop,
-		EQStreamInLoop,
-		EQStreamOutLoop,
-		TCPServerLoop,
-		TCPConnectionLoop,
-		
-		Inventory_GetItem,
-		Inventory_HasItem,
-		
-		BaseTCPServerLoop,
-
-		MakeRandomInt,
-		MakeRandomFloat,
-		
-		Mutex_lock,
-		Timer_Check,
-		
-		WorldConnection_Process,
-		
-		MaxCommonProfilerId
-	};
-	
-	inline CommonProfiler() : GeneralProfiler(MaxCommonProfilerId) { }
-	
-};
-
-extern CommonProfiler _cp;
-
-
-#define _CP(name) _GP(_cp, CommonProfiler, name)
-
-#else
-	//no zone profiling, dummy functions
-#define _CP(name) ;
-
-#endif //COMMON_PROFILE
-
-#else //else !ZONE
-
-#define _CP(name) ;
-
-#endif //!ZONE
-
-#endif
-
@@ -0,0 +1,148 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "debug.h"
+#include "condition.h"
+
+#ifdef _WINDOWS
+
+	Condition::Condition()
+	{
+		m_events[SignalEvent] = CreateEvent (nullptr, // security
+										FALSE, // is auto-reset event?
+										FALSE, // is signaled initially?
+										nullptr); // name
+		m_events[BroadcastEvent] = CreateEvent (nullptr, // security
+										TRUE, // is auto-reset event?
+										FALSE, // is signaled initially?
+										nullptr); // name
+		m_waiters = 0;
+		InitializeCriticalSection(&CSMutex);
+	}
+
+	Condition::~Condition()
+	{
+		DeleteCriticalSection(&CSMutex);
+		CloseHandle(m_events[SignalEvent]);
+		CloseHandle(m_events[BroadcastEvent]);
+	}
+
+	void Condition::Signal()
+	{
+		EnterCriticalSection(&CSMutex);
+		if(m_waiters > 0)
+			SetEvent(m_events[SignalEvent]);
+		LeaveCriticalSection(&CSMutex);
+	}
+
+	void Condition::SignalAll()
+	{
+		EnterCriticalSection(&CSMutex);
+		if(m_waiters > 0)
+			SetEvent(m_events[BroadcastEvent]);
+		LeaveCriticalSection(&CSMutex);
+	}
+
+	void Condition::Wait()
+	{
+		EnterCriticalSection(&CSMutex);
+
+		m_waiters++;
+
+
+		LeaveCriticalSection(&CSMutex);
+		int result = WaitForMultipleObjects (_eventCount, m_events, FALSE, INFINITE);
+		EnterCriticalSection(&CSMutex);
+
+		m_waiters--;
+
+		//see if we are the last person waiting on the condition, and there was a broadcast
+		//if so, we need to reset the broadcast event.
+		if(m_waiters == 0 && result == (WAIT_OBJECT_0+BroadcastEvent))
+			ResetEvent(m_events[BroadcastEvent]);
+
+		LeaveCriticalSection(&CSMutex);
+	}
+
+#else
+	#include <pthread.h>
+	#include <sys/time.h>
+	#include <errno.h>
+	
+	Condition::Condition()
+	{
+		pthread_cond_init(&cond,nullptr);
+		pthread_mutex_init(&mutex,nullptr);
+	}
+
+	void Condition::Signal()
+	{
+		pthread_mutex_lock(&mutex);
+		pthread_cond_signal(&cond);
+		pthread_mutex_unlock(&mutex);
+	}
+
+	void Condition::SignalAll()
+	{
+		pthread_mutex_lock(&mutex);
+		pthread_cond_broadcast(&cond);
+		pthread_mutex_unlock(&mutex);
+	}
+
+	void Condition::Wait()
+	{
+		pthread_mutex_lock(&mutex);
+		pthread_cond_wait(&cond,&mutex);
+		pthread_mutex_unlock(&mutex);
+	}
+
+	/*
+	I commented this specifically because I think it might be very
+	difficult to write a windows counterpart to it, so I would like
+	to discourage its use until we can confirm that it can be reasonably
+	implemented on windows.
+
+	bool Condition::TimedWait(unsigned long usec)
+	{
+	struct timeval now;
+	struct timespec timeout;
+	int retcode=0;
+		pthread_mutex_lock(&mutex);
+		gettimeofday(&now,nullptr);
+		now.tv_usec+=usec;
+		timeout.tv_sec = now.tv_sec + (now.tv_usec/1000000);
+		timeout.tv_nsec = (now.tv_usec%1000000) *1000;
+		//cout << "now=" << now.tv_sec << "."<<now.tv_usec << endl;
+		//cout << "timeout=" << timeout.tv_sec << "."<<timeout.tv_nsec << endl;
+		retcode=pthread_cond_timedwait(&cond,&mutex,&timeout);
+		pthread_mutex_unlock(&mutex);
+
+		return retcode!=ETIMEDOUT;
+	}
+	*/
+
+	Condition::~Condition()
+	{
+		pthread_mutex_lock(&mutex);
+		pthread_cond_destroy(&cond);
+		pthread_mutex_unlock(&mutex);
+		pthread_mutex_destroy(&mutex);
+	}
+	
+#endif
+
@@ -0,0 +1,56 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+#ifndef __CONDITION_H
+#define __CONDITION_H
+
+#include "debug.h"
+#ifndef WIN32
+#include <pthread.h>
+#endif
+
+//Sombody, someday needs to figure out how to implement a condition
+//system on windows...
+
+
+class Condition {
+	private:
+#ifdef WIN32
+		enum {
+			SignalEvent = 0,
+			BroadcastEvent,
+			_eventCount
+		};
+
+		HANDLE m_events[_eventCount];
+		uint32 m_waiters;
+		CRITICAL_SECTION CSMutex;
+#else
+		pthread_cond_t cond;
+		pthread_mutex_t mutex;
+#endif
+	public:
+		Condition();
+		void Signal();
+		void SignalAll();
+		void Wait();
+//		bool TimedWait(unsigned long usec);
+		~Condition();
+};
+
+#endif
+
@@ -7,107 +7,107 @@
 class EQEmuStackWalker : public StackWalker
 {
 public:
-    EQEmuStackWalker() : StackWalker() { }
-    EQEmuStackWalker(DWORD dwProcessId, HANDLE hProcess) : StackWalker(dwProcessId, hProcess) { }
-    virtual void OnOutput(LPCSTR szText) { 
-        char buffer[4096];
-        for(int i = 0; i < 4096; ++i) {
-            if(szText[i] == 0) {
-                buffer[i] = '\0';
-                break;
-            }
+	EQEmuStackWalker() : StackWalker() { }
+	EQEmuStackWalker(DWORD dwProcessId, HANDLE hProcess) : StackWalker(dwProcessId, hProcess) { }
+	virtual void OnOutput(LPCSTR szText) {
+		char buffer[4096];
+		for(int i = 0; i < 4096; ++i) {
+			if(szText[i] == 0) {
+				buffer[i] = '\0';
+				break;
+			}

-            if(szText[i] == '\n' || szText[i] == '\r') {
-                buffer[i] = ' ';
-            } else {
-                buffer[i] = szText[i];
-            }
-        }
+			if(szText[i] == '\n' || szText[i] == '\r') {
+				buffer[i] = ' ';
+			} else {
+				buffer[i] = szText[i];
+			}
+		}

-        LogFile->write(EQEMuLog::Crash, buffer); 
-        StackWalker::OnOutput(szText); 
-    }
+		LogFile->write(EQEMuLog::Crash, buffer);
+		StackWalker::OnOutput(szText);
+	}
 };

 LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 {
-    switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
-    {
-        case EXCEPTION_ACCESS_VIOLATION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_ACCESS_VIOLATION");
-            break;
-        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
-            break;
-        case EXCEPTION_BREAKPOINT:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_BREAKPOINT");
-            break;
-        case EXCEPTION_DATATYPE_MISALIGNMENT:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
-            break;
-        case EXCEPTION_FLT_DENORMAL_OPERAND:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
-            break;
-        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
-            break;
-        case EXCEPTION_FLT_INEXACT_RESULT:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
-            break;
-        case EXCEPTION_FLT_INVALID_OPERATION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
-            break;
-        case EXCEPTION_FLT_OVERFLOW:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_OVERFLOW");
-            break;
-        case EXCEPTION_FLT_STACK_CHECK:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_STACK_CHECK");
-            break;
-        case EXCEPTION_FLT_UNDERFLOW:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_UNDERFLOW");
-            break;
-        case EXCEPTION_ILLEGAL_INSTRUCTION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
-            break;
-        case EXCEPTION_IN_PAGE_ERROR:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_IN_PAGE_ERROR");
-            break;
-        case EXCEPTION_INT_DIVIDE_BY_ZERO:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
-            break;
-        case EXCEPTION_INT_OVERFLOW:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_OVERFLOW");
-            break;
-        case EXCEPTION_INVALID_DISPOSITION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_INVALID_DISPOSITION");
-            break;
-        case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
-            break;
-        case EXCEPTION_PRIV_INSTRUCTION:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_PRIV_INSTRUCTION");
-            break;
-        case EXCEPTION_SINGLE_STEP:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_SINGLE_STEP");
-            break;
-        case EXCEPTION_STACK_OVERFLOW:
-            LogFile->write(EQEMuLog::Crash, "EXCEPTION_STACK_OVERFLOW");
-            break;
-        default:
-            LogFile->write(EQEMuLog::Crash, "Unknown Exception");
-            break;
-    }
-    
-    if(EXCEPTION_STACK_OVERFLOW != ExceptionInfo->ExceptionRecord->ExceptionCode)
-    {
-        EQEmuStackWalker sw; sw.ShowCallstack(GetCurrentThread(), ExceptionInfo->ContextRecord);
-    }    
-    
-    return EXCEPTION_EXECUTE_HANDLER;
+	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
+	{
+		case EXCEPTION_ACCESS_VIOLATION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			break;
+		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			break;
+		case EXCEPTION_BREAKPOINT:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_BREAKPOINT");
+			break;
+		case EXCEPTION_DATATYPE_MISALIGNMENT:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			break;
+		case EXCEPTION_FLT_DENORMAL_OPERAND:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			break;
+		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			break;
+		case EXCEPTION_FLT_INEXACT_RESULT:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			break;
+		case EXCEPTION_FLT_INVALID_OPERATION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			break;
+		case EXCEPTION_FLT_OVERFLOW:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_OVERFLOW");
+			break;
+		case EXCEPTION_FLT_STACK_CHECK:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			break;
+		case EXCEPTION_FLT_UNDERFLOW:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			break;
+		case EXCEPTION_ILLEGAL_INSTRUCTION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			break;
+		case EXCEPTION_IN_PAGE_ERROR:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			break;
+		case EXCEPTION_INT_DIVIDE_BY_ZERO:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			break;
+		case EXCEPTION_INT_OVERFLOW:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_OVERFLOW");
+			break;
+		case EXCEPTION_INVALID_DISPOSITION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			break;
+		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			break;
+		case EXCEPTION_PRIV_INSTRUCTION:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			break;
+		case EXCEPTION_SINGLE_STEP:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_SINGLE_STEP");
+			break;
+		case EXCEPTION_STACK_OVERFLOW:
+			LogFile->write(EQEMuLog::Crash, "EXCEPTION_STACK_OVERFLOW");
+			break;
+		default:
+			LogFile->write(EQEMuLog::Crash, "Unknown Exception");
+			break;
+	}
+
+	if(EXCEPTION_STACK_OVERFLOW != ExceptionInfo->ExceptionRecord->ExceptionCode)
+	{
+		EQEmuStackWalker sw; sw.ShowCallstack(GetCurrentThread(), ExceptionInfo->ContextRecord);
+	}
+
+	return EXCEPTION_EXECUTE_HANDLER;
 }

 void set_exception_handler() {
-    SetUnhandledExceptionFilter(windows_exception_handler);
+	SetUnhandledExceptionFilter(windows_exception_handler);
 }
 #else
 // crash is off or an unhandled platform
@@ -0,0 +1,15 @@
+#include "crc32.h"
+
+uint16 CRC16(const unsigned char *buf, int size, int key)
+{
+	// This is computed as the lowest 16 bits of an Ethernet CRC32 checksum
+	// where the key is prepended to the data in little endian order.
+	uint8 keyBuf[] = {(uint8)((key >> 0) & 0xff),
+					(uint8)((key >> 8) & 0xff),
+					(uint8)((key >> 16) & 0xff),
+					(uint8)((key >> 24) & 0xff)};
+	uint32 crc = CRC32::Update(keyBuf, sizeof(uint32));
+	crc = CRC32::Update(buf, size, crc);
+	return CRC32::Finish(crc) & 0xffff;
+}
+
@@ -0,0 +1,7 @@
+#ifndef _CRC16_H
+#define _CRC16_H
+#include "types.h"
+
+uint16 CRC16(const unsigned char *buf, int size, int key);
+
+#endif
@@ -84,21 +84,21 @@ uint32 CRC32::GenerateNoFlip(const uint8* buf, uint32 bufsize) {
 void CRC32::SetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at)
 {
 	unsigned long data;
-    unsigned long check = 0xffffffff;
-	
+	unsigned long check = 0xffffffff;
+
 	assert(in_length >= start_at && in_data);
-	
-    for(uint32 i=start_at; i<in_length; i++)
-    {
-        data = in_data[i];
-        data = data ^ (check);
-        data = data & 0x000000ff;
-        check = check >> 8;
-        data = CRC32Table[data];
-        check = check ^ data;
-    }
-	
-    memcpy(in_data, (char*)&check, 4);
+
+	for(uint32 i=start_at; i<in_length; i++)
+	{
+		data = in_data[i];
+		data = data ^ (check);
+		data = data & 0x000000ff;
+		check = check >> 8;
+		data = CRC32Table[data];
+		check = check ^ data;
+	}
+
+	memcpy(in_data, (char*)&check, 4);
 }

 uint32 CRC32::Update(const uint8* buf, uint32 bufsize, uint32 crc32var) {
@@ -8,12 +8,12 @@ public:
 	static uint32			Generate(const uint8* buf, uint32 bufsize);
 	static uint32			GenerateNoFlip(const uint8* buf, uint32 bufsize); // Same as Generate(), but without the ~
 	static void				SetEQChecksum(uchar* in_data, uint32 in_length, uint32 start_at=4);
-	
+
 	// Multiple buffer CRC32
 	static uint32			Update(const uint8* buf, uint32 bufsize, uint32 crc32 = 0xFFFFFFFF);
 	static inline uint32	Finish(uint32 crc32)	{ return ~crc32; }
 	static inline void		Finish(uint32* crc32)	{ *crc32 = ~(*crc32); }
-	
+
 private:
 	static inline void		Calc(const uint8 byte, uint32& crc32);
 };
@@ -0,0 +1,48 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+#ifndef COMMON_DATA_VERIFICATION_H
+#define COMMON_DATA_VERIFICATION_H
+
+#include <algorithm>
+
+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) {
+	return std::max(lower, value);
+}
+
+template <typename T>
+T ClampUpper(const T& value, const T& upper) {
+	return std::min(value, upper);
+}
+
+template <typename T>
+bool ValueWithin(const T& value, const T& lower, const T& upper) {
+	return value >= lower && value <= upper;
+}
+
+}
+
+#endif
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-	Copyright (C) 2001-2003  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2003 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 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
+	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.
+	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
+	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_H
 #define EQEMU_DATABASE_H
@@ -26,19 +26,12 @@
 #include "dbcore.h"
 #include "linked_list.h"
 #include "eq_packet_structs.h"
-/*#include "EQStream.h"
-#include "guilds.h"
-#include "MiscFunctions.h"
-#include "Mutex.h"
-#include "Item.h"
-#include "extprofile.h"*/
 #include <string>
 #include <vector>
 #include <map>
-using namespace std;

 //atoi is not uint32 or uint32 safe!!!!
-#define atoul(str) strtoul(str, NULL, 10)
+#define atoul(str) strtoul(str, nullptr, 10)

 //class Spawn;
 class Corpse;
@@ -48,6 +41,7 @@ class SpawnGroupList;
 class Petition;
 class Client;
 class Merc;
+class MySQLRequestResult;
 struct Combine_Struct;
 //struct Faction;
 //struct FactionMods;
@@ -75,21 +69,15 @@ uint8	eventid;
 EventLogDetails_Struct eld[255];
 };

-
-// Added By Hogie 
-// INSERT into variables (varname,value) values('decaytime [minlevel] [maxlevel]','[number of seconds]');
-// IE: decaytime 1 54 = Levels 1 through 54
-//     decaytime 55 100 = Levels 55 through 100
-// It will always put the LAST time for the level (I think) from the Database
 struct npcDecayTimes_Struct {
 	uint16 minlvl;
 	uint16 maxlvl;
 	uint32 seconds;
 };
-// Added By Hogie -- End
+

 struct VarCache_Struct {
-	char varname[26];	// varname is char(25) in database
+	char varname[26];	
 	char value[0];
 };

@@ -100,20 +88,426 @@ struct ExtendedProfile_Struct;
 struct GuildMember_Struct;
 class PTimerList;

+#pragma pack(1)
+
+/* Conversion Structs */
+
+namespace Convert {
+	struct BindStruct {
+		/*000*/ uint32 zoneId;
+		/*004*/ float x;
+		/*008*/ float y;
+		/*012*/ float z;
+		/*016*/ float heading;
+	};
+	struct Color_Struct
+	{
+		union
+		{
+			struct
+			{
+				uint8	blue;
+				uint8	green;
+				uint8	red;
+				uint8	use_tint;	// if there's a tint this is FF
+			} rgb;
+			uint32 color;
+		};
+	};
+	struct AA_Array
+	{
+		uint32 AA;
+		uint32 value;
+	};
+	struct SpellBuff_Struct
+	{
+		/*000*/	uint8	slotid;		//badly named... seems to be 2 for a real buff, 0 otherwise
+		/*001*/ uint8	level;
+		/*002*/	uint8	bard_modifier;
+		/*003*/	uint8	effect;			//not real
+		/*004*/	uint32	spellid;
+		/*008*/ uint32	duration;
+		/*012*/	uint32	counters;
+		/*016*/	uint32	player_id;	//'global' ID of the caster, for wearoff messages
+		/*020*/
+	};
+	struct Tribute_Struct {
+		uint32 tribute;
+		uint32 tier;
+	};
+	struct Disciplines_Struct {
+		uint32 values[MAX_PP_DISCIPLINES];
+	};
+	struct GroupLeadershipAA_Struct {
+		union {
+			struct {
+				uint32 groupAAMarkNPC;
+				uint32 groupAANPCHealth;
+				uint32 groupAADelegateMainAssist;
+				uint32 groupAADelegateMarkNPC;
+				uint32 groupAA4;
+				uint32 groupAA5;
+				uint32 groupAAInspectBuffs;
+				uint32 groupAA7;
+				uint32 groupAASpellAwareness;
+				uint32 groupAAOffenseEnhancement;
+				uint32 groupAAManaEnhancement;
+				uint32 groupAAHealthEnhancement;
+				uint32 groupAAHealthRegeneration;
+				uint32 groupAAFindPathToPC;
+				uint32 groupAAHealthOfTargetsTarget;
+				uint32 groupAA15;
+			};
+			uint32 ranks[MAX_GROUP_LEADERSHIP_AA_ARRAY];
+		};
+	};
+
+	struct RaidLeadershipAA_Struct {
+		union {
+			struct {
+				uint32 raidAAMarkNPC;
+				uint32 raidAANPCHealth;
+				uint32 raidAADelegateMainAssist;
+				uint32 raidAADelegateMarkNPC;
+				uint32 raidAA4;
+				uint32 raidAA5;
+				uint32 raidAA6;
+				uint32 raidAASpellAwareness;
+				uint32 raidAAOffenseEnhancement;
+				uint32 raidAAManaEnhancement;
+				uint32 raidAAHealthEnhancement;
+				uint32 raidAAHealthRegeneration;
+				uint32 raidAAFindPathToPC;
+				uint32 raidAAHealthOfTargetsTarget;
+				uint32 raidAA14;
+				uint32 raidAA15;
+			};
+			uint32 ranks[MAX_RAID_LEADERSHIP_AA_ARRAY];
+		};
+	};
+
+	struct LeadershipAA_Struct {
+		union {
+			struct {
+				Convert::GroupLeadershipAA_Struct group;
+				Convert::RaidLeadershipAA_Struct raid;
+			};
+			uint32 ranks[MAX_LEADERSHIP_AA_ARRAY];
+		};
+	};
+	typedef struct
+	{
+		/*00*/ char Name[64];
+		/*64*/ uint32 Level;
+		/*68*/ uint32 Race;
+		/*72*/ uint32 Class;
+		/*76*/ uint32 Zone;
+		/*80*/ uint32 Time;
+		/*84*/ uint32 Points;
+		/*88*/
+	} PVPStatsEntry_Struct;
+	struct BandolierItem_Struct {
+		uint32 item_id;
+		uint32 icon;
+		char item_name[64];
+	};
+	struct Bandolier_Struct {
+		char name[32];
+		Convert::BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
+	};
+	struct PotionBelt_Struct {
+		Convert::BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
+	};
+	struct SuspendedMinion_Struct
+	{
+		/*000*/	uint16 SpellID;
+		/*002*/	uint32 HP;
+		/*006*/	uint32 Mana;
+		/*010*/	Convert::SpellBuff_Struct Buffs[BUFF_COUNT];
+		/*510*/	uint32 Items[_MaterialCount];
+		/*546*/	char Name[64];
+		/*610*/
+	};
+
+	struct PlayerProfile_Struct {
+		/*0000*/	uint32							checksum;			// Checksum from CRC32::SetEQChecksum
+		/*0004*/	char							name[64];			// Name of player sizes not right
+		/*0068*/	char							last_name[32];		// Last name of player sizes not right
+		/*0100*/	uint32							gender;				// Player Gender - 0 Male, 1 Female
+		/*0104*/	uint32							race;				// Player race
+		/*0108*/	uint32							class_;				// Player class
+		/*0112*/	uint32							unknown0112;		//
+		/*0116*/	uint32							level;				// Level of player (might be one byte)
+		/*0120*/	Convert::BindStruct				binds[5];			// Bind points (primary is first, home city is fifth)
+		/*0220*/	uint32							deity;				// deity
+		/*0224*/	uint32							guild_id;
+		/*0228*/	uint32							birthday;			// characters bday
+		/*0232*/	uint32							lastlogin;			// last login or zone time
+		/*0236*/	uint32							timePlayedMin;		// in minutes
+		/*0240*/	uint8							pvp;
+		/*0241*/	uint8							level2;				//no idea why this is here, but thats how it is on live
+		/*0242*/	uint8							anon;				// 2=roleplay, 1=anon, 0=not anon
+		/*0243*/	uint8							gm;
+		/*0244*/	uint8							guildrank;
+		/*0245*/	uint8							guildbanker;
+		/*0246*/	uint8							unknown0246[6];		//
+		/*0252*/	uint32							intoxication;
+		/*0256*/	uint32							spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
+		/*0292*/	uint32							abilitySlotRefresh;
+		/*0296*/	uint8							haircolor;			// Player hair color
+		/*0297*/	uint8							beardcolor;			// Player beard color
+		/*0298*/	uint8							eyecolor1;			// Player left eye color
+		/*0299*/	uint8							eyecolor2;			// Player right eye color
+		/*0300*/	uint8							hairstyle;			// Player hair style
+		/*0301*/	uint8							beard;				// Beard type
+		/*0302*/	uint8							ability_time_seconds;	//The following four spots are unknown right now.....
+		/*0303*/	uint8							ability_number;		//ability used
+		/*0304*/	uint8							ability_time_minutes;
+		/*0305*/	uint8							ability_time_hours;	//place holder
+		/*0306*/	uint8							unknown0306[6];		// @bp Spacer/Flag?
+		/*0312*/	uint32							item_material[_MaterialCount];	// Item texture/material of worn/held items
+		/*0348*/	uint8							unknown0348[44];
+		/*0392*/	Convert::Color_Struct			item_tint[_MaterialCount];
+		/*0428*/	Convert::AA_Array				aa_array[MAX_PP_AA_ARRAY];
+		/*2348*/	float							unknown2384;		//seen ~128, ~47
+		/*2352*/	char							servername[32];		// length probably not right
+		/*2384*/	char							title[32];			// length might be wrong
+		/*2416*/	char							suffix[32];			// length might be wrong
+		/*2448*/	uint32							guildid2;			//
+		/*2452*/	uint32							exp;				// Current Experience
+		/*2456*/	uint32							unknown2492;
+		/*2460*/	uint32							points;				// Unspent Practice points
+		/*2464*/	uint32							mana;				// current mana
+		/*2468*/	uint32							cur_hp;				// current hp
+		/*2472*/	uint32							unknown2508;		// 0x05
+		/*2476*/	uint32							STR;				// Strength
+		/*2480*/	uint32							STA;				// Stamina
+		/*2484*/	uint32							CHA;				// Charisma
+		/*2488*/	uint32							DEX;				// Dexterity
+		/*2492*/	uint32							INT;				// Intelligence
+		/*2496*/	uint32							AGI;				// Agility
+		/*2500*/	uint32							WIS;				// Wisdom
+		/*2504*/	uint8							face;				// Player face
+		/*2505*/	uint8							unknown2541[47];	// ?
+		/*2552*/	uint8							languages[MAX_PP_LANGUAGE];
+		/*2580*/	uint8							unknown2616[4];
+		/*2584*/	uint32							spell_book[MAX_PP_REF_SPELLBOOK];
+		/*4504*/	uint8							unknown4540[128];	// Was [428] all 0xff
+		/*4632*/	uint32							mem_spells[MAX_PP_REF_MEMSPELL];
+		/*4668*/	uint8							unknown4704[32];	//
+		/*4700*/	float							y;					// Player y position
+		/*4704*/	float							x;					// Player x position
+		/*4708*/	float							z;					// Player z position
+		/*4712*/	float							heading;			// Direction player is facing
+		/*4716*/	uint8							unknown4752[4];		//
+		/*4720*/	int32							platinum;			// Platinum Pieces on player
+		/*4724*/	int32							gold;				// Gold Pieces on player
+		/*4728*/	int32							silver;				// Silver Pieces on player
+		/*4732*/	int32							copper;				// Copper Pieces on player
+		/*4736*/	int32							platinum_bank;		// Platinum Pieces in Bank
+		/*4740*/	int32							gold_bank;			// Gold Pieces in Bank
+		/*4744*/	int32							silver_bank;		// Silver Pieces in Bank
+		/*4748*/	int32							copper_bank;		// Copper Pieces in Bank
+		/*4752*/	int32							platinum_cursor;	// Platinum on cursor
+		/*4756*/	int32							gold_cursor;		// Gold on cursor
+		/*4760*/	int32							silver_cursor;		// Silver on cursor
+		/*4764*/	int32							copper_cursor;		// Copper on cursor
+		/*4768*/	int32							platinum_shared;	// Platinum shared between characters
+		/*4772*/	uint8							unknown4808[24];
+		/*4796*/	uint32							skills[MAX_PP_SKILL];	// [400] List of skills	// 100 dword buffer
+		/*5196*/	uint8							unknown5132[184];
+		/*5380*/	uint32							pvp2;				//
+		/*5384*/	uint32							unknown5420;		//
+		/*5388*/	uint32							pvptype;			//
+		/*5392*/	uint32							unknown5428;		//
+		/*5396*/	uint32							ability_down;		// Guessing
+		/*5400*/	uint8							unknown5436[8];		//
+		/*5408*/	uint32							autosplit;			//not used right now
+		/*5412*/	uint8							unknown5448[8];
+		/*5420*/	uint32							zone_change_count;	// Number of times user has zoned in their career (guessing)
+		/*5424*/	uint8							unknown5460[16];	//
+		/*5440*/	uint32							drakkin_heritage;	//
+		/*5444*/	uint32							drakkin_tattoo;		//
+		/*5448*/	uint32							drakkin_details;	//
+		/*5452*/	uint32							expansions;			// expansion setting, bit field of expansions avaliable
+		/*5456*/	int32							toxicity;			//from drinking potions, seems to increase by 3 each time you drink
+		/*5460*/	char							unknown5496[16];	//
+		/*5476*/	int32							hunger_level;
+		/*5480*/	int32							thirst_level;
+		/*5484*/	uint32							ability_up;
+		/*5488*/	char							unknown5524[16];
+		/*5504*/	uint16							zone_id;			// Current zone of the player
+		/*5506*/	uint16							zoneInstance;		// Instance ID
+		/*5508*/	Convert::SpellBuff_Struct		buffs[BUFF_COUNT];	// Buffs currently on the player
+		/*6008*/	char							groupMembers[6][64];//
+		/*6392*/	char							unknown6428[656];
+		/*7048*/	uint32							entityid;
+		/*7052*/	uint32							leadAAActive;
+		/*7056*/	uint32							unknown7092;
+		/*7060*/	int32							ldon_points_guk;	//client uses these as signed
+		/*7064*/	int32							ldon_points_mir;
+		/*7068*/	int32							ldon_points_mmc;
+		/*7072*/	int32							ldon_points_ruj;
+		/*7076*/	int32							ldon_points_tak;
+		/*7080*/	int32							ldon_points_available;
+		/*7084*/	int32							ldon_wins_guk;
+		/*7088*/	int32							ldon_wins_mir;
+		/*7092*/	int32							ldon_wins_mmc;
+		/*7096*/	int32							ldon_wins_ruj;
+		/*7100*/	int32							ldon_wins_tak;
+		/*7104*/	int32							ldon_losses_guk;
+		/*7108*/	int32							ldon_losses_mir;
+		/*7112*/	int32							ldon_losses_mmc;
+		/*7116*/	int32							ldon_losses_ruj;
+		/*7120*/	int32							ldon_losses_tak;
+		/*7124*/	uint8							unknown7160[72];
+		/*7196*/	uint32							tribute_time_remaining;	//in miliseconds
+		/*7200*/	uint32							showhelm;
+		/*7204*/	uint32							career_tribute_points;
+		/*7208*/	uint32							unknown7244;
+		/*7212*/	uint32							tribute_points;
+		/*7216*/	uint32							unknown7252;
+		/*7220*/	uint32							tribute_active;		//1=active
+		/*7224*/	Convert::Tribute_Struct			tributes[EmuConstants::TRIBUTE_SIZE];
+		/*7264*/	Convert::Disciplines_Struct		disciplines;
+		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
+		/*7744*/	char							unknown7780[160];
+		/*7904*/	uint32							endurance;
+		/*7908*/	uint32							group_leadership_exp;	//0-1000
+		/*7912*/	uint32							raid_leadership_exp;	//0-2000
+		/*7916*/	uint32							group_leadership_points;
+		/*7920*/	uint32							raid_leadership_points;
+		/*7924*/	Convert::LeadershipAA_Struct	leader_abilities;
+		/*8052*/	uint8							unknown8088[132];
+		/*8184*/	uint32							air_remaining;
+		/*8188*/	uint32							PVPKills;
+		/*8192*/	uint32							PVPDeaths;
+		/*8196*/	uint32							PVPCurrentPoints;
+		/*8200*/	uint32							PVPCareerPoints;
+		/*8204*/	uint32							PVPBestKillStreak;
+		/*8208*/	uint32							PVPWorstDeathStreak;
+		/*8212*/	uint32							PVPCurrentKillStreak;
+		/*8216*/	Convert::PVPStatsEntry_Struct	PVPLastKill;
+		/*8304*/	Convert::PVPStatsEntry_Struct	PVPLastDeath;
+		/*8392*/	uint32							PVPNumberOfKillsInLast24Hours;
+		/*8396*/	Convert::PVPStatsEntry_Struct	PVPRecentKills[50];
+		/*12796*/	uint32							aapoints_spent;
+		/*12800*/	uint32							expAA;
+		/*12804*/	uint32							aapoints;			//avaliable, unspent
+		/*12808*/	uint8							unknown12844[36];
+		/*12844*/	Convert::Bandolier_Struct		bandoliers[EmuConstants::BANDOLIERS_COUNT];
+		/*14124*/	uint8							unknown14160[4506];
+		/*18630*/	Convert::SuspendedMinion_Struct	SuspendedMinion; // No longer in use
+		/*19240*/	uint32							timeentitledonaccount;
+		/*19244*/	Convert::PotionBelt_Struct		potionbelt;			//there should be 3 more of these
+		/*19532*/	uint8							unknown19568[8];
+		/*19540*/	uint32							currentRadCrystals; // Current count of radiant crystals
+		/*19544*/	uint32							careerRadCrystals;	// Total count of radiant crystals ever
+		/*19548*/	uint32							currentEbonCrystals;// Current count of ebon crystals
+		/*19552*/	uint32							careerEbonCrystals;	// Total count of ebon crystals ever
+		/*19556*/	uint8							groupAutoconsent;	// 0=off, 1=on
+		/*19557*/	uint8							raidAutoconsent;	// 0=off, 1=on
+		/*19558*/	uint8							guildAutoconsent;	// 0=off, 1=on
+		/*19559*/	uint8							unknown19595[5];	// ***Placeholder (6/29/2005)
+		/*19564*/	uint32							RestTimer;
+		/*19568*/
+	};
+	
+
+	namespace player_lootitem_temp
+	{
+		struct ServerLootItem_Struct_temp {
+			uint32	item_id;
+			int16	equipSlot;
+			uint8	charges;
+			uint16	lootslot;
+			uint32 aug1;
+			uint32 aug2;
+			uint32 aug3;
+			uint32 aug4;
+			uint32 aug5;
+		};
+	}
+
+	struct DBPlayerCorpse_Struct_temp {
+		uint32	crc;
+		bool	locked;
+		uint32	itemcount;
+		uint32	exp;
+		float	size;
+		uint8	level;
+		uint8	race;
+		uint8	gender;
+		uint8	class_;
+		uint8	deity;
+		uint8	texture;
+		uint8	helmtexture;
+		uint32	copper;
+		uint32	silver;
+		uint32	gold;
+		uint32	plat;
+		Color_Struct item_tint[9];
+		uint8 haircolor;
+		uint8 beardcolor;
+		uint8 eyecolor1;
+		uint8 eyecolor2;
+		uint8 hairstyle;
+		uint8 face;
+		uint8 beard;
+		uint32 drakkin_heritage;
+		uint32 drakkin_tattoo;
+		uint32 drakkin_details;
+		player_lootitem_temp::ServerLootItem_Struct_temp	items[0];
+	};
+
+	namespace classic_db_temp {
+		struct DBPlayerCorpse_Struct_temp {
+			uint32	crc;
+			bool	locked;
+			uint32	itemcount;
+			uint32	exp;
+			float	size;
+			uint8	level;
+			uint8	race;
+			uint8	gender;
+			uint8	class_;
+			uint8	deity;
+			uint8	texture;
+			uint8	helmtexture;
+			uint32	copper;
+			uint32	silver;
+			uint32	gold;
+			uint32	plat;
+			Color_Struct item_tint[9];
+			uint8 haircolor;
+			uint8 beardcolor;
+			uint8 eyecolor1;
+			uint8 eyecolor2;
+			uint8 hairstyle;
+			uint8 face;
+			uint8 beard;
+			player_lootitem_temp::ServerLootItem_Struct_temp	items[0];
+		};
+	}
+}
+
+#pragma pack()
+
 class Database : public DBcore {
 public:
 	Database();
 	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
-	
-	
-//	void	ExtraOptions();
-	
+

 	/*
-	 * General Character Related Stuff
-	 */
+	* General Character Related Stuff
+	*/
+
+	/* Character Creation */
+	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
+
 	bool	MoveCharacterToZone(const char* charname, const char* zonename);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
 	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);
@@ -123,32 +517,31 @@ public:
 	bool	AddToNameFilter(const char* name);
 	bool	ReserveName(uint32 account_id, char* name);
 	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
-	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext);
+	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
 	bool	DeleteCharacter(char* name);
-	uint8	CopyCharacter(const char* oldname, const char* newname, uint32 acctid);

 	/*
-	 * General Information Getting Queries
-	 */
+	* General Information Getting Queries
+	*/
 	bool	CheckNameFilter(const char* name, bool surname = false);
 	bool	CheckUsedName(const char* name);
 	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	GetGuildDBIDByCharID(uint32 char_id);
+	uint32	GetGuildIDByCharID(uint32 char_id);
 	void	GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID = 0);
 	void	GetCharName(uint32 char_id, 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	GetCharacterID(const char *name);
-	bool	CheckBannedIPs(const char* loginIP); //Lieka Edit:  Check incomming connection against banned IP table.
- 	bool	AddBannedIP(char* bannedIP, const char* notes); //Lieka Edit:  Add IP address to the Banned_IPs table.
+	bool	CheckBannedIPs(const char* loginIP); //Lieka Edit: Check incomming connection against banned IP table.
+	bool	AddBannedIP(char* bannedIP, const char* notes); //Lieka Edit: Add IP address to the Banned_IPs table.
 	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
 	bool	AddGMIP(char* ip_address, char* name);
 	void	LoginIP(uint32 AccountID, const char* LoginIP);

 	/*
-	 * Instancing Stuff
-	 */
+	* Instancing Stuff
+	*/
 	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
 	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
 	bool CharacterInInstanceGroup(uint16 instance_id, uint32 char_id);
@@ -168,6 +561,7 @@ public:
 	uint16 GetInstanceVersion(uint16 instance_id);
 	uint16 GetInstanceID(const char* zone, uint32 charid, int16 version);
 	uint16 GetInstanceID(uint32 zone, uint32 charid, int16 version);
+	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
 	void AssignGroupToInstance(uint32 gid, uint32 instance_id);
 	void AssignRaidToInstance(uint32 rid, uint32 instance_id);
 	void FlagInstanceByGroupLeader(uint32 zone, int16 version, uint32 charid, uint32 gid);
@@ -176,99 +570,119 @@ public:
 	bool GlobalInstance(uint16 instance_id);

 	/*
-	 * Adventure related.
-	 */
+	* Adventure related.
+	*/
 	void UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win);
-	bool GetAdventureStats(uint32 char_id, uint32 &guk_w, uint32 &mir_w, uint32 &mmc_w, uint32 &ruj_w, uint32 &tak_w, 
-		uint32 &guk_l, uint32 &mir_l, uint32 &mmc_l, uint32 &ruj_l, uint32 &tak_l);
+	bool GetAdventureStats(uint32 char_id, AdventureStats_Struct *as);

 	/*
-	 * Account Related
-	 */
+	* Account Related
+	*/
 	uint32	GetMiniLoginAccount(char* ip);
 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
 	int16	CheckStatus(uint32 account_id);
 	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
 	bool	DeleteAccount(const char* name);
- 	bool	SetAccountStatus(const char* name, int16 status);
+	bool	SetAccountStatus(const char* name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
 	uint32	GetAccountIDFromLSID(uint32 iLSID, char* oAccountName = 0, int16* oStatus = 0);
 	bool	UpdateLiveChar(char* charname,uint32 lsaccount_id);
 	bool	GetLiveChar(uint32 account_id, char* cname);
 	uint8	GetAgreementFlag(uint32 acctid);
 	void	SetAgreementFlag(uint32 acctid);
-	
+
 	/*
-	 * Groups
-	 */
+	* Groups
+	*/
 	uint32	GetGroupID(const char* name);
 	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
 	void	ClearGroup(uint32 gid = 0);
 	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
-	
+
 	void	SetGroupLeaderName(uint32 gid, const char* name);
-	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = NULL, char* assist = NULL, char* puller = NULL, char *marknpc = NULL,
-				       GroupLeadershipAA_Struct* GLAA = NULL);
+	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
+						char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
 	void	ClearGroupLeader(uint32 gid = 0);
+	

 	/*
-	 * Raids
-	 */
+	* Raids
+	*/
 	void	ClearRaid(uint32 rid = 0);
 	void	ClearRaidDetails(uint32 rid = 0);
 	uint32	GetRaidID(const char* name);
 	const char *GetRaidLeaderName(uint32 rid);
+	void	GetGroupLeadershipInfo(uint32 gid, uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
+			char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
+	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
+			RaidLeadershipAA_Struct* RLAA = nullptr);
+	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
+	void	ClearRaidLeader(uint32 gid = 0xFFFFFFFF, uint32 rid = 0);
+
+	/* Database Conversions*/
+	bool	CheckDatabaseConversions();
+	bool	CheckDatabaseConvertPPDeblob();
+	bool	CheckDatabaseConvertCorpseDeblob();
+	bool	CheckDatabaseConvertBotsPostPPDeblob();

 	/*
-	 * Database Varaibles
-	 */
+	* Database Variables
+	*/
 	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
 	bool	SetVariable(const char* varname, const char* varvalue);
 	bool	LoadVariables();
 	uint32	LoadVariables_MQ(char** query);
-	bool	LoadVariables_result(MYSQL_RES* result);
-	
+	bool	LoadVariables_result(MySQLRequestResult results);
+
 	/*
-	 * General Queries
-	 */
+	* General Queries
+	*/
 	bool	LoadZoneNames();
 	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
 	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
 	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
 	uint32	GetZoneID(const char* zonename);
-	uint8    GetPEQZone(uint32 zoneID, uint32 version);
+	uint8	GetPEQZone(uint32 zoneID, uint32 version);
 	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
 	uint8	GetServerType();
-	bool	GetSafePoints(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = NULL);
-	bool	GetSafePoints(uint32 zoneID, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = NULL) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, flag_needed); }
+	bool	GetSafePoints(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr);
+	bool	GetSafePoints(uint32 zoneID, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, flag_needed); }
 	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
 	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
 	bool	LoadPTimers(uint32 charid, PTimerList &into);
 	void	ClearPTimers(uint32 charid);
 	void	ClearMerchantTemp();
-	void	SetLFP(uint32 CharID, bool LFP); 
+	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLFG(uint32 CharID, bool LFG);
 	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
-	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon); 
+	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 	void	AddReport(std::string who, std::string against, std::string lines);
-	

-protected:
-	void	HandleMysqlError(uint32 errnum);
-	//bool	RunQuery(const char* query, uint32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* errnum = 0, bool retry = true);
-	
 private:
 	void DBInitVars();
-	
-	uint32				max_zonename;
-	char**				zonename_array;
-	
+
+	std::map<uint32,std::string>	zonename_array;
+
 	Mutex				Mvarcache;
 	uint32				varcache_max;
 	VarCache_Struct**	varcache_array;
 	uint32				varcache_lastupdate;
+
+
+	/*
+	* Groups, utility methods.
+	*/
+	void    ClearAllGroupLeaders();
+	void    ClearAllGroups();
+
+
+	/*
+	* Raid, utility methods.
+	*/
+	void ClearAllRaids();
+	void ClearAllRaidDetails();
+	void ClearAllRaidLeaders();
 };

-bool	FetchRowMap(MYSQL_RES *result, map<string,string> &rowmap);
 #endif
@@ -1,677 +0,0 @@
-#include "debug.h"
-#ifdef _WINDOWS
-	#include <windows.h>
-	#include <process.h>
-	#include <winsock2.h>
-#endif
-#include <iostream>
-using namespace std;
-#include "dbasync.h"
-#include "database.h"
-#include <errmsg.h>
-#include <mysqld_error.h>
-#include <limits.h>
-#include "dbcore.h"
-#include "common_profile.h"
-#include <string.h>
-#include "../common/MiscFunctions.h"
-#define ASYNC_LOOP_GRANULARITY 4 //# of ms between checking our work
-
-bool DBAsyncCB_LoadVariables(DBAsyncWork* iWork) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	MYSQL_RES* result = 0;
-	DBAsyncQuery* dbaq = iWork->PopAnswer();
-	if (dbaq->GetAnswer(errbuf, &result))
-		iWork->GetDB()->LoadVariables_result(result);
-	else
-		cout << "Error: DBAsyncCB_LoadVariables failed: !GetAnswer: '" << errbuf << "'" << endl;
-	return true;
-}
-
-void AsyncLoadVariables(DBAsync *dba, Database *db) {
-	char* query = 0;
-	DBAsyncWork* dbaw = new DBAsyncWork(db, &DBAsyncCB_LoadVariables, 0, DBAsync::Read);
-	dbaw->AddQuery(0, &query, db->LoadVariables_MQ(&query));
-	dba->AddWork(&dbaw);
-}
-
-
-//we only need to do anything when somebody puts work on the queue
-//so instead of checking all the time, we will wait on a condition
-//which will get signaled when somebody puts something on the queue
-ThreadReturnType DBAsyncLoop(void* tmp) {
-	DBAsync* dba = (DBAsync*) tmp;
-	
-#ifndef WIN32
-	_log(COMMON__THREADS, "Starting DBAsyncLoop with thread ID %d", pthread_self());
-#endif
-	
-	dba->MLoopRunning.lock();
-	while (dba->RunLoop()) {
-		//wait before working so we check the loop condition
-		//as soon as were done working
-		dba->CInList.Wait();
-		//we could check dba->RunLoop() again to see if we
-		//got turned off while we were waiting
-		{
-			_CP(DBAsyncLoop_loop);
-			dba->Process();
-		}
-//		Sleep(ASYNC_LOOP_GRANULARITY);
-	}
-	dba->MLoopRunning.unlock();
-	
-#ifndef WIN32
-	_log(COMMON__THREADS, "Ending DBAsyncLoop with thread ID %d", pthread_self());
-#endif
-	
-	THREAD_RETURN(NULL);
-}
-
-DBAsync::DBAsync(DBcore* iDBC)
-: Timeoutable(10000)
-{
-	pDBC = iDBC;
-	pRunLoop = true;
-	pNextID = 1;
-#ifdef _WINDOWS
-	_beginthread(DBAsyncLoop, 0, this);
-#else
-	pthread_t thread;
-	pthread_create(&thread, NULL, DBAsyncLoop, this);
-#endif
-}
-
-DBAsync::~DBAsync() {
-	StopThread();
-}
-
-bool DBAsync::StopThread() {
-	bool ret;
-	MRunLoop.lock();
-	ret = pRunLoop;
-	pRunLoop = false;
-	MRunLoop.unlock();
-	
-	//signal the condition so we exit the loop if were waiting
-	CInList.Signal();
-	
-	//this effectively waits for the processing thread to finish
-	MLoopRunning.lock();
-	MLoopRunning.unlock();
-	
-	return ret;
-}
-
-uint32 DBAsync::AddWork(DBAsyncWork** iWork, uint32 iDelay) {
-	MInList.lock();
-	uint32 ret = GetNextID();
-	if (!(*iWork)->SetWorkID(ret)) {
-		MInList.unlock();
-		return 0;
-	}
-	InList.Append(*iWork);
-	(*iWork)->SetStatus(Queued);
-	if (iDelay)
-		(*iWork)->pExecuteAfter = Timer::GetCurrentTime() + iDelay;
-#if DEBUG_MYSQL_QUERIES >= 2
-	cout << "Adding AsyncWork #" << (*iWork)->GetWorkID() << endl;
-	cout << "ExecuteAfter = " << (*iWork)->pExecuteAfter << " (" << Timer::GetCurrentTime() << " + " << iDelay << ")" << endl;
-#endif
-	*iWork = 0;
-	MInList.unlock();
-	
-	//wake up the processing thread and tell it to get to work.
-	CInList.Signal();
-	
-	return ret;
-}
-
-bool DBAsync::CancelWork(uint32 iWorkID) {
-	if (iWorkID == 0)
-		return false;
-#if DEBUG_MYSQL_QUERIES >= 2
-	cout << "DBAsync::CancelWork: " << iWorkID << endl;
-#endif
-	MCurrentWork.lock();
-	if (CurrentWork && CurrentWork->GetWorkID() == iWorkID) {
-		CurrentWork->Cancel();
-		MCurrentWork.unlock();
-		return true;
-	}
-	MCurrentWork.unlock();
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->GetWorkID() == iWorkID) {
-			iterator.RemoveCurrent(true);
-			MInList.unlock();
-			return true;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return false;
-}
-
-bool DBAsync::RunLoop() {
-	bool ret;
-	MRunLoop.lock();
-	ret = pRunLoop;
-	MRunLoop.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsync::InListPop() {
-	DBAsyncWork* ret = 0;
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->pExecuteAfter <= Timer::GetCurrentTime()) {
-			ret = iterator.GetData();
-#if DEBUG_MYSQL_QUERIES >= 2
-			cout << "Poping AsyncWork #" << ret->GetWorkID() << endl;
-			cout << ret->pExecuteAfter << " <= " << Timer::GetCurrentTime() << endl;
-#endif
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsync::InListPopWrite() {
-	MInList.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(InList);
-
-	DBAsyncWork* ret = 0;
-	DBAsync::Type tmpType;
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		tmpType = iterator.GetData()->Type();
-		if (tmpType == Write || tmpType == Both) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MInList.unlock();
-	return ret;
-}
-
-void DBAsync::AddFQ(DBAsyncFinishedQueue* iDBAFQ) {
-	MFQList.lock();
-	DBAsyncFinishedQueue** tmp = new DBAsyncFinishedQueue*;
-	*tmp = iDBAFQ;
-	FQList.Append(tmp);
-	MFQList.unlock();
-}
-
-void DBAsync::Process() {
-	DBAsyncWork* tmpWork;
-	MCurrentWork.lock();
-	while ((CurrentWork = InListPop())) {
-		MCurrentWork.unlock();
-		//move from queued to executing
-		Status tmpStatus = CurrentWork->SetStatus(Executing);
-		if (tmpStatus == Queued) {
-			//execute the work
-			ProcessWork(CurrentWork);
-			tmpWork = CurrentWork;
-			MCurrentWork.lock();
-			CurrentWork = 0;
-			MCurrentWork.unlock();
-			//move from executing to finished
-			tmpStatus = tmpWork->SetStatus(DBAsync::Finished);
-			if (tmpStatus != Executing) {
-				if (tmpStatus != Canceled) {
-					cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::Process #1" << endl;
-				}
-				MCurrentWork.lock();
-				safe_delete(tmpWork);
-			}
-			else {
-				//call callbacks or put results on finished queue
-				DispatchWork(tmpWork);
-				Sleep(25);
-				MCurrentWork.lock();
-			}
-		}
-		else {
-			if (tmpStatus != Canceled) {
-				cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::Process #2" << endl;
-			}
-			MCurrentWork.lock();
-			safe_delete(CurrentWork);
-		}
-	}
-	MCurrentWork.unlock();
-}
-
-void DBAsync::CheckTimeout() {
-	try{
-		MFQList.lock();
-		LinkedListIterator<DBAsyncFinishedQueue**> iterator(FQList);
-
-		iterator.Reset();
-		while (iterator.MoreElements()) {
-			(*iterator.GetData())->CheckTimeouts();
-			iterator.Advance();
-		}
-		MFQList.unlock();
-	}
-	catch(...){
-		
-	}
-}
-
-void DBAsync::CommitWrites() {
-#if DEBUG_MYSQL_QUERIES >= 2
-	cout << "DBAsync::CommitWrites() called." << endl;
-#endif
-	DBAsyncWork* tmpWork;
-	while ((tmpWork = InListPopWrite())) {
-		Status tmpStatus = tmpWork->SetStatus(Executing);
-		if (tmpStatus == Queued) {
-			ProcessWork(tmpWork);
-			tmpStatus = tmpWork->SetStatus(DBAsync::Finished);
-			if (tmpStatus != Executing) {
-				if (tmpStatus != Canceled) {
-					cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::CommitWrites #1" << endl;
-				}
-				safe_delete(tmpWork);
-			}
-			else {
-				DispatchWork(tmpWork);
-			}
-		}
-		else {
-			if (tmpStatus != Canceled) {
-				cout << "Error: Unexpected DBAsyncWork->Status in DBAsync::CommitWrites #2" << endl;
-			}
-			safe_delete(tmpWork);
-		}
-	}
-}
-
-void DBAsync::ProcessWork(DBAsyncWork* iWork, bool iSleep) {
-	_CP(DBAsync_ProcessWork);
-	DBAsyncQuery* CurrentQuery;
-#if DEBUG_MYSQL_QUERIES >= 2
-	cout << "Processing AsyncWork #" << iWork->GetWorkID() << endl;
-#endif
-	while ((CurrentQuery = iWork->PopQuery())) {
-		CurrentQuery->Process(pDBC);
-		iWork->PushAnswer(CurrentQuery);
-		if (iSleep)
-			Sleep(1);
-	}
-}
-
-void DBAsync::DispatchWork(DBAsyncWork* iWork) {
-	_CP(DBAsync_DispatchWork);
-	//if this work has a callback, call it
-	//otherwise, stick the work on the finish queue
-	if (iWork->pCB) {
-		if (iWork->pCB(iWork))
-			safe_delete(iWork);
-	}
-	else {
-		if (!iWork->pDBAFQ->Push(iWork))
-			safe_delete(iWork);
-	}
-}
-
-
-
-DBAsyncFinishedQueue::DBAsyncFinishedQueue(uint32 iTimeout) {
-	pTimeout = iTimeout;
-}
-
-DBAsyncFinishedQueue::~DBAsyncFinishedQueue() {
-}
-
-void DBAsyncFinishedQueue::CheckTimeouts() {
-	if (pTimeout == 0xFFFFFFFF)
-		return;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->CheckTimeout(pTimeout))
-			iterator.RemoveCurrent(true);
-		iterator.Advance();
-	}
-	MLock.unlock();
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::Pop() {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	ret = list.Pop();
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::Find(uint32 iWorkID) {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->GetWorkID() == iWorkID) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncWork* DBAsyncFinishedQueue::PopByWPT(uint32 iWPT) {
-	DBAsyncWork* ret = 0;
-	MLock.lock();
-	LinkedListIterator<DBAsyncWork*> iterator(list);
-
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()->WPT() == iWPT) {
-			ret = iterator.GetData();
-			iterator.RemoveCurrent(false);
-			break;
-		}
-		iterator.Advance();
-	}
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncFinishedQueue::Push(DBAsyncWork* iDBAW) {
-	if (!this)
-		return false;
-	MLock.lock();
-	list.Append(iDBAW);
-	MLock.unlock();
-	return true;
-}
-
-
-
-DBAsyncWork::DBAsyncWork(Database *db, DBAsyncFinishedQueue* iDBAFQ, uint32 iWPT, DBAsync::Type iType, uint32 iTimeout)
-: m_db(db)
-{
-	pstatus = DBAsync::AddingWork;
-	pType = iType;
-	pExecuteAfter = 0;
-	pWorkID = 0;
-	pDBAFQ = iDBAFQ;
-	pCB = 0;
-	pWPT = iWPT;
-	pQuestionCount = 0;
-	pAnswerCount = 0;
-	pTimeout = iTimeout;
-	pTSFinish = 0;
-}
-
-DBAsyncWork::DBAsyncWork(Database *db, DBWorkCompleteCallBack iCB, uint32 iWPT, DBAsync::Type iType, uint32 iTimeout)
-: m_db(db)
-{
-	pstatus = DBAsync::AddingWork;
-	pType = iType;
-	pExecuteAfter = 0;
-	pWorkID = 0;
-	pDBAFQ = 0;
-	pCB = iCB;
-	pWPT = iWPT;
-	pQuestionCount = 0;
-	pAnswerCount = 0;
-	pTimeout = iTimeout;
-	pTSFinish = 0;
-}
-
-DBAsyncWork::~DBAsyncWork() {
-	DBAsyncQuery* dbaq = 0;
-	while ((dbaq = todo.pop()))
-		safe_delete(dbaq);
-	while ((dbaq = done.pop()))
-		safe_delete(dbaq);
-	while ((dbaq = todel.pop()))
-		safe_delete(dbaq);
-}
-
-bool DBAsyncWork::AddQuery(DBAsyncQuery** iDBAQ) {
-	bool ret;
-	MLock.lock();
-	if (pstatus != DBAsync::AddingWork)
-		ret = false;
-	else {
-		ret = true;
-		pQuestionCount++;
-		todo.push(*iDBAQ);
-		(*iDBAQ)->pstatus = DBAsync::Queued;
-		*iDBAQ = 0;
-	}
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	DBAsyncQuery* DBAQ = new DBAsyncQuery(iQPT, iQuery, iQueryLen, iGetResultSet, iGetErrbuf);
-	if (AddQuery(&DBAQ))
-		return true;
-	else {
-		safe_delete(DBAQ);
-		return false;
-	}
-}
-
-bool DBAsyncWork::SetWorkID(uint32 iWorkID) {
-	bool ret = true;
-	MLock.lock();
-	if (pWorkID)
-		ret = false;
-	else
-		pWorkID = iWorkID;
-	MLock.unlock();
-	return ret;
-}
-
-uint32 DBAsyncWork::GetWorkID() {
-	uint32 ret;
-	MLock.lock();
-	ret = pWorkID;
-	MLock.unlock();
-	return ret;
-}
-
-uint32 DBAsyncWork::WPT() {
-	uint32 ret;
-	MLock.lock();
-	ret = pWPT;
-	MLock.unlock();
-	return ret;
-}
-
-DBAsync::Type DBAsyncWork::Type() {
-	DBAsync::Type ret;
-	MLock.lock();
-	ret = pType;
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncQuery* DBAsyncWork::PopAnswer() {
-	DBAsyncQuery* ret;
-	MLock.lock();
-	ret = done.pop();
-	if (ret)
-		pAnswerCount--;
-	todel.push(ret);
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::CheckTimeout(uint32 iFQTimeout) {
-	if (pTimeout == 0xFFFFFFFF)
-		return false;
-	bool ret = false;
-	MLock.lock();
-	if (pTimeout > iFQTimeout)
-		iFQTimeout = pTimeout;
-	if (Timer::GetCurrentTime() > (pTSFinish + iFQTimeout))
-		ret = true;
-	MLock.unlock();
-	return ret;
-}
-
-//sets the work's status to the supplied value and returns
-//the revious status
-DBAsync::Status DBAsyncWork::SetStatus(DBAsync::Status iStatus) {
-	DBAsync::Status ret;
-	MLock.lock();
-	if (iStatus == DBAsync::Finished)
-		pTSFinish = Timer::GetCurrentTime();
-	ret = pstatus;
-	pstatus = iStatus;
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::Cancel() {
-	bool ret;
-	MLock.lock();
-	if (pstatus != DBAsync::Finished) {
-		pstatus = DBAsync::Canceled;
-		ret = true;
-	}
-	else
-		ret = false;
-	MLock.unlock();
-	return ret;
-}
-
-bool DBAsyncWork::IsCancled() {
-	bool ret;
-	MLock.lock();
-	ret = (bool) (pstatus == DBAsync::Canceled);
-	MLock.unlock();
-	return ret;
-}
-
-DBAsyncQuery* DBAsyncWork::PopQuery() {
-	DBAsyncQuery* ret = 0;
-	MLock.lock();
-	ret = todo.pop();
-	if (ret)
-		pQuestionCount--;
-	MLock.unlock();
-	return ret;
-}
-
-void DBAsyncWork::PushAnswer(DBAsyncQuery* iDBAQ) {
-	MLock.lock();
-	done.push(iDBAQ);
-	pAnswerCount++;
-	MLock.unlock();
-}
-
-
-DBAsyncQuery::DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	if (iQueryLen == 0xFFFFFFFF)
-		pQueryLen = strlen(*iQuery);
-	else
-		pQueryLen = iQueryLen;
-	pQuery = *iQuery;
-	*iQuery = 0;
-	Init(iQPT, iGetResultSet, iGetErrbuf);
-}
-
-DBAsyncQuery::DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
-	if (iQueryLen == 0xFFFFFFFF)
-		pQueryLen = strlen(iQuery);
-	else
-		pQueryLen = iQueryLen;
-	pQuery = strn0cpy(new char[pQueryLen+1], iQuery, pQueryLen+1);
-	Init(iQPT, iGetResultSet, iGetErrbuf);
-}
-
-void DBAsyncQuery::Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf) {
-	pstatus = DBAsync::AddingWork;
-	pQPT = iQPT;
-	pGetResultSet = iGetResultSet;
-	pGetErrbuf = iGetErrbuf;
-
-	pmysqlsuccess = false;
-	perrbuf = 0;
-	perrnum = 0;
-	presult = 0;
-	paffected_rows = 0;
-	plast_insert_id = 0;
-}
-
-DBAsyncQuery::~DBAsyncQuery() {
-	safe_delete_array(perrbuf);
-	safe_delete_array(pQuery);
-	if (presult)
-		mysql_free_result(presult);
-}
-
-bool DBAsyncQuery::GetAnswer(char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum) {
-	if (pstatus != DBAsync::Finished) {
-		if (errbuf)
-			snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error: Query not finished.");
-		if (errnum)
-			*errnum = UINT_MAX;
-		return false;
-	}
-	if (errbuf) {
-		if (pGetErrbuf) {
-			if (perrbuf)
-				strn0cpy(errbuf, perrbuf, MYSQL_ERRMSG_SIZE);
-			else
-				snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error message should've been saved, but hasnt. errno: %u", perrnum);
-		}
-		else
-			snprintf(errbuf, MYSQL_ERRMSG_SIZE, "Error message not saved. errno: %u", perrnum);
-	}
-	if (errnum)
-		*errnum = perrnum;
-	if (affected_rows)
-		*affected_rows = paffected_rows;
-	if (last_insert_id)
-		*last_insert_id = plast_insert_id;
-	if (result)
-		*result = presult;
-	return pmysqlsuccess;
-}
-
-void DBAsyncQuery::Process(DBcore* iDBC) {
-	pstatus = DBAsync::Executing;
-	if (pGetErrbuf)
-		perrbuf = new char[MYSQL_ERRMSG_SIZE];
-	MYSQL_RES** resultPP = 0;
-	if (pGetResultSet)
-		resultPP = &presult;
-	pmysqlsuccess = iDBC->RunQuery(pQuery, pQueryLen, perrbuf, resultPP, &paffected_rows, &plast_insert_id, &perrnum);
-	pstatus = DBAsync::Finished;
-}
-
-
-
-
-
-
-
-
-
@@ -1,176 +0,0 @@
-#ifndef DBASYNC_H
-#define DBASYNC_H
-#include "../common/dbcore.h"
-#include "../common/timeoutmgr.h"
-
-
-class DBAsyncFinishedQueue;
-class DBAsyncWork;
-class DBAsyncQuery;
-class Database;
-
-// Big daddy that owns the threads and does the work
-class DBAsync : private Timeoutable {
-public:
-	enum Status { AddingWork, Queued, Executing, Finished, Canceled };
-	enum Type { Read, Write, Both };
-
-	DBAsync(DBcore* iDBC);
-	~DBAsync();
-	bool	StopThread();
-
-	uint32	AddWork(DBAsyncWork** iWork, uint32 iDelay = 0);
-	bool	CancelWork(uint32 iWorkID);
-	void	CommitWrites();
-
-	void	AddFQ(DBAsyncFinishedQueue* iDBAFQ);
-protected:
-	//things related to the processing thread:
-	friend ThreadReturnType DBAsyncLoop(void* tmp);
-	Mutex	MLoopRunning;
-	Condition CInList;
-	bool	RunLoop();
-	void	Process();
-	
-private:
-	virtual void CheckTimeout();
-	
-	void	ProcessWork(DBAsyncWork* iWork, bool iSleep = true);
-	void	DispatchWork(DBAsyncWork* iWork);
-	inline	uint32	GetNextID()		{ return pNextID++; }
-	DBAsyncWork*	InListPop();
-	DBAsyncWork*	InListPopWrite();	// Ignores delay
-	void			OutListPush(DBAsyncWork* iDBAW);
-
-	Mutex	MRunLoop;
-	bool	pRunLoop;
-
-	DBcore*	pDBC;
-	uint32	pNextID;
-	Mutex	MInList;
-	LinkedList<DBAsyncWork*> InList;
-
-	Mutex	MFQList;
-	LinkedList<DBAsyncFinishedQueue**> FQList;
-
-	// Mutex for outside access to current work & when current work is being changed.
-	// NOT locked when CurrentWork is being accessed by the DBAsync thread.
-	// Never change pointer from outside DBAsync thread!
-	// Only here for access to thread-safe DBAsyncWork functions.
-	Mutex	MCurrentWork;
-	DBAsyncWork* CurrentWork;
-
-};
-
-/*
-	DB Work Complete Callback:
-		This will be called under the DBAsync thread! Never access any non-threadsafe 
-		data/functions/classes. (ie: zone, entitylist, client, etc are not threadsafe)
-	Function prototype:
-		return value:	true if we should delete the data, false if we should keep it
-*/
-typedef bool(*DBWorkCompleteCallBack)(DBAsyncWork*);
-
-class DBAsyncFinishedQueue {
-public:
-	DBAsyncFinishedQueue(uint32 iTimeout = 90000);
-	~DBAsyncFinishedQueue();
-
-	DBAsyncWork*	Pop();
-	DBAsyncWork*	PopByWPT(uint32 iWPT);
-	DBAsyncWork*	Find(uint32 iWPT);
-	bool			Push(DBAsyncWork* iDBAW);
-
-	void			CheckTimeouts();
-private:
-	Mutex MLock;
-	uint32 pTimeout;
-	LinkedList<DBAsyncWork*> list;
-};
-
-// Container class for multiple queries
-class DBAsyncWork {
-public:
-	DBAsyncWork(Database *db, DBAsyncFinishedQueue* iDBAFQ, uint32 iWPT = 0, DBAsync::Type iType = DBAsync::Both, uint32 iTimeout = 0);
-	DBAsyncWork(Database *db, DBWorkCompleteCallBack iCB, uint32 iWPT = 0, DBAsync::Type iType = DBAsync::Both, uint32 iTimeout = 0);
-	~DBAsyncWork();
-
-	bool			AddQuery(DBAsyncQuery** iDBAQ);
-	bool			AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	uint32			WPT();
-	DBAsync::Type	Type();
-
-	// Pops finished queries off the work
-	DBAsyncQuery*	PopAnswer();
-	uint32			QueryCount();
-	
-	Database *GetDB() const { return(m_db); }
-
-	bool			CheckTimeout(uint32 iFQTimeout);
-	bool			SetWorkID(uint32 iWorkID);
-	uint32			GetWorkID();
-protected:
-	friend class DBAsync;
-	DBAsync::Status	SetStatus(DBAsync::Status iStatus);
-	bool			Cancel();
-	bool			IsCancled();
-	DBAsyncQuery*	PopQuery();	// Get query to be run
-	void			PushAnswer(DBAsyncQuery* iDBAQ);	// Push answer back into workset
-
-	// not mutex'd cause only to be accessed from dbasync class
-	uint32	pExecuteAfter;
-private:
-	Mutex	MLock;
-	uint32	pQuestionCount;
-	uint32	pAnswerCount;
-	uint32	pWorkID;
-	uint32	pWPT;
-	uint32	pTimeout;
-	uint32	pTSFinish; // timestamp when finished
-	DBAsyncFinishedQueue*	pDBAFQ;		//we do now own this pointer
-	DBWorkCompleteCallBack	pCB;
-	DBAsync::Status			pstatus;
-	DBAsync::Type			pType;
-	MyQueue<DBAsyncQuery>	todo;
-	MyQueue<DBAsyncQuery>	done;
-	MyQueue<DBAsyncQuery>	todel;
-	Database *const			m_db;		//we do now own this pointer
-};
-
-// Container class for the query information
-class DBAsyncQuery {
-public:
-	DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
-	~DBAsyncQuery();
-
-	bool	GetAnswer(char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0);
-	inline uint32 QPT()	{ return pQPT; }
-protected:
-	friend class DBAsyncWork;
-	uint32		pQPT;
-
-	friend class DBAsync;
-	void		Process(DBcore* iDBC);
-
-	void		Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf);
-	DBAsync::Status pstatus;
-	char*		pQuery;
-	uint32		pQueryLen;
-	bool		pGetResultSet;
-	bool		pGetErrbuf;
-
-	bool		pmysqlsuccess;
-	char*		perrbuf;
-	uint32		perrnum;
-	uint32		paffected_rows;
-	uint32		plast_insert_id;
-	MYSQL_RES*	presult;
-};
-
-
-void AsyncLoadVariables(DBAsync *dba, Database *db);
-
-
-#endif
-
@@ -4,14 +4,14 @@
 #include <winsock2.h>
 #endif

+#include <fstream>
 #include <iostream>
-using namespace std;
 #include <errmsg.h>
 #include <mysqld_error.h>
 #include <limits.h>
 #include "dbcore.h"
 #include <string.h>
-#include "../common/MiscFunctions.h"
+#include "../common/misc_functions.h"
 #include <cstdlib>

 #ifdef _WINDOWS
@@ -38,6 +38,7 @@ DBcore::DBcore() {
 	pDatabase = 0;
 	pCompress = false;
 	pSSL = false;
+	pStatus = Closed;
 }

 DBcore::~DBcore() {
@@ -58,98 +59,112 @@ void DBcore::ping() {
 	MDatabase.unlock();
 }

-bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum, bool retry) {
-	_CP(DBcore_RunQuery);
-	if (errnum)
-		*errnum = 0;
-	if (errbuf)
-		errbuf[0] = 0;
-	bool ret = false;
+MySQLRequestResult DBcore::QueryDatabase(std::string query, bool retryOnFailureOnce)
+{
+	return QueryDatabase(query.c_str(), query.length(), retryOnFailureOnce);
+}
+
+MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce)
+{
 	LockMutex lock(&MDatabase);
+
+	// Reconnect if we are not connected before hand.
 	if (pStatus != Connected)
 		Open();
-#if DEBUG_MYSQL_QUERIES >= 1
-	char tmp[120];
-	strn0cpy(tmp, query, sizeof(tmp));
-	cout << "QUERY: " << tmp << endl;
-#endif
-	if (mysql_real_query(&mysql, query, querylen)) {
-		if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR)
+
+	// request query. != 0 indicates some kind of error.
+	if (mysql_real_query(&mysql, query, querylen) != 0)
+	{
+		unsigned int errorNumber = mysql_errno(&mysql);
+
+		if (errorNumber == CR_SERVER_GONE_ERROR)
 			pStatus = Error;
-		if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) {
-			if (retry) {
-				cout << "Database Error: Lost connection, attempting to recover...." << endl;
-				ret = RunQuery(query, querylen, errbuf, result, affected_rows, last_insert_id, errnum, false);
-				if (ret)
-					cout << "Reconnection to database successful." << endl;
-			}
-			else {
-				pStatus = Error;
-				if (errnum)
-					*errnum = mysql_errno(&mysql);
-				if (errbuf)
-					snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
-				cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << endl;
-				ret = false;
+
+		// error appears to be a disconnect error, may need to try again.
+		if (errorNumber == CR_SERVER_LOST || errorNumber == CR_SERVER_GONE_ERROR)
+		{
+
+			if (retryOnFailureOnce)
+			{
+				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
+				MySQLRequestResult requestResult = QueryDatabase(query, querylen, false);
+
+				if (requestResult.Success())
+				{
+					std::cout << "Reconnection to database successful." << std::endl;
+					return requestResult;
+				}
+
 			}
+
+			pStatus = Error;
+
+			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+
+			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
+			std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
+
+			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
-		else {
-			if (errnum)
-				*errnum = mysql_errno(&mysql);
-			if (errbuf)
-				snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
+		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+
 #ifdef _EQDEBUG
-			cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << endl;
+		std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
 #endif
-			ret = false;
-		}
-	}
-	else {
-		if (result && mysql_field_count(&mysql)) {
-			*result = mysql_store_result(&mysql);
-#ifdef _EQDEBUG
-			DBMemLeak::Alloc(*result, query);
-#endif
-		}
-		else if (result)
-			*result = 0;
-		if (affected_rows)
-			*affected_rows = mysql_affected_rows(&mysql);
-		if (last_insert_id)
-			*last_insert_id = mysql_insert_id(&mysql);
-		if (result) {
-			if (*result) {
-				ret = true;
-			}
-			else {
-#ifdef _EQDEBUG
-				cout << "DB Query Error: No Result" << endl;
-#endif
-				if (errnum)
-					*errnum = UINT_MAX;
-				if (errbuf)
-					strcpy(errbuf, "DBcore::RunQuery: No Result");
-				ret = false;
-			}
-		}
-		else {
-			ret = true;
+
+		/* Implement Logging at the Root */
+		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
+			std::cout << "\n[MYSQL ERR] " << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << " [Query]: \n" << query << "\n" << std::endl;
+			/* Write to log file */
+			std::ofstream log("eqemu_query_error_log.txt", std::ios_base::app | std::ios_base::out);
+			log << "[MYSQL ERR] " << mysql_error(&mysql) << "\n" << query << "\n";
+			log.close();
 		}
+
+		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;
+
+	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 DEBUG_MYSQL_QUERIES >= 1
-	if (ret) {
-		cout << "query successful";
-		if (result && (*result))
-			cout << ", " << (int) mysql_num_rows(*result) << " rows returned";
-		if (affected_rows)
-			cout << ", " << (*affected_rows) << " rows affected";
-		cout<< endl;
+	if (requestResult.Success())
+	{
+		std::cout << "query successful";
+		if (requestResult.Result())
+			std::cout << ", " << (int) mysql_num_rows(requestResult.Result()) << " rows returned";
+
+		std::cout << ", " << requestResult.RowCount() << " rows affected";
+		std::cout<< std::endl;
 	}
 	else {
-		cout << "QUERY: query FAILED" << endl;
+		std::cout << "QUERY: query FAILED" << std::endl;
 	}
 #endif
-	return ret;
+
+	return requestResult;
+}
+
+void DBcore::TransactionBegin() {
+	QueryDatabase("START TRANSACTION");
+}
+
+void DBcore::TransactionCommit() {
+	QueryDatabase("COMMIT");
+}
+
+void DBcore::TransactionRollback() {
+	QueryDatabase("ROLLBACK");
 }

 uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {
@@ -180,15 +195,16 @@ bool DBcore::Open(uint32* errnum, char* errbuf) {
 	LockMutex lock(&MDatabase);
 	if (GetStatus() == Connected)
 		return true;
-	if (GetStatus() == Error)
+	if (GetStatus() == Error) {
 		mysql_close(&mysql);
 		mysql_init(&mysql);		// Initialize structure again
+	}
 	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 
+	what the function was tring to set it to, therefore the function would think it failed
 	*/
 	uint32 flags = CLIENT_FOUND_ROWS;
 	if (pCompress)
@@ -4,16 +4,17 @@
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <windows.h>
-	//#include <winsock.h>
 #endif
+
 #include <mysql.h>
-#include "../common/DBMemLeak.h"
+#include <string.h>
 #include "../common/types.h"
-#include "../common/Mutex.h"
+#include "../common/mutex.h"
 #include "../common/linked_list.h"
 #include "../common/queue.h"
 #include "../common/timer.h"
-#include "../common/Condition.h"
+#include "../common/condition.h"
+#include "../common/mysql_request_result.h"

 class DBcore {
 public:
@@ -22,11 +23,15 @@ public:
 	DBcore();
 	~DBcore();
 	eStatus	GetStatus() { return pStatus; }
-	bool	RunQuery(const char* query, uint32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0, bool retry = true);
+	MySQLRequestResult	QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce = true);
+	MySQLRequestResult	QueryDatabase(std::string query, bool retryOnFailureOnce = true);
+	void TransactionBegin();
+	void TransactionCommit();
+	void TransactionRollback();
 	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
 	void	ping();
 	MYSQL*	getMySQL(){ return &mysql; }
-	
+
 protected:
 	bool	Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase, uint32 iPort, uint32* errnum = 0, char* errbuf = 0, bool iCompress = false, bool iSSL = false);
 private:
@@ -1,12 +1,10 @@
-
-
 // Doors
 #ifdef SHAREMEM
 int32 Database::GetDoorsCount(uint32* oMaxID) {
 	char errbuf[MYSQL_ERRMSG_SIZE];
-    char *query = 0;
-    MYSQL_RES *result;
-    MYSQL_ROW row;
+	char *query = 0;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
 	query = new char[256];
 	strcpy(query, "SELECT MAX(id), count(*) FROM doors");
 	if (RunQuery(query, strlen(query), errbuf, &result)) {
@@ -29,7 +27,7 @@ int32 Database::GetDoorsCount(uint32* oMaxID) {
 		delete[] query;
 		return -1;
 	}
-	
+
 	return -1;
 }

@@ -65,9 +63,9 @@ bool Database::LoadDoors() {
 bool Database::DBLoadDoors(uint32 iDoorCount, uint32 iMaxDoorID) {
 	cout << "Loading Doors from database..." << endl;
 	char errbuf[MYSQL_ERRMSG_SIZE];
-    char *query = 0;
-    MYSQL_RES *result;
-    MYSQL_ROW row;
+	char *query = 0;
+	MYSQL_RES *result;
+	MYSQL_ROW row;
 	query = new char[256];
 	strcpy(query, "SELECT MAX(id), Count(*) FROM doors");
 	if (RunQuery(query, strlen(query), errbuf, &result))
@@ -1,25 +1,27 @@
-#include "debug.h"
-
 #include <iostream>
-using namespace std;
+#include <string>
+#include <cstdarg>
 #include <time.h>
-#include <string.h>
+
 #ifdef _WINDOWS
 	#include <process.h>

 	#define snprintf	_snprintf
-#if (_MSC_VER < 1500)
 	#define vsnprintf	_vsnprintf
-#endif
 	#define strncasecmp	_strnicmp
-	#define strcasecmp  _stricmp
+	#define strcasecmp	_stricmp
+
 #else
+	
 	#include <sys/types.h>
 	#include <unistd.h>
-	#include <stdarg.h>
+
 #endif
-#include "../common/MiscFunctions.h"
-#include "../common/platform.h"
+
+#include "debug.h"
+#include "string_util.h"
+#include "misc_functions.h"
+#include "platform.h"

 #ifndef va_copy
 	#define va_copy(d,s) ((d) = (s))
@@ -33,29 +35,20 @@ static const char* FileNames[EQEMuLog::MaxLogID] = { "logs/eqemu", "logs/eqemu",
 static const char* LogNames[EQEMuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command", "Crash" };

 EQEMuLog::EQEMuLog() {
-//	MOpen = new Mutex;
-//	MLog = new Mutex*[MaxLogID];
-//	fp = new FILE*[MaxLogID];
-//	pLogStatus = new uint8[MaxLogID];
 	for (int i=0; i<MaxLogID; i++) {
 		fp[i] = 0;
-//		MLog[i] = new Mutex;
-#if EQDEBUG >= 2
-		pLogStatus[i] = 1 | 2;
-#else
-		pLogStatus[i] = 0;
-#endif
-		logCallbackFmt[i] = NULL;
-		logCallbackBuf[i] = NULL;
-		logCallbackPva[i] = NULL;
+		logCallbackFmt[i] = nullptr;
+		logCallbackBuf[i] = nullptr;
+		logCallbackPva[i] = nullptr;
 	}
-// TODO: Make this read from an ini or something, everyone has different opinions on what it should be
-#if EQDEBUG < 2
-	pLogStatus[Status] = 2;
-	pLogStatus[Error] = 2;
-	pLogStatus[Quest] = 2;
-	pLogStatus[Commands] = 1;
-#endif
+	
+	pLogStatus[Status] = LOG_LEVEL_STATUS;
+	pLogStatus[Normal] = LOG_LEVEL_NORMAL;
+	pLogStatus[Error] = LOG_LEVEL_ERROR;
+	pLogStatus[Debug] = LOG_LEVEL_DEBUG;
+	pLogStatus[Quest] = LOG_LEVEL_QUEST;
+	pLogStatus[Commands] = LOG_LEVEL_COMMANDS;
+	pLogStatus[Crash] = LOG_LEVEL_CRASH;
 	logFileValid = true;
 }

@@ -66,41 +59,43 @@ EQEMuLog::~EQEMuLog() {
 		if (fp[i])
 			fclose(fp[i]);
 	}
-//	safe_delete_array(fp);
-//	safe_delete_array(MLog);
-//	safe_delete_array(pLogStatus);
-//	safe_delete(MOpen);
 }

 bool EQEMuLog::open(LogIDs id) {
 	if (!logFileValid) {
 		return false;
-    }
+	}
 	if (id >= MaxLogID) {
 		return false;
-    }
+	}
 	LockMutex lock(&MOpen);
 	if (pLogStatus[id] & 4) {
 		return false;
-    }
-    if (fp[id]) {
-        //cerr<<"Warning: LogFile already open"<<endl;
-        return true;
-    }
+	}
+	if (fp[id]) {
+		//cerr<<"Warning: LogFile already open"<<endl;
+		return true;
+	}

 	char exename[200] = "";
-    const EQEmuExePlatform &platform = GetExecutablePlatform();
-    if(platform == ExePlatformWorld) {
-        snprintf(exename, sizeof(exename), "_world");
-    } else if(platform == ExePlatformZone) {
-        snprintf(exename, sizeof(exename), "_zone");
-    } else if(platform == ExePlatformLaunch) {
-        snprintf(exename, sizeof(exename), "_launch");
-    } else if(platform == ExePlatformUCS) {
-        snprintf(exename, sizeof(exename), "_ucs");
-    } else if(platform == ExePlatformQueryServ) {
-        snprintf(exename, sizeof(exename), "_queryserv");
-    }
+	const EQEmuExePlatform &platform = GetExecutablePlatform();
+	if(platform == ExePlatformWorld) {
+		snprintf(exename, sizeof(exename), "_world");
+	} else if(platform == ExePlatformZone) {
+		snprintf(exename, sizeof(exename), "_zone");
+	} else if(platform == ExePlatformLaunch) {
+		snprintf(exename, sizeof(exename), "_launch");
+	} else if(platform == ExePlatformUCS) {
+		snprintf(exename, sizeof(exename), "_ucs");
+	} else if(platform == ExePlatformQueryServ) {
+		snprintf(exename, sizeof(exename), "_queryserv");
+	} else if(platform == ExePlatformSharedMemory) {
+		snprintf(exename, sizeof(exename), "_shared_memory");
+	} else if(platform == ExePlatformClientImport) {
+		snprintf(exename, sizeof(exename), "_import");
+	} else if(platform == ExePlatformClientExport) {
+		snprintf(exename, sizeof(exename), "_export");
+	}

 	char filename[200];
 #ifndef NO_PIDLOG
@@ -108,24 +103,24 @@ bool EQEMuLog::open(LogIDs id) {
 #else
 	snprintf(filename, sizeof(filename), "%s%s.log", FileNames[id], exename);
 #endif
-    fp[id] = fopen(filename, "a");
-    if (!fp[id]) {
-		cerr << "Failed to open log file: " << filename << endl;
+	fp[id] = fopen(filename, "a");
+	if (!fp[id]) {
+		std::cerr << "Failed to open log file: " << filename << std::endl;
 		pLogStatus[id] |= 4; // set file state to error
-        return false;
-    }
-    fputs("---------------------------------------------\n",fp[id]);
-    write(id, "Starting Log: %s", filename);
-    return true;
+		return false;
+	}
+	fputs("---------------------------------------------\n",fp[id]);
+	write(id, "Starting Log: %s", filename);
+	return true;
 }

 bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
 	if (!logFileValid) {
 		return false;
-    }
+	}
 	if (id >= MaxLogID) {
 		return false;
-    }
+	}
 	bool dofile = false;
 	if (pLogStatus[id] & 1) {
 		dofile = open(id);
@@ -136,13 +131,13 @@ bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
 	if (!logFileValid)
 		return false;	//check again for threading race reasons (to avoid two mutexes)

-    time_t aclock;
-    struct tm *newtime;
-    
-    time( &aclock );                 /* Get time in seconds */
-    newtime = localtime( &aclock );  /* Convert time to struct */
+	time_t aclock;
+	struct tm *newtime;

-    if (dofile)
+	time( &aclock ); /* Get time in seconds */
+	newtime = localtime( &aclock ); /* Convert time to struct */
+
+	if (dofile)
 #ifndef NO_PIDLOG
 		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
 #else
@@ -160,7 +155,7 @@ bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
 		va_copy(tmpargptr, argptr);
 		p(id, fmt, tmpargptr );
 	}
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8) {
 			fprintf(stderr, "[%s] ", LogNames[id]);
 			vfprintf( stderr, fmt, argptr );
@@ -171,9 +166,9 @@ bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
 		}
 	}
 	va_end(argptr);
-    if (dofile)
+	if (dofile)
 		fprintf(fp[id], "\n");
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8) {
 			fprintf(stderr, "\n");
 			fflush(stderr);
@@ -182,19 +177,19 @@ bool EQEMuLog::write(LogIDs id, const char *fmt, ...) {
 			fflush(stdout);
 		}
 	}
-    if(dofile)
-      fflush(fp[id]);
-    return true;
+	if(dofile)
+		fflush(fp[id]);
+	return true;
 }

 //write with Prefix and a VA_list
 bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list argptr) {
 	if (!logFileValid) {
 		return false;
-    }
+	}
 	if (id >= MaxLogID) {
 		return false;
-    }
+	}
 	bool dofile = false;
 	if (pLogStatus[id] & 1) {
 		dofile = open(id);
@@ -206,15 +201,15 @@ bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list
 	if (!logFileValid)
 		return false;	//check again for threading race reasons (to avoid two mutexes)

-    time_t aclock;
-    struct tm *newtime;
-    
-    time( &aclock );                 /* Get time in seconds */
-    newtime = localtime( &aclock );  /* Convert time to struct */
+	time_t aclock;
+	struct tm *newtime;
+
+	time( &aclock ); /* Get time in seconds */
+	newtime = localtime( &aclock ); /* Convert time to struct */

 	va_list tmpargptr;

-    if (dofile) {
+	if (dofile) {
 #ifndef NO_PIDLOG
 		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] %s", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
 #else
@@ -222,13 +217,13 @@ bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list
 #endif
 		va_copy(tmpargptr, argptr);
 		vfprintf( fp[id], fmt, tmpargptr );
-    }
+	}
 	if(logCallbackPva[id]) {
 		msgCallbackPva p = logCallbackPva[id];
 		va_copy(tmpargptr, argptr);
 		p(id, prefix, fmt, tmpargptr );
 	}
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8) {
 			fprintf(stderr, "[%s] %s", LogNames[id], prefix);
 			vfprintf( stderr, fmt, argptr );
@@ -239,26 +234,26 @@ bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list
 		}
 	}
 	va_end(argptr);
-    if (dofile)
+	if (dofile)
 		fprintf(fp[id], "\n");
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8)
 			fprintf(stderr, "\n");
 		else
 			fprintf(stdout, "\n");
 	}
-    if(dofile)
-      fflush(fp[id]);
-    return true;
+	if(dofile)
+		fflush(fp[id]);
+	return true;
 }

 bool EQEMuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count) {
 	if (!logFileValid) {
 		return false;
-    }
+	}
 	if (id >= MaxLogID) {
 		return false;
-    }
+	}
 	bool dofile = false;
 	if (pLogStatus[id] & 1) {
 		dofile = open(id);
@@ -269,13 +264,13 @@ bool EQEMuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count) {
 	if (!logFileValid)
 		return false;	//check again for threading race reasons (to avoid two mutexes)

-    time_t aclock;
-    struct tm *newtime;
-    
-    time( &aclock );                 /* Get time in seconds */
-    newtime = localtime( &aclock );  /* Convert time to struct */
+	time_t aclock;
+	struct tm *newtime;

-    if (dofile)
+	time( &aclock ); /* Get time in seconds */
+	newtime = localtime( &aclock ); /* Convert time to struct */
+
+	if (dofile)
 #ifndef NO_PIDLOG
 		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
 #else
@@ -290,7 +285,7 @@ bool EQEMuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count) {
 		msgCallbackBuf p = logCallbackBuf[id];
 		p(id, buf, size, count);
 	}
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8) {
 			fprintf(stderr, "[%s] ", LogNames[id]);
 			fwrite(buf, size, count, stderr);
@@ -301,9 +296,9 @@ bool EQEMuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count) {
 			fprintf(stdout, "\n");
 		}
 	}
-    if(dofile)
-      fflush(fp[id]);
-    return true;
+	if(dofile)
+		fflush(fp[id]);
+	return true;
 }

 bool EQEMuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...) {
@@ -313,23 +308,23 @@ bool EQEMuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...) {
 		va_copy(tmpargptr, argptr);
 		vfprintf( fp[id], fmt, tmpargptr );
 	}
-    if (pLogStatus[id] & 2) {
+	if (pLogStatus[id] & 2) {
 		if (pLogStatus[id] & 8)
 			vfprintf( stderr, fmt, argptr );
 		else
 			vfprintf( stdout, fmt, argptr );
 	}
 	va_end(argptr);
-    return true;
+	return true;
 };

 bool EQEMuLog::Dump(LogIDs id, uint8* data, uint32 size, uint32 cols, uint32 skip) {
 	if (!logFileValid) {
 #if EQDEBUG >= 10
-    cerr << "Error: Dump() from null pointer"<<endl;
+	std::cerr << "Error: Dump() from null pointer" << std::endl;
 #endif
 		return false;
-    }
+	}
 	if (size == 0)
 		return true;
 	if (!LogFile)
@@ -345,49 +340,58 @@ bool EQEMuLog::Dump(LogIDs id, uint8* data, uint32 size, uint32 cols, uint32 ski
 	LockMutex lock(&MLog[id]);
 	if (!logFileValid)
 		return false;	//check again for threading race reasons (to avoid two mutexes)
-	
+
 	write(id, "Dumping Packet: %i", size);
 	// Output as HEX
-	int j = 0; char* ascii = new char[cols+1]; memset(ascii, 0, cols+1);
-	uint32 i;
-    for(i=skip; i<size; i++) {
-		if ((i-skip)%cols==0) {
-			if (i != skip)
-				writeNTS(id, dofile, " | %s\n", ascii);
-			writeNTS(id, dofile, "%4i: ", i-skip);
-			memset(ascii, 0, cols+1);
-			j = 0;
+	
+	int beginningOfLineOffset = 0; 
+	uint32 indexInData;
+	std::string asciiOutput;
+
+	for(indexInData=skip; indexInData<size; indexInData++) {
+		if ((indexInData-skip)%cols==0) {
+			if (indexInData != skip)
+				writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
+			writeNTS(id, dofile, "%4i: ", indexInData-skip);
+			asciiOutput.clear();
+			beginningOfLineOffset = 0;
 		}
-		else if ((i-skip)%(cols/2) == 0) {
+		else if ((indexInData-skip)%(cols/2) == 0) {
 			writeNTS(id, dofile, "- ");
 		}
-		writeNTS(id, dofile, "%02X ", (unsigned char)data[i]);
+		writeNTS(id, dofile, "%02X ", (unsigned char)data[indexInData]);

-		if (data[i] >= 32 && data[i] < 127)
-			ascii[j++] = data[i];
+		if (data[indexInData] >= 32 && data[indexInData] < 127)
+		{
+			// According to http://msdn.microsoft.com/en-us/library/vstudio/ee404875(v=vs.100).aspx
+			// Visual Studio 2010 doesn't have std::to_string(int) but it does have the long long 
+			// version.
+			asciiOutput.append(std::to_string((long long)data[indexInData]));
+		}
 		else
-			ascii[j++] = '.';
-    }
-	uint32 k = ((i-skip)-1)%cols;
+		{
+			asciiOutput.append(".");
+		}
+	}
+	uint32 k = ((indexInData-skip)-1)%cols;
 	if (k < 8)
 		writeNTS(id, dofile, "  ");
 	for (uint32 h = k+1; h < cols; h++) {
 		writeNTS(id, dofile, "   ");
 	}
-	writeNTS(id, dofile, " | %s\n", ascii);
+	writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
 	if (dofile)
 		fflush(fp[id]);
-	safe_delete_array(ascii);
 	return true;
 }
-	
+
 void EQEMuLog::SetCallback(LogIDs id, msgCallbackFmt proc) {
 	if (!logFileValid)
 		return;
 	if (id >= MaxLogID) {
 		return;
-    }
-    logCallbackFmt[id] = proc;
+	}
+	logCallbackFmt[id] = proc;
 }

 void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc) {
@@ -395,8 +399,8 @@ void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc) {
 		return;
 	if (id >= MaxLogID) {
 		return;
-    }
-    logCallbackBuf[id] = proc;
+	}
+	logCallbackBuf[id] = proc;
 }

 void EQEMuLog::SetCallback(LogIDs id, msgCallbackPva proc) {
@@ -404,8 +408,8 @@ void EQEMuLog::SetCallback(LogIDs id, msgCallbackPva proc) {
 		return;
 	if (id >= MaxLogID) {
 		return;
-    }
-    logCallbackPva[id] = proc;
+	}
+	logCallbackPva[id] = proc;
 }

 void EQEMuLog::SetAllCallbacks(msgCallbackFmt proc) {
@@ -435,5 +439,3 @@ void EQEMuLog::SetAllCallbacks(msgCallbackPva proc) {
 	}
 }

-
-
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)

-    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 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
+	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.
+	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
+	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
 */

 // Debug Levels
@@ -23,11 +23,11 @@
 ////// File/Console options
 // 0 <= Quiet mode Errors to file Status and Normal ignored
 // 1 >= Status and Normal to console, Errors to file
-// 2 >= Status, Normal, and Error  to console and logfile
+// 2 >= Status, Normal, and Error to console and logfile
 // 3 >= Lite debug
 // 4 >= Medium debug
 // 5 >= Debug release (Anything higher is not recommended for regular use)
-// 6 == (Reserved for special builds) Login  opcode debug All packets dumped
+// 6 == (Reserved for special builds) Login opcode debug All packets dumped
 // 7 == (Reserved for special builds) Chat Opcode debug All packets dumped
 // 8 == (Reserved for special builds) World opcode debug All packets dumped
 // 9 == (Reserved for special builds) Zone Opcode debug All packets dumped
@@ -45,31 +45,9 @@
 	#ifndef _CRTDBG_MAP_ALLOC
 		#include <stdlib.h>
 		#include <crtdbg.h>
-		#if (_MSC_VER < 1300)
-			#include <new>
-			#include <memory>
-			#define _CRTDBG_MAP_ALLOC
-			#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
-			#define malloc(s) _malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__)
-		#endif
 	#endif
 #endif

-#ifndef ThrowError
-	void CatchSignal(int);
-	#if defined(CATCH_CRASH) || defined(_EQDEBUG)
-		#define ThrowError(errstr)	{ cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogFile->write(EQEMuLog::Error, "Thown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); throw errstr; }
-	#else
-		#define ThrowError(errstr)	{ cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogFile->write(EQEMuLog::Error, "Thown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); CatchSignal(0); }
-	#endif
-#endif
-
-#ifdef _WINDOWS
-	// VS6 doesn't like the length of STL generated names: disabling
-	#pragma warning(disable:4786)
-	#pragma warning(disable:4996)
-#endif
-
 #ifndef EQDEBUG_H
 #define EQDEBUG_H

@@ -90,12 +68,8 @@
 #endif

 #include "logsys.h"
-#include "common_profile.h"
-#ifdef ZONE
-#include "../zone/zone_profile.h"
-#endif

-#include "../common/Mutex.h"
+#include "../common/mutex.h"
 #include <stdio.h>
 #include <stdarg.h>

@@ -106,28 +80,29 @@ public:
 	~EQEMuLog();

 	enum LogIDs {
-		Status = 0,	//this must stay the first entry in this list
-		Normal,
-		Error,
-		Debug,
-		Quest,
-		Commands,
-        Crash,
-		MaxLogID
+		Status = 0,	 /* This must stay the first entry in this list */
+		Normal,		 /* Normal Logs */
+		Error,		 /* Error Logs */
+		Debug,		 /* Debug Logs */
+		Quest,		 /* Quest Logs */
+		Commands,	 /* Issued Comamnds */
+		Crash,		 /* Crash Logs */
+		Save,		 /* Client Saves */
+		MaxLogID	 /* Max, used in functions to get the max log ID */
 	};
-	
+
 	//these are callbacks called for each
 	typedef void (* msgCallbackBuf)(LogIDs id, const char *buf, uint8 size, uint32 count);
 	typedef void (* msgCallbackFmt)(LogIDs id, const char *fmt, va_list ap);
 	typedef void (* msgCallbackPva)(LogIDs id, const char *prefix, const char *fmt, va_list ap);
-	
+
 	void SetAllCallbacks(msgCallbackFmt proc);
 	void SetAllCallbacks(msgCallbackBuf proc);
 	void SetAllCallbacks(msgCallbackPva proc);
 	void SetCallback(LogIDs id, msgCallbackFmt proc);
 	void SetCallback(LogIDs id, msgCallbackBuf proc);
 	void SetCallback(LogIDs id, msgCallbackPva proc);
-	
+
 	bool writebuf(LogIDs id, const char *buf, uint8 size, uint32 count);
 	bool write(LogIDs id, const char *fmt, ...);
 	bool writePVA(LogIDs id, const char *prefix, const char *fmt, va_list args);
@@ -139,6 +114,7 @@ private:
 	Mutex	MOpen;
 	Mutex	MLog[MaxLogID];
 	FILE*	fp[MaxLogID];
+
 /* LogStatus: bitwise variable
 	1 = output to file
 	2 = output to stdout
@@ -146,7 +122,7 @@ private:
 	8 = use stderr instead (2 must be set)
 */
 	uint8	pLogStatus[MaxLogID];
-	
+
 	msgCallbackFmt logCallbackFmt[MaxLogID];
 	msgCallbackBuf logCallbackBuf[MaxLogID];
 	msgCallbackPva logCallbackPva[MaxLogID];
@@ -1,65 +1,166 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2002  EQEMu Development Team (http://eqemu.org)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)

-    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 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
+	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.
+	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
+	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 DEITY_H
 #define DEITY_H

-/* 
-** Diety List
-*/
-#define DEITY_AGNOSTIC		396		//drop the high bit for 140
-#define DEITY_BRELL			202
-#define DEITY_CAZIC			203
-#define DEITY_EROLLSI		204
-#define DEITY_BRISTLE		205
-#define DEITY_INNY			206
-#define DEITY_KARANA		207
-#define DEITY_MITH			208
-#define DEITY_PREXUS		209
-#define DEITY_QUELLIOUS		210
-#define DEITY_RALLOS		211
-#define DEITY_SOLUSEK		213
-#define DEITY_TRIBUNAL		214
-#define DEITY_TUNARE		215
+#include "types.h"
+#include <string>

-//Guessed:
-#define DEITY_BERTOX		201	
-#define DEITY_RODCET		212
-#define DEITY_VEESHAN		216
+// NOTE: This code is not fully implemented since there are no references in the existing code

-/* on items:
- *All 0
-AGNOSTIC 1
-BERTOX 2
-BRELL 4
-CAZIC 8
-EROLLSI 16
-BRISTLE 32
-INNY 64
-KARANA 128
-MITH 256
-PREXUS 512
-QUELLIOUS 1024
-RALLOS 2048
-RODCET 4096
-SOLUSEK 8192
-TRIBUNAL 16384
-TUNARE 32768
-VEESHAN 65536
+/*
+**	Diety types
+**
+**	(ref: eqstr_us.txt)
+**
+**	(Another orphaned enumeration...)
 */
+enum DeityTypes
+{
+/*----*/	DeityUnknown = 0,
+/*----*/	DeityAgnostic_LB = 140,
+/*3251*/	DeityBertoxxulous = 201,
+/*3262*/	DeityBrellSirilis,
+/*3253*/	DeityCazicThule,
+/*3256*/	DeityErollisiMarr,
+/*3252*/	DeityBristlebane,
+/*3254*/	DeityInnoruuk,
+/*3255*/	DeityKarana,
+/*3257*/	DeityMithanielMarr,
+/*3259*/	DeityPrexus,
+/*3260*/	DeityQuellious,
+/*3266*/	DeityRallosZek,
+/*3258*/	DeityRodcetNife,
+/*3261*/	DeitySolusekRo,
+/*3263*/	DeityTheTribunal,
+/*3264*/	DeityTunare,
+/*3265*/	DeityVeeshan,
+/*3250*/	DeityAgnostic = 396
+};
+
+/*
+**	Deity type bits
+**
+**	(New orphan, but make use of it!)
+*/
+enum DeityTypeBits : uint32
+{
+	BIT_DeityAll			= 0x00000000,
+	BIT_DeityAgnostic		= 0x00000001,
+	BIT_DeityBertoxxulous	= 0x00000002,
+	BIT_DeityBrellSirilis	= 0x00000004,
+	BIT_DeityCazicThule		= 0x00000008,
+	BIT_DeityErollisiMarr	= 0x00000010,
+	BIT_DeityBristlebane	= 0x00000020,
+	BIT_DeityInnoruuk		= 0x00000040,
+	BIT_DeityKarana			= 0x00000080,
+	BIT_DeityMithanielMarr	= 0x00000100,
+	BIT_DeityPrexus			= 0x00000200,
+	BIT_DeityQuellious		= 0x00000400,
+	BIT_DeityRallosZek		= 0x00000800,
+	BIT_DeityRodcetNife		= 0x00001000,
+	BIT_DeitySolusekRo		= 0x00002000,
+	BIT_DeityTheTribunal	= 0x00004000,
+	BIT_DeityTunare			= 0x00008000,
+	BIT_DeityVeeshan		= 0x00010000
+};
+
+static DeityTypeBits ConvertDeityToBitDeity(DeityTypes deity)
+{
+	switch(deity)
+	{
+		case DeityBertoxxulous:		{ return BIT_DeityBertoxxulous; }
+		case DeityBrellSirilis:		{ return BIT_DeityBrellSirilis; }
+		case DeityCazicThule:		{ return BIT_DeityCazicThule; }
+		case DeityErollisiMarr:		{ return BIT_DeityErollisiMarr; }
+		case DeityBristlebane:		{ return BIT_DeityBristlebane; }
+		case DeityInnoruuk:			{ return BIT_DeityInnoruuk; }
+		case DeityKarana:			{ return BIT_DeityKarana; }
+		case DeityMithanielMarr:	{ return BIT_DeityMithanielMarr; }
+		case DeityPrexus:			{ return BIT_DeityPrexus; }
+		case DeityQuellious:		{ return BIT_DeityQuellious; }
+		case DeityRallosZek:		{ return BIT_DeityRallosZek; }
+		case DeityRodcetNife:		{ return BIT_DeityRodcetNife; }
+		case DeitySolusekRo:		{ return BIT_DeitySolusekRo; }
+		case DeityTheTribunal:		{ return BIT_DeityTheTribunal; }
+		case DeityTunare:			{ return BIT_DeityTunare; }
+		case DeityVeeshan:			{ return BIT_DeityVeeshan; }
+		case DeityAgnostic_LB:
+		case DeityAgnostic:			{ return BIT_DeityAgnostic; }
+		default: { break; }
+	};
+
+	return BIT_DeityAll;
+};
+
+static DeityTypes ConvertBitDeityToDeity(DeityTypeBits deity_bit)
+{
+	switch(deity_bit)
+	{
+		case BIT_DeityAgnostic:			{ return DeityAgnostic; }
+		case BIT_DeityBertoxxulous:		{ return DeityBertoxxulous; }
+		case BIT_DeityBrellSirilis:		{ return DeityBrellSirilis; }
+		case BIT_DeityCazicThule:		{ return DeityCazicThule; }
+		case BIT_DeityErollisiMarr:		{ return DeityErollisiMarr; }
+		case BIT_DeityBristlebane:		{ return DeityBristlebane; }
+		case BIT_DeityInnoruuk:			{ return DeityInnoruuk; }
+		case BIT_DeityKarana:			{ return DeityKarana; }
+		case BIT_DeityMithanielMarr:	{ return DeityMithanielMarr; }
+		case BIT_DeityPrexus:			{ return DeityPrexus; }
+		case BIT_DeityQuellious:		{ return DeityQuellious; }
+		case BIT_DeityRallosZek:		{ return DeityRallosZek; }
+		case BIT_DeityRodcetNife:		{ return DeityRodcetNife; }
+		case BIT_DeitySolusekRo:		{ return DeitySolusekRo; }
+		case BIT_DeityTheTribunal:		{ return DeityTheTribunal; }
+		case BIT_DeityTunare:			{ return DeityTunare; }
+		case BIT_DeityVeeshan:			{ return DeityVeeshan; }
+		default: { break; }
+	};
+
+	return DeityUnknown;
+};
+
+static std::string GetDeityName(DeityTypes deity)
+{
+	switch(deity)
+	{
+		case DeityBertoxxulous:		{ return "Bertoxxulous"; }
+		case DeityBrellSirilis:		{ return "Brell Serilis"; }
+		case DeityCazicThule:		{ return "Cazic-Thule"; }
+		case DeityErollisiMarr:		{ return "Erollisi Marr"; }
+		case DeityBristlebane:		{ return "Bristlebane"; }
+		case DeityInnoruuk:			{ return "Innoruuk"; }
+		case DeityKarana:			{ return "Karana"; }
+		case DeityMithanielMarr:	{ return "Mithaniel Marr"; }
+		case DeityPrexus:			{ return "Prexus"; }
+		case DeityQuellious:		{ return "Quellious"; }
+		case DeityRallosZek:		{ return "Rallos Zek"; }
+		case DeityRodcetNife:		{ return "Rodcet Nife"; }
+		case DeitySolusekRo:		{ return "Solusek Ro"; }
+		case DeityTheTribunal:		{ return "The Tribunal"; }
+		case DeityTunare:			{ return "Tunare"; }
+		case DeityVeeshan:			{ return "Veeshan"; }
+		case DeityAgnostic_LB:
+		case DeityAgnostic:			{ return "Agnostic"; }
+		default: { break; }
+	};
+
+	return "Unknown";
+};

 #endif
@@ -1,19 +1,19 @@
-/*  EQEMu:  Everquest Server Emulator
-Copyright (C) 2001-2005  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2005 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 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.
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.

-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */

 #include "debug.h"
@@ -21,13 +21,13 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA

 const char *OpcodeNames[_maxEmuOpcode+1] = {
 	"OP_Unknown",
-	
+
 //a preprocessor hack so we dont have to maintain two lists
 #define N(x) #x
 	#include "emu_oplist.h"
-    #include "mail_oplist.h"
+	#include "mail_oplist.h"
 #undef N
-	
+
 	""
 };

@@ -1,5 +1,5 @@
-/*  EQEMu:  Everquest Server Emulator
-Copyright (C) 2001-2005  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2005 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
@@ -9,11 +9,11 @@ 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.
+A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */
 #ifndef EMU_OPCODES_H
 #define EMU_OPCODES_H
@@ -49,5 +49,3 @@ extern const char *OpcodeNames[_maxEmuOpcode+1];

 #endif

-
-
@@ -1,59 +1,37 @@
-/*  EQEMu:  Everquest Server Emulator
-    Copyright (C) 2001-2006  EQEMu Development Team (http://eqemulator.net)
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)

-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; version 2 of the License.
+	This program is 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
+	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.
+	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
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

 /*
- * 
- * 
- * 
- * 
- * There are really two or three different objects shoe-hored into this
- * connection object. Sombody really needs to factor out the relay link
- * crap into its own subclass of this object, it will clean things up 
- * tremendously.
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- * 
- */
+There are really two or three different objects shoe-hored into this
+connection object. Sombody really needs to factor out the relay link
+crap into its own subclass of this object, it will clean things up
+tremendously.
+*/

 #include "../common/debug.h"

 #include <iostream>
-using namespace std;
 #include <string.h>
 #include <stdio.h>
 #include <iomanip>
-using namespace std;

-#include "EmuTCPConnection.h"
-#include "EmuTCPServer.h"
+#include "emu_tcp_connection.h"
+#include "emu_tcp_server.h"
 #include "../common/servertalk.h"
 #include "../common/packet_dump.h"

@@ -71,12 +49,12 @@ using namespace std;

 //server side case
 EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_socket, uint32 irIP, uint16 irPort, bool iOldFormat)
-: TCPConnection(ID, in_socket, irIP, irPort),
-  keepalive_timer(SERVER_TIMEOUT),
-  timeout_timer(SERVER_TIMEOUT * 2)
+:	TCPConnection(ID, in_socket, irIP, irPort),
+	keepalive_timer(SERVER_TIMEOUT),
+	timeout_timer(SERVER_TIMEOUT * 2)
 {
 	id = 0;
-	Server = NULL;
+	Server = nullptr;
 	pOldFormat = iOldFormat;
 	#ifdef MINILOGIN
 		TCPMode = modePacket;
@@ -92,14 +70,14 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_s
 	RelayServer = false;
 	RelayCount = 0;
 	RemoteID = 0;
-	
+
 }

 //client outgoing connection case (and client side relay)
 EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer, eTCPMode iMode)
-: TCPConnection(),
-  keepalive_timer(SERVER_TIMEOUT),
-  timeout_timer(SERVER_TIMEOUT * 2)
+:	TCPConnection(),
+	keepalive_timer(SERVER_TIMEOUT),
+	timeout_timer(SERVER_TIMEOUT * 2)
 {
 	Server = iRelayServer;
 	if (Server)
@@ -113,29 +91,27 @@ EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer,
 	TCPMode = iMode;
 	PacketMode = packetModeZone;
 #if TCPN_DEBUG_Memory >= 7
-	cout << "Constructor #1 on outgoing TCP# " << GetID() << endl;
+	std::cout << "Constructor #1 on outgoing TCP# " << GetID() << std::endl;
 #endif
 }

 //server side relay case
 EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort)
-: TCPConnection(ID, 0, irIP, irPort),
-  keepalive_timer(SERVER_TIMEOUT),
-  timeout_timer(SERVER_TIMEOUT * 2)
+:	TCPConnection(ID, 0, irIP, irPort),
+	keepalive_timer(SERVER_TIMEOUT),
+	timeout_timer(SERVER_TIMEOUT * 2)
 {
 	Server = iServer;
 	RelayLink = iRelayLink;
 	RelayServer = true;
 	RelayCount = 0;
 	RemoteID = iRemoteID;
-	if (!RemoteID)
-		ThrowError("Error: TCPConnection: RemoteID == 0 on RelayLink constructor");
 	pOldFormat = false;
 	ConnectionType = Incomming;
 	TCPMode = modePacket;
 	PacketMode = packetModeZone;
 #if TCPN_DEBUG_Memory >= 7
-	cout << "Constructor #3 on outgoing TCP# " << GetID() << endl;
+	std::cout << "Constructor #3 on outgoing TCP# " << GetID() << std::endl;
 #endif
 }

@@ -143,7 +119,6 @@ EmuTCPConnection::~EmuTCPConnection() {
 	//the queues free their content right now I believe.
 }

-
 EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32 iDestination) {
 	int32 size = sizeof(EmuTCPNetPacket_Struct) + pack->size;
 	if (pack->compressed) {
@@ -196,7 +171,7 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
 				struct in_addr	in;
 				in.s_addr = GetrIP();
 				CoutTimestamp(true);
-				cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl;
+				std::cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
 				#if TCPN_LOG_PACKETS == 2
 					if (pack->size >= 32)
 						DumpPacket(pack->pBuffer, 32);
@@ -223,7 +198,7 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
 					struct in_addr	in;
 					in.s_addr = GetrIP();
 					CoutTimestamp(true);
-					cout << ": Logging outgoing TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl;
+					std::cout << ": Logging outgoing TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
 					#if TCPN_LOG_PACKETS == 2
 						if (pack->size >= 32)
 							DumpPacket(pack->pBuffer, 32);
@@ -248,7 +223,7 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
 		return false;
 	if (GetMode() != modePacket)
 		return false;
-	
+
 	LockMutex lock(&MState);
 	eTCPMode tmp = GetMode();
 	if (tmp == modeTransition) {
@@ -262,10 +237,10 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
 			struct in_addr	in;
 			in.s_addr = GetrIP();
 			CoutTimestamp(true);
-			cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << tnps->opcode << dec << ", size: " << setw(5) << setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort();
+			std::cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << tnps->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort();
 			if (pOldFormat)
-				cout << " (OldFormat)";
-			cout << endl;
+				std::cout << " (OldFormat)";
+			std::cout << std::endl;
 			#if TCPN_LOG_PACKETS == 2
 				if (tnps->size >= 32)
 					DumpPacket((uchar*) tnps, 32);
@@ -284,7 +259,7 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
 ServerPacket* EmuTCPConnection::PopPacket() {
 	ServerPacket* ret;
 	if (!MOutQueueLock.trylock())
-		return NULL;
+		return nullptr;
 	ret = OutQueue.pop();
 	MOutQueueLock.unlock();
 	return ret;
@@ -307,7 +282,7 @@ bool EmuTCPConnection::LineOutQueuePush(char* line) {
 	#if defined(GOTFRAGS) && 0
 		if (strcmp(line, "**CRASHME**") == 0) {
 			int i = 0;
-			cout << (5 / i) << endl;
+			std::cout << (5 / i) << std::endl;
 		}
 	#endif
 	if(line[0] == '*') {
@@ -391,15 +366,14 @@ bool EmuTCPConnection::LineOutQueuePush(char* line) {
 			safe_delete_array(line);
 			return(true);
 		}
-
 	}
-	
+
 	return(TCPConnection::LineOutQueuePush(line));
 }

 void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
 	TCPConnection::Disconnect();
-	
+
 	if (RelayLink) {
 		RelayLink->RemoveRelay(this, iSendRelayDisconnect);
 		RelayLink = 0;
@@ -409,7 +383,7 @@ void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
 bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 	if(!TCPConnection::ConnectIP(irIP, irPort, errbuf))
 		return(false);
-	
+
 	MSendQueue.lock();
 	#ifdef MINILOGIN
 		TCPMode = modePacket;
@@ -444,7 +418,8 @@ bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 				sendbuf_used = sendbuf_size;
 				sendbuf = new uchar[sendbuf_size];
 				memcpy(sendbuf, "\0**PACKETMODEQS**\r", sendbuf_size);
-			} else {
+			} 
+			else {
 				//default: packetModeZone
 				safe_delete_array(sendbuf);
 				sendbuf_size = 20;
@@ -455,35 +430,34 @@ bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 		}
 	#endif
 	MSendQueue.unlock();
-	
+
 	return(true);
 }

 void EmuTCPConnection::ClearBuffers() {
 	TCPConnection::ClearBuffers();
-	
+
 	LockMutex lock2(&MOutQueueLock);
 	ServerPacket* pack = 0;
 	while ((pack = OutQueue.pop()))
 		safe_delete(pack);
-	
+
 	EmuTCPNetPacket_Struct* tnps = 0;
 	while ((tnps = InModeQueue.pop()))
 		safe_delete(tnps);
-	
+
 	keepalive_timer.Start();
 	timeout_timer.Start();
 }

-
 void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
 	#if TCPC_DEBUG >= 1
 		struct in_addr	in;
 		in.s_addr = GetrIP();
-		cout "NetError: '";
+		std::cout "NetError: '";
 		if (reason)
-			cout << reason;
-		cout << "': " << inet_ntoa(in) << ":" << GetPort() << endl;
+			std::cout << reason;
+		std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
 	#endif
 	ServerPacket* pack = new ServerPacket(0);
 	pack->size = 1;
@@ -546,7 +520,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 		size = tnps->size;
 		if (size >= MaxTCPReceiveBuffferSize) {
 #if TCPN_DEBUG_Memory >= 1
-			cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << endl;
+			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
 			DumpPacket(&recvbuf[base], 16);
 #endif
 			if (errbuf)
@@ -586,13 +560,13 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 			if (pack->opcode == 0) {
 				if (pack->size) {
 					#if TCPN_DEBUG >= 2
-						cout << "Received TCP Network layer packet" << endl;
+						std::cout << "Received TCP Network layer packet" << std::endl;
 					#endif
 					ProcessNetworkLayerPacket(pack);
 				}
 				#if TCPN_DEBUG >= 5
 					else {
-						cout << "Received TCP keepalive packet. (opcode=0)" << endl;
+						std::cout << "Received TCP keepalive packet. (opcode=0)" << std::endl;
 					}
 				#endif
 				// keepalive, no need to process
@@ -604,7 +578,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 						struct in_addr	in;
 						in.s_addr = GetrIP();
 						CoutTimestamp(true);
-						cout << ": Logging incoming TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl;
+						std::cout << ": Logging incoming TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
 						#if TCPN_LOG_PACKETS == 2
 							if (pack->size >= 32)
 								DumpPacket(pack->pBuffer, 32);
@@ -620,7 +594,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 					EmuTCPConnection* con = Server->FindConnection(pack->destination);
 					if (!con) {
 						#if TCPN_DEBUG >= 1
-							cout << "Error relaying packet: con = 0" << endl;
+							std::cout << "Error relaying packet: con = 0" << std::endl;
 						#endif
 						safe_delete(pack);
 					}
@@ -659,7 +633,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 		memcpy(&size, &buffer[2], 2);
 		if (size >= MaxTCPReceiveBuffferSize) {
 #if TCPN_DEBUG_Memory >= 1
-			cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << endl;
+			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
 #endif
 			if (errbuf)
 				snprintf(errbuf, TCPConnection_ErrorBufferSize, "EmuTCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBuffferSize");
@@ -689,7 +663,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 						struct in_addr	in;
 						in.s_addr = GetrIP();
 						CoutTimestamp(true);
-						cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl;
+						std::cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
 						#if TCPN_LOG_PACKETS == 2
 							if (pack->size >= 32)
 								DumpPacket(pack->pBuffer, 32);
@@ -750,7 +724,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 			#if TCPC_DEBUG >= 3
 				struct in_addr	in;
 				in.s_addr = GetrIP();
-				cout << "Switching to RelayServer mode: " << inet_ntoa(in) << ":" << GetPort() << endl;
+				std::cout << "Switching to RelayServer mode: " << inet_ntoa(in) << ":" << GetPort() << std::endl;
 			#endif
 			RelayServer = true;
 			break;
@@ -798,10 +772,10 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 			#if TCPC_DEBUG >= 1
 				struct in_addr	in;
 				in.s_addr = GetrIP();
-				cout "Received NetError: '";
+				std::cout "Received NetError: '";
 				if (pack->size > 1)
-					cout << (char*) data;
-				cout << "': " << inet_ntoa(in) << ":" << GetPort() << endl;
+					std::cout << (char*) data;
+				std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
 			#endif
 			break;
 		}
@@ -812,7 +786,7 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 	sent_something = false;
 	if(!TCPConnection::SendData(sent_something, errbuf))
 		return(false);
-	
+
 	if(sent_something)
 		keepalive_timer.Start();
 	else if (TCPMode == modePacket && keepalive_timer.Check()) {
@@ -820,11 +794,11 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 		SendPacket(pack);
 		safe_delete(pack);
 		#if TCPN_DEBUG >= 5
-			cout << "Sending TCP keepalive packet. (timeout=" << timeout_timer.GetRemainingTime() << " remaining)" << endl;
+		std::cout << "Sending TCP keepalive packet. (timeout=" << timeout_timer.GetRemainingTime() << " remaining)" << std::endl;
 		#endif
-    }
-    
-    return(true);
+	}
+
+	return(true);
 }

 bool EmuTCPConnection::RecvData(char* errbuf) {
@@ -834,24 +808,13 @@ bool EmuTCPConnection::RecvData(char* errbuf) {
 		else
 			return(false);
 	}
-	
+
 	if ((TCPMode == modePacket || TCPMode == modeTransition) && timeout_timer.Check()) {
 		if (errbuf)
 			snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Connection timeout");
 		return false;
 	}
-	
+
 	return(true);
 }

-
-
-
-
-
-
-
-
-
-
-
@@ -1,7 +1,7 @@
 #ifndef EmuTCPCONNECTION_H_
 #define EmuTCPCONNECTION_H_

-#include "TCPConnection.h"
+#include "tcp_connection.h"
 #include "timer.h"

 //moved out of TCPConnection:: to be more exportable
@@ -31,67 +31,67 @@ class EmuTCPConnection : public TCPConnection {
 public:
 	enum eTCPMode { modeConsole, modeTransition, modePacket };
 	enum ePacketMode { packetModeZone, packetModeLauncher, packetModeLogin, packetModeUCS, packetModeQueryServ };
-	
+
 	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET iSock, uint32 irIP, uint16 irPort, bool iOldFormat = false);
 	EmuTCPConnection(bool iOldFormat = false, EmuTCPServer* iRelayServer = 0, eTCPMode iMode = modePacket);	// for outgoing connections
 	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort);				// for relay connections
 	virtual ~EmuTCPConnection();
-	
+
 	virtual bool	ConnectIP(uint32 irIP, uint16 irPort, char* errbuf = 0);
 	virtual void	Disconnect(bool iSendRelayDisconnect = true);
-	
+
 	static EmuTCPNetPacket_Struct* MakePacket(ServerPacket* pack, uint32 iDestination = 0);
 	static SPackSendQueue* MakeOldPacket(ServerPacket* pack);
-	
+
 	virtual bool	SendPacket(ServerPacket* pack, uint32 iDestination = 0);
 	virtual bool	SendPacket(EmuTCPNetPacket_Struct* tnps);
 	ServerPacket*	PopPacket(); // OutQueuePop()
 	void SetPacketMode(ePacketMode mode) { PacketMode = mode; }
-	
+
 	eTCPMode		GetMode()	const		{ return TCPMode; }
-	ePacketMode		GetPacketMode() const 	{ return(PacketMode); }
-	
+	ePacketMode		GetPacketMode() const	{ return(PacketMode); }
+
 	//relay crap:
 	inline bool		IsRelayServer() const { return RelayServer; }
 	inline TCPConnection* GetRelayLink() const	{ return RelayLink; }
 	inline uint32	GetRemoteID() const	{ return RemoteID; }
-	
+
 protected:
 	void	OutQueuePush(ServerPacket* pack);
 	void	RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect);
-	
+
 	void	SendNetErrorPacket(const char* reason = 0);
-	
+
 	virtual bool SendData(bool &sent_something, char* errbuf = 0);
 	virtual bool RecvData(char* errbuf = 0);
-	
+
 	virtual bool ProcessReceivedData(char* errbuf = 0);
 	bool ProcessReceivedDataAsPackets(char* errbuf = 0);
 	bool ProcessReceivedDataAsOldPackets(char* errbuf = 0);
 	void ProcessNetworkLayerPacket(ServerPacket* pack);
-	
+
 	virtual bool LineOutQueuePush(char* line);
 	virtual void ClearBuffers();
-	
+
 	EmuTCPServer*		Server;
-	
+
 	eTCPMode		TCPMode;
 	ePacketMode		PacketMode;
 	bool pOldFormat;
-	
+
 	Timer keepalive_timer;
 	Timer timeout_timer;
-	
+
 	//relay crap:
 	EmuTCPConnection*	RelayLink;
 	int32			RelayCount;
 	bool	RelayServer;
 	uint32			RemoteID;
-	
+
 	//input queue...
 	void	InModeQueuePush(EmuTCPNetPacket_Struct* tnps);
 	MyQueue<EmuTCPNetPacket_Struct> InModeQueue;
-	
+
 	//output queue...
 	MyQueue<ServerPacket> OutQueue;
 	Mutex	MOutQueueLock;
--- a/Show More
+++ b/Show More