Some of these really slow down profiling without adding much (short functions)

.gitignore

@@ -23,24 +23,15 @@ CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
-[Bb]uild/
-[Bb]uild32/
-[Bb]uild64/
-[Bb]uild_32/
-[Bb]uild_64/
-deploy/server/
-x64/
-x86/
+Build/
+build/
+Build32/
+build32/
+Build64/
+build64/
+Build_32/
+build_32/
+Build_64/
+build_64/
 log/
 logs/
-
-docker/db
-
-# Protobuf generated files
-*.pb.cc
-*.pb.h
-protobuf/csharp/*
-protobuf/go/*
-protobuf/java/*
-protobuf/python/*
-.vscode

.travis.yml

@@ -1,25 +1,11 @@
 language: cpp
 compiler: gcc
-sudo: false
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.8
-    - g++-4.8
-    - libmysqlclient-dev
-    - libperl-dev
-    - libboost-dev
-    - liblua5.1-0-dev
-    - zlib1g-dev
-    - uuid-dev
-    - libssl-dev
-install:
-  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
+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 -DEQEMU_BUILD_LOGIN=ON
-  - make -j2
+  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
+  - make
   - ./bin/tests
 branches:
   only:

CMakeLists.txt

@@ -13,6 +13,12 @@
 #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
@@ -24,12 +30,12 @@
 #EQEMU_BUILD_LUA
 #EQEMU_SANITIZE_LUA_LIBS
 #EQEMU_BUILD_CLIENT_FILES
-#EQEMU_USE_MAP_MMFS
 #EQEMU_MAP_DIR
+#EQEMU_ENABLE_PROFILING
 
 #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
 #Can change this if you really want but you should upgrade!
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12)
+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})
@@ -52,102 +58,16 @@ IF(MSVC OR MINGW)
 	ENDIF(CMAKE_CL_64)
 ENDIF(MSVC OR MINGW)
 
-# include dirs are universal
-SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats")
-
-#Try to find protobuf automatically
-FIND_PACKAGE(Protobuf QUIET)
-#IF(NOT PROTOBUF_FOUND)
-	SET(Protobuf_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf" CACHE PATH "Root protobuf directory" FORCE)
-	SET(PROTOBUF_FOUND TRUE CACHE BOOL "" FORCE)
-	IF(MSVC)
-		IF(CMAKE_CL_64)		
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/windows/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/windows/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/windows/x64/bin/protoc.exe" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/windows/x64/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/windows/x64/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)		
-		ELSE(CMAKE_CL_64)			
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/windows/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/windows/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/windows/x86/bin/protoc.exe" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/windows/x86/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/windows/x86/lib/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE)		
-		ENDIF(CMAKE_CL_64)
-	ELSE(MSVC)
-		IF(CMAKE_CL_64)
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/linux/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/linux/x86/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/linux/x86/bin/protoc" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/linux/x86/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/linux/x86/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)				
-		ELSE(CMAKE_CL_64)
-			SET(Protobuf_INCLUDE_DIR "${Protobuf_DIR}/linux/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_SRC_ROOT_FOLDER "${Protobuf_DIR}/linux/x64/include" CACHE PATH "Include dir" FORCE)
-			SET(Protobuf_PROTOC_EXECUTABLE  "${Protobuf_DIR}/linux/x64/bin/protoc" CACHE PATH "Executable path" FORCE)	
-			SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/linux/x64/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)
-			SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/linux/x64/lib/libprotobuf.so.16" CACHE PATH "Root protobuf directory" FORCE)	
-		ENDIF(CMAKE_CL_64)	
-	ENDIF()
-	IF(NOT Protobuf_LIBRARY_DEBUG)
-		MESSAGE(ERROR "Protobuf library was not found in ${Protobuf_LIBRARY_DEBUG}. Please download the depenencies and extract them as noted.")
-	ENDIF()
-	FILE(COPY ${Protobuf_LIBRARY_DEBUG} DESTINATION ${CMAKE_HOME_DIRECTORY}/bin)	
-#ENDIF()
-
-INCLUDE_DIRECTORIES(SYSTEM "${Protobuf_INCLUDE_DIR}")
-
-IF(MSVC)
-	IF(CMAKE_CL_64)
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/windows/x64/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/windows/x64/lib/nats.lib")
-	ELSE(CMAKE_CL_64)	
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/windows/x86/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/windows/x86/lib/nats.lib")
-	ENDIF(CMAKE_CL_64)
-ELSE(MSVC)
-	IF(CMAKE_CL_64)
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/linux/x86/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/linux/x86/lib/libnats.so")
-	ELSE(CMAKE_CL_64)			
-		SET(NATS_INCLUDE_DIR "${NATS_ROOT}/linux/x64/include")
-		SET(NATS_LIBRARY_DEBUG "${NATS_ROOT}/linux/x64/lib/libnats.so")
-	ENDIF(CMAKE_CL_64)
-ENDIF()
-IF(${NATS_LIBRARY_DEBUG})
-	MESSAGE(ERROR " NATS library was not found in ${NATS_LIBRARY_DEBUG}/libnats.so. Please download the depenencies and extract them as noted.")
-ENDIF()
-FILE(COPY ${NATS_LIBRARY_DEBUG} DESTINATION ${CMAKE_HOME_DIRECTORY}/bin)	
-
 IF(MSVC)
 	#Set our default locations for zlib/mysql based on x86/x64
 	IF(CMAKE_CL_64)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
 		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x64")
-		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x64")
-		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-		IF(MSVC_VERSION GREATER 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v140/dynamic")
-		ELSEIF(MSVC_VERSION EQUAL 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v120/dynamic")
-		ELSE()
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v110/dynamic")
-		ENDIF()
 	ELSE(CMAKE_CL_64)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
 		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
-		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86")
-		SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats_x86")
-		IF(MSVC_VERSION GREATER 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic")
-		ELSEIF(MSVC_VERSION EQUAL 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v120/dynamic")
-		ELSE()
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v110/dynamic")
-		ENDIF()
 	ENDIF(CMAKE_CL_64)
 
 	#disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
@@ -199,8 +119,6 @@ IF(MSVC)
 
 	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)
 ENDIF(MSVC)
@@ -301,6 +219,14 @@ SET(EQEMU_LOG_LEVEL_CRASH 3 CACHE STRING "EQEmu logging level for [Crash]:
 
 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)
 
@@ -328,11 +254,11 @@ ENDIF(EQEMU_ENABLE_BOTS)
 #What to build
 OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
 OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
-OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
 OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
 OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
 OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
 OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
+OPTION(EQEMU_ENABLE_PROFILING "Enable CPU profiler. Note: will slow down execution time." OFF)
 
 #C++11 stuff
 IF(NOT MSVC)
@@ -351,17 +277,17 @@ IF(EQEMU_BUILD_LUA)
 	ADD_DEFINITIONS(-DLUA_EQEMU)
 ENDIF(EQEMU_BUILD_LUA)
 
-OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-IF(EQEMU_USE_MAP_MMFS)
-	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-ENDIF(EQEMU_USE_MAP_MMFS)
-
 SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
 
 ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
 ADD_DEFINITIONS(-DINVERSEXY)
 ADD_DEFINITIONS(-DFIELD_ITEMS)
 ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
+ADD_DEFINITIONS(-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})
@@ -371,6 +297,12 @@ 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)
@@ -379,30 +311,6 @@ IF(EQEMU_BUILD_PERL)
 	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
 ENDIF(EQEMU_BUILD_PERL)
 
-SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt ${NATS_LIBRARY_DEBUG} ${PROTOBUF_LIBRARY_DEBUG})
-
-FIND_PACKAGE(Sodium REQUIRED)
-IF(SODIUM_FOUND)
-	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
-	IF(EQEMU_ENABLE_SECURITY)
-		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
-		ADD_DEFINITIONS(-DENABLE_SECURITY)
-		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
-	ENDIF()
-ENDIF()
-
-IF(WIN32)
-	SET(SERVER_LIBS ${SERVER_LIBS} "ws2_32" "psapi" "iphlpapi" "userenv")
-ENDIF()
-
-IF(UNIX)
-	SET(SERVER_LIBS ${SERVER_LIBS} ${CMAKE_DL_LIBS} "z" "m" "pthread")
-	IF(NOT DARWIN)
-		SET(SERVER_LIBS ${SERVER_LIBS} "rt")
-	ENDIF()
-	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
-ENDIF()
-
 IF(EQEMU_BUILD_LUA)
 	FIND_PACKAGE(EQLua51 REQUIRED)
 	SET(Boost_USE_STATIC_LIBS OFF)
@@ -411,8 +319,7 @@ IF(EQEMU_BUILD_LUA)
 	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
 
 	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/luabind")
+	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)
@@ -420,21 +327,25 @@ IF(EQEMU_BUILD_LUA)
 	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
 ENDIF(EQEMU_BUILD_LUA)
 
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
-INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
-INCLUDE_DIRECTORIES(SYSTEM "${NATS_INCLUDE_DIR}")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
 
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" )
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format")
+IF(EQEMU_BUILD_LUA)
+    ADD_SUBDIRECTORY(luabind)
+ENDIF(EQEMU_BUILD_LUA)
 
+IF(EQEMU_ENABLE_PROFILING)
+	ADD_DEFINITIONS(-DEQPERF_ENABLED)
+	ADD_DEFINITIONS(-DEQP_MULTITHREAD)
+	INCLUDE_DIRECTORIES("eqperf")
+	ADD_SUBDIRECTORY(eqperf)
+	SET(PERF_LIBS eqperf)
+ELSE(EQEMU_ENABLE_PROFILING)
+	SET(PERF_LIBS "")
+ENDIF(EQEMU_ENABLE_PROFILING)
 
-IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
+IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(common)
-	ADD_SUBDIRECTORY(libs)
-ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
+ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -447,10 +358,6 @@ IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)
 
-IF(EQEMU_BUILD_HC)
-	ADD_SUBDIRECTORY(hc)
-ENDIF(EQEMU_BUILD_HC)
-
 IF(EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(tests)
 ENDIF(EQEMU_BUILD_TESTS)

GPL.txt

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

LICENSE

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

LICENSE.md

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

README.md

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

client_files/export/CMakeLists.txt

@@ -9,8 +9,31 @@ SET(export_headers
 
 ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
 
-INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(export_client_files ${SERVER_LIBS})
+TARGET_LINK_LIBRARIES(export_client_files common ${PERF_LIBS} 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")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
+ENDIF(MSVC)
+
+IF(MINGW)
+	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
+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")
+	TARGET_LINK_LIBRARIES(export_client_files "uuid")
+	ADD_DEFINITIONS(-fPIC)
+ENDIF(UNIX)
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/export/main.cpp

@@ -27,55 +27,53 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys LogSys;
+EQEmuLogSys Log;
 
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
-void ExportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
-	LogSys.LoadLogSettingsDefaults();
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log(Logs::General, Logs::Status, "Client Files Export Utility");
+	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	Log(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}
 
 	/* Register Log System and Settings */
-	database.LoadLogSettings(LogSys.log_settings);
-	LogSys.StartFileLogs();
+	database.LoadLogSettings(Log.log_settings);
+	Log.StartFileLogs();
 
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
-	ExportDBStrings(&database);
 
-	LogSys.CloseFileLogs();
+	Log.CloseFileLogs();
 
 	return 0;
 }
 
 void ExportSpells(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Spells...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}
 
@@ -142,11 +140,11 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
 }
 
 void ExportSkillCaps(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
@@ -171,11 +169,11 @@ void ExportSkillCaps(SharedDatabase *db) {
 }
 
 void ExportBaseData(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}
 
@@ -196,38 +194,7 @@ void ExportBaseData(SharedDatabase *db) {
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	}
-
-	fclose(f);
-}
-
-void ExportDBStrings(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Exporting DB Strings...");
-
-	FILE *f = fopen("export/dbstr_us.txt", "w");
-	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
-		return;
-	}
-
-	fprintf(f, "Major^Minor^String(New)\n");
-	const std::string query = "SELECT * FROM db_str ORDER BY id, type";
-	auto results = db->QueryDatabase(query);
-	if(results.Success()) {
-		for(auto row = results.begin(); row != results.end(); ++row) {
-			std::string line;
-			unsigned int fields = results.ColumnCount();
-			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
-				if(rowIndex != 0)
-					line.push_back('^');
-
-				if(row[rowIndex] != nullptr) {
-					line += row[rowIndex];
-				}
-			}
-
-			fprintf(f, "%s\n", line.c_str());
-		}
+	} else {
 	}
 
 	fclose(f);

client_files/import/CMakeLists.txt

@@ -9,8 +9,31 @@ SET(import_headers
 
 ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
 
-INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(import_client_files ${SERVER_LIBS})
+TARGET_LINK_LIBRARIES(import_client_files common ${PERF_LIBS} 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")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
+ENDIF(MSVC)
+
+IF(MINGW)
+	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
+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")
+	TARGET_LINK_LIBRARIES(import_client_files "uuid")
+	ADD_DEFINITIONS(-fPIC)
+ENDIF(UNIX)
 
 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

client_files/import/main.cpp

@@ -25,44 +25,42 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys LogSys;
+EQEmuLogSys Log;
 
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
-void ImportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	LogSys.LoadLogSettingsDefaults();
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log(Logs::General, Logs::Status, "Client Files Import Utility");
+	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *config = EQEmuConfig::get();
 
 	SharedDatabase database;
-	Log(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}
 
-	database.LoadLogSettings(LogSys.log_settings);
-	LogSys.StartFileLogs();
+	database.LoadLogSettings(Log.log_settings);
+	Log.StartFileLogs();
 
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
-	ImportDBStrings(&database);
 
-	LogSys.CloseFileLogs();
+	Log.CloseFileLogs();
 	
 	return 0;
 }
@@ -97,10 +95,10 @@ bool IsStringField(int i) {
 }
 
 void ImportSpells(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Spells...");
+	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
@@ -173,23 +171,23 @@ void ImportSpells(SharedDatabase *db) {
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
@@ -204,6 +202,7 @@ void ImportSkillCaps(SharedDatabase *db) {
 			continue;
 		}
 
+
 		int class_id, skill_id, level, cap;
 		class_id = atoi(split[0].c_str());
 		skill_id = atoi(split[1].c_str());
@@ -220,11 +219,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 
@@ -263,56 +262,3 @@ void ImportBaseData(SharedDatabase *db) {
 
 	fclose(f);
 }
-
-void ImportDBStrings(SharedDatabase *db) {
-	Log(Logs::General, Logs::Status, "Importing DB Strings...");
-
-	FILE *f = fopen("import/dbstr_us.txt", "r");
-	if(!f) {
-		Log(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
-		return;
-	}
-
-	std::string delete_sql = "DELETE FROM db_str";
-	db->QueryDatabase(delete_sql);
-
-	char buffer[2048];
-	bool first = true;
-	while(fgets(buffer, 2048, f)) {
-		if(first) {
-			first = false;
-			continue;
-		}
-
-		for(int i = 0; i < 2048; ++i) {
-			if(buffer[i] == '\n') {
-				buffer[i] = 0;
-				break;
-			}
-		}
-
-		auto split = SplitString(buffer, '^');
-
-		if(split.size() < 2) {
-			continue;
-		}
-
-		std::string sql;
-		int id, type;
-		std::string value;
-		
-		id = atoi(split[0].c_str());
-		type = atoi(split[1].c_str());
-		
-		if(split.size() >= 3) {
-			value = ::EscapeString(split[2]);
-		}
-
-		sql = StringFormat("INSERT INTO db_str(id, type, value) VALUES(%u, %u, '%s')",
-						   id, type, value.c_str());
-
-		db->QueryDatabase(sql);
-	}
-
-	fclose(f);
-}

cmake/FindMySQL.cmake

@@ -21,12 +21,6 @@ IF(MYSQL_ROOT)
 		NAMES mysql.h
 		PATHS ${MYSQL_ROOT}/include
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
-	)
-	FIND_PATH(MySQL_INCLUDE_DIR
-		NAMES mysql.h
-		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
 	FIND_PATH(MySQL_INCLUDE_DIR
@@ -36,46 +30,49 @@ ELSE(MYSQL_ROOT)
 ENDIF(MYSQL_ROOT)
 
 # Library
-SET(MySQL_NAMES libmysql)
+SET(MySQL_NAMES mysqlclient_r mysqlclient)
 IF(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
 		NAMES ${MySQL_NAMES}
-		PATHS ${MYSQL_ROOT}/lib
+		PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
 	)
-	
-	FIND_LIBRARY(MySQL_LIBRARY
+
+	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
-		NAMES ${MySQL_NAMES} mysqlclient_r mysqlclient
+	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)
+IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 	SET(MySQL_FOUND TRUE)
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY} )
-ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+	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 )
-ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 
 
 # handle the QUIETLY and REQUIRED arguments and set MySQL_FOUND to TRUE if
 # all listed variables are TRUE
 INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY_DEBUG MySQL_LIBRARY_RELEASE MySQL_INCLUDE_DIR)
 
 IF(MySQL_FOUND)
-	SET( MySQL_LIBRARY_RELEASE ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARY_DEBUG ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_RELEASE} ${MySQL_LIBRARY_DEBUG} )
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
 ELSE(MySQL_FOUND)
 	SET( MySQL_LIBRARIES )
 ENDIF(MySQL_FOUND)

cmake/FindPackageHandleStandardArgs.cmake

@@ -1,386 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindPackageHandleStandardArgs
------------------------------
-
-This module provides a function intended to be used in :ref:`Find Modules`
-implementing :command:`find_package(<PackageName>)` calls.  It handles the
-``REQUIRED``, ``QUIET`` and version-related arguments of ``find_package``.
-It also sets the ``<PackageName>_FOUND`` variable.  The package is
-considered found if all variables listed contain valid results, e.g.
-valid filepaths.
-
-.. command:: find_package_handle_standard_args
-
-  There are two signatures::
-
-    find_package_handle_standard_args(<PackageName>
-      (DEFAULT_MSG|<custom-failure-message>)
-      <required-var>...
-      )
-
-    find_package_handle_standard_args(<PackageName>
-      [FOUND_VAR <result-var>]
-      [REQUIRED_VARS <required-var>...]
-      [VERSION_VAR <version-var>]
-      [HANDLE_COMPONENTS]
-      [CONFIG_MODE]
-      [FAIL_MESSAGE <custom-failure-message>]
-      )
-
-  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all
-  the variables ``<required-var>...`` are valid and any optional
-  constraints are satisfied, and ``FALSE`` otherwise.  A success or
-  failure message may be displayed based on the results and on
-  whether the ``REQUIRED`` and/or ``QUIET`` option was given to
-  the :command:`find_package` call.
-
-  The options are:
-
-  ``(DEFAULT_MSG|<custom-failure-message>)``
-    In the simple signature this specifies the failure message.
-    Use ``DEFAULT_MSG`` to ask for a default message to be computed
-    (recommended).  Not valid in the full signature.
-
-  ``FOUND_VAR <result-var>``
-    Obsolete.  Specifies either ``<PackageName>_FOUND`` or
-    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only
-    for compatibility with older versions of CMake and is now ignored.
-    Result variables of both names are always set for compatibility.
-
-  ``REQUIRED_VARS <required-var>...``
-    Specify the variables which are required for this package.
-    These may be named in the generated failure message asking the
-    user to set the missing variable values.  Therefore these should
-    typically be cache entries such as ``FOO_LIBRARY`` and not output
-    variables like ``FOO_LIBRARIES``.
-
-  ``VERSION_VAR <version-var>``
-    Specify the name of a variable that holds the version of the package
-    that has been found.  This version will be checked against the
-    (potentially) specified required version given to the
-    :command:`find_package` call, including its ``EXACT`` option.
-    The default messages include information about the required
-    version and the version which has been actually found, both
-    if the version is ok or not.
-
-  ``HANDLE_COMPONENTS``
-    Enable handling of package components.  In this case, the command
-    will report which components have been found and which are missing,
-    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``
-    if any of the required components (i.e. not the ones listed after
-    the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are
-    missing.
-
-  ``CONFIG_MODE``
-    Specify that the calling find module is a wrapper around a
-    call to ``find_package(<PackageName> NO_MODULE)``.  This implies
-    a ``VERSION_VAR`` value of ``<PackageName>_VERSION``.  The command
-    will automatically check whether the package configuration file
-    was found.
-
-  ``FAIL_MESSAGE <custom-failure-message>``
-    Specify a custom failure message instead of using the default
-    generated message.  Not recommended.
-
-Example for the simple signature:
-
-.. code-block:: cmake
-
-  find_package_handle_standard_args(LibXml2 DEFAULT_MSG
-    LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
-
-The ``LibXml2`` package is considered to be found if both
-``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid.
-Then also ``LibXml2_FOUND`` is set to ``TRUE``.  If it is not found
-and ``REQUIRED`` was used, it fails with a
-:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was
-used or not.  If it is found, success will be reported, including
-the content of the first ``<required-var>``.  On repeated CMake runs,
-the same message will not be printed again.
-
-Example for the full signature:
-
-.. code-block:: cmake
-
-  find_package_handle_standard_args(LibArchive
-    REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR
-    VERSION_VAR LibArchive_VERSION)
-
-In this case, the ``LibArchive`` package is considered to be found if
-both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid.
-Also the version of ``LibArchive`` will be checked by using the version
-contained in ``LibArchive_VERSION``.  Since no ``FAIL_MESSAGE`` is given,
-the default messages will be printed.
-
-Another example for the full signature:
-
-.. code-block:: cmake
-
-  find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
-  find_package_handle_standard_args(Automoc4  CONFIG_MODE)
-
-In this case, a ``FindAutmoc4.cmake`` module wraps a call to
-``find_package(Automoc4 NO_MODULE)`` and adds an additional search
-directory for ``automoc4``.  Then the call to
-``find_package_handle_standard_args`` produces a proper success/failure
-message.
-#]=======================================================================]
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
-
-# internal helper macro
-macro(_FPHSA_FAILURE_MESSAGE _msg)
-  if (${_NAME}_FIND_REQUIRED)
-    message(FATAL_ERROR "${_msg}")
-  else ()
-    if (NOT ${_NAME}_FIND_QUIETLY)
-      message(STATUS "${_msg}")
-    endif ()
-  endif ()
-endmacro()
-
-
-# internal helper macro to generate the failure message when used in CONFIG_MODE:
-macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
-  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
-  if(${_NAME}_CONFIG)
-    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
-  else()
-    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
-    # List them all in the error message:
-    if(${_NAME}_CONSIDERED_CONFIGS)
-      set(configsText "")
-      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
-      math(EXPR configsCount "${configsCount} - 1")
-      foreach(currentConfigIndex RANGE ${configsCount})
-        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
-        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
-        string(APPEND configsText "    ${filename} (version ${version})\n")
-      endforeach()
-      if (${_NAME}_NOT_FOUND_MESSAGE)
-        string(APPEND configsText "    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
-      endif()
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
-
-    else()
-      # Simple case: No Config-file was found at all:
-      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
-    endif()
-  endif()
-endmacro()
-
-
-function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
-
-# Set up the arguments for `cmake_parse_arguments`.
-  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
-  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
-  set(multiValueArgs REQUIRED_VARS)
-
-# Check whether we are in 'simple' or 'extended' mode:
-  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
-  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
-
-  if(${INDEX} EQUAL -1)
-    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
-    set(FPHSA_REQUIRED_VARS ${ARGN})
-    set(FPHSA_VERSION_VAR)
-  else()
-    cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
-
-    if(FPHSA_UNPARSED_ARGUMENTS)
-      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
-    endif()
-
-    if(NOT FPHSA_FAIL_MESSAGE)
-      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
-    endif()
-
-    # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
-    # when it successfully found the config-file, including version checking:
-    if(FPHSA_CONFIG_MODE)
-      list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
-      list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
-      set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
-    endif()
-
-    if(NOT FPHSA_REQUIRED_VARS)
-      message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
-    endif()
-  endif()
-
-# now that we collected all arguments, process them
-
-  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
-    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
-  endif()
-
-  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
-
-  string(TOUPPER ${_NAME} _NAME_UPPER)
-  string(TOLOWER ${_NAME} _NAME_LOWER)
-
-  if(FPHSA_FOUND_VAR)
-    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
-      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
-    else()
-      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
-    endif()
-  else()
-    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
-  endif()
-
-  # collect all variables which were not found, so they can be printed, so the
-  # user knows better what went wrong (#6375)
-  set(MISSING_VARS "")
-  set(DETAILS "")
-  # check if all passed variables are valid
-  set(FPHSA_FOUND_${_NAME} TRUE)
-  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
-    if(NOT ${_CURRENT_VAR})
-      set(FPHSA_FOUND_${_NAME} FALSE)
-      string(APPEND MISSING_VARS " ${_CURRENT_VAR}")
-    else()
-      string(APPEND DETAILS "[${${_CURRENT_VAR}}]")
-    endif()
-  endforeach()
-  if(FPHSA_FOUND_${_NAME})
-    set(${_NAME}_FOUND TRUE)
-    set(${_NAME_UPPER}_FOUND TRUE)
-  else()
-    set(${_NAME}_FOUND FALSE)
-    set(${_NAME_UPPER}_FOUND FALSE)
-  endif()
-
-  # component handling
-  unset(FOUND_COMPONENTS_MSG)
-  unset(MISSING_COMPONENTS_MSG)
-
-  if(FPHSA_HANDLE_COMPONENTS)
-    foreach(comp ${${_NAME}_FIND_COMPONENTS})
-      if(${_NAME}_${comp}_FOUND)
-
-        if(NOT DEFINED FOUND_COMPONENTS_MSG)
-          set(FOUND_COMPONENTS_MSG "found components: ")
-        endif()
-        string(APPEND FOUND_COMPONENTS_MSG " ${comp}")
-
-      else()
-
-        if(NOT DEFINED MISSING_COMPONENTS_MSG)
-          set(MISSING_COMPONENTS_MSG "missing components: ")
-        endif()
-        string(APPEND MISSING_COMPONENTS_MSG " ${comp}")
-
-        if(${_NAME}_FIND_REQUIRED_${comp})
-          set(${_NAME}_FOUND FALSE)
-          string(APPEND MISSING_VARS " ${comp}")
-        endif()
-
-      endif()
-    endforeach()
-    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
-    string(APPEND DETAILS "[c${COMPONENT_MSG}]")
-  endif()
-
-  # version handling:
-  set(VERSION_MSG "")
-  set(VERSION_OK TRUE)
-
-  # check with DEFINED here as the requested or found version may be "0"
-  if (DEFINED ${_NAME}_FIND_VERSION)
-    if(DEFINED ${FPHSA_VERSION_VAR})
-      set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}})
-
-      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
-        # count the dots in the version string
-        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${_FOUND_VERSION}")
-        # add one dot because there is one dot more than there are components
-        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
-        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
-          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
-          # is at most 4 here. Therefore a simple lookup table is used.
-          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
-            set(_VERSION_REGEX "[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*")
-          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
-          else ()
-            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
-          endif ()
-          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${_FOUND_VERSION}")
-          unset(_VERSION_REGEX)
-          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
-            set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")")
-          endif ()
-          unset(_VERSION_HEAD)
-        else ()
-          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _FOUND_VERSION)
-            set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-            set(VERSION_OK FALSE)
-          else ()
-            set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")")
-          endif ()
-        endif ()
-        unset(_VERSION_DOTS)
-
-      else()     # minimum version specified:
-        if (${_NAME}_FIND_VERSION VERSION_GREATER _FOUND_VERSION)
-          set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
-          set(VERSION_OK FALSE)
-        else ()
-          set(VERSION_MSG "(found suitable version \"${_FOUND_VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
-        endif ()
-      endif()
-
-    else()
-
-      # if the package was not found, but a version was given, add that to the output:
-      if(${_NAME}_FIND_VERSION_EXACT)
-         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
-      else()
-         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
-      endif()
-
-    endif()
-  else ()
-    # Check with DEFINED as the found version may be 0.
-    if(DEFINED ${FPHSA_VERSION_VAR})
-      set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")")
-    endif()
-  endif ()
-
-  if(VERSION_OK)
-    string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]")
-  else()
-    set(${_NAME}_FOUND FALSE)
-  endif()
-
-
-  # print the result:
-  if (${_NAME}_FOUND)
-    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
-  else ()
-
-    if(FPHSA_CONFIG_MODE)
-      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
-    else()
-      if(NOT VERSION_OK)
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
-      else()
-        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}")
-      endif()
-    endif()
-
-  endif ()
-
-  set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
-  set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
-endfunction()

cmake/FindPackageMessage.cmake

@@ -1,47 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# FindPackageMessage
-# ------------------
-#
-#
-#
-# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
-#
-# This macro is intended to be used in FindXXX.cmake modules files.  It
-# will print a message once for each unique find result.  This is useful
-# for telling the user where a package was found.  The first argument
-# specifies the name (XXX) of the package.  The second argument
-# specifies the message to display.  The third argument lists details
-# about the find result so that if they change the message will be
-# displayed again.  The macro also obeys the QUIET argument to the
-# find_package command.
-#
-# Example:
-#
-# ::
-#
-#   if(X11_FOUND)
-#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
-#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
-#   else()
-#    ...
-#   endif()
-
-function(FIND_PACKAGE_MESSAGE pkg msg details)
-  # Avoid printing a message repeatedly for the same find result.
-  if(NOT ${pkg}_FIND_QUIETLY)
-    string(REPLACE "\n" "" details "${details}")
-    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
-    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
-      # The message has not yet been printed.
-      message(STATUS "${msg}")
-
-      # Save the find details in the cache to avoid printing the same
-      # message again.
-      set("${DETAILS_VAR}" "${details}"
-        CACHE INTERNAL "Details about finding ${pkg}")
-    endif()
-  endif()
-endfunction()

cmake/FindProtobuf.cmake

@@ -1,579 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# FindProtobuf
-# ------------
-#
-# Locate and configure the Google Protocol Buffers library.
-#
-# The following variables can be set and are optional:
-#
-# ``Protobuf_SRC_ROOT_FOLDER``
-#   When compiling with MSVC, if this cache variable is set
-#   the protobuf-default VS project build locations
-#   (vsprojects/Debug and vsprojects/Release
-#   or vsprojects/x64/Debug and vsprojects/x64/Release)
-#   will be searched for libraries and binaries.
-# ``Protobuf_IMPORT_DIRS``
-#   List of additional directories to be searched for
-#   imported .proto files.
-# ``Protobuf_DEBUG``
-#   Show debug messages.
-# ``Protobuf_USE_STATIC_LIBS``
-#   Set to ON to force the use of the static libraries.
-#   Default is OFF.
-#
-# Defines the following variables:
-#
-# ``Protobuf_FOUND``
-#   Found the Google Protocol Buffers library
-#   (libprotobuf & header files)
-# ``Protobuf_VERSION``
-#   Version of package found.
-# ``Protobuf_INCLUDE_DIRS``
-#   Include directories for Google Protocol Buffers
-# ``Protobuf_LIBRARIES``
-#   The protobuf libraries
-# ``Protobuf_PROTOC_LIBRARIES``
-#   The protoc libraries
-# ``Protobuf_LITE_LIBRARIES``
-#   The protobuf-lite libraries
-#
-# The following :prop_tgt:`IMPORTED` targets are also defined:
-#
-# ``protobuf::libprotobuf``
-#   The protobuf library.
-# ``protobuf::libprotobuf-lite``
-#   The protobuf lite library.
-# ``protobuf::libprotoc``
-#   The protoc library.
-# ``protobuf::protoc``
-#   The protoc compiler.
-#
-# The following cache variables are also available to set or use:
-#
-# ``Protobuf_LIBRARY``
-#   The protobuf library
-# ``Protobuf_PROTOC_LIBRARY``
-#   The protoc library
-# ``Protobuf_INCLUDE_DIR``
-#   The include directory for protocol buffers
-# ``Protobuf_PROTOC_EXECUTABLE``
-#   The protoc compiler
-# ``Protobuf_LIBRARY_DEBUG``
-#   The protobuf library (debug)
-# ``Protobuf_PROTOC_LIBRARY_DEBUG``
-#   The protoc library (debug)
-# ``Protobuf_LITE_LIBRARY``
-#   The protobuf lite library
-# ``Protobuf_LITE_LIBRARY_DEBUG``
-#   The protobuf lite library (debug)
-#
-# Example:
-#
-# .. code-block:: cmake
-#
-#   find_package(Protobuf REQUIRED)
-#   include_directories(${Protobuf_INCLUDE_DIRS})
-#   include_directories(${CMAKE_CURRENT_BINARY_DIR})
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS foo.proto)
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS EXPORT_MACRO DLL_EXPORT foo.proto)
-#   protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS DESCRIPTORS PROTO_DESCS foo.proto)
-#   protobuf_generate_python(PROTO_PY foo.proto)
-#   add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS})
-#   target_link_libraries(bar ${Protobuf_LIBRARIES})
-#
-# .. note::
-#   The ``protobuf_generate_cpp`` and ``protobuf_generate_python``
-#   functions and :command:`add_executable` or :command:`add_library`
-#   calls only work properly within the same directory.
-#
-# .. command:: protobuf_generate_cpp
-#
-#   Add custom commands to process ``.proto`` files to C++::
-#
-#     protobuf_generate_cpp (<SRCS> <HDRS>
-#         [DESCRIPTORS <DESC>] [EXPORT_MACRO <MACRO>] [<ARGN>...])
-#
-#   ``SRCS``
-#     Variable to define with autogenerated source files
-#   ``HDRS``
-#     Variable to define with autogenerated header files
-#   ``DESCRIPTORS``
-#     Variable to define with autogenerated descriptor files, if requested.
-#   ``EXPORT_MACRO``
-#     is a macro which should expand to ``__declspec(dllexport)`` or
-#     ``__declspec(dllimport)`` depending on what is being compiled.
-#   ``ARGN``
-#     ``.proto`` files
-#
-# .. command:: protobuf_generate_python
-#
-#   Add custom commands to process ``.proto`` files to Python::
-#
-#     protobuf_generate_python (<PY> [<ARGN>...])
-#
-#   ``PY``
-#     Variable to define with autogenerated Python files
-#   ``ARGN``
-#     ``.proto`` filess
-
-function(PROTOBUF_GENERATE_CPP SRCS HDRS)
-  cmake_parse_arguments(protobuf "" "EXPORT_MACRO;DESCRIPTORS" "" ${ARGN})
-
-  set(PROTO_FILES "${protobuf_UNPARSED_ARGUMENTS}")
-  if(NOT PROTO_FILES)
-    message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
-    return()
-  endif()
-
-  if(protobuf_EXPORT_MACRO)
-    set(DLL_EXPORT_DECL "dllexport_decl=${protobuf_EXPORT_MACRO}:")
-  endif()
-
-  if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
-    # Create an include path for each file specified
-    foreach(FIL ${PROTO_FILES})
-      get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-      get_filename_component(ABS_PATH ${ABS_FIL} PATH)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  else()
-    set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-
-  if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
-    set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
-  endif()
-
-  if(DEFINED Protobuf_IMPORT_DIRS)
-    foreach(DIR ${Protobuf_IMPORT_DIRS})
-      get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  endif()
-
-  set(${SRCS})
-  set(${HDRS})
-  if (protobuf_DESCRIPTORS)
-    set(${protobuf_DESCRIPTORS})
-  endif()
-
-  foreach(FIL ${PROTO_FILES})
-    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-    get_filename_component(FIL_WE ${FIL} NAME_WE)
-    if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH)
-      get_filename_component(FIL_DIR ${FIL} DIRECTORY)
-      if(FIL_DIR)
-        set(FIL_WE "${FIL_DIR}/${FIL_WE}")
-      endif()
-    endif()
-    
-    set(_protobuf_protoc_src "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.cc")
-    set(_protobuf_protoc_hdr "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.h")
-    list(APPEND ${SRCS} "${_protobuf_protoc_src}")
-    list(APPEND ${HDRS} "${_protobuf_protoc_hdr}")
-
-    if(protobuf_DESCRIPTORS)
-      set(_protobuf_protoc_desc "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.desc")
-      set(_protobuf_protoc_flags "--descriptor_set_out=${_protobuf_protoc_desc}")
-      list(APPEND ${protobuf_DESCRIPTORS} "${_protobuf_protoc_desc}")
-    else()
-      set(_protobuf_protoc_desc "")
-      set(_protobuf_protoc_flags "")
-    endif()
-  
-    add_custom_command(
-      OUTPUT "${_protobuf_protoc_src}"
-             "${_protobuf_protoc_hdr}"
-             ${_protobuf_protoc_desc}
-      COMMAND  protobuf::protoc
-               "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_CURRENT_SOURCE_DIR}"
-               ${_protobuf_protoc_flags}
-               ${_protobuf_include_path} ${ABS_FIL}
-      DEPENDS ${ABS_FIL} protobuf::protoc
-      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
-      VERBATIM )
-  endforeach()
-
-  set(${SRCS} "${${SRCS}}" PARENT_SCOPE)
-  set(${HDRS} "${${HDRS}}" PARENT_SCOPE)
-  if(protobuf_DESCRIPTORS)
-    set(${protobuf_DESCRIPTORS} "${${protobuf_DESCRIPTORS}}" PARENT_SCOPE)
-  endif()
-  
-endfunction()
-
-function(PROTOBUF_GENERATE_PYTHON SRCS)
-  if(NOT ARGN)
-    message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files")
-    return()
-  endif()
-
-  if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
-    # Create an include path for each file specified
-    foreach(FIL ${ARGN})
-      get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-      get_filename_component(ABS_PATH ${ABS_FIL} PATH)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  else()
-    set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-
-  if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS)
-    set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}")
-  endif()
-
-  if(DEFINED Protobuf_IMPORT_DIRS)
-    foreach(DIR ${Protobuf_IMPORT_DIRS})
-      get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
-      list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
-      if(${_contains_already} EQUAL -1)
-          list(APPEND _protobuf_include_path -I ${ABS_PATH})
-      endif()
-    endforeach()
-  endif()
-
-  set(${SRCS})
-  foreach(FIL ${ARGN})
-    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
-    get_filename_component(FIL_WE ${FIL} NAME_WE)
-    if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH)
-      get_filename_component(FIL_DIR ${FIL} DIRECTORY)
-      if(FIL_DIR)
-        set(FIL_WE "${FIL_DIR}/${FIL_WE}")
-      endif()
-    endif()
-
-    list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py")
-    add_custom_command(
-      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py"
-      COMMAND  protobuf::protoc --python_out ${CMAKE_CURRENT_BINARY_DIR} ${_protobuf_include_path} ${ABS_FIL}
-      DEPENDS ${ABS_FIL} protobuf::protoc
-      COMMENT "Running Python protocol buffer compiler on ${FIL}"
-      VERBATIM )
-  endforeach()
-
-  set(${SRCS} ${${SRCS}} PARENT_SCOPE)
-endfunction()
-
-
-if(Protobuf_DEBUG)
-  # Output some of their choices
-  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-                 "Protobuf_USE_STATIC_LIBS = ${Protobuf_USE_STATIC_LIBS}")
-endif()
-
-
-# Backwards compatibility
-# Define camel case versions of input variables
-foreach(UPPER
-    PROTOBUF_SRC_ROOT_FOLDER
-    PROTOBUF_IMPORT_DIRS
-    PROTOBUF_DEBUG
-    PROTOBUF_LIBRARY
-    PROTOBUF_PROTOC_LIBRARY
-    PROTOBUF_INCLUDE_DIR
-    PROTOBUF_PROTOC_EXECUTABLE
-    PROTOBUF_LIBRARY_DEBUG
-    PROTOBUF_PROTOC_LIBRARY_DEBUG
-    PROTOBUF_LITE_LIBRARY
-    PROTOBUF_LITE_LIBRARY_DEBUG
-    )
-    if (DEFINED ${UPPER})
-        string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER})
-        if (NOT DEFINED ${Camel})
-            set(${Camel} ${${UPPER}})
-        endif()
-    endif()
-endforeach()
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  set(_PROTOBUF_ARCH_DIR x64/)
-endif()
-
-
-# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
-if( Protobuf_USE_STATIC_LIBS )
-  set( _protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  if(WIN32)
-    set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
-  else()
-    set(CMAKE_FIND_LIBRARY_SUFFIXES .a )
-  endif()
-endif()
-
-include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
-
-# Internal function: search for normal library as well as a debug one
-#    if the debug one is specified also include debug/optimized keywords
-#    in *_LIBRARIES variable
-function(_protobuf_find_libraries name filename)
-  if(${name}_LIBRARIES)
-    # Use result recorded by a previous call.
-    return()
-  elseif(${name}_LIBRARY)
-    # Honor cache entry used by CMake 3.5 and lower.
-    set(${name}_LIBRARIES "${${name}_LIBRARY}" PARENT_SCOPE)
-  else()
-    find_library(${name}_LIBRARY_RELEASE
-      NAMES ${filename}
-      PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release)
-    mark_as_advanced(${name}_LIBRARY_RELEASE)
-
-    find_library(${name}_LIBRARY_DEBUG
-      NAMES ${filename}d ${filename}
-      PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug)
-    mark_as_advanced(${name}_LIBRARY_DEBUG)
-
-    select_library_configurations(${name})
-    set(${name}_LIBRARY "${${name}_LIBRARY}" PARENT_SCOPE)
-    set(${name}_LIBRARIES "${${name}_LIBRARIES}" PARENT_SCOPE)
-  endif()
-endfunction()
-
-# Internal function: find threads library
-function(_protobuf_find_threads)
-    set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-    find_package(Threads)
-    if(Threads_FOUND)
-        list(APPEND Protobuf_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
-        set(Protobuf_LIBRARIES "${Protobuf_LIBRARIES}" PARENT_SCOPE)
-    endif()
-endfunction()
-
-#
-# Main.
-#
-
-# By default have PROTOBUF_GENERATE_CPP macro pass -I to protoc
-# for each directory where a proto file is referenced.
-if(NOT DEFINED PROTOBUF_GENERATE_CPP_APPEND_PATH)
-  set(PROTOBUF_GENERATE_CPP_APPEND_PATH TRUE)
-endif()
-
-
-# Google's provided vcproj files generate libraries with a "lib"
-# prefix on Windows
-if(MSVC)
-    set(Protobuf_ORIG_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
-    set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
-
-    find_path(Protobuf_SRC_ROOT_FOLDER protobuf.pc.in)
-endif()
-
-# The Protobuf library
-_protobuf_find_libraries(Protobuf protobuf)
-#DOC "The Google Protocol Buffers RELEASE Library"
-
-_protobuf_find_libraries(Protobuf_LITE protobuf-lite)
-
-# The Protobuf Protoc Library
-_protobuf_find_libraries(Protobuf_PROTOC protoc)
-
-# Restore original find library prefixes
-if(MSVC)
-    set(CMAKE_FIND_LIBRARY_PREFIXES "${Protobuf_ORIG_FIND_LIBRARY_PREFIXES}")
-endif()
-
-if(UNIX)
-    _protobuf_find_threads()
-endif()
-
-# Find the include directory
-find_path(Protobuf_INCLUDE_DIR
-    google/protobuf/service.h
-    PATHS ${Protobuf_SRC_ROOT_FOLDER}/src
-)
-mark_as_advanced(Protobuf_INCLUDE_DIR)
-
-# Find the protoc Executable
-find_program(Protobuf_PROTOC_EXECUTABLE
-    NAMES protoc
-    DOC "The Google Protocol Buffers Compiler"
-    PATHS /usr/bin    
-    ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release
-    ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug
-)
-mark_as_advanced(Protobuf_PROTOC_EXECUTABLE)
-
-if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "requested version of Google Protobuf is ${Protobuf_FIND_VERSION}")
-endif()
-
-if(Protobuf_INCLUDE_DIR)
-  set(_PROTOBUF_COMMON_HEADER ${Protobuf_INCLUDE_DIR}/google/protobuf/stubs/common.h)
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-                   "location of common.h: ${_PROTOBUF_COMMON_HEADER}")
-  endif()
-
-  set(Protobuf_VERSION "")
-  set(Protobuf_LIB_VERSION "")
-  file(STRINGS ${_PROTOBUF_COMMON_HEADER} _PROTOBUF_COMMON_H_CONTENTS REGEX "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+")
-  if(_PROTOBUF_COMMON_H_CONTENTS MATCHES "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+([0-9]+)")
-      set(Protobuf_LIB_VERSION "${CMAKE_MATCH_1}")
-  endif()
-  unset(_PROTOBUF_COMMON_H_CONTENTS)
-
-  math(EXPR _PROTOBUF_MAJOR_VERSION "${Protobuf_LIB_VERSION} / 1000000")
-  math(EXPR _PROTOBUF_MINOR_VERSION "${Protobuf_LIB_VERSION} / 1000 % 1000")
-  math(EXPR _PROTOBUF_SUBMINOR_VERSION "${Protobuf_LIB_VERSION} % 1000")
-  set(Protobuf_VERSION "${_PROTOBUF_MAJOR_VERSION}.${_PROTOBUF_MINOR_VERSION}.${_PROTOBUF_SUBMINOR_VERSION}")
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "${_PROTOBUF_COMMON_HEADER} reveals protobuf ${Protobuf_VERSION}")
-  endif()
-
-  # Check Protobuf compiler version to be aligned with libraries version
-  execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --version
-                  OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION)
-
-  if("${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" MATCHES "libprotoc ([0-9.]+)")
-    set(_PROTOBUF_PROTOC_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
-  endif()
-
-  if(Protobuf_DEBUG)
-    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
-        "${Protobuf_PROTOC_EXECUTABLE} reveals version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}")
-  endif()
-
-  if(NOT "${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" VERSION_EQUAL "${Protobuf_VERSION}")
-      message(WARNING "Protobuf compiler version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}"
-          " doesn't match library version ${Protobuf_VERSION}")
-  endif()
-
-  if(Protobuf_LIBRARY)
-      if(NOT TARGET protobuf::libprotobuf)
-          add_library(protobuf::libprotobuf UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotobuf PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_LIBRARY}")
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotobuf APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotobuf PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_LITE_LIBRARY)
-      if(NOT TARGET protobuf::libprotobuf-lite)
-          add_library(protobuf::libprotobuf-lite UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_LITE_LIBRARY}")
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_LITE_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_LITE_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_LITE_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_LITE_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotobuf-lite PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_LITE_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_PROTOC_LIBRARY)
-      if(NOT TARGET protobuf::libprotoc)
-          add_library(protobuf::libprotoc UNKNOWN IMPORTED)
-          set_target_properties(protobuf::libprotoc PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}")
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY}")
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_PROTOC_LIBRARY}")
-          endif()
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY_RELEASE}")
-            set_property(TARGET protobuf::libprotoc APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS RELEASE)
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION_RELEASE "${Protobuf_PROTOC_LIBRARY_RELEASE}")
-          endif()
-          if(EXISTS "${Protobuf_PROTOC_LIBRARY_DEBUG}")
-            set_property(TARGET protobuf::libprotoc APPEND PROPERTY
-              IMPORTED_CONFIGURATIONS DEBUG)
-            set_target_properties(protobuf::libprotoc PROPERTIES
-              IMPORTED_LOCATION_DEBUG "${Protobuf_PROTOC_LIBRARY_DEBUG}")
-          endif()
-      endif()
-  endif()
-
-  if(Protobuf_PROTOC_EXECUTABLE)
-      if(NOT TARGET protobuf::protoc)
-          add_executable(protobuf::protoc IMPORTED)
-          if(EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
-            set_target_properties(protobuf::protoc PROPERTIES
-              IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}")
-          endif()
-      endif()
-  endif()
-endif()
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Protobuf
-    REQUIRED_VARS Protobuf_LIBRARIES Protobuf_INCLUDE_DIR
-    VERSION_VAR Protobuf_VERSION
-)
-
-if(Protobuf_FOUND)
-    set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR})
-endif()
-
-# Restore the original find library ordering
-if( Protobuf_USE_STATIC_LIBS )
-  set(CMAKE_FIND_LIBRARY_SUFFIXES ${_protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
-endif()
-
-# Backwards compatibility
-# Define upper case versions of output variables
-foreach(Camel
-    Protobuf_SRC_ROOT_FOLDER
-    Protobuf_IMPORT_DIRS
-    Protobuf_DEBUG
-    Protobuf_INCLUDE_DIRS
-    Protobuf_LIBRARIES
-    Protobuf_PROTOC_LIBRARIES
-    Protobuf_LITE_LIBRARIES
-    Protobuf_LIBRARY
-    Protobuf_PROTOC_LIBRARY
-    Protobuf_INCLUDE_DIR
-    Protobuf_PROTOC_EXECUTABLE
-    Protobuf_LIBRARY_DEBUG
-    Protobuf_PROTOC_LIBRARY_DEBUG
-    Protobuf_LITE_LIBRARY
-    Protobuf_LITE_LIBRARY_DEBUG
-    )
-    string(TOUPPER ${Camel} UPPER)
-    set(${UPPER} ${${Camel}})
-endforeach()

cmake/FindSodium.cmake

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

cmake/SelectLibraryConfigurations.cmake

@@ -1,71 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#.rst:
-# SelectLibraryConfigurations
-# ---------------------------
-#
-#
-#
-# select_library_configurations( basename )
-#
-# This macro takes a library base name as an argument, and will choose
-# good values for basename_LIBRARY, basename_LIBRARIES,
-# basename_LIBRARY_DEBUG, and basename_LIBRARY_RELEASE depending on what
-# has been found and set.  If only basename_LIBRARY_RELEASE is defined,
-# basename_LIBRARY will be set to the release value, and
-# basename_LIBRARY_DEBUG will be set to basename_LIBRARY_DEBUG-NOTFOUND.
-# If only basename_LIBRARY_DEBUG is defined, then basename_LIBRARY will
-# take the debug value, and basename_LIBRARY_RELEASE will be set to
-# basename_LIBRARY_RELEASE-NOTFOUND.
-#
-# If the generator supports configuration types, then basename_LIBRARY
-# and basename_LIBRARIES will be set with debug and optimized flags
-# specifying the library to be used for the given configuration.  If no
-# build type has been set or the generator in use does not support
-# configuration types, then basename_LIBRARY and basename_LIBRARIES will
-# take only the release value, or the debug value if the release one is
-# not set.
-
-# This macro was adapted from the FindQt4 CMake module and is maintained by Will
-# Dicharry <wdicharry@stellarscience.com>.
-
-macro( select_library_configurations basename )
-    if(NOT ${basename}_LIBRARY_RELEASE)
-        set(${basename}_LIBRARY_RELEASE "${basename}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library.")
-    endif()
-    if(NOT ${basename}_LIBRARY_DEBUG)
-        set(${basename}_LIBRARY_DEBUG "${basename}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library.")
-    endif()
-
-    get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if( ${basename}_LIBRARY_DEBUG AND ${basename}_LIBRARY_RELEASE AND
-           NOT ${basename}_LIBRARY_DEBUG STREQUAL ${basename}_LIBRARY_RELEASE AND
-           ( _isMultiConfig OR CMAKE_BUILD_TYPE ) )
-        # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
-        # single-config generators, set optimized and debug libraries
-        set( ${basename}_LIBRARY "" )
-        foreach( _libname IN LISTS ${basename}_LIBRARY_RELEASE )
-            list( APPEND ${basename}_LIBRARY optimized "${_libname}" )
-        endforeach()
-        foreach( _libname IN LISTS ${basename}_LIBRARY_DEBUG )
-            list( APPEND ${basename}_LIBRARY debug "${_libname}" )
-        endforeach()
-    elseif( ${basename}_LIBRARY_RELEASE )
-        set( ${basename}_LIBRARY ${${basename}_LIBRARY_RELEASE} )
-    elseif( ${basename}_LIBRARY_DEBUG )
-        set( ${basename}_LIBRARY ${${basename}_LIBRARY_DEBUG} )
-    else()
-        set( ${basename}_LIBRARY "${basename}_LIBRARY-NOTFOUND")
-    endif()
-
-    set( ${basename}_LIBRARIES "${${basename}_LIBRARY}" )
-
-    if( ${basename}_LIBRARY )
-        set( ${basename}_FOUND TRUE )
-    endif()
-
-    mark_as_advanced( ${basename}_LIBRARY_RELEASE
-        ${basename}_LIBRARY_DEBUG
-    )
-endmacro()

common/CMakeLists.txt

@@ -1,7 +1,4 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-SET(PROTOBUF_GENERATE_CPP_APPEND_PATH "../../")
-
-PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HEADERS message.proto)
 
 SET(common_sources
 	base_packet.cpp
@@ -14,44 +11,34 @@ SET(common_sources
 	database_conversions.cpp
 	database_instances.cpp
 	dbcore.cpp
-	deity.cpp
-	emu_constants.cpp
-	emu_legacy.cpp
-	emu_limits.cpp
 	emu_opcodes.cpp
-	emu_versions.cpp
+	emu_tcp_connection.cpp
+	emu_tcp_server.cpp
+	eq_dictionary.cpp
 	eqdb.cpp
 	eqdb_res.cpp
 	eqemu_exception.cpp
 	eqemu_config.cpp
 	eqemu_logsys.cpp
-	eq_limits.cpp
 	eq_packet.cpp
+	eq_stream.cpp
+	eq_stream_factory.cpp
 	eq_stream_ident.cpp
 	eq_stream_proxy.cpp
 	eqtime.cpp
-	event_sub.cpp
 	extprofile.cpp
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
-	inventory_profile.cpp
-	inventory_slot.cpp
 	ipc_mutex.cpp
-	item_data.cpp
-	item_instance.cpp
-	json_config.cpp
-	light_source.cpp
-	md5.cpp	
-	memory_buffer.cpp
+	item.cpp
+	md5.cpp
 	memory_mapped_file.cpp
-	message.pb.cc
 	misc.cpp
 	misc_functions.cpp
 	mutex.cpp
 	mysql_request_result.cpp
 	mysql_request_row.cpp
-	opcode_map.cpp
 	opcodemgr.cpp
 	packet_dump.cpp
 	packet_dump_file.cpp
@@ -61,54 +48,45 @@ SET(common_sources
 	proc_launcher.cpp
 	ptimer.cpp
 	races.cpp
-	rdtsc.cpp
 	rulesys.cpp
-	say_link.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
 	spdat.cpp
 	string_util.cpp
 	struct_strategy.cpp
-	textures.cpp
+	tcp_connection.cpp
+	tcp_server.cpp
+	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
+	uuid.cpp
+	worldconn.cpp
 	xml_parser.cpp
 	platform.cpp
-	event/event_loop.cpp
-	json/jsoncpp.cpp
-	net/console_server.cpp
-	net/console_server_connection.cpp
-	net/crc32.cpp
-	net/daybreak_connection.cpp
-	net/eqstream.cpp
-	net/packet.cpp
-	net/servertalk_client_connection.cpp
-	net/servertalk_legacy_client_connection.cpp
-	net/servertalk_server.cpp
-	net/servertalk_server_connection.cpp
-	net/tcp_connection.cpp
-	net/tcp_server.cpp
 	patches/patches.cpp
 	patches/sod.cpp
-	patches/sod_limits.cpp
 	patches/sof.cpp
-	patches/sof_limits.cpp
 	patches/rof.cpp
-	patches/rof_limits.cpp
 	patches/rof2.cpp
-	patches/rof2_limits.cpp
 	patches/titanium.cpp
-	patches/titanium_limits.cpp
 	patches/uf.cpp
-	patches/uf_limits.cpp	
+	SocketLib/Base64.cpp
+	SocketLib/File.cpp
+	SocketLib/HttpdCookies.cpp
+	SocketLib/HttpdForm.cpp
+	SocketLib/HttpdSocket.cpp
+	SocketLib/HTTPSocket.cpp
+	SocketLib/MemFile.cpp
+	SocketLib/Mime.cpp
+	SocketLib/Parse.cpp
+	SocketLib/socket_include.cpp
+	SocketLib/Utility.cpp
 	StackWalker/StackWalker.cpp
 	tinyxml/tinystr.cpp
 	tinyxml/tinyxml.cpp
 	tinyxml/tinyxmlerror.cpp
 	tinyxml/tinyxmlparser.cpp
-	util/directory.cpp
-	util/uuid.cpp
 )
 
 SET(common_headers
@@ -125,13 +103,12 @@ SET(common_headers
 	database.h
 	dbcore.h
 	deity.h
-	emu_constants.h
-	emu_legacy.h
-	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
-	emu_versions.h
+	emu_tcp_connection.h
+	emu_tcp_server.h
 	eq_constants.h
+	eq_dictionary.h
 	eq_packet_structs.h
 	eqdb.h
 	eqdb_res.h
@@ -139,15 +116,16 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
-	eq_limits.h
 	eq_packet.h
+	eq_stream.h
+	eq_stream_factory.h
 	eq_stream_ident.h
 	eq_stream_intf.h
 	eq_stream_locator.h
 	eq_stream_proxy.h
+	eq_stream_type.h
 	eqtime.h
 	errmsg.h
-	event_sub.h
 	extprofile.h
 	faction.h
 	features.h
@@ -156,22 +134,16 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
-	inventory_profile.h
-	inventory_slot.h
 	ipc_mutex.h
-	item_data.h
+	item.h
 	item_fieldlist.h
-	item_instance.h
-	json_config.h
+	item_struct.h
 	languages.h
-	light_source.h
 	linked_list.h
 	loottable.h
 	mail_oplist.h
 	md5.h
-	memory_buffer.h
 	memory_mapped_file.h
-	message.pb.h
 	misc.h
 	misc_functions.h
 	mutex.h
@@ -185,15 +157,12 @@ SET(common_headers
 	packet_functions.h
 	platform.h
 	proc_launcher.h
-	profiler.h
 	ptimer.h
 	queue.h
 	races.h
 	random.h
-	rdtsc.h
 	rulesys.h
 	ruletypes.h
-	say_link.h
 	seperator.h
 	serverinfo.h
 	servertalk.h
@@ -202,159 +171,140 @@ SET(common_headers
 	spdat.h
     string_util.h
 	struct_strategy.h
-	textures.h
+	tcp_basic_server.h
+	tcp_connection.h
+	tcp_server.h
+	timeoutmgr.h
 	timer.h
 	types.h
 	unix.h
 	useperl.h
+	uuid.h
 	version.h
+	worldconn.h
 	xml_parser.h
 	zone_numbers.h
-	event/background_task.h
-	event/event_loop.h
-	event/timer.h
-	json/json.h
-	json/json-forwards.h
-	net/console_server.h
-	net/console_server_connection.h
-	net/crc32.h
-	net/daybreak_connection.h
-	net/daybreak_structs.h
-	net/dns.h
-	net/endian.h
-	net/eqstream.h
-	net/packet.h
-	net/servertalk_client_connection.h
-	net/servertalk_legacy_client_connection.h
-	net/servertalk_common.h
-	net/servertalk_server.h
-	net/servertalk_server_connection.h
-	net/tcp_connection.h
-	net/tcp_server.h
 	patches/patches.h
 	patches/sod.h
-	patches/sod_limits.h
+	patches/sod_constants.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_limits.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_limits.h
+	patches/rof_constants.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_limits.h
+	patches/rof2_constants.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_limits.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_limits.h
+	patches/uf_constants.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
 	patches/uf_structs.h
+	SocketLib/Base64.h
+	SocketLib/File.h
+	SocketLib/HttpdCookies.h
+	SocketLib/HttpdForm.h
+	SocketLib/HttpdSocket.h
+	SocketLib/HTTPSocket.h
+	SocketLib/IFile.h
+	SocketLib/MemFile.h
+	SocketLib/Mime.h
+	SocketLib/Parse.h
+	SocketLib/socket_include.h
+	SocketLib/Utility.h
 	StackWalker/StackWalker.h
 	tinyxml/tinystr.h
 	tinyxml/tinyxml.h
-	util/memory_stream.h
-	util/directory.h
-	util/uuid.h
-)
-
-SOURCE_GROUP(Event FILES
-	event/background_task.h
-	event/event_loop.cpp
-	event/event_loop.h
-	event/timer.h
-)
-
-SOURCE_GROUP(Json FILES
-	json/json.h
-	json/jsoncpp.cpp
-	json/json-forwards.h
-)
-
-SOURCE_GROUP(Net FILES
-	net/console_server.cpp
-	net/console_server.h
-	net/console_server_connection.cpp
-	net/console_server_connection.h
-	net/crc32.cpp
-	net/crc32.h
-	net/daybreak_connection.cpp
-	net/daybreak_connection.h
-	net/daybreak_structs.h
-	net/dns.h
-	net/endian.h
-	net/eqmq.cpp
-	net/eqmq.h
-	net/eqstream.cpp
-	net/eqstream.h
-	net/packet.cpp
-	net/packet.h
-	net/servertalk_client_connection.cpp
-	net/servertalk_client_connection.h
-	net/servertalk_legacy_client_connection.cpp
-	net/servertalk_legacy_client_connection.h
-	net/servertalk_common.h
-	net/servertalk_server.cpp
-	net/servertalk_server.h
-	net/servertalk_server_connection.cpp
-	net/servertalk_server_connection.h
-	net/tcp_connection.cpp
-	net/tcp_connection.h
-	net/tcp_server.cpp
-	net/tcp_server.h
 )
 
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-	patches/sod_limits.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
+	patches/sod_constants.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_limits.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_limits.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
+	patches/rof_constants.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_limits.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
+	patches/rof2_constants.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_limits.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
+	patches/titanium_constants.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_limits.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
+	patches/uf_constants.h
 	patches/uf_structs.h
 	patches/patches.cpp
 	patches/sod.cpp
-	patches/sod_limits.cpp
 	patches/sof.cpp
-	patches/sof_limits.cpp
 	patches/rof.cpp
-	patches/rof_limits.cpp
 	patches/rof2.cpp
-	patches/rof2_limits.cpp
 	patches/titanium.cpp
-	patches/titanium_limits.cpp
 	patches/uf.cpp
-	patches/uf_limits.cpp
+)
+
+SOURCE_GROUP(SocketLib FILES
+	SocketLib/Base64.h
+	SocketLib/File.h
+	SocketLib/HttpdCookies.h
+	SocketLib/HttpdForm.h
+	SocketLib/HttpdSocket.h
+	SocketLib/HTTPSocket.h
+	SocketLib/IFile.h
+	SocketLib/MemFile.h
+	SocketLib/Mime.h
+	SocketLib/Parse.h
+	SocketLib/socket_include.h
+	SocketLib/Utility.h
+	SocketLib/Base64.cpp
+	SocketLib/File.cpp
+	SocketLib/HttpdCookies.cpp
+	SocketLib/HttpdForm.cpp
+	SocketLib/HttpdSocket.cpp
+	SocketLib/HTTPSocket.cpp
+	SocketLib/MemFile.cpp
+	SocketLib/Mime.cpp
+	SocketLib/Parse.cpp
+	SocketLib/socket_include.cpp
+	SocketLib/Utility.cpp
 )
 
 SOURCE_GROUP(StackWalker FILES
@@ -371,19 +321,12 @@ SOURCE_GROUP(TinyXML FILES
 	tinyxml/tinyxmlparser.cpp
 )
 
-SOURCE_GROUP(Util FILES
-	util/memory_stream.h
-	util/directory.cpp
-	util/directory.h
-	util/uuid.cpp
-	util/uuid.h
-)
-
 INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)
 
 ADD_LIBRARY(common ${common_sources} ${common_headers})
 
 IF(UNIX)
+	ADD_DEFINITIONS(-fPIC)
 	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)
 	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp"  "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)

common/base_data.h

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

common/base_packet.h

@@ -22,10 +22,10 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifdef _WINDOWS
+#ifdef WIN32
 	#include <time.h>
-	#include <winsock2.h>
 	#include <windows.h>
+	#include <winsock2.h>
 #else
 	#include <sys/time.h>
 	#include <netinet/in.h>
@@ -63,12 +63,9 @@ public:
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }
 	void WriteDouble(double value) { *(double *)(pBuffer + _wpos) = value; _wpos += sizeof(double); }
 	void WriteString(const char * str) { uint32 len = static_cast<uint32>(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; }
-	void WriteData(const void *ptr, size_t n) { memcpy(pBuffer + _wpos, ptr, n); _wpos += n; }
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
 	uint8 ReadUInt8(uint32 Offset) const { uint8 value = *(uint8 *)(pBuffer + Offset); return value; }
-	uint16 ReadUInt16() { uint16 value = *(uint16 *)(pBuffer + _rpos); _rpos += sizeof(uint16); return value; }
-	uint16 ReadUInt16(uint32 Offset) const { uint16 value = *(uint16 *)(pBuffer + Offset); return value; }
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }

common/bodytypes.h

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

common/classes.cpp

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemu.org)
+	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
@@ -18,576 +18,275 @@
 #include "../common/global_define.h"
 #include "../common/classes.h"
 
-const char* GetClassIDName(uint8 class_id, uint8 level)
-{
-	switch (class_id) {
-	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:
-		return "Cleric Guildmaster";
-	case PALADINGM:
-		return "Paladin Guildmaster";
-	case RANGERGM:
-		return "Ranger Guildmaster";
-	case SHADOWKNIGHTGM:
-		return "Shadowknight Guildmaster";
-	case DRUIDGM:
-		return "Druid Guildmaster";
-	case MONKGM:
-		return "Monk Guildmaster";
-	case BARDGM:
-		return "Bard Guildmaster";
-	case ROGUEGM:
-		return "Rogue Guildmaster";
-	case SHAMANGM:
-		return "Shaman Guildmaster";
-	case NECROMANCERGM:
-		return "Necromancer Guildmaster";
-	case WIZARDGM:
-		return "Wizard Guildmaster";
-	case MAGICIANGM:
-		return "Magician Guildmaster";
-	case ENCHANTERGM:
-		return "Enchanter Guildmaster";
-	case BEASTLORDGM:
-		return "Beastlord Guildmaster";
-	case BERSERKERGM:
-		return "Berserker Guildmaster";
-	case MERCHANT:
-		return "Merchant";
-	case ADVENTURERECRUITER:
-		return "Adventure Recruiter";
-	case ADVENTUREMERCHANT:
-		return "Adventure Merchant";
-	case CORPSE_CLASS:
-		return "Corpse Class";
-	case TRIBUTE_MASTER:
-		return "Tribute Master";
-	case GUILD_TRIBUTE_MASTER:
-		return "Guild Tribute Master";
-	default:
-		return "Unknown";
+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:
+			return "Warrior Guildmaster";
+		case CLERICGM:
+			return "Cleric Guildmaster";
+		case PALADINGM:
+			return "Paladin Guildmaster";
+		case RANGERGM:
+			return "Ranger Guildmaster";
+		case SHADOWKNIGHTGM:
+			return "Shadowknight Guildmaster";
+		case DRUIDGM:
+			return "Druid Guildmaster";
+		case MONKGM:
+			return "Monk Guildmaster";
+		case BARDGM:
+			return "Bard Guildmaster";
+		case ROGUEGM:
+			return "Rogue Guildmaster";
+		case SHAMANGM:
+			return "Shaman Guildmaster";
+		case NECROMANCERGM:
+			return "Necromancer Guildmaster";
+		case WIZARDGM:
+			return "Wizard Guildmaster";
+		case MAGICIANGM:
+			return "Magician Guildmaster";
+		case ENCHANTERGM:
+			return "Enchanter Guildmaster";
+		case BEASTLORDGM:
+			return "Beastlord Guildmaster";
+		case BERSERKERGM:
+			return "Berserker Guildmaster";
+		case MERCHANT:
+			return "Merchant";
+		case ADVENTURERECRUITER:
+			return "Adventure Recruiter";
+		case ADVENTUREMERCHANT:
+			return "Adventure Merchant";
+		case CORPSE_CLASS:
+			return "Corpse Class";
+		case TRIBUTE_MASTER:
+			return "Tribute Master";
+		case GUILD_TRIBUTE_MASTER:
+			return "Guild Tribute Master";
+		default:
+			return "Unknown";
 	}
 }
 
-const char* GetPlayerClassName(uint32 player_class_value, uint8 level)
-{
-	return GetClassIDName(GetClassIDFromPlayerClassValue(player_class_value), level);
-}
-
-uint32 GetPlayerClassValue(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case DRUID:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-	case BEASTLORD:
-	case BERSERKER:
-		return class_id;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-uint32 GetPlayerClassBit(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-		return PLAYER_CLASS_WARRIOR_BIT;
-	case CLERIC:
-		return PLAYER_CLASS_CLERIC_BIT;
-	case PALADIN:
-		return PLAYER_CLASS_PALADIN_BIT;
-	case RANGER:
-		return PLAYER_CLASS_RANGER_BIT;
-	case SHADOWKNIGHT:
-		return PLAYER_CLASS_SHADOWKNIGHT_BIT;
-	case DRUID:
-		return PLAYER_CLASS_DRUID_BIT;
-	case MONK:
-		return PLAYER_CLASS_MONK_BIT;
-	case BARD:
-		return PLAYER_CLASS_BARD_BIT;
-	case ROGUE:
-		return PLAYER_CLASS_ROGUE_BIT;
-	case SHAMAN:
-		return PLAYER_CLASS_SHAMAN_BIT;
-	case NECROMANCER:
-		return PLAYER_CLASS_NECROMANCER_BIT;
-	case WIZARD:
-		return PLAYER_CLASS_WIZARD_BIT;
-	case MAGICIAN:
-		return PLAYER_CLASS_MAGICIAN_BIT;
-	case ENCHANTER:
-		return PLAYER_CLASS_ENCHANTER_BIT;
-	case BEASTLORD:
-		return PLAYER_CLASS_BEASTLORD_BIT;
-	case BERSERKER:
-		return PLAYER_CLASS_BERSERKER_BIT;
-	default:
-		return PLAYER_CLASS_UNKNOWN_BIT;
-	}
-}
-
-uint8 GetClassIDFromPlayerClassValue(uint32 player_class_value)
-{
-	switch (player_class_value) {
-	case PLAYER_CLASS_WARRIOR:
-	case PLAYER_CLASS_CLERIC:
-	case PLAYER_CLASS_PALADIN:
-	case PLAYER_CLASS_RANGER:
-	case PLAYER_CLASS_SHADOWKNIGHT:
-	case PLAYER_CLASS_DRUID:
-	case PLAYER_CLASS_MONK:
-	case PLAYER_CLASS_BARD:
-	case PLAYER_CLASS_ROGUE:
-	case PLAYER_CLASS_SHAMAN:
-	case PLAYER_CLASS_NECROMANCER:
-	case PLAYER_CLASS_WIZARD:
-	case PLAYER_CLASS_MAGICIAN:
-	case PLAYER_CLASS_ENCHANTER:
-	case PLAYER_CLASS_BEASTLORD:
-	case PLAYER_CLASS_BERSERKER:
-		return player_class_value;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit)
-{
-	switch (player_class_bit) {
-	case PLAYER_CLASS_WARRIOR_BIT:
-		return WARRIOR;
-	case PLAYER_CLASS_CLERIC_BIT:
-		return CLERIC;
-	case PLAYER_CLASS_PALADIN_BIT:
-		return PALADIN;
-	case PLAYER_CLASS_RANGER_BIT:
-		return RANGER;
-	case PLAYER_CLASS_SHADOWKNIGHT_BIT:
-		return SHADOWKNIGHT;
-	case PLAYER_CLASS_DRUID_BIT:
-		return DRUID;
-	case PLAYER_CLASS_MONK_BIT:
-		return MONK;
-	case PLAYER_CLASS_BARD_BIT:
-		return BARD;
-	case PLAYER_CLASS_ROGUE_BIT:
-		return ROGUE;
-	case PLAYER_CLASS_SHAMAN_BIT:
-		return SHAMAN;
-	case PLAYER_CLASS_NECROMANCER_BIT:
-		return NECROMANCER;
-	case PLAYER_CLASS_WIZARD_BIT:
-		return WIZARD;
-	case PLAYER_CLASS_MAGICIAN_BIT:
-		return MAGICIAN;
-	case PLAYER_CLASS_ENCHANTER_BIT:
-		return ENCHANTER;
-	case PLAYER_CLASS_BEASTLORD_BIT:
-		return BEASTLORD;
-	case PLAYER_CLASS_BERSERKER_BIT:
-		return BERSERKER;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-bool IsFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case BEASTLORD:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsSpellFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case BEASTLORD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsNonSpellFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsINTCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsWISCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsPlateClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case SHADOWKNIGHT:
-	case BARD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsChainClass(uint8 class_id)
-{
-	switch (class_id) {
-	case RANGER:
-	case ROGUE:
-	case SHAMAN:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsLeatherClass(uint8 class_id)
-{
-	switch (class_id) {
-	case DRUID:
-	case MONK:
-	case BEASTLORD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsClothClass(uint8 class_id)
-{
-	switch (class_id) {
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-uint8 ClassArmorType(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case SHADOWKNIGHT:
-	case BARD:
-		return ARMOR_TYPE_PLATE;
-	case RANGER:
-	case ROGUE:
-	case SHAMAN:
-	case BERSERKER:
-		return ARMOR_TYPE_CHAIN;
-	case DRUID:
-	case MONK:
-	case BEASTLORD:
-		return ARMOR_TYPE_LEATHER;
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return ARMOR_TYPE_CLOTH;
-	default:
-		return ARMOR_TYPE_UNKNOWN;
-	}
-}

common/classes.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemu.org)
+	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
@@ -17,25 +17,26 @@
 */
 #ifndef CLASSES_CH
 #define CLASSES_CH
-
 #include "../common/types.h"
 
-#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 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 PLAYER_CLASS_COUNT	16 // used for array defines, must be the count of playable classes
 #define WARRIORGM 20
 #define CLERICGM 21
 #define PALADINGM 22
@@ -57,92 +58,33 @@
 #define DISCORD_MERCHANT 59
 #define ADVENTURERECRUITER 60
 #define ADVENTUREMERCHANT 61
-#define LDON_TREASURE 62	// objects you can use /open on first seen in LDONs
-#define CORPSE_CLASS 62	// only seen on Danvi's Corpse in Akheva so far..
-#define TRIBUTE_MASTER 63
-#define GUILD_TRIBUTE_MASTER 64	// not sure
+#define LDON_TREASURE 62 //objects you can use /open on first seen in LDONs
+#define CORPSE_CLASS 62	//only seen on Danvi's Corpse in Akheva so far..
+#define TRIBUTE_MASTER	63
+#define GUILD_TRIBUTE_MASTER	64	//not sure
 #define NORRATHS_KEEPERS_MERCHANT 67
 #define DARK_REIGN_MERCHANT 68
 #define FELLOWSHIP_MASTER 69
 #define ALT_CURRENCY_MERCHANT 70
 #define MERCERNARY_MASTER 71
+#define warrior_1 1
+#define monk_1 64
+#define paladin_1 4
+#define shadow_1 16
+#define bard_1 128
+#define cleric_1 2
+#define necromancer_1 1024
+#define ranger_1 8
+#define druid_1 32
+#define mage_1 4096
+#define wizard_1 2048
+#define enchanter_1 8192
+#define rogue_1 256
+#define shaman_1 512
+#define beastlord_1 16384
+#define berserker_1 32768
+#define call_1 65536
 
-
-// player class values
-#define PLAYER_CLASS_UNKNOWN 0
-#define PLAYER_CLASS_WARRIOR 1
-#define PLAYER_CLASS_CLERIC 2
-#define PLAYER_CLASS_PALADIN 3
-#define PLAYER_CLASS_RANGER 4
-#define PLAYER_CLASS_SHADOWKNIGHT 5
-#define PLAYER_CLASS_DRUID 6
-#define PLAYER_CLASS_MONK 7
-#define PLAYER_CLASS_BARD 8
-#define PLAYER_CLASS_ROGUE 9
-#define PLAYER_CLASS_SHAMAN 10
-#define PLAYER_CLASS_NECROMANCER 11
-#define PLAYER_CLASS_WIZARD 12
-#define PLAYER_CLASS_MAGICIAN 13
-#define PLAYER_CLASS_ENCHANTER 14
-#define PLAYER_CLASS_BEASTLORD 15
-#define PLAYER_CLASS_BERSERKER 16
-
-#define PLAYER_CLASS_COUNT 16
-
-
-// player class bits
-#define PLAYER_CLASS_UNKNOWN_BIT 0
-#define PLAYER_CLASS_WARRIOR_BIT 1
-#define PLAYER_CLASS_CLERIC_BIT 2
-#define PLAYER_CLASS_PALADIN_BIT 4
-#define PLAYER_CLASS_RANGER_BIT 8
-#define PLAYER_CLASS_SHADOWKNIGHT_BIT 16
-#define PLAYER_CLASS_DRUID_BIT 32
-#define PLAYER_CLASS_MONK_BIT 64
-#define PLAYER_CLASS_BARD_BIT 128
-#define PLAYER_CLASS_ROGUE_BIT 256
-#define PLAYER_CLASS_SHAMAN_BIT 512
-#define PLAYER_CLASS_NECROMANCER_BIT 1024
-#define PLAYER_CLASS_WIZARD_BIT 2048
-#define PLAYER_CLASS_MAGICIAN_BIT 4096
-#define PLAYER_CLASS_ENCHANTER_BIT 8192
-#define PLAYER_CLASS_BEASTLORD_BIT 16384
-#define PLAYER_CLASS_BERSERKER_BIT 32768
-
-#define PLAYER_CLASS_ALL_MASK 65535	// was 65536
-
-
-#define ARMOR_TYPE_UNKNOWN 0
-#define ARMOR_TYPE_CLOTH 1
-#define ARMOR_TYPE_LEATHER 2
-#define ARMOR_TYPE_CHAIN 3
-#define ARMOR_TYPE_PLATE 4
-
-#define ARMOR_TYPE_FIRST ARMOR_TYPE_UNKNOWN
-#define ARMOR_TYPE_LAST ARMOR_TYPE_PLATE
-#define ARMOR_TYPE_COUNT 5
-
-
-const char* GetClassIDName(uint8 class_id, uint8 level = 0);
-const char* GetPlayerClassName(uint32 player_class_value, uint8 level = 0);
-
-uint32 GetPlayerClassValue(uint8 class_id);
-uint32 GetPlayerClassBit(uint8 class_id);
-
-uint8 GetClassIDFromPlayerClassValue(uint32 player_class_value);
-uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit);
-
-bool IsFighterClass(uint8 class_id);
-bool IsSpellFighterClass(uint8 class_id);
-bool IsNonSpellFighterClass(uint8 class_id);
-bool IsCasterClass(uint8 class_id);
-bool IsINTCasterClass(uint8 class_id);
-bool IsWISCasterClass(uint8 class_id);
-
-bool IsPlateClass(uint8 class_id);
-bool IsChainClass(uint8 class_id);
-bool IsLeatherClass(uint8 class_id);
-bool IsClothClass(uint8 class_id);
-uint8 ClassArmorType(uint8 class_id);
-
+const char* GetEQClassName(uint8 class_, uint8 level = 0);
 #endif
+

common/clientversions.h

@@ -0,0 +1,77 @@
+#ifndef CLIENTVERSIONS_H
+#define CLIENTVERSIONS_H
+
+#include "types.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_UF			= 16;
+static const uint32 BIT_RoF			= 32;
+static const uint32 BIT_RoF2		= 64;
+
+static const uint32 BIT_TitaniumAndEarlier	= 0x00000003;
+static const uint32 BIT_SoFAndLater			= 0xFFFFFFFC;
+static const uint32 BIT_SoDAndLater			= 0xFFFFFFF8;
+static const uint32 BIT_UFAndLater			= 0xFFFFFFF0;
+static const uint32 BIT_RoFAndLater			= 0xFFFFFFE0;
+static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0;
+static const uint32 BIT_AllClients			= 0xFFFFFFFF;
+
+enum class ClientVersion
+{
+	Unknown = 0,
+	Client62,	// Build: 'Aug  4 2005 15:40:59'
+	Titanium,	// Build: 'Oct 31 2005 10:33:37'
+	SoF,		// Build: 'Sep  7 2007 09:11:49'
+	SoD,		// Build: 'Dec 19 2008 15:22:49'
+	UF,			// Build: 'Jun  8 2010 16:44:32'
+	RoF,		// Build: 'Dec 10 2012 17:35:44'
+	RoF2,		// Build: 'May 10 2013 23:30:08'
+
+	MobNPC,
+	MobMerc,
+	MobBot,
+	MobPet,
+};
+
+#define CLIENT_VERSION_COUNT 12
+#define LAST_PC_CLIENT ClientVersion::RoF2
+#define LAST_NPC_CLIENT ClientVersion::MobPet
+
+
+static const char* ClientVersionName(ClientVersion version)
+{
+	switch (version)
+	{
+	case ClientVersion::Unknown:
+		return "ClientVersion::Unknown";
+	case ClientVersion::Client62:
+		return "ClientVersion::Client62";
+	case ClientVersion::Titanium:
+		return "ClientVersion::Titanium";
+	case ClientVersion::SoF:
+		return "ClientVersion::SoF";
+	case ClientVersion::SoD:
+		return "ClientVersion::SoD";
+	case ClientVersion::UF:
+		return "ClientVersion::UF";
+	case ClientVersion::RoF:
+		return "ClientVersion::RoF";
+	case ClientVersion::RoF2:
+		return "ClientVersion::RoF2";
+	case ClientVersion::MobNPC:
+		return "ClientVersion::MobNPC";
+	case ClientVersion::MobMerc:
+		return "ClientVersion::MobMerc";
+	case ClientVersion::MobBot:
+		return "ClientVersion::MobBot";
+	case ClientVersion::MobPet:
+		return "ClientVersion::MobPet";
+	default:
+		return "<ERROR> Invalid ClientVersion";
+	};
+}
+
+#endif /* CLIENTVERSIONS_H */

common/crash.cpp

@@ -25,7 +25,7 @@ public:
 			}
 		}
 
-		Log(Logs::General, Logs::Crash, buffer);
+		Log.Out(Logs::General, Logs::Crash, buffer);
 		StackWalker::OnOutput(szText);
 	}
 };
@@ -35,67 +35,67 @@ LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
 			break;
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
 			break;
 		case EXCEPTION_BREAKPOINT:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
 			break;
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
 			break;
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
 			break;
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_FLT_INEXACT_RESULT:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
 			break;
 		case EXCEPTION_FLT_INVALID_OPERATION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
 			break;
 		case EXCEPTION_FLT_OVERFLOW:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
 			break;
 		case EXCEPTION_FLT_STACK_CHECK:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
 			break;
 		case EXCEPTION_FLT_UNDERFLOW:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
 			break;
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
 			break;
 		case EXCEPTION_IN_PAGE_ERROR:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
 			break;
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_INT_OVERFLOW:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
 			break;
 		case EXCEPTION_INVALID_DISPOSITION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
 			break;
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
 			break;
 		case EXCEPTION_PRIV_INSTRUCTION:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
 			break;
 		case EXCEPTION_SINGLE_STEP:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
 			break;
 		case EXCEPTION_STACK_OVERFLOW:
-			Log(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
 			break;
 		default:
-			Log(Logs::General, Logs::Crash, "Unknown Exception");
+			Log.Out(Logs::General, Logs::Crash, "Unknown Exception");
 			break;
 	}
 

common/data_verification.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -14,42 +13,36 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 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 Clamp(const T& value, const T& lower, const T& upper) {
+	return std::max(lower, std::min(value, upper));
+}
 
-	template <typename T>
-	T ClampUpper(const T& value, const T& upper) {
-		return std::min(value, upper);
-	}
+template <typename T>
+T ClampLower(const T& value, const T& lower) {
+	return std::max(lower, value);
+}
 
-	template <typename T>
-	bool ValueWithin(const T& value, const T& lower, const T& upper) {
-		return value >= lower && value <= upper;
-	}
+template <typename T>
+T ClampUpper(const T& value, const T& upper) {
+	return std::min(value, upper);
+}
 
-	template <typename T1, typename T2, typename T3>
-	bool ValueWithin(const T1& value, const T2& lower, const T3& upper) {
-		return value >= (T1)lower && value <= (T1)upper;
-	}
+template <typename T>
+bool ValueWithin(const T& value, const T& lower, const T& upper) {
+	return value >= lower && value <= upper;
+}
 
-} /*EQEmu*/
+}
 
-#endif /*COMMON_DATA_VERIFICATION_H*/
+#endif

common/database.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -23,7 +23,6 @@
 
 #include "global_define.h"
 #include "eqemu_logsys.h"
-
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
@@ -37,14 +36,10 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
+class Inventory;
 class MySQLRequestResult;
 class Client;
 
-namespace EQEmu
-{
-	class InventoryProfile;
-}
-
 struct EventLogDetails_Struct {
 	uint32	id;
 	char	accountname[64];
@@ -71,14 +66,8 @@ struct npcDecayTimes_Struct {
 
 
 struct VarCache_Struct {
-	std::map<std::string, std::string> m_cache;
-	uint32 last_update;
-	VarCache_Struct() : last_update(0) { }
-	void Add(const std::string &key, const std::string &value) { m_cache[key] = value; }
-	const std::string *Get(const std::string &key) {
-		auto it = m_cache.find(key);
-		return (it != m_cache.end() ? &it->second : nullptr);
-	}
+	char varname[26];	
+	char value[0];
 };
 
 class PTimerList;
@@ -98,7 +87,7 @@ class Database : public DBcore {
 public:
 	Database();
 	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
-	bool Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port);
+	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
 
 	/* Character Creation */
@@ -113,7 +102,7 @@ public:
 	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
 	bool	SetHackerFlag(const char* accountname, const char* charactername, const char* hacked);
 	bool	SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone);
-	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv);
+	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
 	bool	UpdateName(const char* oldname, const char* newname);
 
 	/* General Information Queries */
@@ -190,10 +179,6 @@ public:
 
 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
-	
-	int		GetIPExemption(std::string account_ip);
-
-	int		GetInstanceID(uint32 char_id, uint32 zone_id);
 
 
 	/* Groups */
@@ -224,14 +209,17 @@ public:
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
+	bool	CheckDatabaseConvertBotsPostPPDeblob();
 	bool	CheckDatabaseConvertCorpseDeblob();
 	bool	CheckDatabaseConvertPPDeblob();
 
 	/* Database Variables */
 
-	bool	GetVariable(std::string varname, std::string &varvalue);
-	bool	SetVariable(const std::string varname, const std::string &varvalue);
+	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(MySQLRequestResult results);
 
 	/* General Queries */
 
@@ -253,8 +241,6 @@ public:
 	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
 
 	void	AddReport(std::string who, std::string against, std::string lines);
-	struct TimeOfDay_Struct		LoadTime(time_t &realtime);
-	bool	SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
 	void	ClearMerchantTemp();
 	void	ClearPTimers(uint32 charid);
 	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
@@ -262,16 +248,18 @@ public:
 	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
-	void	ClearInvSnapshots(bool use_rule = true);
-
 	/* EQEmuLogSys */
 	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
+	void DBInitVars();
+
 	std::map<uint32,std::string>	zonename_array;
 
-	Mutex Mvarcache;
-	VarCache_Struct varcache;
+	Mutex				Mvarcache;
+	uint32				varcache_max;
+	VarCache_Struct**	varcache_array;
+	uint32				varcache_lastupdate;
 
 	/* Groups, utility methods. */
 	void    ClearAllGroupLeaders();

common/database_conversions.cpp

@@ -157,36 +157,25 @@ namespace Convert {
 		/*84*/ uint32 Points;
 		/*88*/
 	} PVPStatsEntry_Struct;
-
-	static const size_t BANDOLIERS_SIZE = 4;
-	static const size_t BANDOLIER_ITEM_COUNT = 4;
 	struct BandolierItem_Struct {
-		uint32 ID;
-		uint32 Icon;
-		char Name[64];
+		uint32 item_id;
+		uint32 icon;
+		char item_name[64];
 	};
 	struct Bandolier_Struct {
-		char Name[32];
-		Convert::BandolierItem_Struct Items[Convert::BANDOLIER_ITEM_COUNT];
-	};
-
-	static const size_t POTION_BELT_ITEM_COUNT = 4;
-	struct PotionBeltItem_Struct {
-		uint32 ID;
-		uint32 Icon;
-		char Name[64];
+		char name[32];
+		Convert::BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
 	};
 	struct PotionBelt_Struct {
-		Convert::PotionBeltItem_Struct Items[Convert::POTION_BELT_ITEM_COUNT];
+		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[EQEmu::textures::materialCount];
+		/*510*/	uint32 Items[_MaterialCount];
 		/*546*/	char Name[64];
 		/*610*/
 	};
@@ -227,9 +216,9 @@ namespace Convert {
 		/*0304*/	uint8							ability_time_minutes;
 		/*0305*/	uint8							ability_time_hours;	//place holder
 		/*0306*/	uint8							unknown0306[6];		// @bp Spacer/Flag?
-		/*0312*/	uint32							item_material[EQEmu::textures::materialCount];	// Item texture/material of worn/held items
+		/*0312*/	uint32							item_material[_MaterialCount];	// Item texture/material of worn/held items
 		/*0348*/	uint8							unknown0348[44];
-		/*0392*/	Convert::Color_Struct			item_tint[EQEmu::textures::materialCount];
+		/*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
@@ -330,7 +319,7 @@ namespace Convert {
 		/*7212*/	uint32							tribute_points;
 		/*7216*/	uint32							unknown7252;
 		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EQEmu::legacy::TRIBUTE_SIZE];
+		/*7224*/	Convert::Tribute_Struct			tributes[EmuConstants::TRIBUTE_SIZE];
 		/*7264*/	Convert::Disciplines_Struct		disciplines;
 		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 		/*7744*/	char							unknown7780[160];
@@ -357,7 +346,7 @@ namespace Convert {
 		/*12800*/	uint32							expAA;
 		/*12804*/	uint32							aapoints;			//avaliable, unspent
 		/*12808*/	uint8							unknown12844[36];
-		/*12844*/	Convert::Bandolier_Struct		bandoliers[Convert::BANDOLIERS_SIZE];
+		/*12844*/	Convert::Bandolier_Struct		bandoliers[EmuConstants::BANDOLIERS_COUNT];
 		/*14124*/	uint8							unknown14160[4506];
 		/*18630*/	Convert::SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 		/*19240*/	uint32							timeentitledonaccount;
@@ -470,10 +459,34 @@ static inline void loadbar(unsigned int x, unsigned int n, unsigned int w = 50)
 
 bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertPPDeblob();
+	CheckDatabaseConvertBotsPostPPDeblob();
 	CheckDatabaseConvertCorpseDeblob();
 
-	/* Run EQEmu Server script (Checks for database updates) */
-	system("perl eqemu_server.pl ran_from_world");
+	/* Fetch Automatic Upgrade Script */
+	if (!std::ifstream("eqemu_update.pl")){
+		std::cout << "Pulling down automatic database upgrade script..." << std::endl;
+#ifdef _WIN32
+		system("perl -MLWP::UserAgent -e \"require LWP::UserAgent;  my $ua = LWP::UserAgent->new; $ua->timeout(10); $ua->env_proxy; my $response = $ua->get('https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_update.pl'); if ($response->is_success){ open(FILE, '> eqemu_update.pl'); print FILE $response->decoded_content; close(FILE); }\"");
+#else
+		system("wget --no-check-certificate -O eqemu_update.pl https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/eqemu_update.pl");
+#endif
+	}
+
+	/*
+		Automatic (Database) Upgrade Script
+		Script: eqemu_update.pl V 1 - the number that world passes to the script will
+		force the script to check for a newer version to update itself with
+		eqemu_update.pl ran_from_world - won't bring up a menu if your database versions match
+		eqemu_update.pl - ran standalone will bring up a menu prompt
+	*/
+
+	/* Check for a new version of this script, the arg passed
+	would have to be higher than the copy they have downloaded
+	locally and they will re fetch */
+	system("perl eqemu_update.pl V 2"); 
+
+	/* Run Automatic Database Upgrade Script */
+	system("perl eqemu_update.pl ran_from_world");
 
 	return true;
 }
@@ -1393,7 +1406,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Material Color Convert */
 				first_entry = 0; rquery = "";
-				for (i = EQEmu::textures::textureBegin; i < EQEmu::textures::materialCount; i++){
+				for (i = 0; i < _MaterialCount; i++){
 					if (pp->item_tint[i].color > 0){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_material` (id, slot, blue, green, red, use_tint, color) VALUES (%u, %u, %u, %u, %u, %u, %u)", character_id, i, pp->item_tint[i].rgb.blue, pp->item_tint[i].rgb.green, pp->item_tint[i].rgb.red, pp->item_tint[i].rgb.use_tint, pp->item_tint[i].color);
@@ -1405,7 +1418,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Tribute Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++){
+				for (i = 0; i < EmuConstants::TRIBUTE_SIZE; i++){
 					if (pp->tributes[i].tribute > 0 && pp->tributes[i].tribute != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_tribute` (id, tier, tribute) VALUES (%u, %u, %u)", character_id, pp->tributes[i].tier, pp->tributes[i].tribute);
@@ -1417,15 +1430,15 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Bandolier Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < Convert::BANDOLIERS_SIZE; i++){
-					if (strlen(pp->bandoliers[i].Name) < 32) {
-						for (int si = 0; si < Convert::BANDOLIER_ITEM_COUNT; si++){
-							if (pp->bandoliers[i].Items[si].ID > 0){
+				for (i = 0; i < EmuConstants::BANDOLIERS_COUNT; i++){
+					if (strlen(pp->bandoliers[i].name) < 32) {
+						for (int si = 0; si < EmuConstants::BANDOLIER_SIZE; si++){
+							if (pp->bandoliers[i].items[si].item_id > 0){
 								if (first_entry != 1) {
-									rquery = StringFormat("REPLACE INTO `character_bandolier` (id, bandolier_id, bandolier_slot, item_id, icon, bandolier_name) VALUES (%i, %u, %i, %u, %u, '%s')", character_id, i, si, pp->bandoliers[i].Items[si].ID, pp->bandoliers[i].Items[si].Icon, pp->bandoliers[i].Name);
+									rquery = StringFormat("REPLACE INTO `character_bandolier` (id, bandolier_id, bandolier_slot, item_id, icon, bandolier_name) VALUES (%i, %u, %i, %u, %u, '%s')", character_id, i, si, pp->bandoliers[i].items[si].item_id, pp->bandoliers[i].items[si].icon, pp->bandoliers[i].name);
 									first_entry = 1;
 								}
-								rquery = rquery + StringFormat(", (%i, %u, %i, %u, %u, '%s')", character_id, i, si, pp->bandoliers[i].Items[si].ID, pp->bandoliers[i].Items[si].Icon, pp->bandoliers[i].Name);
+								rquery = rquery + StringFormat(", (%i, %u, %i, %u, %u, '%s')", character_id, i, si, pp->bandoliers[i].items[si].item_id, pp->bandoliers[i].items[si].icon, pp->bandoliers[i].name);
 							}
 						}
 					}
@@ -1433,13 +1446,13 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Potion Belt Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < Convert::POTION_BELT_ITEM_COUNT; i++){
-					if (pp->potionbelt.Items[i].ID > 0){
+				for (i = 0; i < EmuConstants::POTION_BELT_SIZE; i++){
+					if (pp->potionbelt.items[i].item_id > 0){
 						if (first_entry != 1){
-							rquery = StringFormat("REPLACE INTO `character_potionbelt` (id, potion_id, item_id, icon) VALUES (%i, %u, %u, %u)", character_id, i, pp->potionbelt.Items[i].ID, pp->potionbelt.Items[i].Icon);
+							rquery = StringFormat("REPLACE INTO `character_potionbelt` (id, potion_id, item_id, icon) VALUES (%i, %u, %u, %u)", character_id, i, pp->potionbelt.items[i].item_id, pp->potionbelt.items[i].icon);
 							first_entry = 1;
 						}
-						rquery = rquery + StringFormat(", (%i, %u, %u, %u)", character_id, i, pp->potionbelt.Items[i].ID, pp->potionbelt.Items[i].Icon);
+						rquery = rquery + StringFormat(", (%i, %u, %u, %u)", character_id, i, pp->potionbelt.items[i].item_id, pp->potionbelt.items[i].icon);
 
 					}
 				}
@@ -1467,6 +1480,163 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 	return true;
 }
 
+bool Database::CheckDatabaseConvertBotsPostPPDeblob(){
+#ifdef BOTS
+	int runbotsconvert = 0;
+
+	/* Check For Legacy Bot References */
+	std::string rquery = StringFormat("SHOW CREATE VIEW `vwBotCharacterMobs`");
+	auto results = QueryDatabase(rquery);
+	if (results.RowCount() == 1){
+		auto row = results.begin();
+		std::string table_check = row[1];
+
+		if (table_check.find("character_data") == -1){
+			runbotsconvert = 1;
+			printf("\n\n::: Legacy Bot Views and Function Detected... \n");
+			printf("----------------------------------------------------------\n\n");
+			printf(" Database currently has bot view/function linkage to obselete \n");
+			printf("  table references and will now be converted...\n\n");
+			printf(" It is recommended that you backup your database \n");
+			printf("  before continuing the automatic conversion process...\n\n");
+			printf("----------------------------------------------------------\n\n");
+			std::cout << "Press ENTER to continue....." << std::endl << std::endl;
+			std::cin.ignore(1);
+		}
+	}
+
+	if (runbotsconvert == 1){
+		printf("Running bot views/function database conversion... \n");
+
+		/* Update view `vwbotcharactermobs` */
+		rquery = StringFormat("DROP VIEW `vwBotCharacterMobs`;");
+		results = QueryDatabase(rquery);
+
+		rquery = StringFormat(
+			"CREATE VIEW `vwBotCharacterMobs` AS\n"
+			"SELECT _utf8'C' AS mobtype,\n" // Natedog: '_utf8'
+			"c.`id`,\n"
+			"c.`name`,\n"
+			"c.`class`,\n"
+			"c.`level`,\n"
+			"c.`last_login`,\n"
+			"c.`zone_id`\n"
+			"FROM `character_data` AS c\n"
+			"UNION ALL\n"
+			"SELECT _utf8'B' AS mobtype,\n" // Natedog: '_utf8'
+			"b.`BotID` AS id,\n"
+			"b.`Name` AS name,\n"
+			"b.`Class` AS class,\n"
+			"b.`BotLevel` AS level,\n"
+			"0 AS timelaston,\n"
+			"0 AS zoneid\n"
+			"FROM bots AS b;"
+			);
+		results = QueryDatabase(rquery);
+
+
+		/* Update function `GetMobType` */
+		rquery = StringFormat("DROP FUNCTION IF EXISTS `GetMobType`;");
+		results = QueryDatabase(rquery);
+
+		rquery = StringFormat(
+			"CREATE FUNCTION `GetMobType` (mobname VARCHAR(64)) RETURNS CHAR(1)\n"
+			"BEGIN\n"
+			"	DECLARE Result CHAR(1);\n"
+			"\n"
+			"	SET Result = NULL;\n"
+			"\n"
+			"	IF (SELECT COUNT(*) FROM `character_data` WHERE `name` = mobname) > 0 THEN\n"
+			"		SET Result = 'C';\n"
+			"	ELSEIF (SELECT COUNT(*) FROM `bots` WHERE `Name` = mobname) > 0 THEN\n"
+			"		SET Result = 'B';\n"
+			"	END IF;\n "
+			"\n"
+			"	RETURN Result;\n"
+			"END"
+			);
+		results = QueryDatabase(rquery);
+
+
+		/* Update view `vwgroups` */
+		rquery = StringFormat("DROP VIEW IF EXISTS `vwGroups`;");
+		results = QueryDatabase(rquery);
+
+		rquery = StringFormat(
+			"CREATE VIEW `vwGroups` AS\n"
+			"SELECT g.`groupid` AS groupid,\n"
+			"GetMobType(g.`name`) AS mobtype,\n"
+			"g.`name` AS name,\n"
+			"g.`charid` AS mobid,\n"
+			"IFNULL(c.`level`, b.`BotLevel`) AS level\n"
+			"FROM `group_id` AS g\n"
+			"LEFT JOIN `character_data` AS c ON g.`name` = c.`name`\n"
+			"LEFT JOIN `bots` AS b ON g.`name` = b.`Name`;"
+			);
+		results = QueryDatabase(rquery);
+
+
+		/* Update view `vwbotgroups` */
+		rquery = StringFormat("DROP VIEW IF EXISTS `vwBotGroups`;");
+		results = QueryDatabase(rquery);
+
+		rquery = StringFormat(
+			"CREATE VIEW `vwBotGroups` AS\n"
+			"SELECT g.`BotGroupId`,\n"
+			"g.`BotGroupName`,\n"
+			"g.`BotGroupLeaderBotId`,\n"
+			"b.`Name` AS BotGroupLeaderName,\n"
+			"b.`BotOwnerCharacterId`,\n"
+			"c.`name` AS BotOwnerCharacterName\n"
+			"FROM `botgroup` AS g\n"
+			"JOIN `bots` AS b ON g.`BotGroupLeaderBotId` = b.`BotID`\n"
+			"JOIN `character_data` AS c ON b.`BotOwnerCharacterID` = c.`id`\n"
+			"ORDER BY b.`BotOwnerCharacterId`, g.`BotGroupName`;"
+			);
+		results = QueryDatabase(rquery);
+
+
+		/* Update view `vwguildmembers` */
+		rquery = StringFormat("DROP VIEW IF EXISTS `vwGuildMembers`;");
+		results = QueryDatabase(rquery);
+
+		rquery = StringFormat(
+			"CREATE VIEW `vwGuildMembers` AS\n"
+			"SELECT 'C' AS mobtype,\n"
+			"cm.`char_id`,\n"
+			"cm.`guild_id`,\n"
+			"cm.`rank`,\n"
+			"cm.`tribute_enable`,\n"
+			"cm.`total_tribute`,\n"
+			"cm.`last_tribute`,\n"
+			"cm.`banker`,\n"
+			"cm.`public_note`,\n"
+			"cm.`alt`\n"
+			"FROM `guild_members` AS cm\n"
+			"UNION ALL\n"
+			"SELECT 'B' AS mobtype,\n"
+			"bm.`char_id`,\n"
+			"bm.`guild_id`,\n"
+			"bm.`rank`,\n"
+			"bm.`tribute_enable`,\n"
+			"bm.`total_tribute`,\n"
+			"bm.`last_tribute`,\n"
+			"bm.`banker`,\n"
+			"bm.`public_note`,\n"
+			"bm.`alt`\n"
+			"FROM `botguildmembers` AS bm;"
+			);
+		results = QueryDatabase(rquery);
+	}
+
+	if (runbotsconvert == 1){
+		printf("\n\nBot views/function conversion complete, continuing world bootup...\n");
+	}
+
+#endif
+	return true;
+}
+
 bool Database::CheckDatabaseConvertCorpseDeblob(){
 	Convert::DBPlayerCorpse_Struct_temp* dbpc;
 	Convert::classic_db_temp::DBPlayerCorpse_Struct_temp* dbpc_c;

common/dbcore.cpp

@@ -98,20 +98,20 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			pStatus = Error;
 
-			auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 
 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
 
-		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 		/* Implement Logging at the Root */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
-				Log(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
+			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
+				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
@@ -127,15 +127,8 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
 	
-	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
-	{
-		if ((strncasecmp(query, "select", 6) == 0)) {
-			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
-		}
-		else {
-			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
-		}
-	}
+	if (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
+		Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
 
 	return requestResult;
 }

common/dbcore.h

@@ -2,7 +2,7 @@
 #define DBCORE_H
 
 #ifdef _WINDOWS
-	#include <winsock2.h>
+	#include <winsock.h>
 	#include <windows.h>
 #endif
 

common/deity.cpp

@@ -1,149 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "deity.h"
-
-
-EQEmu::deity::DeityTypeBit EQEmu::deity::ConvertDeityTypeToDeityTypeBit(DeityType deity_type)
-{
-	switch (deity_type) {
-	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:
-		return bit_DeityAll;
-	};
-}
-
-EQEmu::deity::DeityType EQEmu::deity::ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit)
-{
-	switch (deity_type_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:
-		return DeityUnknown;
-	};
-}
-
-const char* EQEmu::deity::DeityName(DeityType deity_type)
-{
-	switch (deity_type) {
-	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:
-		return "Unknown";
-	};
-}

common/deity.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemu.org)
+	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
@@ -14,68 +13,154 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#ifndef COMMON_DEITY_H
-#define COMMON_DEITY_H
+#ifndef DEITY_H
+#define DEITY_H
 
 #include "types.h"
+#include <string>
 
+// NOTE: This code is not fully implemented since there are no references in the existing code
 
-namespace EQEmu
+/*
+**	Diety types
+**
+**	(ref: eqstr_us.txt)
+**
+**	(Another orphaned enumeration...)
+*/
+enum DeityTypes
 {
-	namespace deity {
-		enum DeityType {
-			DeityUnknown = 0,
-			DeityAgnostic_LB = 140,
-			DeityBertoxxulous = 201,
-			DeityBrellSirilis,
-			DeityCazicThule,
-			DeityErollisiMarr,
-			DeityBristlebane,
-			DeityInnoruuk,
-			DeityKarana,
-			DeityMithanielMarr,
-			DeityPrexus,
-			DeityQuellious,
-			DeityRallosZek,
-			DeityRodcetNife,
-			DeitySolusekRo,
-			DeityTheTribunal,
-			DeityTunare,
-			DeityVeeshan,
-			DeityAgnostic = 396
-		};
+/*----*/	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
+};
 
-		enum DeityTypeBit : uint32 {
-			bit_DeityNone = 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,
-			bit_DeityAll = 0xFFFFFFFF
-		};
+/*
+**	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
+};
 
-		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);
-		extern DeityType ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit);
-		extern const char* DeityName(DeityType deity_type);
+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; }
+	};
 
-	} /*deity*/
+	return BIT_DeityAll;
+};
 
-} /*EQEmu*/
+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; }
+	};
 
-#endif /* COMMON_DEITY_H */
+	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

common/emu_constants.cpp

@@ -1,85 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_constants.h"
-
-
-const char* EQEmu::bug::CategoryIDToCategoryName(CategoryID category_id) {
-	switch (category_id) {
-	case catVideo:
-		return "Video";
-	case catAudio:
-		return "Audio";
-	case catPathing:
-		return "Pathing";
-	case catQuest:
-		return "Quest";
-	case catTradeskills:
-		return "Tradeskills";
-	case catSpellStacking:
-		return "Spell stacking";
-	case catDoorsPortals:
-		return "Doors/Portals";
-	case catItems:
-		return "Items";
-	case catNPC:
-		return "NPC";
-	case catDialogs:
-		return "Dialogs";
-	case catLoNTCG:
-		return "LoN - TCG";
-	case catMercenaries:
-		return "Mercenaries";
-	case catOther:
-	default:
-		return "Other";
-	}
-}
-
-EQEmu::bug::CategoryID EQEmu::bug::CategoryNameToCategoryID(const char* category_name) {
-	if (!category_name)
-		return catOther;
-
-	if (!strcmp(category_name, "Video"))
-		return catVideo;
-	if (!strcmp(category_name, "Audio"))
-		return catAudio;
-	if (!strcmp(category_name, "Pathing"))
-		return catPathing;
-	if (!strcmp(category_name, "Quest"))
-		return catQuest;
-	if (!strcmp(category_name, "Tradeskills"))
-		return catTradeskills;
-	if (!strcmp(category_name, "Spell stacking"))
-		return catSpellStacking;
-	if (!strcmp(category_name, "Doors/Portals"))
-		return catDoorsPortals;
-	if (!strcmp(category_name, "Items"))
-		return catItems;
-	if (!strcmp(category_name, "NPC"))
-		return catNPC;
-	if (!strcmp(category_name, "Dialogs"))
-		return catDialogs;
-	if (!strcmp(category_name, "LoN - TCG"))
-		return catLoNTCG;
-	if (!strcmp(category_name, "Mercenaries"))
-		return catMercenaries;
-	
-	return catOther;
-}

common/emu_constants.h

@@ -1,193 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EMU_CONSTANTS_H
-#define COMMON_EMU_CONSTANTS_H
-
-#include "eq_limits.h"
-#include "emu_legacy.h"
-#include "emu_versions.h"
-
-#include <string.h>
-
-
-namespace EQEmu
-{
-	namespace inventory {
-		//using namespace RoF2::invtype;
-		//using namespace RoF2::invslot;
-		//using namespace RoF2::invbag;
-		//using namespace RoF2::invaug;
-
-		enum : int16 { typeInvalid = -1, slotInvalid = -1, containerInvalid = -1, socketInvalid = -1 }; // temporary
-		enum : int16 { typeBegin = 0, slotBegin = 0, containerBegin = 0, socketBegin = 0 }; // temporary
-
-		enum PossessionsSlots : int16 { // temporary
-			slotCharm = 0,
-			slotEar1,
-			slotHead,
-			slotFace,
-			slotEar2,
-			slotNeck, // 5
-			slotShoulders,
-			slotArms,
-			slotBack,
-			slotWrist1,
-			slotWrist2, // 10
-			slotRange,
-			slotHands,
-			slotPrimary,
-			slotSecondary,
-			slotFinger1, // 15
-			slotFinger2,
-			slotChest,
-			slotLegs,
-			slotFeet,
-			slotWaist, // 20
-			slotPowerSource = 9999,
-			slotAmmo = 21,
-			slotGeneral1,
-			slotGeneral2,
-			slotGeneral3,
-			slotGeneral4, // 25
-			slotGeneral5,
-			slotGeneral6,
-			slotGeneral7,
-			slotGeneral8,
-			slotCursor, // 30
-			slotCount
-		};
-
-		enum InventoryTypes : int16 { // temporary
-			typePossessions = 0,
-			typeBank,
-			typeSharedBank,
-			typeTrade,
-			typeWorld,
-			typeLimbo, // 5
-			typeTribute,
-			typeTrophyTribute,
-			typeGuildTribute,
-			typeMerchant,
-			typeDeleted, // 10
-			typeCorpse,
-			typeBazaar,
-			typeInspect,
-			typeRealEstate,
-			typeViewMODPC, // 15
-			typeViewMODBank,
-			typeViewMODSharedBank,
-			typeViewMODLimbo,
-			typeAltStorage,
-			typeArchived, // 20
-			typeMail,
-			typeGuildTrophyTribute,
-			typeKrono,
-			typeOther,
-			typeCount
-		};
-
-		static int16 SlotCount(int16 type_index) { return 0; } // temporary
-
-		const int16 ContainerCount = 10; // temporary
-		const int16 SocketCount = 6; // temporary
-
-	} /*inventory*/
-
-	namespace constants {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
-
-		const size_t SayLinkOpenerSize = 1;
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
-		const size_t SayLinkTextSize = 256; // this may be varied until it breaks something (tested:374) - the others are constant
-		const size_t SayLinkCloserSize = 1;
-		const size_t SayLinkMaximumSize = (SayLinkOpenerSize + SayLinkBodySize + SayLinkTextSize + SayLinkCloserSize);
-
-		const int LongBuffs = RoF2::constants::LongBuffs;
-		const int ShortBuffs = RoF2::constants::ShortBuffs;
-		const int DiscBuffs = RoF2::constants::DiscBuffs;
-		const int TotalBuffs = RoF2::constants::TotalBuffs;
-		const int NPCBuffs = RoF2::constants::NPCBuffs;
-		const int PetBuffs = RoF2::constants::PetBuffs;
-		const int MercBuffs = RoF2::constants::MercBuffs;
-
-	} /*constants*/
-
-	namespace bug {
-		enum CategoryID : uint32 {
-			catOther = 0,
-			catVideo,
-			catAudio,
-			catPathing,
-			catQuest,
-			catTradeskills,
-			catSpellStacking,
-			catDoorsPortals,
-			catItems,
-			catNPC,
-			catDialogs,
-			catLoNTCG,
-			catMercenaries
-		};
-
-		enum OptionalInfoFlag : uint32 {
-			infoNoOptionalInfo = 0x0,
-			infoCanDuplicate = 0x1,
-			infoCrashBug = 0x2,
-			infoTargetInfo = 0x4,
-			infoCharacterFlags = 0x8,
-			infoUnknownValue = 0xFFFFFFF0
-		};
-
-		const char* CategoryIDToCategoryName(CategoryID category_id);
-		CategoryID CategoryNameToCategoryID(const char* category_name);
-
-	} // namespace bug
-
-	enum class CastingSlot : uint32 {
-		Gem1       = 0,
-		Gem2       = 1,
-		Gem3       = 2,
-		Gem4       = 3,
-		Gem5       = 4,
-		Gem6       = 5,
-		Gem7       = 6,
-		Gem8       = 7,
-		Gem9       = 8,
-		Gem10      = 9,
-		Gem11      = 10,
-		Gem12      = 11,
-		MaxGems    = 12,
-		Ability    = 20, // HT/LoH for Tit
-		PotionBelt = 21, // Tit uses a different slot for PB
-		Item       = 22,
-		Discipline = 23,
-		AltAbility = 0xFF
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_EMU_CONSTANTS_H*/
-
-/*	hack list to prevent circular references
-	
-	eq_limits.h:EQEmu::inventory::LookupEntry::InventoryTypeSize[n];
-
-*/

common/emu_legacy.cpp

@@ -1,20 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_legacy.h"

common/emu_legacy.h

@@ -1,182 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-	
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EMU_LEGACY_H
-#define COMMON_EMU_LEGACY_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	// this is for perl and other legacy systems
-	namespace legacy {
-		enum InventorySlot {
-			SLOT_CHARM = 0,
-			SLOT_EAR01 = 1,
-			SLOT_HEAD = 2,
-			SLOT_FACE = 3,
-			SLOT_EAR02 = 4,
-			SLOT_NECK = 5,
-			SLOT_SHOULDER = 6,
-			SLOT_ARMS = 7,
-			SLOT_BACK = 8,
-			SLOT_BRACER01 = 9,
-			SLOT_BRACER02 = 10,
-			SLOT_RANGE = 11,
-			SLOT_HANDS = 12,
-			SLOT_PRIMARY = 13,
-			SLOT_SECONDARY = 14,
-			SLOT_RING01 = 15,
-			SLOT_RING02 = 16,
-			SLOT_CHEST = 17,
-			SLOT_LEGS = 18,
-			SLOT_FEET = 19,
-			SLOT_WAIST = 20,
-			SLOT_POWER_SOURCE = 9999,
-			SLOT_AMMO = 21,
-			SLOT_GENERAL_1 = 22,
-			SLOT_GENERAL_2 = 23,
-			SLOT_GENERAL_3 = 24,
-			SLOT_GENERAL_4 = 25,
-			SLOT_GENERAL_5 = 26,
-			SLOT_GENERAL_6 = 27,
-			SLOT_GENERAL_7 = 28,
-			SLOT_GENERAL_8 = 29,
-			SLOT_CURSOR = 30,
-			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
-			SLOT_TRADESKILL = 1000,
-			SLOT_AUGMENT = 1001,
-			SLOT_INVALID = (int16)0xFFFF,
-			SLOT_POSSESSIONS_BEGIN = 0,
-			SLOT_POSSESSIONS_END = 30,
-			SLOT_EQUIPMENT_BEGIN = 0,
-			SLOT_EQUIPMENT_END = 21,
-			SLOT_PERSONAL_BEGIN = 22,
-			SLOT_PERSONAL_END = 29,
-			SLOT_PERSONAL_BAGS_BEGIN = 251,
-			SLOT_PERSONAL_BAGS_END = 330,
-			SLOT_CURSOR_BAG_BEGIN = 331,
-			SLOT_CURSOR_BAG_END = 340,
-			SLOT_TRIBUTE_BEGIN = 400,
-			SLOT_TRIBUTE_END = 404,
-			SLOT_GUILD_TRIBUTE_BEGIN = 450,
-			SLOT_GUILD_TRIBUTE_END = 451,
-			SLOT_BANK_BEGIN = 2000,
-			SLOT_BANK_END = 2023,
-			SLOT_BANK_BAGS_BEGIN = 2031,
-			SLOT_BANK_BAGS_END = 2270,
-			SLOT_SHARED_BANK_BEGIN = 2500,
-			SLOT_SHARED_BANK_END = 2501,
-			SLOT_SHARED_BANK_BAGS_BEGIN = 2531,
-			SLOT_SHARED_BANK_BAGS_END = 2550,
-			SLOT_TRADE_BEGIN = 3000,
-			SLOT_TRADE_END = 3007,
-			SLOT_TRADE_BAGS_BEGIN = 3031,
-			SLOT_TRADE_BAGS_END = 3110,
-			SLOT_WORLD_BEGIN = 4000,
-			SLOT_WORLD_END = 4009
-		};
-
-		// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
-		static const uint16	TYPE_POSSESSIONS_SIZE = 31;
-		static const uint16 TYPE_BANK_SIZE = 24;
-		static const uint16 TYPE_SHARED_BANK_SIZE = 2;
-		static const uint16 TYPE_TRADE_SIZE = 8;
-		static const uint16 TYPE_WORLD_SIZE = 10;
-		static const uint16 TYPE_LIMBO_SIZE = 36;
-		static const uint16 TYPE_TRIBUTE_SIZE = 5; // (need client values)
-		static const uint16 TYPE_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_GUILD_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_MERCHANT_SIZE = 0;
-		static const uint16 TYPE_DELETED_SIZE = 0;
-		static const uint16 TYPE_CORPSE_SIZE = 31; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
-		static const uint16 TYPE_BAZAAR_SIZE = 80;
-		static const uint16 TYPE_INSPECT_SIZE = 22;
-		static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;
-		static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
-		static const uint16 TYPE_ARCHIVED_SIZE = 0;
-		static const uint16 TYPE_MAIL_SIZE = 0;
-		static const uint16 TYPE_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_KRONO_SIZE = 0;
-		static const uint16 TYPE_OTHER_SIZE = 0;
-
-		// most of these definitions will go away with the structure-based system..this maintains compatibility for now
-		// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
-		static const int16 EQUIPMENT_BEGIN = 0;
-		static const int16 EQUIPMENT_END = 21;
-		static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
-
-		static const int16 GENERAL_BEGIN = 22;
-		static const int16 GENERAL_END = 29;
-		static const uint16 GENERAL_SIZE = 8;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 79;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR_BAG_BEGIN = 331;
-		static const int16 CURSOR_BAG_END_OFFSET = 9;
-		static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
-
-		static const int16 BANK_BEGIN = 2000;
-		static const int16 BANK_END = 2023;
-		static const int16 BANK_BAGS_BEGIN = 2031;
-		static const int16 BANK_BAGS_END_OFFSET = 239;
-		static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
-
-		static const int16 SHARED_BANK_BEGIN = 2500;
-		static const int16 SHARED_BANK_END = 2501;
-		static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-		static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-		static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
-
-		static const int16 TRADE_BEGIN = 3000;
-		static const int16 TRADE_END = 3007;
-		static const int16 TRADE_NPC_END = 3003;
-		static const int16 TRADE_BAGS_BEGIN = 3031;
-		static const int16 TRADE_BAGS_END_OFFSET = 79;
-		static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
-
-		static const int16 WORLD_BEGIN = 4000;
-		static const int16 WORLD_END = 4009;
-		static const int16 WORLD_SIZE = TYPE_WORLD_SIZE;
-
-		static const int16 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-		static const int16 TRIBUTE_SIZE = TYPE_TRIBUTE_SIZE;
-
-		static const int16 CORPSE_BEGIN = 22;
-
-		// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t BANDOLIERS_SIZE = 20;		// number of bandolier instances
-		static const size_t BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
-
-		// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t POTION_BELT_ITEM_COUNT = 5;
-	}
-
-}
-
-#endif /* COMMON_EMU_LEGACY_H */

common/emu_limits.cpp

@@ -1,18 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/

common/emu_limits.h

@@ -1,104 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EMU_LIMITS_H
-#define COMMON_EMU_LIMITS_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EntityLimits
-{
-	namespace NPC {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*NPC*/
-
-	namespace NPCMerchant {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*NPCMerchant*/
-
-	namespace Merc {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*Merc*/
-
-	namespace Bot {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 8;
-
-	} /*Bot*/
-
-	namespace ClientPet {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*Pet*/
-
-	namespace NPCPet {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*Pet*/
-
-	namespace MercPet {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*Pet*/
-
-	namespace BotPet {
-		enum : int { Invalid = -1, Null, Safety };
-
-		enum : bool { False = false, True = true };
-
-		const size_t InvTypeTradeSize = 4;
-
-	} /*Pet*/
-
-}; /*EntityLimits*/
-
-#endif /*COMMON_EMU_LIMITS_H*/

common/emu_oplist.h

@@ -9,7 +9,6 @@ N(OP_AcceptNewTask),
 N(OP_AckPacket),
 N(OP_Action),
 N(OP_Action2),
-N(OP_AddNimbusEffect),
 N(OP_AdventureData),
 N(OP_AdventureDetails),
 N(OP_AdventureFinish),
@@ -26,9 +25,6 @@ N(OP_AdventureRequest),
 N(OP_AdventureStatsReply),
 N(OP_AdventureStatsRequest),
 N(OP_AdventureUpdate),
-N(OP_AggroMeterLockTarget),
-N(OP_AggroMeterTargetInfo),
-N(OP_AggroMeterUpdate),
 N(OP_AltCurrency),
 N(OP_AltCurrencyMerchantReply),
 N(OP_AltCurrencyMerchantRequest),
@@ -68,7 +64,6 @@ N(OP_BuffRemoveRequest),
 N(OP_Bug),
 N(OP_CameraEffect),
 N(OP_Camp),
-N(OP_CancelSneakHide),
 N(OP_CancelTask),
 N(OP_CancelTrade),
 N(OP_CastSpell),
@@ -169,7 +164,6 @@ N(OP_FinishTrade),
 N(OP_FinishWindow),
 N(OP_FinishWindow2),
 N(OP_Fishing),
-N(OP_Fling),
 N(OP_FloatListThing),
 N(OP_Forage),
 N(OP_ForceFindPerson),
@@ -221,7 +215,6 @@ N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
-N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -293,7 +286,6 @@ N(OP_LFGuild),
 N(OP_LFPCommand),
 N(OP_LFPGetMatchesRequest),
 N(OP_LFPGetMatchesResponse),
-N(OP_LinkedReuse),
 N(OP_LoadSpellSet),
 N(OP_LocInfo),
 N(OP_LockoutTimerInfo),
@@ -340,7 +332,6 @@ N(OP_MOTD),
 N(OP_MoveCoin),
 N(OP_MoveDoor),
 N(OP_MoveItem),
-N(OP_MoveMultipleItems),
 N(OP_MoveLogDisregard),
 N(OP_MoveLogRequest),
 N(OP_MultiLineMsg),
@@ -357,8 +348,6 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
-N(OP_PetCommandState),
-N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
 N(OP_PetitionCheckIn),
@@ -375,8 +364,6 @@ N(OP_PetitionUnCheckout),
 N(OP_PetitionUpdate),
 N(OP_PickPocket),
 N(OP_PlayerProfile),
-N(OP_PlayerStateAdd),
-N(OP_PlayerStateRemove),
 N(OP_PlayEverquestRequest),
 N(OP_PlayEverquestResponse),
 N(OP_PlayMP3),
@@ -393,7 +380,6 @@ N(OP_PVPLeaderBoardReply),
 N(OP_PVPLeaderBoardRequest),
 N(OP_PVPStats),
 N(OP_QueryResponseThing),
-N(OP_QueryUCSServerStatus),
 N(OP_RaidInvite),
 N(OP_RaidJoin),
 N(OP_RaidUpdate),
@@ -411,7 +397,6 @@ N(OP_ReloadUI),
 N(OP_RemoveAllDoors),
 N(OP_RemoveBlockedBuffs),
 N(OP_RemoveNimbusEffect),
-N(OP_RemoveTrap),
 N(OP_Report),
 N(OP_ReqClientSpawn),
 N(OP_ReqNewZone),
@@ -527,7 +512,6 @@ N(OP_TributeToggle),
 N(OP_TributeUpdate),
 N(OP_Untargetable),
 N(OP_UpdateAA),
-N(OP_UpdateAura),
 N(OP_UpdateLeadershipAA),
 N(OP_VetClaimReply),
 N(OP_VetClaimRequest),
@@ -535,6 +519,8 @@ N(OP_VetRewardsAvaliable),
 N(OP_VoiceMacroIn),
 N(OP_VoiceMacroOut),
 N(OP_WeaponEquip1),
+N(OP_WeaponEquip2),
+N(OP_WeaponUnequip2),
 N(OP_WearChange),
 N(OP_Weather),
 N(OP_Weblink),
@@ -548,8 +534,6 @@ N(OP_WorldLogout),
 N(OP_WorldObjectsSent),
 N(OP_WorldUnknown001),
 N(OP_XTargetAutoAddHaters),
-N(OP_XTargetOpen),
-N(OP_XTargetOpenResponse),
 N(OP_XTargetRequest),
 N(OP_XTargetResponse),
 N(OP_YellForHelp),
@@ -563,5 +547,4 @@ N(OP_ZoneServerInfo),
 N(OP_ZoneServerReady),
 N(OP_ZoneSpawns),
 N(OP_ZoneUnavail),
-N(OP_ResetAA),
 // mail and chat opcodes located in ../mail_oplist.h

common/emu_tcp_connection.cpp

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

common/emu_tcp_connection.h

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

common/emu_tcp_server.cpp

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

common/emu_tcp_server.h

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

common/emu_versions.cpp

@@ -1,370 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_versions.h"
-
-
-bool EQEmu::versions::IsValidClientVersion(ClientVersion client_version)
-{
-	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
-		return false;
-
-	return true;
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ValidateClientVersion(ClientVersion client_version)
-{
-	if (client_version <= ClientVersion::Unknown || client_version > LastClientVersion)
-		return ClientVersion::Unknown;
-
-	return client_version;
-}
-
-const char* EQEmu::versions::ClientVersionName(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-		return "Unknown Version";
-	case ClientVersion::Client62:
-		return "Client 6.2";
-	case ClientVersion::Titanium:
-		return "Titanium";
-	case ClientVersion::SoF:
-		return "SoF";
-	case ClientVersion::SoD:
-		return "SoD";
-	case ClientVersion::UF:
-		return "UF";
-	case ClientVersion::RoF:
-		return "RoF";
-	case ClientVersion::RoF2:
-		return "RoF2";
-	default:
-		return "Invalid Version";
-	};
-}
-
-uint32 EQEmu::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-		return bit_Unknown;
-	case ClientVersion::Titanium:
-		return bit_Titanium;
-	case ClientVersion::SoF:
-		return bit_SoF;
-	case ClientVersion::SoD:
-		return bit_SoD;
-	case ClientVersion::UF:
-		return bit_UF;
-	case ClientVersion::RoF:
-		return bit_RoF;
-	case ClientVersion::RoF2:
-		return bit_RoF2;
-	default:
-		return bit_Unknown;
-	}
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
-{
-	switch (client_version_bit) {
-	case (uint32)static_cast<unsigned int>(ClientVersion::Unknown) :
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)) :
-		return ClientVersion::Unknown;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
-		return ClientVersion::Titanium;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)) :
-		return ClientVersion::SoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)) :
-		return ClientVersion::SoD;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)) :
-		return ClientVersion::UF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)) :
-		return ClientVersion::RoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)) :
-		return ClientVersion::RoF2;
-	default:
-		return ClientVersion::Unknown;
-	}
-}
-
-uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-	case ClientVersion::Titanium:
-		return 0x000007FFU;
-	case ClientVersion::SoF:
-		return 0x00007FFFU;
-	case ClientVersion::SoD:
-		return 0x0000FFFFU;
-	case ClientVersion::UF:
-		return 0x0001FFFFU;
-	case ClientVersion::RoF:
-	case ClientVersion::RoF2:
-		return 0x000FFFFFU;
-	default:
-		return 0;
-	}
-}
-
-bool EQEmu::versions::IsValidMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::versions::IsValidPCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::versions::IsValidNonPCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
-		return false;
-
-	return true;
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ValidateMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
-		return MobVersion::Unknown;
-
-	return mob_version;
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ValidatePCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
-		return MobVersion::Unknown;
-
-	return mob_version;
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ValidateNonPCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
-		return MobVersion::Unknown;
-
-	return mob_version;
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
-{
-	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
-		return MobVersion::Unknown;
-
-	return mob_version;
-}
-
-const char* EQEmu::versions::MobVersionName(MobVersion mob_version)
-{
-	switch (mob_version) {
-	case MobVersion::Unknown:
-		return "Unknown Version";
-	case MobVersion::Client62:
-		return "Client 6.2";
-	case MobVersion::Titanium:
-		return "Titanium";
-	case MobVersion::SoF:
-		return "SoF";
-	case MobVersion::SoD:
-		return "SoD";
-	case MobVersion::UF:
-		return "UF";
-	case MobVersion::RoF:
-		return "RoF";
-	case MobVersion::RoF2:
-		return "RoF2";
-	case MobVersion::NPC:
-		return "NPC";
-	case MobVersion::NPCMerchant:
-		return "NPC Merchant";
-	case MobVersion::Merc:
-		return "Merc";
-	case MobVersion::Bot:
-		return "Bot";
-	case MobVersion::ClientPet:
-		return "Client Pet";
-	case MobVersion::NPCPet:
-		return "NPC Pet";
-	case MobVersion::MercPet:
-		return "Merc Pet";
-	case MobVersion::BotPet:
-		return "Bot Pet";
-	case MobVersion::OfflineTitanium:
-		return "Offline Titanium";
-	case MobVersion::OfflineSoF:
-		return "Offline SoF";
-	case MobVersion::OfflineSoD:
-		return "Offline SoD";
-	case MobVersion::OfflineUF:
-		return "Offline UF";
-	case MobVersion::OfflineRoF:
-		return "Offline RoF";
-	case MobVersion::OfflineRoF2:
-		return "Offline RoF2";
-	default:
-		return "Invalid Version";
-	};
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
-{
-	switch (mob_version) {
-	case MobVersion::Unknown:
-	case MobVersion::Client62:
-		return ClientVersion::Unknown;
-	case MobVersion::Titanium:
-		return ClientVersion::Titanium;
-	case MobVersion::SoF:
-		return ClientVersion::SoF;
-	case MobVersion::SoD:
-		return ClientVersion::SoD;
-	case MobVersion::UF:
-		return ClientVersion::UF;
-	case MobVersion::RoF:
-		return ClientVersion::RoF;
-	case MobVersion::RoF2:
-		return ClientVersion::RoF2;
-	default:
-		return ClientVersion::Unknown;
-	}
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-		return MobVersion::Unknown;
-	case ClientVersion::Titanium:
-		return MobVersion::Titanium;
-	case ClientVersion::SoF:
-		return MobVersion::SoF;
-	case ClientVersion::SoD:
-		return MobVersion::SoD;
-	case ClientVersion::UF:
-		return MobVersion::UF;
-	case ClientVersion::RoF:
-		return MobVersion::RoF;
-	case ClientVersion::RoF2:
-		return MobVersion::RoF2;
-	default:
-		return MobVersion::Unknown;
-	}
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
-{
-	switch (mob_version) {
-	case MobVersion::Titanium:
-		return MobVersion::OfflineTitanium;
-	case MobVersion::SoF:
-		return MobVersion::OfflineSoF;
-	case MobVersion::SoD:
-		return MobVersion::OfflineSoD;
-	case MobVersion::UF:
-		return MobVersion::OfflineUF;
-	case MobVersion::RoF:
-		return MobVersion::OfflineRoF;
-	case MobVersion::RoF2:
-		return MobVersion::OfflineRoF2;
-	default:
-		return MobVersion::Unknown;
-	}
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
-{
-	switch (mob_version) {
-	case MobVersion::OfflineTitanium:
-		return MobVersion::Titanium;
-	case MobVersion::OfflineSoF:
-		return MobVersion::SoF;
-	case MobVersion::OfflineSoD:
-		return MobVersion::SoD;
-	case MobVersion::OfflineUF:
-		return MobVersion::UF;
-	case MobVersion::OfflineRoF:
-		return MobVersion::RoF;
-	case MobVersion::OfflineRoF2:
-		return MobVersion::RoF2;
-	default:
-		return MobVersion::Unknown;
-	}
-}
-
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
-{
-	switch (mob_version) {
-	case MobVersion::OfflineTitanium:
-		return ClientVersion::Titanium;
-	case MobVersion::OfflineSoF:
-		return ClientVersion::SoF;
-	case MobVersion::OfflineSoD:
-		return ClientVersion::SoD;
-	case MobVersion::OfflineUF:
-		return ClientVersion::UF;
-	case MobVersion::OfflineRoF:
-		return ClientVersion::RoF;
-	case MobVersion::OfflineRoF2:
-		return ClientVersion::RoF2;
-	default:
-		return ClientVersion::Unknown;
-	}
-}
-
-EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Titanium:
-		return MobVersion::OfflineTitanium;
-	case ClientVersion::SoF:
-		return MobVersion::OfflineSoF;
-	case ClientVersion::SoD:
-		return MobVersion::OfflineSoD;
-	case ClientVersion::UF:
-		return MobVersion::OfflineUF;
-	case ClientVersion::RoF:
-		return MobVersion::OfflineRoF;
-	case ClientVersion::RoF2:
-		return MobVersion::OfflineRoF2;
-	default:
-		return MobVersion::Unknown;
-	}
-}

common/emu_versions.h

@@ -1,142 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EMU_VERSIONS_H
-#define COMMON_EMU_VERSIONS_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	namespace versions {
-		enum class ClientVersion : uint32 {
-			Unknown = 0,
-			Client62,	// Build: 'Aug  4 2005 15:40:59'
-			Titanium,	// Build: 'Oct 31 2005 10:33:37'
-			SoF,		// Build: 'Sep  7 2007 09:11:49'
-			SoD,		// Build: 'Dec 19 2008 15:22:49'
-			UF,			// Build: 'Jun  8 2010 16:44:32'
-			RoF,		// Build: 'Dec 10 2012 17:35:44'
-			RoF2		// Build: 'May 10 2013 23:30:08'
-		};
-
-		enum ClientVersionBit : uint32 {
-			bit_Unknown = 0,
-			bit_Client62 = 0x00000001, // unsupported (placeholder for scripts)
-			bit_Titanium = 0x00000002,
-			bit_SoF = 0x00000004,
-			bit_SoD = 0x00000008,
-			bit_UF = 0x00000010,
-			bit_RoF = 0x00000020,
-			bit_RoF2 = 0x00000040,
-			bit_TitaniumAndEarlier = 0x00000003,
-			bit_SoFAndEarlier = 0x00000007,
-			bit_SoDAndEarlier = 0x0000000F,
-			bit_UFAndEarlier = 0x0000001F,
-			bit_RoFAndEarlier = 0x0000003F,
-			bit_SoFAndLater = 0xFFFFFFFC,
-			bit_SoDAndLater = 0xFFFFFFF8,
-			bit_UFAndLater = 0xFFFFFFF0,
-			bit_RoFAndLater = 0xFFFFFFE0,
-			bit_RoF2AndLater = 0xFFFFFFC0,
-			bit_AllClients = 0xFFFFFFFF
-		};
-
-		const ClientVersion LastClientVersion = ClientVersion::RoF2;
-		const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
-
-		bool IsValidClientVersion(ClientVersion client_version);
-		ClientVersion ValidateClientVersion(ClientVersion client_version);
-		const char* ClientVersionName(ClientVersion client_version);
-		uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
-		ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
-		uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
-
-
-		enum class MobVersion : uint32 {
-			Unknown = 0,
-			Client62,
-			Titanium,
-			SoF,
-			SoD,
-			UF,
-			RoF,
-			RoF2,
-			NPC,
-			NPCMerchant,
-			Merc,
-			Bot,
-			ClientPet,
-			NPCPet,
-			MercPet,
-			BotPet,
-			OfflineTitanium,
-			OfflineSoF,
-			OfflineSoD,
-			OfflineUF,
-			OfflineRoF,
-			OfflineRoF2
-		};
-
-		const MobVersion LastMobVersion = MobVersion::OfflineRoF2;
-		const MobVersion LastPCMobVersion = MobVersion::RoF2;
-		const MobVersion LastNonPCMobVersion = MobVersion::BotPet;
-		const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineRoF2;
-		const size_t MobVersionCount = (static_cast<size_t>(LastMobVersion) + 1);
-
-		bool IsValidMobVersion(MobVersion mob_version);
-		bool IsValidPCMobVersion(MobVersion mob_version);
-		bool IsValidNonPCMobVersion(MobVersion mob_version);
-		bool IsValidOfflinePCMobVersion(MobVersion mob_version);
-
-		MobVersion ValidateMobVersion(MobVersion mob_version);
-		MobVersion ValidatePCMobVersion(MobVersion mob_version);
-		MobVersion ValidateNonPCMobVersion(MobVersion mob_version);
-		MobVersion ValidateOfflinePCMobVersion(MobVersion mob_version);
-
-		const char* MobVersionName(MobVersion mob_version);
-		ClientVersion ConvertMobVersionToClientVersion(MobVersion mob_version);
-		MobVersion ConvertClientVersionToMobVersion(ClientVersion client_version);
-		MobVersion ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version);
-		MobVersion ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version);
-		ClientVersion ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version);
-		MobVersion ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version);
-
-
-		enum UCSVersion : char {
-			ucsUnknown = '\0',
-			ucsClient62Chat = 'A',
-			ucsClient62Mail = 'a',
-			ucsTitaniumChat = 'B',
-			ucsTitaniumMail = 'b',
-			ucsSoFCombined = 'C',
-			ucsSoDCombined = 'D',
-			ucsUFCombined = 'E',
-			ucsRoFCombined = 'F',
-			ucsRoF2Combined = 'G'
-		};
-
-	} /*versions*/
-
-} /*EQEmu*/
-
-#endif /*COMMON_EMU_VERSIONS_H*/

common/eq_constants.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -14,61 +13,360 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#ifndef COMMON_EQ_CONSTANTS_H
-#define COMMON_EQ_CONSTANTS_H
+#ifndef EQ_CONSTANTS_H
+#define EQ_CONSTANTS_H
 
 #include "skills.h"
 #include "types.h"
 
+/*
+**	Item attributes
+**
+**	(There are no grepwin hits other than these declarations... Do they have a use?)
+*/
+enum ItemAttributes : uint32
+{
+	ItemAttrNone			= 0x00000000,
+	ItemAttrLore			= 0x00000001,
+	ItemAttrArtifact		= 0x00000002,
+	ItemAttrSummoned		= 0x00000004,
+	ItemAttrMagic			= 0x00000008,
+	ItemAttrAugment			= 0x00000010,
+	ItemAttrPendingLore		= 0x00000020,
+	ItemAttrUnknown			= 0xFFFFFFFF
+};
 
-//SpawnAppearance types: (compared two clients for server-originating types: SoF & RoF2)
-#define AT_Die 0			// this causes the client to keel over and zone to bind point (default action)
-#define AT_WhoLevel 1		// the level that shows up on /who
-#define AT_HPMax 2			// idk
-#define AT_Invis 3			// 0 = visible, 1 = invisible
-#define AT_PVP 4			// 0 = blue, 1 = pvp (red)
-#define AT_Light 5			// light type emitted by player (lightstone, shiny shield)
-#define AT_Anim 14			// 100=standing, 110=sitting, 111=ducking, 115=feigned, 105=looting
-#define AT_Sneak 15			// 0 = normal, 1 = sneaking
-#define AT_SpawnID 16		// server to client, sets player spawn id
-#define AT_HP 17			// Client->Server, my HP has changed (like regen tic)
-#define AT_Linkdead 18		// 0 = normal, 1 = linkdead
-#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate max 5, see GravityBehavior enum
-#define AT_GM 20			// 0 = normal, 1 = GM - all odd numbers seem to make it GM
-#define AT_Anon 21			// 0 = normal, 1 = anon, 2 = roleplay
-#define AT_GuildID 22
-#define AT_GuildRank 23		// 0=member, 1=officer, 2=leader
-#define AT_AFK 24			// 0 = normal, 1 = afk
-#define AT_Pet 25			// Param is EntityID of owner, or 0 for when charm breaks
-#define AT_Summoned 27		// Unsure
-#define AT_Split 28			// 0 = normal, 1 = autosplit on (not showing in SoF+) (client-to-server only)
-#define AT_Size 29			// spawn's size (present: SoF, absent: RoF2)
-#define AT_SetType 30		// 0 = PC, 1 = NPC, 2 <= = corpse
-#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name, Trader on RoF2?
-#define AT_AARank 32		// AA Rank Title ID thingy, does is this the title in /who?
-#define AT_CancelSneakHide 33	// Turns off Hide and Sneak
-//#define AT_34 34			// unknown (present: SoF, absent: RoF2)
-#define AT_AreaHPRegen 35	// guild hall regen pool sets to value * 0.001
-#define AT_AreaManaRegen 36	// guild hall regen pool sets to value * 0.001
-#define AT_AreaEndRegen 37	// guild hall regen pool sets to value * 0.001
-#define AT_FreezeBuffs 38	// Freezes beneficial buff timers
-#define AT_NpcTintIndex 39	// not 100% sure
-#define AT_GroupConsent 40	// auto consent group
-#define AT_RaidConsent 41	// auto consent raid
-#define AT_GuildConsent 42	// auto consent guild
-#define AT_ShowHelm 43		// 0 = hide graphic, 1 = show graphic
-#define AT_DamageState 44	// The damage state of a destructible object (0 through 10) plays soundids most only have 2 or 4 states though
-#define AT_EQPlayers 45		// /eqplayersupdate
-#define AT_FindBits 46		// set FindBits, whatever those are!
-#define AT_TextureType 48	// TextureType
-#define AT_FacePick 49		// Turns off face pick window? maybe ...
-#define AT_GuildShow 52		// this is what MQ2 call sit, not sure
-#define AT_Offline 53		// Offline mode
+/*
+**	Item class types
+**
+*/
+enum ItemClassTypes
+{
+	ItemClassCommon = 0,
+	ItemClassContainer,
+	ItemClassBook,
+	_ItemClassCount
+};
 
-//#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
+/*
+**	Item use types
+**
+**	(ref: database and eqstr_us.txt)
+**
+**	(Looking at a recent database, it's possible that some of the item values may be off [10-27-2013] -U)
+*/
+enum ItemUseTypes : uint8
+{
+/*9138*/	ItemType1HSlash = 0,
+/*9141*/	ItemType2HSlash,
+/*9140*/	ItemType1HPiercing,
+/*9139*/	ItemType1HBlunt,
+/*9142*/	ItemType2HBlunt,
+/*5504*/	ItemTypeBow,
+/*----*/	ItemTypeUnknown1,
+/*----*/	ItemTypeLargeThrowing,
+/*5505*/	ItemTypeShield,
+/*5506*/	ItemTypeScroll,
+/*5507*/	ItemTypeArmor,
+/*5508*/	ItemTypeMisc,			// a lot of random crap has this item use.
+/*7564*/	ItemTypeLockPick,
+/*----*/	ItemTypeUnknown2,
+/*5509*/	ItemTypeFood,
+/*5510*/	ItemTypeDrink,
+/*5511*/	ItemTypeLight,
+/*5512*/	ItemTypeCombinable,		// not all stackable items are this use...
+/*5513*/	ItemTypeBandage,
+/*----*/	ItemTypeSmallThrowing,
+/*----*/	ItemTypeSpell,			// spells and tomes
+/*5514*/	ItemTypePotion,
+/*----*/	ItemTypeUnknown3,
+/*0406*/	ItemTypeWindInstrument,
+/*0407*/	ItemTypeStringedInstrument,
+/*0408*/	ItemTypeBrassInstrument,
+/*0405*/	ItemTypePercussionInstrument,
+/*5515*/	ItemTypeArrow,
+/*----*/	ItemTypeUnknown4,
+/*5521*/	ItemTypeJewelry,
+/*----*/	ItemTypeSkull,
+/*5516*/	ItemTypeBook,			// skill-up tomes/books? (would probably need a pp flag if true...)
+/*5517*/	ItemTypeNote,
+/*5518*/	ItemTypeKey,
+/*----*/	ItemTypeCoin,
+/*5520*/	ItemType2HPiercing,
+/*----*/	ItemTypeFishingPole,
+/*----*/	ItemTypeFishingBait,
+/*5519*/	ItemTypeAlcohol,
+/*----*/	ItemTypeKey2,			// keys and satchels?? (questable keys?)
+/*----*/	ItemTypeCompass,
+/*----*/	ItemTypeUnknown5,
+/*----*/	ItemTypePoison,			// might be wrong, but includes poisons
+/*----*/	ItemTypeUnknown6,
+/*----*/	ItemTypeUnknown7,
+/*5522*/	ItemTypeMartial,
+/*----*/	ItemTypeUnknown8,
+/*----*/	ItemTypeUnknown9,
+/*----*/	ItemTypeUnknown10,
+/*----*/	ItemTypeUnknown11,
+/*----*/	ItemTypeSinging,
+/*5750*/	ItemTypeAllInstrumentTypes,
+/*5776*/	ItemTypeCharm,
+/*----*/	ItemTypeDye,
+/*----*/	ItemTypeAugmentation,
+/*----*/	ItemTypeAugmentationSolvent,
+/*----*/	ItemTypeAugmentationDistiller,
+/*----*/	ItemTypeUnknown12,
+/*----*/	ItemTypeFellowshipKit,
+/*----*/	ItemTypeUnknown13,
+/*----*/	ItemTypeRecipe,
+/*----*/	ItemTypeAdvancedRecipe,
+/*----*/	ItemTypeJournal,		// only one(1) database entry
+/*----*/	ItemTypeAltCurrency,	// alt-currency (as opposed to coinage)
+/*5881*/	ItemTypePerfectedAugmentationDistiller,
+/*----*/	_ItemTypeCount
+
+/*
+	Unknowns:
+
+	Mounts?
+	Ornamentations?
+	GuildBanners?
+	Collectible? 
+	Placeable?
+	(others?)
+*/
+};
+
+/*
+**	Augmentation use type bitmasks (1-based)
+**
+**	(ref: dbstr_us.txt)
+**
+*/
+enum AugmentationUseTypeBitmasks : uint32 {
+	AugUseNone					= 0x00000000,
+	AugUseGeneralSingleStat		= 0x00000001,	/*1^16^1 (General: Single Stat)^0*/
+	AugUseGeneralMultipleStat	= 0x00000002,	/*2^16^2 (General: Multiple Stat)^0*/
+	AugUseGeneralSpellEffect	= 0x00000004,	/*3^16^3 (General: Spell Effect)^0*/
+	AugUseWeaponGeneral			= 0x00000008,	/*4^16^4 (Weapon: General)^0*/
+	AugUseWeaponElemDamage		= 0x00000010,	/*5^16^5 (Weapon: Elem Damage)^0*/
+	AugUseWeaponBaseDamage		= 0x00000020,	/*6^16^6 (Weapon: Base Damage)^0*/
+	AugUseGeneralGroup			= 0x00000040,	/*7^16^7 (General: Group)^0*/
+	AugUseGeneralRaid			= 0x00000080,	/*8^16^8 (General: Raid)^0*/
+	AugUseGeneralDragonsPoints	= 0x00000100,	/*9^16^9 (General: Dragons Points)^0*/
+	AugUseCraftedCommon			= 0x00000200,	/*10^16^10 (Crafted: Common)^0*/
+	AugUseCraftedGroup1			= 0x00000400,	/*11^16^11 (Crafted: Group)^0*/
+	AugUseCraftedRaid1			= 0x00000800,	/*12^16^12 (Crafted: Raid)^0*/
+	AugUseEnergeiacGroup		= 0x00001000,	/*13^16^13 (Energeiac: Group)^0*/
+	AugUseEnergeiacRaid			= 0x00002000,	/*14^16^14 (Energeiac: Raid)^0*/
+	AugUseEmblem				= 0x00004000,	/*15^16^15 (Emblem)^0*/
+	AugUseCraftedGroup2			= 0x00008000,	/*16^16^16 (Crafted: Group)^0*/
+	AugUseCraftedRaid2			= 0x00010000,	/*17^16^17 (Crafted: Raid)^0*/
+	AugUseUnknown1				= 0x00020000,	/*18^16^18^0*/
+	AugUseUnknown2				= 0x00040000,	/*19^16^19^0*/
+	AugUseOrnamentation			= 0x00080000,	/*20^16^20 (Ornamentation)^0*/
+	AugUseSpecialOrnamentation	= 0x00100000,	/*21^16^21 (Special Ornamentation)^0*/
+	AugUseUnknown3				= 0x00200000,	/*22^16^22^0*/
+	AugUseUnknown4				= 0x00400000,	/*23^16^23^0*/
+	AugUseUnknown5				= 0x00800000,	/*24^16^24^0*/
+	AugUseUnknown6				= 0x01000000,	/*25^16^25^0*/
+	AugUseUnknown7				= 0x02000000,	/*26^16^26^0*/
+	AugUseUnknown8				= 0x04000000,	/*27^16^27^0*/
+	AugUseUnknown9				= 0x08000000,	/*28^16^28^0*/
+	AugUseUnknown10				= 0x10000000,	/*29^16^29^0*/
+	AugUseEpic25				= 0x20000000,	/*30^16^30^0*/
+	AugUseTest					= 0x40000000,	/*31^16^Test^0*/ // listed as 31^16^31^0 in 5-10 client
+	AugUseAll					= 0xFFFFFFFF
+};
+
+/*
+**	Augmentation use types (enumerated)
+**
+*/
+enum AugmentationUseTypes : uint8 {
+	AugTypeNone = 0,
+	AugTypeGeneralSingleStat,
+	AugTypeGeneralMultipleStat,
+	AugTypeGeneralSpellEffect,
+	AugTypeWeaponGeneral,
+	AugTypeWeaponElemDamage,
+	AugTypeWeaponBaseDamage,
+	AugTypeGeneralGroup,
+	AugTypeGeneralRaid,
+	AugTypeGeneralDragonsPoints,
+	AugTypeCraftedCommon,
+	AugTypeCraftedGroup1,
+	AugTypeCraftedRaid1,
+	AugTypeEnergeiacGroup,
+	AugTypeEnergeiacRaid,
+	AugTypeEmblem,
+	AugTypeCraftedGroup2,
+	AugTypeCraftedRaid2,
+	AugTypeUnknown1,
+	AugTypeUnknown2,
+	AugTypeOrnamentation,
+	AugTypeSpecialOrnamentation,
+	AugTypeUnknown3,
+	AugTypeUnknown4,
+	AugTypeUnknown5,
+	AugTypeUnknown6,
+	AugTypeUnknown7,
+	AugTypeUnknown8,
+	AugTypeUnknown9,
+	AugTypeUnknown10,
+	AugTypeEpic25,
+	AugTypeTest,
+	_AugTypeCount,
+	AugTypeAll = 255
+};
+
+/*
+**	Augmentation restriction types (in-work)
+**
+**	(ref: eqstr_us.txt)
+**
+*/
+enum AugmentationRestrictionTypes : uint8 {
+/*4690*/	AugRestrAny = 0,
+/*9134*/	AugRestrArmor,
+/*9135*/	AugRestrWeapons,
+/*9136*/	AugRestr1HWeapons,
+/*9137*/	AugRestr2HWeapons,
+/*9138*/	AugRestr1HSlash,
+/*9139*/	AugRestr1HBlunt,
+/*9140*/	AugRestrPiercing,
+/*9148*/	AugRestrHandToHand,
+/*9141*/	AugRestr2HSlash,
+/*9142*/	AugRestr2HBlunt,
+/*9143*/	AugRestr2HPierce,
+/*9144*/	AugRestrBows,
+/*9145*/	AugRestrShields,
+/*8052*/	AugRestr1HSlash1HBluntOrHandToHand,
+/*9200*/	AugRestr1HBluntOrHandToHand,		// no listed peq entries
+
+// these three appear to be post-RoF (12-10-2012) and can not be verified until RoF (05-10-2013) is supported
+/*????*/	AugRestrUnknown1,
+/*????*/	AugRestrUnknown2,
+/*????*/	AugRestrUnknown3,					// last value in peq entries
+			_AugRestrCount
+
+/*4687*/	//AugTypeAllItems, // ?? unknown atm
+/*4688*/	//AugTypePrestige, // ?? unknown atm
+/*4689*/	//AugTypeNonPrestige, // ?? unknown atm
+};
+
+/*
+**	Container use types
+**
+**	This correlates to world 'object.type' (object.h/Object.cpp) as well as Item_Struct.BagType
+**
+**	(ref: database, web forums and eqstr_us.txt)
+*/
+enum ContainerUseTypes : uint8
+{
+/*3400*/	BagTypeSmallBag = 0,
+/*3401*/	BagTypeLargeBag,
+/*3402*/	BagTypeQuiver,
+/*3403*/	BagTypeBeltPouch,
+/*3404*/	BagTypeWristPouch,
+/*3405*/	BagTypeBackPack,
+/*3406*/	BagTypeSmallChest,
+/*3407*/	BagTypeLargeChest,
+/*----*/	BagTypeBandolier,				// <*Database Reference Only>
+/*3408*/	BagTypeMedicineBag,
+/*3409*/	BagTypeToolBox,
+/*3410*/	BagTypeLexicon,
+/*3411*/	BagTypeMortar,
+/*3412*/	BagTypeSelfDusting,				// Quest container (Auto-clear contents?)
+/*3413*/	BagTypeMixingBowl,
+/*3414*/	BagTypeOven,
+/*3415*/	BagTypeSewingKit,
+/*3416*/	BagTypeForge,
+/*3417*/	BagTypeFletchingKit,
+/*3418*/	BagTypeBrewBarrel,
+/*3419*/	BagTypeJewelersKit,
+/*3420*/	BagTypePotteryWheel,
+/*3421*/	BagTypeKiln,
+/*3422*/	BagTypeKeymaker,				// (no database entries as of peq rev 69)
+/*3423*/	BagTypeWizardsLexicon,
+/*3424*/	BagTypeMagesLexicon,
+/*3425*/	BagTypeNecromancersLexicon,
+/*3426*/	BagTypeEnchantersLexicon,
+/*----*/	BagTypeUnknown1,				// (a coin pouch/purse?) (no database entries as of peq rev 69)
+/*----*/	BagTypeConcordanceofResearch,	// <*Database Reference Only>
+/*3427*/	BagTypeAlwaysWorks,				// Quest container (Never-fail combines?)
+/*3428*/	BagTypeKoadaDalForge,			// High Elf
+/*3429*/	BagTypeTeirDalForge,			// Dark Elf
+/*3430*/	BagTypeOggokForge,				// Ogre
+/*3431*/	BagTypeStormguardForge,			// Dwarf
+/*3432*/	BagTypeAkanonForge,				// Gnome
+/*3433*/	BagTypeNorthmanForge,			// Barbarian
+/*----*/	BagTypeUnknown2,				// (no database entries as of peq rev 69)
+/*3434*/	BagTypeCabilisForge,			// Iksar
+/*3435*/	BagTypeFreeportForge,			// Human 1
+/*3436*/	BagTypeRoyalQeynosForge,		// Human 2
+/*3439*/	BagTypeHalflingTailoringKit,
+/*3438*/	BagTypeErudTailoringKit,
+/*3440*/	BagTypeFierDalTailoringKit,		// Wood Elf
+/*3441*/	BagTypeFierDalFletchingKit,		// Wood Elf
+/*3437*/	BagTypeIksarPotteryWheel,
+/*3442*/	BagTypeTackleBox,
+/*3443*/	BagTypeTrollForge,
+/*3445*/	BagTypeFierDalForge,			// Wood Elf
+/*3444*/	BagTypeValeForge,				// Halfling
+/*3446*/	BagTypeErudForge,
+/*----*/	BagTypeTradersSatchel,			// <*Database Reference Only> (db: Yellow Trader's Satchel Token?)
+/*5785*/	BagTypeGuktaForge,				// Froglok (no database entries as of peq rev 69)
+/*3359*/	BagTypeAugmentationSealer,
+/*----*/	BagTypeIceCreamChurn,			// <*Database Reference Only>
+/*6325*/	BagTypeTransformationmold,		// Ornamentation
+/*6340*/	BagTypeDetransformationmold,	// Ornamentation Stripper
+/*5400*/	BagTypeUnattuner,
+/*7684*/	BagTypeTradeskillBag,
+/*7692*/	BagTypeCollectibleBag,
+/*----*/	_BagTypeCount
+};
+
+/*
+** Item Effect Types
+**
+*/
+enum {
+	ET_CombatProc = 0,
+	ET_ClickEffect = 1,
+	ET_WornEffect = 2,
+	ET_Expendable = 3,
+	ET_EquipClick = 4,
+	ET_ClickEffect2 = 5,	//name unknown
+	ET_Focus = 6,
+	ET_Scroll = 7
+};
+
+//SpawnAppearance types:
+#define AT_Die			0	// this causes the client to keel over and zone to bind point
+#define AT_WhoLevel		1	// the level that shows up on /who
+#define AT_Invis		3	// 0 = visible, 1 = invisible
+#define AT_PVP			4	// 0 = blue, 1 = pvp (red)
+#define AT_Light		5	// light type emitted by player (lightstone, shiny shield)
+#define AT_Anim			14	// 100=standing, 110=sitting, 111=ducking, 115=feigned, 105=looting
+#define AT_Sneak		15	// 0 = normal, 1 = sneaking
+#define AT_SpawnID		16	// server to client, sets player spawn id
+#define AT_HP			17	// Client->Server, my HP has changed (like regen tic)
+#define AT_Linkdead		18	// 0 = normal, 1 = linkdead
+#define AT_Levitate		19	// 0=off, 1=flymode, 2=levitate
+#define AT_GM			20	// 0 = normal, 1 = GM - all odd numbers seem to make it GM
+#define AT_Anon			21	// 0 = normal, 1 = anon, 2 = roleplay
+#define AT_GuildID		22
+#define AT_GuildRank	23	// 0=member, 1=officer, 2=leader
+#define AT_AFK			24	// 0 = normal, 1 = afk
+#define AT_Pet			25	// Param is EntityID of owner, or 0 for when charm breaks
+#define AT_Split		28	// 0 = normal, 1 = autosplit on
+#define AT_Size			29	// spawn's size
+#define AT_NPCName		31	// change PC's name's color to NPC color 0 = normal, 1 = npc name
+#define AT_ShowHelm		43	// 0 = do not show helmet graphic, 1 = show graphic
+#define AT_DamageState	44	// The damage state of a destructible object (0 through 4)
+//#define AT_Trader		300	// Bazzar Trader Mode
 
 // animations for AT_Anim
 #define ANIM_FREEZE	102
@@ -174,40 +472,15 @@ typedef enum {
 #define MT_StrikeThrough		339
 #define MT_Stun					340
 
-// TODO: Really should combine above and below into one
-
 //from showeq
 enum ChatColor
 {
-	/*
 	CC_Default					= 0,
 	CC_DarkGrey					= 1,
 	CC_DarkGreen				= 2,
 	CC_DarkBlue					= 3,
 	CC_Purple					= 5,
 	CC_LightGrey				= 6,
-	*/
-
-	CC_WhiteSmoke				= 0,	// FF|F0F0F0
-	CC_Green					= 2,	// FF|008000
-	CC_BrightBlue				= 3,	// FF|0040FF
-	CC_Magenta					= 5,	// FF|F000F0
-	CC_Gray						= 6,	// FF|808080
-	CC_LightGray				= 7,	// FF|E0E0E0
-	//CC_WhiteSmoke2				= 10,	// FF|F0F0F0
-	CC_DarkGray					= 12,	// FF|A0A0A0
-	CC_Red						= 13,	// FF|F00000
-	CC_Lime						= 14,	// FF|00F000
-	CC_Yellow					= 15,	// FF|F0F000
-	CC_Blue						= 16,	// FF|0000F0
-	CC_LightNavy				= 17,	// FF|0000AF
-	CC_Cyan						= 18,	// FF|00F0F0
-	CC_Black					= 20,	// FF|000000
-	
-	// any index <= 255 that is not defined above
-	CC_DimGray					= 1,	// FF|606060
-	CC_Default					= 1,
-
 	CC_User_Say					= 256,
 	CC_User_Tell				= 257,
 	CC_User_Group				= 258,
@@ -403,7 +676,7 @@ static const uint8 DamageTypeUnknown	= 0xFF;
 **
 **	(indexed by 'Skill' of SkillUseTypes)
 */
-static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
+static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
 {
 /*1HBlunt*/					0,
 /*1HSlashing*/				1,
@@ -479,10 +752,29 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 /*Intimidation*/			DamageTypeUnknown,
 /*Berserking*/				DamageTypeUnknown,
 /*Taunt*/					DamageTypeUnknown,
-/*Frenzy*/					74,
-/*RemoveTrap*/				DamageTypeUnknown,	// Needs research (set for SenseTrap value)
-/*TripleAttack*/			DamageTypeUnknown,	// Needs research (set for DoubleAttack value)
-/*2HPiercing*/				36					// Needs research (set for 1HPiercing value - similar to slash/blunt)
+/*Frenzy*/					74 //,
+// /*RemoveTrap*/				DamageTypeUnknown,	// Needs research (set for SenseTrap value)
+// /*TripleAttack*/			DamageTypeUnknown,	// Needs research (set for DoubleAttack value)
+// /*2HPiercing*/				36					// Needs research (set for 1HPiercing value - similar to slash/blunt)
+};
+
+/*
+**	Material use slots
+**
+*/
+enum MaterialUseSlots : uint8
+{
+	MaterialHead = 0,
+	MaterialChest,
+	MaterialArms,
+	MaterialWrist,
+	MaterialHands,
+	MaterialLegs,
+	MaterialFeet,
+	MaterialPrimary,
+	MaterialSecondary,
+	_MaterialCount,
+	_MaterialInvalid = 255
 };
 
 /*
@@ -519,8 +811,164 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 **
 */
 
+enum InventoryMapTypes : int16 {
+	MapPossessions = 0,
+	MapBank,
+	MapSharedBank,
+	MapTrade,
+	MapWorld,
+	MapLimbo,
+	MapTribute,
+	MapTrophyTribute,
+	MapGuildTribute,
+	MapMerchant,
+	MapDeleted,
+	MapCorpse,
+	MapBazaar,
+	MapInspect,
+	MapRealEstate,
+	MapViewMODPC,
+	MapViewMODBank,
+	MapViewMODSharedBank,
+	MapViewMODLimbo,
+	MapAltStorage,
+	MapArchived,
+	MapMail,
+	MapGuildTrophyTribute,
+	MapKrono,
+	MapOther,
+	_MapCount
+};
+
+enum InventoryMainTypes : int16 {
+	MainCharm = 0,
+	MainEar1,
+	MainHead,
+	MainFace,
+	MainEar2,
+	MainNeck,
+	MainShoulders,
+	MainArms,
+	MainBack,
+	MainWrist1,
+	MainWrist2,
+	MainRange,
+	MainHands,
+	MainPrimary,
+	MainSecondary,
+	MainFinger1,
+	MainFinger2,
+	MainChest,
+	MainLegs,
+	MainFeet,
+	MainWaist,
+	MainPowerSource = 9999, // temp
+	MainAmmo = 21, // temp
+	MainGeneral1,
+	MainGeneral2,
+	MainGeneral3,
+	MainGeneral4,
+	MainGeneral5,
+	MainGeneral6,
+	MainGeneral7,
+	MainGeneral8,
+	//MainGeneral9,
+	//MainGeneral10,
+	MainCursor,
+	_MainCount
+};
+
 #define INVALID_INDEX	-1
+#define NOT_USED		0
+#define NO_ITEM			0
+
+// yes..these are redundant... but, they help to identify and define what is actually being performed
+// plus, since they're pre-op's, they don't affect the actual binary size
+#define MAP_BEGIN	0
+#define MAIN_BEGIN	0
+#define SUB_BEGIN	0
+#define AUG_BEGIN	0
+
+namespace legacy {
+	// this is for perl and other legacy systems
+
+	typedef enum {
+		SLOT_CHARM			= 0,
+		SLOT_EAR01			= 1,
+		SLOT_HEAD			= 2,
+		SLOT_FACE			= 3,
+		SLOT_EAR02			= 4,
+		SLOT_NECK			= 5,
+		SLOT_SHOULDER		= 6,
+		SLOT_ARMS			= 7,
+		SLOT_BACK			= 8,
+		SLOT_BRACER01		= 9,
+		SLOT_BRACER02		= 10,
+		SLOT_RANGE			= 11,
+		SLOT_HANDS			= 12,
+		SLOT_PRIMARY		= 13,
+		SLOT_SECONDARY		= 14,
+		SLOT_RING01			= 15,
+		SLOT_RING02			= 16,
+		SLOT_CHEST			= 17,
+		SLOT_LEGS			= 18,
+		SLOT_FEET			= 19,
+		SLOT_WAIST			= 20,
+		SLOT_POWER_SOURCE	= 9999,
+		SLOT_AMMO			= 21,
+		SLOT_GENERAL_1		= 22,
+		SLOT_GENERAL_2		= 23,
+		SLOT_GENERAL_3		= 24,
+		SLOT_GENERAL_4		= 25,
+		SLOT_GENERAL_5		= 26,
+		SLOT_GENERAL_6		= 27,
+		SLOT_GENERAL_7		= 28,
+		SLOT_GENERAL_8		= 29,
+		//SLOT_GENERAL_9	= not supported
+		//SLOT_GENERAL_10	= not supported
+		SLOT_CURSOR			= 30,
+		SLOT_CURSOR_END		= (int16)0xFFFE, // I hope no one is using this...
+		SLOT_TRADESKILL		= 1000,
+		SLOT_AUGMENT		= 1001,
+		SLOT_INVALID		= (int16)0xFFFF,
+
+		SLOT_POSSESSIONS_BEGIN	= 0,
+		SLOT_POSSESSIONS_END	= 30,
+
+		SLOT_EQUIPMENT_BEGIN	= 0,
+		SLOT_EQUIPMENT_END		= 21,
+
+		SLOT_PERSONAL_BEGIN		= 22,
+		SLOT_PERSONAL_END		= 29,
+		SLOT_PERSONAL_BAGS_BEGIN	= 251,
+		SLOT_PERSONAL_BAGS_END		= 330,
+
+		SLOT_CURSOR_BAG_BEGIN		= 331,
+		SLOT_CURSOR_BAG_END			= 340,
+
+		SLOT_TRIBUTE_BEGIN	= 400,
+		SLOT_TRIBUTE_END	= 404,
+
+		SLOT_BANK_BEGIN			= 2000,
+		SLOT_BANK_END			= 2023,
+		SLOT_BANK_BAGS_BEGIN	= 2031,
+		SLOT_BANK_BAGS_END		= 2270,
+
+		SLOT_SHARED_BANK_BEGIN		= 2500,
+		SLOT_SHARED_BANK_END		= 2501,
+		SLOT_SHARED_BANK_BAGS_BEGIN	= 2531,
+		SLOT_SHARED_BANK_BAGS_END	= 2550,
+
+		SLOT_TRADE_BEGIN		= 3000,
+		SLOT_TRADE_END			= 3007,
+		SLOT_TRADE_BAGS_BEGIN	= 3031,
+		SLOT_TRADE_BAGS_END		= 3110,
+
+		SLOT_WORLD_BEGIN	= 4000,
+		SLOT_WORLD_END		= 4009
+	} InventorySlot;
+}
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
-#endif /*COMMON_EQ_CONSTANTS_H*/
+#endif

common/eq_dictionary.cpp

@@ -0,0 +1,956 @@
+/*
+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
+
+*/
+
+#include "eq_dictionary.h"
+#include "string_util.h"
+
+//
+// class EmuConstants
+//
+uint16 EmuConstants::InventoryMapSize(int16 indexMap) {
+	switch (indexMap) {
+	case MapPossessions:
+		return MAP_POSSESSIONS_SIZE;
+	case MapBank:
+		return MAP_BANK_SIZE;
+	case MapSharedBank:
+		return MAP_SHARED_BANK_SIZE;
+	case MapTrade:
+		return MAP_TRADE_SIZE;
+	case MapWorld:
+		return MAP_WORLD_SIZE;
+	case MapLimbo:
+		return MAP_LIMBO_SIZE;
+	case MapTribute:
+		return MAP_TRIBUTE_SIZE;
+	case MapTrophyTribute:
+		return MAP_TROPHY_TRIBUTE_SIZE;
+	case MapGuildTribute:
+		return MAP_GUILD_TRIBUTE_SIZE;
+	case MapMerchant:
+		return MAP_MERCHANT_SIZE;
+	case MapDeleted:
+		return MAP_DELETED_SIZE;
+	case MapCorpse:
+		return MAP_CORPSE_SIZE;
+	case MapBazaar:
+		return MAP_BAZAAR_SIZE;
+	case MapInspect:
+		return MAP_INSPECT_SIZE;
+	case MapRealEstate:
+		return MAP_REAL_ESTATE_SIZE;
+	case MapViewMODPC:
+		return MAP_VIEW_MOD_PC_SIZE;
+	case MapViewMODBank:
+		return MAP_VIEW_MOD_BANK_SIZE;
+	case MapViewMODSharedBank:
+		return MAP_VIEW_MOD_SHARED_BANK_SIZE;
+	case MapViewMODLimbo:
+		return MAP_VIEW_MOD_LIMBO_SIZE;
+	case MapAltStorage:
+		return MAP_ALT_STORAGE_SIZE;
+	case MapArchived:
+		return MAP_ARCHIVED_SIZE;
+	case MapMail:
+		return MAP_MAIL_SIZE;
+	case MapGuildTrophyTribute:
+		return MAP_GUILD_TROPHY_TRIBUTE_SIZE;
+	case MapKrono:
+		return MAP_KRONO_SIZE;
+	case MapOther:
+		return MAP_OTHER_SIZE;
+	default:
+		return NOT_USED;
+	}
+}
+
+/*
+std::string EmuConstants::InventoryLocationName(Location_Struct location) {
+	// not ready for implementation...
+	std::string ret_str;
+	StringFormat(ret_str, "%s, %s, %s, %s", InventoryMapName(location.map), InventoryMainName(location.main), InventorySubName(location.sub), InventoryAugName(location.aug));
+	return  ret_str;
+}
+*/
+
+std::string EmuConstants::InventoryMapName(int16 indexMap) {
+	switch (indexMap) {
+	case INVALID_INDEX:
+		return "Invalid Map";
+	case MapPossessions:
+		return "Possessions";
+	case MapBank:
+		return "Bank";
+	case MapSharedBank:
+		return "Shared Bank";
+	case MapTrade:
+		return "Trade";
+	case MapWorld:
+		return "World";
+	case MapLimbo:
+		return "Limbo";
+	case MapTribute:
+		return "Tribute";
+	case MapTrophyTribute:
+		return "Trophy Tribute";
+	case MapGuildTribute:
+		return "Guild Tribute";
+	case MapMerchant:
+		return "Merchant";
+	case MapDeleted:
+		return "Deleted";
+	case MapCorpse:
+		return "Corpse";
+	case MapBazaar:
+		return "Bazaar";
+	case MapInspect:
+		return "Inspect";
+	case MapRealEstate:
+		return "Real Estate";
+	case MapViewMODPC:
+		return "View MOD PC";
+	case MapViewMODBank:
+		return "View MOD Bank";
+	case MapViewMODSharedBank:
+		return "View MOD Shared Bank";
+	case MapViewMODLimbo:
+		return "View MOD Limbo";
+	case MapAltStorage:
+		return "Alt Storage";
+	case MapArchived:
+		return "Archived";
+	case MapMail:
+		return "Mail";
+	case MapGuildTrophyTribute:
+		return "Guild Trophy Tribute";
+	case MapKrono:
+		return "Krono";
+	case MapOther:
+		return "Other";
+	default:
+		return "Unknown Map";
+	}
+}
+
+std::string EmuConstants::InventoryMainName(int16 indexMain) {
+	switch (indexMain) {
+	case INVALID_INDEX:
+		return "Invalid Main";
+	case MainCharm:
+		return "Charm";
+	case MainEar1:
+		return "Ear 1";
+	case MainHead:
+		return "Head";
+	case MainFace:
+		return "Face";
+	case MainEar2:
+		return "Ear 2";
+	case MainNeck:
+		return "Neck";
+	case MainShoulders:
+		return "Shoulders";
+	case MainArms:
+		return "Arms";
+	case MainBack:
+		return "Back";
+	case MainWrist1:
+		return "Wrist 1";
+	case MainWrist2:
+		return "Wrist 2";
+	case MainRange:
+		return "Range";
+	case MainHands:
+		return "Hands";
+	case MainPrimary:
+		return "Primary";
+	case MainSecondary:
+		return "Secondary";
+	case MainFinger1:
+		return "Finger 1";
+	case MainFinger2:
+		return "Finger 2";
+	case MainChest:
+		return "Chest";
+	case MainLegs:
+		return "Legs";
+	case MainFeet:
+		return "Feet";
+	case MainWaist:
+		return "Waist";
+	case MainPowerSource:
+		return "Power Source";
+	case MainAmmo:
+		return "Ammo";
+	case MainGeneral1:
+		return "General 1";
+	case MainGeneral2:
+		return "General 2";
+	case MainGeneral3:
+		return "General 3";
+	case MainGeneral4:
+		return "General 4";
+	case MainGeneral5:
+		return "General 5";
+	case MainGeneral6:
+		return "General 6";
+	case MainGeneral7:
+		return "General 7";
+	case MainGeneral8:
+		return "General 8";
+	/*
+	case MainGeneral9:
+		return "General 9";
+	case MainGeneral10:
+		return "General 10";
+	*/
+	case MainCursor:
+		return "Cursor";
+	default:
+		return "Unknown Main";
+	}
+}
+
+std::string EmuConstants::InventorySubName(int16 indexSub) {
+	if (indexSub == INVALID_INDEX)
+		return "Invalid Sub";
+
+	if ((uint16)indexSub >= ITEM_CONTAINER_SIZE)
+		return "Unknown Sub";
+
+	std::string ret_str;
+	ret_str = StringFormat("Container %i", (indexSub + 1)); // zero-based index..but, count starts at one
+
+	return ret_str;
+}
+
+std::string EmuConstants::InventoryAugName(int16 indexAug) {
+	if (indexAug == INVALID_INDEX)
+		return "Invalid Aug";
+
+	if ((uint16)indexAug >= ITEM_COMMON_SIZE)
+		return "Unknown Aug";
+
+	std::string ret_str;
+	ret_str = StringFormat("Augment %i", (indexAug + 1)); // zero-based index..but, count starts at one
+
+	return ret_str;
+}
+
+
+// 
+// class EQLimits
+//
+// client validation
+bool EQLimits::IsValidPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidatePCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// npc validation
+bool EQLimits::IsValidNPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidateNPCClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// mob validation
+bool EQLimits::IsValidMobClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
+		return true;
+
+	return false;
+}
+
+ClientVersion EQLimits::ValidateMobClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
+}
+
+// inventory
+uint16 EQLimits::InventoryMapSize(int16 indexMap, ClientVersion clientVersion) {
+	// not all maps will have an instantiated container..some are references for queue generators (i.e., bazaar, mail, etc...)
+	// a zero '0' indicates a needed value..otherwise, change to '_NOTUSED' for a null value so indices requiring research can be identified
+	// ALL of these values need to be verified before pushing to live
+	//
+	// make sure that you transcribe the actual value from 'defaults' to here before updating or client crashes will ensue..and/or...
+	// insert older clients inside of the progression of client order
+	//
+	// MAP_POSSESSIONS_SIZE does not reflect all actual <client>_constants size due to bitmask-use compatibility
+	//
+	// when setting NPC-based values, try to adhere to an EmuConstants::<property> or NOT_USED value to avoid unnecessary issues
+
+	static const uint16 local[_MapCount][CLIENT_VERSION_COUNT] = {
+		// server and database are sync'd to current MapPossessions's client as set in 'using namespace RoF::slots;' and
+		// 'EmuConstants::MAP_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask()
+		// for partial range validation checks and 'EmuConstants::MAP_POSSESSIONS_SIZE' for full range iterations
+		{ // local[MainPossessions]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Titanium*/	EmuConstants::MAP_POSSESSIONS_SIZE,
+/*SoF*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*SoD*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Underfoot*/	EmuConstants::MAP_POSSESSIONS_SIZE,
+/*RoF*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*RoF2*/		EmuConstants::MAP_POSSESSIONS_SIZE,
+
+/*NPC*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Merc*/		EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Bot*/			EmuConstants::MAP_POSSESSIONS_SIZE,
+/*Pet*/			EmuConstants::MAP_POSSESSIONS_SIZE
+		},
+		{ // local[MapBank]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_BANK_SIZE,
+/*SoF*/			EmuConstants::MAP_BANK_SIZE,
+/*SoD*/			EmuConstants::MAP_BANK_SIZE,
+/*Underfoot*/	EmuConstants::MAP_BANK_SIZE,
+/*RoF*/			EmuConstants::MAP_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_BANK_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapSharedBank]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*Titanium*/	EmuConstants::MAP_SHARED_BANK_SIZE,
+/*SoF*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*SoD*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*Underfoot*/	EmuConstants::MAP_SHARED_BANK_SIZE,
+/*RoF*/			EmuConstants::MAP_SHARED_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_SHARED_BANK_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapTrade]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_TRADE_SIZE,
+/*Titanium*/	EmuConstants::MAP_TRADE_SIZE,
+/*SoF*/			EmuConstants::MAP_TRADE_SIZE,
+/*SoD*/			EmuConstants::MAP_TRADE_SIZE,
+/*Underfoot*/	EmuConstants::MAP_TRADE_SIZE,
+/*RoF*/			EmuConstants::MAP_TRADE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TRADE_SIZE,
+
+/*NPC*/			4,
+/*Merc*/		4,
+/*Bot*/			EmuConstants::MAP_TRADE_SIZE, // client thinks this is another client
+/*Pet*/			4
+		},
+		{ // local[MapWorld]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_WORLD_SIZE,
+/*Titanium*/	EmuConstants::MAP_WORLD_SIZE,
+/*SoF*/			EmuConstants::MAP_WORLD_SIZE,
+/*SoD*/			EmuConstants::MAP_WORLD_SIZE,
+/*Underfoot*/	EmuConstants::MAP_WORLD_SIZE,
+/*RoF*/			EmuConstants::MAP_WORLD_SIZE,
+/*RoF2*/		EmuConstants::MAP_WORLD_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapLimbo]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_LIMBO_SIZE,
+/*Titanium*/	EmuConstants::MAP_LIMBO_SIZE,
+/*SoF*/			EmuConstants::MAP_LIMBO_SIZE,
+/*SoD*/			EmuConstants::MAP_LIMBO_SIZE,
+/*Underfoot*/	EmuConstants::MAP_LIMBO_SIZE,
+/*RoF*/			EmuConstants::MAP_LIMBO_SIZE,
+/*RoF2*/		EmuConstants::MAP_LIMBO_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*Titanium*/	EmuConstants::MAP_TRIBUTE_SIZE,
+/*SoF*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*SoD*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*Underfoot*/	EmuConstants::MAP_TRIBUTE_SIZE,
+/*RoF*/			EmuConstants::MAP_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapTrophyTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_TROPHY_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_TROPHY_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapGuildTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_GUILD_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_GUILD_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapMerchant]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_MERCHANT_SIZE,
+/*RoF2*/		EmuConstants::MAP_MERCHANT_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapDeleted]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_DELETED_SIZE,
+/*RoF2*/		EmuConstants::MAP_DELETED_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapCorpse]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_CORPSE_SIZE,
+/*SoF*/			SoF::consts::MAP_CORPSE_SIZE,
+/*SoD*/			SoD::consts::MAP_CORPSE_SIZE,
+/*Underfoot*/	UF::consts::MAP_CORPSE_SIZE,
+/*RoF*/			RoF::consts::MAP_CORPSE_SIZE,
+/*RoF2*/		RoF2::consts::MAP_CORPSE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapBazaar]
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*Titanium*/	EmuConstants::MAP_BAZAAR_SIZE,
+/*SoF*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*SoD*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*Underfoot*/	EmuConstants::MAP_BAZAAR_SIZE,
+/*RoF*/			EmuConstants::MAP_BAZAAR_SIZE,
+/*RoF2*/		EmuConstants::MAP_BAZAAR_SIZE,
+
+/*NPC*/			0, // this may need to be 'EmuConstants::MAP_BAZAAR_SIZE' if offline client traders respawn as an npc
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapInspect]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	Titanium::consts::MAP_INSPECT_SIZE,
+/*SoF*/			SoF::consts::MAP_INSPECT_SIZE,
+/*SoD*/			SoD::consts::MAP_INSPECT_SIZE,
+/*Underfoot*/	UF::consts::MAP_INSPECT_SIZE,
+/*RoF*/			RoF::consts::MAP_INSPECT_SIZE,
+/*RoF2*/		RoF2::consts::MAP_INSPECT_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+		},
+		{ // local[MapRealEstate]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_REAL_ESTATE_SIZE,
+/*RoF2*/		EmuConstants::MAP_REAL_ESTATE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODPC]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_PC_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_PC_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODBank]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_BANK_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODSharedBank]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_SHARED_BANK_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_SHARED_BANK_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapViewMODLimbo]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_VIEW_MOD_LIMBO_SIZE,
+/*RoF2*/		EmuConstants::MAP_VIEW_MOD_LIMBO_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapAltStorage]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_ALT_STORAGE_SIZE,
+/*RoF2*/		EmuConstants::MAP_ALT_STORAGE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapArchived]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_ARCHIVED_SIZE,
+/*RoF2*/		EmuConstants::MAP_ARCHIVED_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapMail]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_MAIL_SIZE,
+/*RoF2*/		EmuConstants::MAP_MAIL_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapGuildTrophyTribute]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_GUILD_TROPHY_TRIBUTE_SIZE,
+/*RoF2*/		EmuConstants::MAP_GUILD_TROPHY_TRIBUTE_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapKrono]
+/*Unknown*/		NOT_USED,
+/*62*/			NOT_USED,
+/*Titanium*/	NOT_USED,
+/*SoF*/			NOT_USED,
+/*SoD*/			NOT_USED,
+/*Underfoot*/	NOT_USED,
+/*RoF*/			EmuConstants::MAP_KRONO_SIZE,
+/*RoF2*/		EmuConstants::MAP_KRONO_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		},
+		{ // local[MapOther]
+/*Unknown*/		NOT_USED,
+/*62*/			0,
+/*Titanium*/	0,
+/*SoF*/			0,
+/*SoD*/			0,
+/*Underfoot*/	0,
+/*RoF*/			EmuConstants::MAP_OTHER_SIZE,
+/*RoF2*/		EmuConstants::MAP_OTHER_SIZE,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+		}
+	};
+
+	if ((uint16)indexMap < _MapCount)
+		return local[indexMap][static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+
+	return NOT_USED;
+}
+
+uint64 EQLimits::PossessionsBitmask(ClientVersion clientVersion) {
+	// these are for the new inventory system (RoF)..not the current (Ti) one...
+	// 0x0000000000200000 is SlotPowerSource (SoF+)
+	// 0x0000000080000000 is SlotGeneral9 (RoF+)
+	// 0x0000000100000000 is SlotGeneral10 (RoF+)
+
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x000000027FDFFFFF,
+/*Titanium*/	0x000000027FDFFFFF,
+/*SoF*/			0x000000027FFFFFFF,
+/*SoD*/			0x000000027FFFFFFF,
+/*Underfoot*/	0x000000027FFFFFFF,
+/*RoF*/			0x00000003FFFFFFFF,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::EquipmentBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x00000000005FFFFF,
+/*Titanium*/	0x00000000005FFFFF,
+/*SoF*/			0x00000000007FFFFF,
+/*SoD*/			0x00000000007FFFFF,
+/*Underfoot*/	0x00000000007FFFFF,
+/*RoF*/			0x00000000007FFFFF,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::GeneralBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x000000007F800000,
+/*Titanium*/	0x000000007F800000,
+/*SoF*/			0x000000007F800000,
+/*SoD*/			0x000000007F800000,
+/*Underfoot*/	0x000000007F800000,
+/*RoF*/			0x00000001FF800000,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint64 EQLimits::CursorBitmask(ClientVersion clientVersion) {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			0x0000000200000000,
+/*Titanium*/	0x0000000200000000,
+/*SoF*/			0x0000000200000000,
+/*SoD*/			0x0000000200000000,
+/*Underfoot*/	0x0000000200000000,
+/*RoF*/			0x0000000200000000,
+/*RoF2*/		0,
+
+/*NPC*/			0,
+/*Merc*/		0,
+/*Bot*/			0,
+/*Pet*/			0
+	};
+
+	return NOT_USED;
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::AllowsEmptyBagInBag(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		false,
+/*62*/			false,
+/*Titanium*/	Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*SoF*/			SoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*SoD*/			SoD::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*RoF*/			RoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*RoF2*/		RoF2::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+
+/*NPC*/			false,
+/*Merc*/		false,
+/*Bot*/			false,
+/*Pet*/			false
+	};
+
+	return false; // not implemented
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::AllowsClickCastFromBag(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		false,
+/*62*/			false,
+/*Titanium*/	Titanium::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*SoF*/			SoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*SoD*/			SoD::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*RoF*/			RoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*RoF2*/		RoF2::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+
+/*NPC*/			false,
+/*Merc*/		false,
+/*Bot*/			false,
+/*Pet*/			false
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+// items
+uint16 EQLimits::ItemCommonSize(ClientVersion clientVersion) {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Titanium*/	EmuConstants::ITEM_COMMON_SIZE,
+/*SoF*/			EmuConstants::ITEM_COMMON_SIZE,
+/*SoD*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Underfoot*/	EmuConstants::ITEM_COMMON_SIZE,
+/*RoF*/			EmuConstants::ITEM_COMMON_SIZE,
+/*RoF2*/		EmuConstants::ITEM_COMMON_SIZE,
+
+/*NPC*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Merc*/		EmuConstants::ITEM_COMMON_SIZE,
+/*Bot*/			EmuConstants::ITEM_COMMON_SIZE,
+/*Pet*/			EmuConstants::ITEM_COMMON_SIZE
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint16 EQLimits::ItemContainerSize(ClientVersion clientVersion) {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Titanium*/	EmuConstants::ITEM_CONTAINER_SIZE,
+/*SoF*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*SoD*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Underfoot*/	EmuConstants::ITEM_CONTAINER_SIZE,
+/*RoF*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*RoF2*/		EmuConstants::ITEM_CONTAINER_SIZE,
+
+/*NPC*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Merc*/		EmuConstants::ITEM_CONTAINER_SIZE,
+/*Bot*/			EmuConstants::ITEM_CONTAINER_SIZE,
+/*Pet*/			EmuConstants::ITEM_CONTAINER_SIZE
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+bool EQLimits::CoinHasWeight(ClientVersion clientVersion) {
+	static const bool local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		true,
+/*62*/			true,
+/*Titanium*/	Titanium::limits::COIN_HAS_WEIGHT,
+/*SoF*/			SoF::limits::COIN_HAS_WEIGHT,
+/*SoD*/			SoD::limits::COIN_HAS_WEIGHT,
+/*Underfoot*/	UF::limits::COIN_HAS_WEIGHT,
+/*RoF*/			RoF::limits::COIN_HAS_WEIGHT,
+/*RoF2*/		RoF::limits::COIN_HAS_WEIGHT,
+
+/*NPC*/			true,
+/*Merc*/		true,
+/*Bot*/			true,
+/*Pet*/			true
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::BandoliersCount(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::BANDOLIERS_COUNT,
+/*Titanium*/	EmuConstants::BANDOLIERS_COUNT,
+/*SoF*/			EmuConstants::BANDOLIERS_COUNT,
+/*SoD*/			EmuConstants::BANDOLIERS_COUNT,
+/*Underfoot*/	EmuConstants::BANDOLIERS_COUNT,
+/*RoF*/			EmuConstants::BANDOLIERS_COUNT,
+/*RoF2*/		EmuConstants::BANDOLIERS_COUNT,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::BandolierSize(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::BANDOLIER_SIZE,
+/*Titanium*/	EmuConstants::BANDOLIER_SIZE,
+/*SoF*/			EmuConstants::BANDOLIER_SIZE,
+/*SoD*/			EmuConstants::BANDOLIER_SIZE,
+/*Underfoot*/	EmuConstants::BANDOLIER_SIZE,
+/*RoF*/			EmuConstants::BANDOLIER_SIZE,
+/*RoF2*/		EmuConstants::BANDOLIER_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+uint32 EQLimits::PotionBeltSize(ClientVersion clientVersion) {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*62*/			EmuConstants::POTION_BELT_SIZE,
+/*Titanium*/	EmuConstants::POTION_BELT_SIZE,
+/*SoF*/			EmuConstants::POTION_BELT_SIZE,
+/*SoD*/			EmuConstants::POTION_BELT_SIZE,
+/*Underfoot*/	EmuConstants::POTION_BELT_SIZE,
+/*RoF*/			EmuConstants::POTION_BELT_SIZE,
+/*RoF2*/		EmuConstants::POTION_BELT_SIZE,
+
+/*NPC*/			NOT_USED,
+/*Merc*/		NOT_USED,
+/*Bot*/			NOT_USED,
+/*Pet*/			NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}

common/eq_dictionary.h

@@ -0,0 +1,209 @@
+/*
+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 EQ_DICTIONARY_H
+#define EQ_DICTIONARY_H
+
+#include "types.h"
+#include "eq_constants.h"
+#include "clientversions.h"
+#include <string>
+#include "../common/patches/titanium_constants.h"
+#include "../common/patches/sof_constants.h"
+#include "../common/patches/sod_constants.h"
+#include "../common/patches/uf_constants.h"
+#include "../common/patches/rof_constants.h"
+#include "../common/patches/rof2_constants.h"
+
+// *** DO NOT CHANGE without a full understanding of the consequences..the server is set up to use these settings explicitly!! ***
+// *** You will cause compilation failures and corrupt your database if partial or incorrect attempts to change them are made!! ***
+
+// Hard-coded values usually indicate that further research is needed and the values given are from the old (known) system
+
+// (future use)
+//using namespace RoF2::maps;	// server inventory maps enumeration (code and database sync'd to reference)
+//using namespace RoF::slots;	// server possessions slots enumeration (code and database sync'd to reference)
+
+class EmuConstants {
+	// an immutable value is required to initialize arrays, etc... use this class as a repository for those
+public:
+	// database
+	static const ClientVersion CHARACTER_CREATION_CLIENT = ClientVersion::RoF2; // adjust according to starting item placement and target client
+
+	// inventory
+	static uint16 InventoryMapSize(int16 indexMap);
+	//static std::string InventoryLocationName(Location_Struct location);
+	static std::string InventoryMapName(int16 indexMap);
+	static std::string InventoryMainName(int16 indexMain);
+	static std::string InventorySubName(int16 indexSub);
+	static std::string InventoryAugName(int16 indexAug);
+
+	// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
+	static const uint16	MAP_POSSESSIONS_SIZE = _MainCount;
+	static const uint16 MAP_BANK_SIZE = 24;
+	static const uint16 MAP_SHARED_BANK_SIZE = 2;
+	static const uint16 MAP_TRADE_SIZE = 8;
+	static const uint16 MAP_WORLD_SIZE = 10;
+	static const uint16 MAP_LIMBO_SIZE = 36;
+	static const uint16 MAP_TRIBUTE_SIZE = 5; // (need client values)
+	static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_MERCHANT_SIZE = 0;
+	static const uint16 MAP_DELETED_SIZE = 0;
+	static const uint16 MAP_CORPSE_SIZE = _MainCount; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
+	static const uint16 MAP_BAZAAR_SIZE = 80;
+	static const uint16 MAP_INSPECT_SIZE = 22;
+	static const uint16 MAP_REAL_ESTATE_SIZE = 0;
+	static const uint16 MAP_VIEW_MOD_PC_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_BANK_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = NOT_USED;
+	static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = NOT_USED;
+	static const uint16 MAP_ALT_STORAGE_SIZE = 0;
+	static const uint16 MAP_ARCHIVED_SIZE = 0;
+	static const uint16 MAP_MAIL_SIZE = 0;
+	static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
+	static const uint16 MAP_KRONO_SIZE = 0;
+	static const uint16 MAP_OTHER_SIZE = 0;
+
+	// most of these definitions will go away with the structure-based system..this maintains compatibility for now
+	// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
+	static const int16 EQUIPMENT_BEGIN = MainCharm;
+	static const int16 EQUIPMENT_END = MainAmmo;
+	static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
+
+	static const int16 GENERAL_BEGIN = MainGeneral1;
+	static const int16 GENERAL_END = MainGeneral8;
+	static const uint16 GENERAL_SIZE = 8;
+	static const int16 GENERAL_BAGS_BEGIN = 251;
+	static const int16 GENERAL_BAGS_END_OFFSET = 79;
+	static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
+
+	static const int16 CURSOR_BAG_BEGIN = 331;
+	static const int16 CURSOR_BAG_END_OFFSET = 9;
+	static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
+
+	static const int16 BANK_BEGIN = 2000;
+	static const int16 BANK_END = 2023;
+	static const int16 BANK_BAGS_BEGIN = 2031;
+	static const int16 BANK_BAGS_END_OFFSET = 239;
+	static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
+
+	static const int16 SHARED_BANK_BEGIN = 2500;
+	static const int16 SHARED_BANK_END = 2501;
+	static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
+	static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
+	static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
+
+	static const int16 TRADE_BEGIN = 3000;
+	static const int16 TRADE_END = 3007;
+	static const int16 TRADE_NPC_END = 3003;
+	static const int16 TRADE_BAGS_BEGIN = 3031;
+	static const int16 TRADE_BAGS_END_OFFSET = 79;
+	static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
+
+	static const int16 WORLD_BEGIN = 4000;
+	static const int16 WORLD_END = 4009;
+	static const int16 WORLD_SIZE = MAP_WORLD_SIZE;
+
+	static const int16 TRIBUTE_BEGIN = 400;
+	static const int16 TRIBUTE_END = 404;
+	static const int16 TRIBUTE_SIZE = MAP_TRIBUTE_SIZE;
+
+	static const int16 CORPSE_BEGIN = 22;
+	//static const int16 CORPSE_END = RoF::consts::CORPSE_END; // not ready for use
+
+	static const int16 MATERIAL_BEGIN = MaterialHead;
+	static const int16 MATERIAL_END = MaterialSecondary;
+	static const int16 MATERIAL_TINT_END = MaterialFeet;
+	static const int16 MATERIAL_SIZE = _MaterialCount;
+
+	// items
+	// common and container sizes will not increase until the new 'location' struct is implemented
+	static const uint16 ITEM_COMMON_SIZE = RoF::consts::ITEM_COMMON_SIZE;
+	static const uint16 ITEM_CONTAINER_SIZE = Titanium::consts::ITEM_CONTAINER_SIZE;
+
+	// player profile
+	//static const uint32 CLASS_BITMASK = 0;	// needs value
+	//static const uint32 RACE_BITMASK = 0;	// needs value
+
+	// BANDOLIERS_COUNT sets maximum limit..active limit will need to be handled by the appropriate AA
+	static const uint32 BANDOLIERS_COUNT = Titanium::consts::BANDOLIERS_COUNT;	// count = number of bandolier instances
+	static const uint32 BANDOLIER_SIZE = Titanium::consts::BANDOLIER_SIZE;		// size = number of equipment slots in bandolier instance
+	static const uint32 POTION_BELT_SIZE = Titanium::consts::POTION_BELT_SIZE;
+
+	static const size_t TEXT_LINK_BODY_LENGTH = 56;
+
+	// legacy-related functions
+	//static int ServerToPerlSlot(int slot);	// encode
+	//static int PerlToServerSlot(int slot);	// decode
+};
+
+class EQLimits {
+	// values should default to a non-beneficial value..unless value conflicts with intended operation
+	//
+	// EmuConstants may be used as references..but, not every reference needs to be in EmuConstants (i.e., AllowsEmptyBagInBag(), CoinHasWeight(), etc...)
+public:
+	// client version validation (checks to avoid crashing zone server when accessing reference arrays)
+	// use this inside of class Client (limits to actual clients)
+	static bool IsValidPCClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidatePCClientVersion(ClientVersion clientVersion);
+
+	// basically..any non-client classes - do not when setting a valid client
+	static bool IsValidNPCClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidateNPCClientVersion(ClientVersion clientVersion);
+
+	// these are 'universal' - do not when setting a valid client
+	static bool IsValidMobClientVersion(ClientVersion clientVersion);
+	static ClientVersion ValidateMobClientVersion(ClientVersion clientVersion);
+
+	// inventory
+	static uint16 InventoryMapSize(int16 indexMap, ClientVersion clientVersion);
+	static uint64 PossessionsBitmask(ClientVersion clientVersion);
+	static uint64 EquipmentBitmask(ClientVersion clientVersion);
+	static uint64 GeneralBitmask(ClientVersion clientVersion);
+	static uint64 CursorBitmask(ClientVersion clientVersion);
+
+	static bool AllowsEmptyBagInBag(ClientVersion clientVersion);
+	static bool AllowsClickCastFromBag(ClientVersion clientVersion);
+
+	// items
+	static uint16 ItemCommonSize(ClientVersion clientVersion);
+	static uint16 ItemContainerSize(ClientVersion clientVersion);
+
+	// player profile
+	static bool CoinHasWeight(ClientVersion clientVersion);
+
+	static uint32 BandoliersCount(ClientVersion clientVersion);
+	static uint32 BandolierSize(ClientVersion clientVersion);
+
+	static uint32 PotionBeltSize(ClientVersion clientVersion);
+};
+
+#endif /* EQ_DICTIONARY_H */
+
+/*
+Working Notes:
+--------------
+
+- full review of client_packet.cpp and client translators needed
+
+
+*/

common/eq_limits.cpp

@@ -1,983 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_constants.h"
-#include "emu_limits.h"
-
-
-static const EQEmu::constants::LookupEntry constants_lookup_entries[EQEmu::versions::ClientVersionCount] =
-{
-	{
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null
-	},
-	{
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null
-	},
-	{
-		Titanium::constants::CharacterCreationLimit,
-		Titanium::constants::LongBuffs,
-		Titanium::constants::ShortBuffs,
-		Titanium::constants::DiscBuffs,
-		Titanium::constants::TotalBuffs,
-		Titanium::constants::NPCBuffs,
-		Titanium::constants::PetBuffs,
-		Titanium::constants::MercBuffs
-	},
-	{
-		SoF::constants::CharacterCreationLimit,
-		SoF::constants::LongBuffs,
-		SoF::constants::ShortBuffs,
-		SoF::constants::DiscBuffs,
-		SoF::constants::TotalBuffs,
-		SoF::constants::NPCBuffs,
-		SoF::constants::PetBuffs,
-		SoF::constants::MercBuffs
-	},
-	{
-		SoD::constants::CharacterCreationLimit,
-		SoD::constants::LongBuffs,
-		SoD::constants::ShortBuffs,
-		SoD::constants::DiscBuffs,
-		SoD::constants::TotalBuffs,
-		SoD::constants::NPCBuffs,
-		SoD::constants::PetBuffs,
-		SoD::constants::MercBuffs
-	},
-	{
-		UF::constants::CharacterCreationLimit,
-		UF::constants::LongBuffs,
-		UF::constants::ShortBuffs,
-		UF::constants::DiscBuffs,
-		UF::constants::TotalBuffs,
-		UF::constants::NPCBuffs,
-		UF::constants::PetBuffs,
-		UF::constants::MercBuffs
-	},
-	{
-		RoF::constants::CharacterCreationLimit,
-		RoF::constants::LongBuffs,
-		RoF::constants::ShortBuffs,
-		RoF::constants::DiscBuffs,
-		RoF::constants::TotalBuffs,
-		RoF::constants::NPCBuffs,
-		RoF::constants::PetBuffs,
-		RoF::constants::MercBuffs
-	},
-	{
-		RoF2::constants::CharacterCreationLimit,
-		RoF2::constants::LongBuffs,
-		RoF2::constants::ShortBuffs,
-		RoF2::constants::DiscBuffs,
-		RoF2::constants::TotalBuffs,
-		RoF2::constants::NPCBuffs,
-		RoF2::constants::PetBuffs,
-		RoF2::constants::MercBuffs
-	}
-};
-
-const EQEmu::constants::LookupEntry* EQEmu::constants::Lookup(versions::ClientVersion client_version)
-{
-	return &constants_lookup_entries[static_cast<int>(versions::ValidateClientVersion(client_version))];
-}
-
-static const EQEmu::inventory::LookupEntry inventory_lookup_entries[EQEmu::versions::MobVersionCount] =
-{
-	{
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-		ClientUnknown::Null,
-
-		ClientUnknown::False,
-		ClientUnknown::False,
-		ClientUnknown::False,
-		ClientUnknown::False
-	},
-	{
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-
-		Client62::Null,
-		Client62::Null,
-		Client62::Null,
-
-		Client62::False,
-		Client62::False,
-		Client62::False,
-		Client62::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*Titanium::invtype::InvTypePossessionsSize,*/
-		Titanium::invtype::InvTypeBankSize,
-		Titanium::invtype::InvTypeSharedBankSize,
-		Titanium::invtype::InvTypeTradeSize,
-		Titanium::invtype::InvTypeWorldSize,
-		Titanium::invtype::InvTypeLimboSize,
-		Titanium::invtype::InvTypeTributeSize,
-		Titanium::Null,
-		Titanium::Null, /*Titanium::invtype::InvTypeGuildTributeSize,*/
-		Titanium::invtype::InvTypeMerchantSize,
-		Titanium::Null,
-		Titanium::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*Titanium::invtype::InvTypeBazaarSize,*/
-		Titanium::invtype::InvTypeInspectSize,
-		Titanium::Null,
-		Titanium::invtype::InvTypeViewMODPCSize,
-		Titanium::invtype::InvTypeViewMODBankSize,
-		Titanium::invtype::InvTypeViewMODSharedBankSize,
-		Titanium::invtype::InvTypeViewMODLimboSize,
-		Titanium::invtype::InvTypeAltStorageSize,
-		Titanium::invtype::InvTypeArchivedSize,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::invtype::InvTypeOtherSize,
-
-		Titanium::Null, /*0x000000027FDFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*Titanium::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*Titanium::invaug::ItemAugSize,*/
-
-		Titanium::inventory::AllowEmptyBagInBag,
-		Titanium::inventory::AllowClickCastFromBag,
-		Titanium::inventory::ConcatenateInvTypeLimbo,
-		Titanium::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*SoF::invtype::InvTypePossessionsSize,*/
-		SoF::invtype::InvTypeBankSize,
-		SoF::invtype::InvTypeSharedBankSize,
-		SoF::invtype::InvTypeTradeSize,
-		SoF::invtype::InvTypeWorldSize,
-		SoF::invtype::InvTypeLimboSize,
-		SoF::invtype::InvTypeTributeSize,
-		SoF::Null,
-		SoF::Null, /*SoF::invtype::InvTypeGuildTributeSize,*/
-		SoF::invtype::InvTypeMerchantSize,
-		SoF::Null,
-		SoF::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*SoF::invtype::InvTypeBazaarSize,*/
-		SoF::invtype::InvTypeInspectSize,
-		SoF::Null,
-		SoF::invtype::InvTypeViewMODPCSize,
-		SoF::invtype::InvTypeViewMODBankSize,
-		SoF::invtype::InvTypeViewMODSharedBankSize,
-		SoF::invtype::InvTypeViewMODLimboSize,
-		SoF::invtype::InvTypeAltStorageSize,
-		SoF::invtype::InvTypeArchivedSize, SoF::Null, SoF::Null, SoF::Null, SoF::invtype::InvTypeOtherSize,
-
-		SoF::Null, /*0x000000027FFFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*SoF::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*SoF::invaug::ItemAugSize,*/
-
-		SoF::inventory::AllowEmptyBagInBag,
-		SoF::inventory::AllowClickCastFromBag,
-		SoF::inventory::ConcatenateInvTypeLimbo,
-		SoF::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*SoD::invtype::InvTypePossessionsSize,*/
-		SoD::invtype::InvTypeBankSize,
-		SoD::invtype::InvTypeSharedBankSize,
-		SoD::invtype::InvTypeTradeSize,
-		SoD::invtype::InvTypeWorldSize,
-		SoD::invtype::InvTypeLimboSize,
-		SoD::invtype::InvTypeTributeSize,
-		SoD::Null,
-		SoD::Null, /*SoD::invtype::InvTypeGuildTributeSize,*/
-		SoD::invtype::InvTypeMerchantSize,
-		SoD::Null,
-		SoD::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*SoD::invtype::InvTypeBazaarSize,*/
-		SoD::invtype::InvTypeInspectSize,
-		SoD::Null,
-		SoD::invtype::InvTypeViewMODPCSize,
-		SoD::invtype::InvTypeViewMODBankSize,
-		SoD::invtype::InvTypeViewMODSharedBankSize,
-		SoD::invtype::InvTypeViewMODLimboSize,
-		SoD::invtype::InvTypeAltStorageSize,
-		SoD::invtype::InvTypeArchivedSize,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::invtype::InvTypeOtherSize,
-
-		SoD::Null, /*0x000000027FFFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*SoD::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*SoD::invaug::ItemAugSize,*/
-
-		SoD::inventory::AllowEmptyBagInBag,
-		SoD::inventory::AllowClickCastFromBag,
-		SoD::inventory::ConcatenateInvTypeLimbo,
-		SoD::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*UF::invtype::InvTypePossessionsSize,*/
-		UF::invtype::InvTypeBankSize,
-		UF::invtype::InvTypeSharedBankSize,
-		UF::invtype::InvTypeTradeSize,
-		UF::invtype::InvTypeWorldSize,
-		UF::invtype::InvTypeLimboSize,
-		UF::invtype::InvTypeTributeSize,
-		UF::Null,
-		UF::Null, /*UF::invtype::InvTypeGuildTributeSize,*/
-		UF::invtype::InvTypeMerchantSize,
-		UF::Null,
-		UF::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*UF::invtype::InvTypeBazaarSize,*/
-		UF::invtype::InvTypeInspectSize,
-		UF::Null,
-		UF::invtype::InvTypeViewMODPCSize,
-		UF::invtype::InvTypeViewMODBankSize,
-		UF::invtype::InvTypeViewMODSharedBankSize,
-		UF::invtype::InvTypeViewMODLimboSize,
-		UF::invtype::InvTypeAltStorageSize,
-		UF::invtype::InvTypeArchivedSize,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::invtype::InvTypeOtherSize,
-
-		UF::Null, /*0x000000027FFFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*UF::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*UF::invaug::ItemAugSize,*/
-
-		UF::inventory::AllowEmptyBagInBag,
-		UF::inventory::AllowClickCastFromBag,
-		UF::inventory::ConcatenateInvTypeLimbo,
-		UF::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*RoF::invtype::InvTypePossessionsSize,*/
-		RoF::invtype::InvTypeBankSize,
-		RoF::invtype::InvTypeSharedBankSize,
-		RoF::invtype::InvTypeTradeSize,
-		RoF::invtype::InvTypeWorldSize,
-		RoF::invtype::InvTypeLimboSize,
-		RoF::invtype::InvTypeTributeSize,
-		RoF::Null, /*RoF::invtype::InvTypeTrophyTributeSize,*/
-		RoF::Null, /*RoF::invtype::InvTypeGuildTributeSize,*/
-		RoF::invtype::InvTypeMerchantSize,
-		RoF::Null, /*RoF::invtype::InvTypeDeletedSize,*/
-		RoF::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*RoF::invtype::InvTypeBazaarSize,*/
-		RoF::invtype::InvTypeInspectSize,
-		RoF::Null, /*RoF::invtype::InvTypeRealEstateSize,*/
-		RoF::invtype::InvTypeViewMODPCSize,
-		RoF::invtype::InvTypeViewMODBankSize,
-		RoF::invtype::InvTypeViewMODSharedBankSize,
-		RoF::invtype::InvTypeViewMODLimboSize,
-		RoF::invtype::InvTypeAltStorageSize,
-		RoF::invtype::InvTypeArchivedSize,
-		RoF::invtype::InvTypeMailSize,
-		RoF::invtype::InvTypeGuildTrophyTributeSize,
-		RoF::Null,
-		RoF::invtype::InvTypeOtherSize,
-
-		RoF::Null, /*0x00000003FFFFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*RoF::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*RoF::invaug::ItemAugSize,*/
-
-		RoF::False, /*RoF::inventory::AllowEmptyBagInBag,*/
-		RoF::inventory::AllowClickCastFromBag,
-		RoF::inventory::ConcatenateInvTypeLimbo,
-		RoF::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*RoF2::invtype::InvTypePossessionsSize,*/
-		RoF2::invtype::InvTypeBankSize,
-		RoF2::invtype::InvTypeSharedBankSize,
-		RoF2::invtype::InvTypeTradeSize,
-		RoF2::invtype::InvTypeWorldSize,
-		RoF2::invtype::InvTypeLimboSize,
-		RoF2::invtype::InvTypeTributeSize,
-		RoF2::Null, /*RoF2::invtype::InvTypeTrophyTributeSize,*/
-		RoF2::Null, /*RoF2::invtype::InvTypeGuildTributeSize,*/
-		RoF2::invtype::InvTypeMerchantSize,
-		RoF2::Null, /*RoF2::invtype::InvTypeDeletedSize,*/
-		RoF2::invtype::InvTypeCorpseSize,
-		EQEmu::legacy::TYPE_BAZAAR_SIZE, /*RoF2::invtype::InvTypeBazaarSize,*/
-		RoF2::invtype::InvTypeInspectSize,
-		RoF2::Null, /*RoF2::invtype::InvTypeRealEstateSize*/
-		RoF2::invtype::InvTypeViewMODPCSize,
-		RoF2::invtype::InvTypeViewMODBankSize,
-		RoF2::invtype::InvTypeViewMODSharedBankSize,
-		RoF2::invtype::InvTypeViewMODLimboSize,
-		RoF2::invtype::InvTypeAltStorageSize,
-		RoF2::invtype::InvTypeArchivedSize,
-		RoF2::invtype::InvTypeMailSize,
-		RoF2::invtype::InvTypeGuildTrophyTributeSize,
-		RoF2::invtype::InvTypeKronoSize,
-		RoF2::invtype::InvTypeOtherSize,
-
-		RoF2::Null, /*0x00000003FFFFFFFF,*/
-		EQEmu::inventory::ContainerCount, /*RoF2::invbag::ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*RoF2::invaug::ItemAugSize,*/
-
-		RoF2::False, /*RoF2::inventory::AllowEmptyBagInBag,*/
-		RoF2::inventory::AllowClickCastFromBag,
-		RoF2::inventory::ConcatenateInvTypeLimbo,
-		RoF2::inventory::AllowOverLevelEquipment
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::InvTypeTradeSize,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-		EntityLimits::NPC::Null,
-
-		EntityLimits::NPC::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::NPC::False,
-		EntityLimits::NPC::False,
-		EntityLimits::NPC::False,
-		EntityLimits::NPC::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::InvTypeTradeSize,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-		EntityLimits::NPCMerchant::Null,
-
-		EntityLimits::NPCMerchant::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::NPCMerchant::False,
-		EntityLimits::NPCMerchant::False,
-		EntityLimits::NPCMerchant::False,
-		EntityLimits::NPCMerchant::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::InvTypeTradeSize,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-		EntityLimits::Merc::Null,
-
-		EntityLimits::Merc::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::Merc::False,
-		EntityLimits::Merc::False,
-		EntityLimits::Merc::False,
-		EntityLimits::Merc::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::InvTypeTradeSize,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null, 
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-		EntityLimits::Bot::Null,
-
-		EntityLimits::Bot::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::Bot::False,
-		EntityLimits::Bot::False,
-		EntityLimits::Bot::False,
-		EntityLimits::Bot::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::InvTypeTradeSize,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-		EntityLimits::ClientPet::Null,
-
-		EntityLimits::ClientPet::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::ClientPet::False,
-		EntityLimits::ClientPet::False,
-		EntityLimits::ClientPet::False,
-		EntityLimits::ClientPet::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::InvTypeTradeSize,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-		EntityLimits::NPCPet::Null,
-
-		EntityLimits::NPCPet::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::NPCPet::False,
-		EntityLimits::NPCPet::False,
-		EntityLimits::NPCPet::False,
-		EntityLimits::NPCPet::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::InvTypeTradeSize,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-		EntityLimits::MercPet::Null,
-
-		EntityLimits::MercPet::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::MercPet::False,
-		EntityLimits::MercPet::False,
-		EntityLimits::MercPet::False,
-		EntityLimits::MercPet::False
-	},
-	{
-		EQEmu::legacy::TYPE_POSSESSIONS_SIZE, /*InvTypePossessionsSize,*/
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::InvTypeTradeSize,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null, /*InvTypeCorpseSize,*/
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-		EntityLimits::BotPet::Null,
-
-		EntityLimits::BotPet::Null,
-		EQEmu::inventory::ContainerCount, /*ItemBagSize,*/
-		EQEmu::inventory::SocketCount, /*ItemAugSize,*/
-
-		EntityLimits::BotPet::False,
-		EntityLimits::BotPet::False,
-		EntityLimits::BotPet::False,
-		EntityLimits::BotPet::False
-	},
-	{ // OfflineTitanium
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::invtype::InvTypeTradeSize,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::invtype::InvTypeMerchantSize,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null, /*Titanium::invtype::InvTypeBazaarSize,*/
-		Titanium::invtype::InvTypeInspectSize,
-		Titanium::Null,
-		Titanium::invtype::InvTypeViewMODPCSize,
-		Titanium::invtype::InvTypeViewMODBankSize,
-		Titanium::invtype::InvTypeViewMODSharedBankSize,
-		Titanium::invtype::InvTypeViewMODLimboSize,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-		Titanium::Null,
-
-		Titanium::Null,
-		EQEmu::inventory::ContainerCount, /*Titanium::Null,*/
-		Titanium::Null,
-
-		Titanium::False,
-		Titanium::False,
-		Titanium::False,
-		Titanium::False
-	},
-	{ // OfflineSoF
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::invtype::InvTypeTradeSize,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::invtype::InvTypeMerchantSize,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null, /*SoF::invtype::InvTypeBazaarSize,*/
-		SoF::invtype::InvTypeInspectSize,
-		SoF::Null,
-		SoF::invtype::InvTypeViewMODPCSize,
-		SoF::invtype::InvTypeViewMODBankSize,
-		SoF::invtype::InvTypeViewMODSharedBankSize,
-		SoF::invtype::InvTypeViewMODLimboSize,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-		SoF::Null,
-
-		SoF::Null,
-		EQEmu::inventory::ContainerCount, /*SoF::Null,*/
-		SoF::Null,
-
-		SoF::False,
-		SoF::False,
-		SoF::False,
-		SoF::False
-	},
-	{ // OfflineSoD
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::invtype::InvTypeTradeSize,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::invtype::InvTypeMerchantSize,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null, /*SoD::invtype::InvTypeBazaarSize,*/
-		SoD::invtype::InvTypeInspectSize,
-		SoD::Null,
-		SoD::invtype::InvTypeViewMODPCSize,
-		SoD::invtype::InvTypeViewMODBankSize,
-		SoD::invtype::InvTypeViewMODSharedBankSize,
-		SoD::invtype::InvTypeViewMODLimboSize,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-		SoD::Null,
-
-		SoD::Null,
-		EQEmu::inventory::ContainerCount, /*SoD::Null,*/
-		SoD::Null,
-
-		SoD::False,
-		SoD::False,
-		SoD::False,
-		SoD::False
-	},
-	{ // OfflineUF
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::invtype::InvTypeTradeSize,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::invtype::InvTypeMerchantSize,
-		UF::Null,
-		UF::Null,
-		UF::Null, /*UF::invtype::InvTypeBazaarSize,*/
-		UF::invtype::InvTypeInspectSize,
-		UF::Null,
-		UF::invtype::InvTypeViewMODPCSize,
-		UF::invtype::InvTypeViewMODBankSize,
-		UF::invtype::InvTypeViewMODSharedBankSize,
-		UF::invtype::InvTypeViewMODLimboSize,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-		UF::Null,
-
-		UF::Null,
-		EQEmu::inventory::ContainerCount, /*UF::Null,*/
-		UF::Null,
-
-		UF::False,
-		UF::False,
-		UF::False,
-		UF::False
-	},
-	{ // OfflineRoF
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::invtype::InvTypeTradeSize,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::invtype::InvTypeMerchantSize,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null, /*RoF::invtype::InvTypeBazaarSize,*/
-		RoF::invtype::InvTypeInspectSize,
-		RoF::Null,
-		RoF::invtype::InvTypeViewMODPCSize,
-		RoF::invtype::InvTypeViewMODBankSize,
-		RoF::invtype::InvTypeViewMODSharedBankSize,
-		RoF::invtype::InvTypeViewMODLimboSize,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-		RoF::Null,
-
-		RoF::Null,
-		EQEmu::inventory::ContainerCount, /*RoF::Null,*/
-		RoF::Null,
-
-		RoF::False,
-		RoF::False,
-		RoF::False,
-		RoF::False
-	},
-	{ // OfflineRoF2
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::invtype::InvTypeTradeSize,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::invtype::InvTypeMerchantSize,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null, /*RoF2::invtype::InvTypeBazaarSize,*/
-		RoF2::invtype::InvTypeInspectSize,
-		RoF2::Null,
-		RoF2::invtype::InvTypeViewMODPCSize,
-		RoF2::invtype::InvTypeViewMODBankSize,
-		RoF2::invtype::InvTypeViewMODSharedBankSize,
-		RoF2::invtype::InvTypeViewMODLimboSize,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-		RoF2::Null,
-
-		RoF2::Null,
-		EQEmu::inventory::ContainerCount, /*RoF2::Null,*/
-		RoF2::Null,
-
-		RoF2::False,
-		RoF2::False,
-		RoF2::False,
-		RoF2::False
-	}
-};
-
-const EQEmu::inventory::LookupEntry* EQEmu::inventory::Lookup(versions::MobVersion mob_version)
-{
-	return &inventory_lookup_entries[static_cast<int>(versions::ValidateMobVersion(mob_version))];
-}
-
-static const EQEmu::behavior::LookupEntry behavior_lookup_entries[EQEmu::versions::MobVersionCount] =
-{
-	{ // Unknown
-		ClientUnknown::True
-	},
-	{ // Client62
-		Client62::True
-	},
-	{ // Titanium
-		Titanium::behavior::CoinHasWeight
-	},
-	{ // SoF
-		SoF::behavior::CoinHasWeight
-	},
-	{ // SoD
-		SoD::behavior::CoinHasWeight
-	},
-	{ // UF
-		UF::behavior::CoinHasWeight
-	},
-	{ // RoF
-		RoF::behavior::CoinHasWeight
-	},
-	{ // RoF2
-		RoF2::behavior::CoinHasWeight
-	},
-	{ // NPC
-		EntityLimits::NPC::True /*CoinHasWeight*/
-	},
-	{ // NPCMerchant
-		EntityLimits::NPC::True /*CoinHasWeight*/
-	},
-	{ // Merc
-		EntityLimits::Merc::True /*CoinHasWeight*/
-	},
-	{ // Bot
-		EntityLimits::Bot::True /*CoinHasWeight*/
-	},
-	{ // ClientPet
-		EntityLimits::ClientPet::True /*CoinHasWeight*/
-	},
-	{ // NPCPet
-		EntityLimits::NPCPet::True /*CoinHasWeight*/
-	},
-	{ // MercPet
-		EntityLimits::MercPet::True /*CoinHasWeight*/
-	},
-	{ // BotPet
-		EntityLimits::BotPet::True /*CoinHasWeight*/
-	},
-	{ // OfflineTitanium
-		Titanium::False
-	},
-	{ // OfflineSoF
-		SoF::False
-	},
-	{ // OfflineSoD
-		SoD::False
-	},
-	{ // OfflineUF
-		UF::False
-	},
-	{ // OfflineRoF
-		RoF::False
-	},
-	{ // OfflineRoF2
-		RoF2::False
-	}
-};
-
-const EQEmu::behavior::LookupEntry* EQEmu::behavior::Lookup(versions::MobVersion mob_version)
-{
-	return &behavior_lookup_entries[static_cast<int>(versions::ValidateMobVersion(mob_version))];
-}

common/eq_limits.h

@@ -1,101 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-	
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EQ_LIMITS_H
-#define COMMON_EQ_LIMITS_H
-
-#include "emu_legacy.h"
-#include "types.h"
-#include "eq_constants.h"
-#include "emu_versions.h"
-#include "../common/patches/titanium_limits.h"
-#include "../common/patches/sof_limits.h"
-#include "../common/patches/sod_limits.h"
-#include "../common/patches/uf_limits.h"
-#include "../common/patches/rof_limits.h"
-#include "../common/patches/rof2_limits.h"
-
-
-namespace EQEmu
-{
-	namespace constants {
-		class LookupEntry {
-		public:
-			size_t CharacterCreationLimit;
-			int LongBuffs;
-			int ShortBuffs;
-			int DiscBuffs;
-			int TotalBuffs;
-			int NPCBuffs;
-			int PetBuffs;
-			int MercBuffs;
-		};
-
-		const LookupEntry* Lookup(versions::ClientVersion client_version);
-
-	} /*constants*/
-	
-	namespace inventory {
-		class LookupEntry {
-		public:
-			size_t InventoryTypeSize[25]; // should reflect EQEmu::inventory::typeCount referenced in emu_constants.h
-
-			uint64 PossessionsBitmask;
-			size_t ItemBagSize;
-			size_t ItemAugSize;
-
-			bool AllowEmptyBagInBag;
-			bool AllowClickCastFromBag;
-			bool ConcatenateInvTypeLimbo;
-			bool AllowOverLevelEquipment;
-		};
-
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
-
-	} /*inventory*/
-	
-	namespace behavior {
-		class LookupEntry {
-		public:
-			bool CoinHasWeight;
-		};
-
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
-
-	} /*behavior*/
-
-} /*EQEmu*/
-
-namespace ClientUnknown
-{
-	enum : int { Invalid = -1, Null, Safety };
-
-	enum : bool { False = false, True = true };
-
-} /*ClientUnknown*/
-
-namespace Client62
-{
-	enum : int { Invalid = -1, Null, Safety };
-
-	enum : bool { False = false, True = true };
-
-} /*Client62*/
-
-#endif /*COMMON_EQ_LIMITS_H*/

common/eq_packet.cpp

@@ -40,9 +40,11 @@ EQPacket::EQPacket(EmuOpcode op, const unsigned char *buf, uint32 len)
 :	BasePacket(buf, len),
 	emu_opcode(op)
 {
+	_eqp
 }
 
 void EQPacket::build_raw_header_dump(char *buffer, uint16 seq) const {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -51,17 +53,20 @@ void EQPacket::build_raw_header_dump(char *buffer, uint16 seq) const {
 
 void EQPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
 }
 
 void EQPacket::build_header_dump(char *buffer) const {
+	_eqp
 	sprintf(buffer, "[EmuOpCode 0x%04x Size=%u]", emu_opcode, size);
 }
 
 void EQPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -76,6 +81,7 @@ void EQPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQProtocolPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -84,6 +90,7 @@ void EQProtocolPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 
 void EQProtocolPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -91,11 +98,13 @@ void EQProtocolPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQProtocolPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 	sprintf(buffer, "[ProtoOpCode 0x%04x Size=%u]",opcode,size);
 }
 
 void EQProtocolPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -110,6 +119,7 @@ void EQProtocolPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -122,6 +132,7 @@ void EQApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 
 void EQApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -129,15 +140,17 @@ void EQApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQApplicationPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x Size=%u]\n", emu_opcode,size);
 #else
-	sprintf(buffer, "[OpCode %s(0x%04x) Size=%u]",OpcodeManager::EmuToName(emu_opcode), GetProtocolOpcode(), size);
+	sprintf(buffer, "[OpCode %s Size=%u]",OpcodeManager::EmuToName(emu_opcode),size);
 #endif
 }
 
 void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -156,6 +169,7 @@ void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) const
 {
+	_eqp
 	BasePacket::build_raw_header_dump(buffer, seq);
 	buffer += strlen(buffer);
 
@@ -168,6 +182,7 @@ void EQRawApplicationPacket::build_raw_header_dump(char *buffer, uint16 seq) con
 
 void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 {
+	_eqp
 	char buff[196];
 	build_raw_header_dump(buff, seq);
 	fprintf(to, "%s", buff);
@@ -175,6 +190,7 @@ void EQRawApplicationPacket::DumpRawHeader(uint16 seq, FILE *to) const
 
 void EQRawApplicationPacket::build_header_dump(char *buffer) const
 {
+	_eqp
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x (0x%04x) Size=%u]\n", emu_opcode, opcode,size);
 #else
@@ -184,6 +200,7 @@ void EQRawApplicationPacket::build_header_dump(char *buffer) const
 
 void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
+	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -202,6 +219,7 @@ void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 {
+	_eqp
 	if (opcode>0xff) {
 		*(uint16 *)dest=opcode;
 	} else {
@@ -215,6 +233,7 @@ uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 
 uint32 EQApplicationPacket::serialize(uint16 opcode, unsigned char *dest) const
 {
+	_eqp
 	uint8 OpCodeBytes = app_opcode_size;
 
 	if (app_opcode_size==1)
@@ -236,31 +255,12 @@ uint32 EQApplicationPacket::serialize(uint16 opcode, unsigned char *dest) const
 	return size+OpCodeBytes;
 }
 
-/*EQProtocolPacket::EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len)
-:	BasePacket(buf, len),
-	opcode(op)
-{
-
-uint32 offset;
-	opcode=ntohs(*(const uint16 *)buf);
-	offset=2;
-
-	if (len-offset) {
-		pBuffer= new unsigned char[len-offset];
-		memcpy(pBuffer,buf+offset,len-offset);
-		size=len-offset;
-	} else {
-		pBuffer=nullptr;
-		size=0;
-	}
-	OpMgr=&RawOpcodeManager;
-}*/
-
 bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 {
-bool result=false;
+	_eqp
+	bool result=false;
 	if (opcode==OP_Combined && size+rhs->size+5<256) {
-		auto tmpbuffer = new unsigned char[size + rhs->size + 3];
+		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+3];
 		memcpy(tmpbuffer,pBuffer,size);
 		uint32 offset=size;
 		tmpbuffer[offset++]=rhs->Size();
@@ -270,7 +270,7 @@ bool result=false;
 		pBuffer=tmpbuffer;
 		result=true;
 	} else if (size+rhs->size+7<256) {
-		auto tmpbuffer = new unsigned char[size + rhs->size + 6];
+		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+6];
 		uint32 offset=0;
 		tmpbuffer[offset++]=Size();
 		offset+=serialize(tmpbuffer+offset);
@@ -284,61 +284,12 @@ bool result=false;
 	}
 
 	return result;
-
 }
 
-/*
-this is the code to do app-layer combining, instead of protocol layer.
-this was taken out due to complex interactions with the opcode manager,
-and will require a bit more thinking (likely moving into EQStream) to
-get running again... but might be a good thing some day.
-
-bool EQApplicationPacket::combine(const EQApplicationPacket *rhs)
-{
-uint32 newsize=0, offset=0;
-unsigned char *tmpbuffer=nullptr;
-
-	if (opcode!=OP_AppCombined) {
-		newsize=app_opcode_size+size+(size>254?3:1)+app_opcode_size+rhs->size+(rhs->size>254?3:1);
-		tmpbuffer=new unsigned char [newsize];
-		offset=0;
-		if (size>254) {
-			tmpbuffer[offset++]=0xff;
-			*(uint16 *)(tmpbuffer+offset)=htons(size);
-			offset+=1;
-		} else {
-			tmpbuffer[offset++]=size;
-		}
-		offset+=serialize(tmpbuffer+offset);
-	} else {
-		newsize=size+app_opcode_size+rhs->size+(rhs->size>254?3:1);
-		tmpbuffer=new unsigned char [newsize];
-		memcpy(tmpbuffer,pBuffer,size);
-		offset=size;
-	}
-
-	if (rhs->size>254) {
-		tmpbuffer[offset++]=0xff;
-		*(uint16 *)(tmpbuffer+offset)=htons(rhs->size);
-		offset+=1;
-	} else {
-		tmpbuffer[offset++]=rhs->size;
-	}
-	offset+=rhs->serialize(tmpbuffer+offset);
-
-	size=offset;
-	opcode=OP_AppCombined;
-
-	delete[] pBuffer;
-	pBuffer=tmpbuffer;
-
-	return true;
-}
-*/
-
 bool EQProtocolPacket::ValidateCRC(const unsigned char *buffer, int length, uint32 Key)
 {
-bool valid=false;
+	_eqp
+	bool valid=false;
 	// OP_SessionRequest, OP_SessionResponse, OP_OutOfSession are not CRC'd
 	if (buffer[0]==0x00 && (buffer[1]==OP_SessionRequest || buffer[1]==OP_SessionResponse || buffer[1]==OP_OutOfSession)) {
 		valid=true;
@@ -357,8 +308,9 @@ bool valid=false;
 
 uint32 EQProtocolPacket::Decompress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize)
 {
-uint32 newlen=0;
-uint32 flag_offset=0;
+	_eqp
+	uint32 newlen=0;
+	uint32 flag_offset=0;
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0x00) {
 		flag_offset=2;
@@ -382,7 +334,8 @@ uint32 flag_offset=0;
 }
 
 uint32 EQProtocolPacket::Compress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize) {
-uint32 flag_offset=1,newlength;
+	_eqp
+	uint32 flag_offset=1,newlength;
 	//dump_message_column(buffer,length,"Before: ");
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0) {
@@ -405,6 +358,7 @@ uint32 flag_offset=1,newlength;
 
 void EQProtocolPacket::ChatDecode(unsigned char *buffer, int size, int DecodeKey)
 {
+	_eqp
 	if ((size >= 2) && buffer[1]!=0x01 && buffer[0]!=0x02 && buffer[0]!=0x1d) {
 		int Key=DecodeKey;
 		unsigned char *test=(unsigned char *)malloc(size);
@@ -430,6 +384,7 @@ void EQProtocolPacket::ChatDecode(unsigned char *buffer, int size, int DecodeKey
 
 void EQProtocolPacket::ChatEncode(unsigned char *buffer, int size, int EncodeKey)
 {
+	_eqp
 	if (buffer[1]!=0x01 && buffer[0]!=0x02 && buffer[0]!=0x1d) {
 		int Key=EncodeKey;
 		char *test=(char*)malloc(size);
@@ -453,11 +408,13 @@ void EQProtocolPacket::ChatEncode(unsigned char *buffer, int size, int EncodeKey
 }
 
 EQApplicationPacket *EQApplicationPacket::Copy() const {
+	_eqp
 	return(new EQApplicationPacket(*this));
 }
 
 EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
+	_eqp
+	EQRawApplicationPacket *res = new EQRawApplicationPacket(opcode, pBuffer, size);
 	res->copyInfo(this);
 	return(res);
 }
@@ -466,10 +423,13 @@ EQRawApplicationPacket::EQRawApplicationPacket(uint16 opcode, const unsigned cha
 :	EQApplicationPacket(OP_Unknown, buf, len),
 	opcode(opcode)
 {
+	_eqp
 }
+
 EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const uint32 len)
 : EQApplicationPacket(OP_Unknown, buf+sizeof(uint16), len-sizeof(uint16))
 {
+	_eqp
 	if(GetExecutablePlatform() != ExePlatformUCS) {
 		opcode = *((const uint16 *) buf);
 		if(opcode == 0x0000)
@@ -503,16 +463,17 @@ EQRawApplicationPacket::EQRawApplicationPacket(const unsigned char *buf, const u
 }
 
 void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
+	_eqp
 	if (iShowInfo) {
 		std::cout << "Dumping Applayer: 0x" << std::hex << std::setfill('0') << std::setw(4) << app->GetOpcode() << std::dec;
 		std::cout << " size:" << app->size << std::endl;
 	}
 	DumpPacketHex(app->pBuffer, app->size);
-//	DumpPacketAscii(app->pBuffer, app->size);
 }
 
 std::string DumpPacketToString(const EQApplicationPacket* app){
+	_eqp
 	std::ostringstream out;
 	out << DumpPacketHexToString(app->pBuffer, app->size);
 	return out.str();
-}
+}

common/eq_packet.h

@@ -62,7 +62,7 @@ class EQProtocolPacket : public BasePacket {
 	friend class EQStream;
 	friend class EQStreamPair;
 public:
-	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf, len), opcode(op) { acked = false; sent_time = 0; }
+	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf,len), opcode(op) { acked = false; }
 //	EQProtocolPacket(const unsigned char *buf, uint32 len);
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
@@ -70,7 +70,6 @@ public:
 	EQRawApplicationPacket *MakeAppPacket() const;
 
 	bool acked;
-	uint32 sent_time;
 
 	virtual void build_raw_header_dump(char *buffer, uint16 seq=0xffff) const;
 	virtual void build_header_dump(char *buffer) const;
@@ -115,14 +114,11 @@ public:
 	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
 	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;
 
-	uint16 GetOpcodeBypass() const { return opcode_bypass; }
+	uint16 GetOpcodeBypass() { return opcode_bypass; }
 	void SetOpcodeBypass(uint16 v) { opcode_bypass = v; }
 
-	uint16 GetProtocolOpcode() const { return protocol_opcode; }
-	void SetProtocolOpcode(uint16 v) { protocol_opcode = v; }
 protected:
 
-	uint16 protocol_opcode;
 	uint8 app_opcode_size;
 	uint16 opcode_bypass;
 private:

common/eq_stream.h

@@ -71,7 +71,7 @@ struct SessionResponse {
 };
 
 //Deltas are in ms, representing round trip times
-struct ClientSessionStats {
+struct SessionStats {
 /*000*/	uint16 RequestID;
 /*002*/	uint32 last_local_delta;
 /*006*/	uint32 average_delta;
@@ -83,16 +83,6 @@ struct ClientSessionStats {
 /*038*/
 };
 
-struct ServerSessionStats {
-/*000*/	uint16 RequestID;
-/*002*/	uint32 ServerTime;
-/*006*/	uint64 packets_sent_echo;
-/*014*/	uint64 packets_received_echo;
-/*022*/	uint64 packets_sent;
-/*030*/	uint64 packets_received;
-/*038*/
-};
-
 #pragma pack()
 
 class OpcodeManager;
@@ -153,6 +143,7 @@ class EQStream : public EQStreamInterface {
 		std::deque<EQProtocolPacket *> SequencedQueue;
 		uint16 NextOutSeq;
 		uint16 SequencedBase;	//the sequence number of SequencedQueue[0]
+		long NextSequencedSend;	//index into SequencedQueue
 		Mutex MOutboundQueue;
 
 		//a buffer we use for compression/decompression
@@ -167,13 +158,10 @@ class EQStream : public EQStreamInterface {
 
 		int32 BytesWritten;
 
-		uint64 sent_packet_count;
-		uint64 received_packet_count;
-
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
-		uint32 AverageDelta;
+
 
 		OpcodeManager **OpMgr;
 
@@ -241,7 +229,7 @@ class EQStream : public EQStreamInterface {
 		virtual bool CheckState(EQStreamState state) { return GetState() == state; }
 		virtual std::string Describe() const { return("Direct EQStream"); }
 
-		virtual void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
+		void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
 
 		void CheckTimeout(uint32 now, uint32 timeout=30);
 		bool HasOutgoingData();
@@ -250,13 +238,13 @@ class EQStream : public EQStreamInterface {
 		void Write(int eq_fd);
 
 		// whether or not the stream has been assigned (we passed our stream match)
-		virtual void SetActive(bool val) { streamactive = val; }
+		void SetActive(bool val) { streamactive = val; }
 
 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }
 
-		virtual EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
+		inline EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
 
 		static SeqOrder CompareSequence(uint16 expected_seq , uint16 seq);
 
@@ -277,13 +265,11 @@ class EQStream : public EQStreamInterface {
 		void AddBytesSent(uint32 bytes)
 		{
 			bytes_sent += bytes;
-			++sent_packet_count;
 		}
 
 		void AddBytesRecv(uint32 bytes)
 		{
 			bytes_recv += bytes;
-			++received_packet_count;
 		}
 
 		virtual const uint32 GetBytesSent() const { return bytes_sent; }
@@ -302,11 +288,20 @@ class EQStream : public EQStreamInterface {
 			return bytes_recv / (Timer::GetTimeSeconds() - create_time);
 		}
 
-		const uint64 GetPacketsSent() { return sent_packet_count; }
-		const uint64 GetPacketsReceived() { return received_packet_count; }
-
 		//used for dynamic stream identification
-		virtual MatchState CheckSignature(const Signature *sig);
+		class Signature {
+		public:
+			//this object could get more complicated if needed...
+			uint16 ignore_eq_opcode;		//0=dont ignore
+			uint16 first_eq_opcode;
+			uint32 first_length;			//0=dont check length
+		};
+		typedef enum {
+			MatchNotReady,
+			MatchSuccessful,
+			MatchFailed
+		} MatchState;
+		MatchState CheckSignature(const Signature *sig);
 
 };
 

common/eq_stream_factory.cpp

@@ -3,7 +3,7 @@
 #include "eq_stream_factory.h"
 
 #ifdef _WINDOWS
-	#include <winsock2.h>
+	#include <winsock.h>
 	#include <process.h>
 	#include <io.h>
 	#include <stdio.h>
@@ -23,25 +23,44 @@
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
+
+#ifndef WIN32
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+#endif
 
 	fs->ReaderLoop();
 
+#ifndef WIN32
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+#endif
+
 	THREAD_RETURN(nullptr);
 }
 
 ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
-	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
+
+#ifndef WIN32
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+#endif
 
 	fs->WriterLoop();
 
+#ifndef WIN32
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+#endif
+
 	THREAD_RETURN(nullptr);
 }
 
 EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 	: Timeoutable(5000), stream_timeout(timeout)
 {
+	_eqp
 	StreamType=type;
 	Port=port;
 	sock=-1;
@@ -49,6 +68,7 @@ EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 
 void EQStreamFactory::Close()
 {
+	_eqp
 	Stop();
 
 #ifdef _WINDOWS
@@ -61,7 +81,8 @@ void EQStreamFactory::Close()
 
 bool EQStreamFactory::Open()
 {
-struct sockaddr_in address;
+	_eqp
+	struct sockaddr_in address;
 #ifndef WIN32
 	pthread_t t1,t2;
 #endif
@@ -102,9 +123,10 @@ struct sockaddr_in address;
 
 std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
+	_eqp
 	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
-	if (!NewStreams.empty()) {
+	if (NewStreams.size()) {
 		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
@@ -116,6 +138,7 @@ std::shared_ptr<EQStream> EQStreamFactory::Pop()
 
 void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
+	_eqp
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
@@ -123,6 +146,7 @@ void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 
 void EQStreamFactory::ReaderLoop()
 {
+	_eqp
 	fd_set readset;
 	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 	int num;
@@ -200,6 +224,7 @@ void EQStreamFactory::ReaderLoop()
 
 void EQStreamFactory::CheckTimeout()
 {
+	_eqp
 	//lock streams the entire time were checking timeouts, it should be fast.
 	MStreams.lock();
 
@@ -219,7 +244,7 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				auto temp = stream_itr;
+				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
 				++stream_itr;
 				temp->second = nullptr;
 				Streams.erase(temp);
@@ -234,7 +259,9 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-	bool havework = true;
+	_eqp
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
+	bool havework=true;
 	std::vector<std::shared_ptr<EQStream>> wants_write;
 	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
 	bool decay = false;
@@ -243,7 +270,7 @@ void EQStreamFactory::WriterLoop()
 	WriterRunning = true;
 	DecayTimer.Enable();
 
-	while (sock != -1) {
+	while(sock!=-1) {
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -252,36 +279,34 @@ void EQStreamFactory::WriterLoop()
 		havework = false;
 		wants_write.clear();
 
-		decay = DecayTimer.Check();
+		decay=DecayTimer.Check();
 
-		// copy streams into a seperate list so we dont have to keep
-		// MStreams locked while we are writting
+		//copy streams into a seperate list so we dont have to keep
+		//MStreams locked while we are writting
 		MStreams.lock();
-		for (auto stream_itr = Streams.begin(); stream_itr != Streams.end(); ++stream_itr) {
+		for(stream_itr=Streams.begin();stream_itr!=Streams.end();++stream_itr) {
 			// If it's time to decay the bytes sent, then let's do it before we try to write
 			if (decay)
 				stream_itr->second->Decay();
 
-			// bullshit checking, to see if this is really happening, GDB seems to think so...
-			if (stream_itr->second == nullptr) {
-				fprintf(stderr,
-					"ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i",
-					stream_itr->first.first, stream_itr->first.second);
+			//bullshit checking, to see if this is really happening, GDB seems to think so...
+			if(stream_itr->second == nullptr) {
+				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i", stream_itr->first.first, stream_itr->first.second);
 				continue;
 			}
 
 			if (stream_itr->second->HasOutgoingData()) {
-				havework = true;
+				havework=true;
 				stream_itr->second->PutInUse();
 				wants_write.push_back(stream_itr->second);
 			}
 		}
 		MStreams.unlock();
 
-		// do the actual writes
+		//do the actual writes
 		cur = wants_write.begin();
 		end = wants_write.end();
-		for (; cur != end; ++cur) {
+		for(; cur != end; ++cur) {
 			(*cur)->Write(sock);
 			(*cur)->ReleaseFromUse();
 		}

common/eq_stream_ident.cpp

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

common/eq_stream_ident.h

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

common/eq_stream_intf.h

@@ -4,8 +4,7 @@
 //this is the only part of an EQStream that is seen by the application.
 
 #include <string>
-#include "emu_versions.h"
-#include "eq_packet.h"
+#include "clientversions.h"
 
 typedef enum {
 	ESTABLISHED,
@@ -16,46 +15,27 @@ typedef enum {
 } EQStreamState;
 
 class EQApplicationPacket;
-class OpcodeManager;
 
 class EQStreamInterface {
 public:
 	virtual ~EQStreamInterface() {}
 
-	class Signature {
-	public:
-		//this object could get more complicated if needed...
-		uint16 ignore_eq_opcode;		//0=dont ignore
-		uint16 first_eq_opcode;
-		uint32 first_length;			//0=dont check length
-	};
-	typedef enum {
-		MatchNotReady,
-		MatchSuccessful,
-		MatchFailed
-	} MatchState;
-
 	virtual void QueuePacket(const EQApplicationPacket *p, bool ack_req=true) = 0;
 	virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true) = 0;
 	virtual EQApplicationPacket *PopPacket() = 0;
 	virtual void Close() = 0;
 	virtual void ReleaseFromUse() = 0;
 	virtual void RemoveData() = 0;
-	virtual std::string GetRemoteAddr() const = 0;
 	virtual uint32 GetRemoteIP() const = 0;
 	virtual uint16 GetRemotePort() const = 0;
 	virtual bool CheckState(EQStreamState state) = 0;
 	virtual std::string Describe() const = 0;
-	virtual void SetActive(bool val) { }
-	virtual MatchState CheckSignature(const Signature *sig) { return MatchFailed; }
-	virtual EQStreamState GetState() = 0;
-	virtual void SetOpcodeManager(OpcodeManager **opm) = 0;
 
 	virtual const uint32 GetBytesSent() const { return 0; }
 	virtual const uint32 GetBytesRecieved() const { return 0; }
 	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
 	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
-	virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
+	virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -1,12 +1,11 @@
 
 #include "global_define.h"
 #include "eq_stream_proxy.h"
+#include "eq_stream.h"
 #include "struct_strategy.h"
-#include "eqemu_logsys.h"
-#include "opcodemgr.h"
 
 
-EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -22,30 +21,15 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
+const ClientVersion EQStreamProxy::GetClientVersion() const
 {
-	return m_structs->ClientVersion();
-}
-
-EQStreamState EQStreamProxy::GetState()
-{
-	return m_stream->GetState();
-}
-
-void EQStreamProxy::SetOpcodeManager(OpcodeManager **opm)
-{
-	return m_stream->SetOpcodeManager(opm);
+	return m_structs->GetClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 	if(p == nullptr)
 		return;
 
-	if (p->GetOpcode() != OP_SpecialMesg) {
-		Log(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
-		Log(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
-	}
-
 	EQApplicationPacket *newp = p->Copy();
 	FastQueuePacket(&newp, ack_req);
 }
@@ -70,10 +54,6 @@ void EQStreamProxy::Close() {
 	m_stream->Close();
 }
 
-std::string EQStreamProxy::GetRemoteAddr() const {
-	return(m_stream->GetRemoteAddr());
-}
-
 uint32 EQStreamProxy::GetRemoteIP() const {
 	return(m_stream->GetRemoteIP());
 }

common/eq_stream_proxy.h

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

common/eqdb.cpp

@@ -63,7 +63,7 @@ EQDBRes * EQDB::query(Const_char *q) {
 //NOT THREAD SAFE!
 Const_char *EQDB::escape_string(Const_char *from) {
 	int len = strlen(from);
-	auto res = new char[len * 2 + 1];
+	char *res = new char[len*2+1];
 
 	mysql_real_escape_string(mysql_ref,res,from,len);
 

common/eqemu_config.cpp

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

common/eqemu_config.h

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

common/eqemu_logsys.cpp

@@ -96,25 +96,13 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	memset(log_settings, 0, sizeof(LogSettings) * Logs::LogCategory::MaxCategoryID);
 
 	/* Set Defaults */
+	log_settings[Logs::LoginServer].log_to_console = Logs::General;
 	log_settings[Logs::World_Server].log_to_console = Logs::General;
 	log_settings[Logs::Zone_Server].log_to_console = Logs::General;
 	log_settings[Logs::QS_Server].log_to_console = Logs::General;
 	log_settings[Logs::UCS_Server].log_to_console = Logs::General;
 	log_settings[Logs::Crash].log_to_console = Logs::General;
 	log_settings[Logs::MySQLError].log_to_console = Logs::General;
-	log_settings[Logs::Login_Server].log_to_console = Logs::General;
-	log_settings[Logs::Headless_Client].log_to_console = Logs::General;
-	log_settings[Logs::NATS].log_to_console = Logs::General;
-
-	/* Set Category enabled status on defaults */
-	log_settings[Logs::World_Server].is_category_enabled = 1;
-	log_settings[Logs::Zone_Server].is_category_enabled = 1;
-	log_settings[Logs::QS_Server].is_category_enabled = 1;
-	log_settings[Logs::UCS_Server].is_category_enabled = 1;
-	log_settings[Logs::Crash].is_category_enabled = 1;
-	log_settings[Logs::MySQLError].is_category_enabled = 1;
-	log_settings[Logs::Login_Server].is_category_enabled = 1;
-	log_settings[Logs::NATS].is_category_enabled = 1;
 
 	/*	Declare process file names for log writing
 		If there is no process_file_name declared, no log file will be written, simply
@@ -131,27 +119,30 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		platform_file_name = "login";
 	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
 		platform_file_name = "launcher";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC)
-		platform_file_name = "hc";
 }
 
 std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
 {
-	std::string ret;
-	ret.push_back('[');
-	ret.append(Logs::LogCategoryName[log_category]);
-	ret.push_back(']');
-	ret.push_back(' ');
-	ret.append(in_message);
-	return ret;
+	std::string category_string;
+	if (log_category > 0 && Logs::LogCategoryName[log_category])
+		category_string = StringFormat("[%s] ", Logs::LogCategoryName[log_category]);
+	return StringFormat("%s%s", category_string.c_str(), in_message.c_str());
 }
 
 void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
 {
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_gmsay == 0)
+		return;
+
 	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
 	if (log_category == Logs::LogCategory::Netcode)
 		return;
 
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_gmsay < debug_level)
+		return;
+
 	/* Check to see if the process that actually ran this is zone */
 	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
 		on_log_gmsay_hook(log_category, message);
@@ -169,6 +160,14 @@ void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const
 		crash_log.close();
 	}
 
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_file == 0)
+		return;
+
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_file < debug_level)
+		return;
+
 	char time_stamp[80];
 	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 
@@ -247,6 +246,13 @@ uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {
 
 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
+	/* Check if category enabled for process */
+	if (log_settings[log_category].log_to_console == 0)
+		return;
+
+	/* Make sure the message inbound is at a debug level we're set at */
+	if (log_settings[log_category].log_to_console < debug_level)
+		return;
 
 	#ifdef _WINDOWS
 		HANDLE  console_handle;
@@ -267,24 +273,13 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 
 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
-
-	bool log_to_console = true;
-	if (log_settings[log_category].log_to_console < debug_level) {
-		log_to_console = false;
-	}
-
-	bool log_to_file = true;
-	if (log_settings[log_category].log_to_file < debug_level) {
-		log_to_file = false;
-	}
-
-	bool log_to_gmsay = true;
-	if (log_settings[log_category].log_to_gmsay < debug_level) {
-		log_to_gmsay = false;
-	}
-
+	_eqp
+	const bool log_to_console = log_settings[log_category].log_to_console > 0;
+	const bool log_to_file = log_settings[log_category].log_to_file > 0;
+	const bool log_to_gmsay = log_settings[log_category].log_to_gmsay > 0;
 	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
-	if (nothing_to_log)
+
+	if (nothing_to_log) 
 		return;
 
 	va_list args;

common/eqemu_logsys.h

@@ -1,4 +1,3 @@
-
 /*	EQEMu: Everquest Server Emulator
 	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
 
@@ -20,11 +19,11 @@
 #ifndef EQEMU_LOGSYS_H
 #define EQEMU_LOGSYS_H
 
-#include <fmt/format.h>
 #include <iostream>
 #include <fstream>
 #include <stdio.h>
 #include <functional>
+
 #include "types.h"
 
 namespace Logs {
@@ -39,127 +38,105 @@ namespace Logs {
 		NOTE: Only add to the bottom of the enum because that is the type ID assignment
 	*/
 
-enum LogCategory {
-	None = 0,
-	AA,
-	AI,
-	Aggro,
-	Attack,
-	Client_Server_Packet,
-	Combat,
-	Commands,
-	Crash,
-	Debug,
-	Doors,
-	Error,
-	Guilds,
-	Inventory,
-	Launcher,
-	Netcode,
-	Normal,
-	Object,
-	Pathing,
-	QS_Server,
-	Quests,
-	Rules,
-	Skills,
-	Spawns,
-	Spells,
-	Status,
-	TCP_Connection,
-	Tasks,
-	Tradeskills,
-	Trading,
-	Tribute,
-	UCS_Server,
-	WebInterface_Server,
-	World_Server,
-	Zone_Server,
-	MySQLError,
-	MySQLQuery,
-	Mercenaries,
-	QuestDebug,
-	Server_Client_Packet,
-	Client_Server_Packet_Unhandled,
-	Server_Client_Packet_With_Dump,
-	Client_Server_Packet_With_Dump,
-	Login_Server,
-	Client_Login,
-	Headless_Client,
-	HP_Update,
-	FixZ,
-	Food,
-	Traps,
-	NATS,
-	MaxCategoryID	/* Don't Remove this*/
-};
+	enum LogCategory {
+		None = 0,
+		AA,
+		AI,
+		Aggro,
+		Attack,
+		Client_Server_Packet,
+		Combat,
+		Commands,
+		Crash,
+		Database,
+		Debug,
+		Doors,
+		Error,
+		Guilds,
+		Inventory,
+		Launcher,
+		LoginServer,
+		Netcode,
+		Normal,
+		Object,
+		Pathing,
+		QS_Server,
+		Quests,
+		Rules,
+		Skills,
+		Spawns,
+		Spells,
+		Status,
+		TCP_Connection,
+		Tasks,
+		Tradeskills,
+		Trading,
+		Tribute,
+		UCS_Server,
+		WebInterface_Server,
+		World_Server,
+		Zone_Server,
+		MySQLError,
+		MySQLQuery,
+		Mercenaries,
+		QuestDebug,
+		Server_Client_Packet,
+		Client_Server_Packet_Unhandled,
+		Server_Client_Packet_With_Dump,
+		Client_Server_Packet_With_Dump,
+		MaxCategoryID	/* Don't Remove this*/
+	};
 
-/* If you add to this, make sure you update LogCategory */
-static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
-	"",
-	"AA",
-	"AI",
-	"Aggro",
-	"Attack",
-	"Packet :: Client -> Server",
-	"Combat",
-	"Commands",
-	"Crash",
-	"Debug",
-	"Doors",
-	"Error",
-	"Guilds",
-	"Inventory",
-	"Launcher",
-	"Netcode",
-	"Normal",
-	"Object",
-	"Pathing",
-	"QS Server",
-	"Quests",
-	"Rules",
-	"Skills",
-	"Spawns",
-	"Spells",
-	"Status",
-	"TCP Connection",
-	"Tasks",
-	"Tradeskills",
-	"Trading",
-	"Tribute",
-	"UCS Server",
-	"WebInterface Server",
-	"World Server",
-	"Zone Server",
-	"MySQL Error",
-	"MySQL Query",
-	"Mercenaries",
-	"Quest Debug",
-	"Packet :: Server -> Client",
-	"Packet :: Client -> Server Unhandled",
-	"Packet :: Server -> Client (Dump)",
-	"Packet :: Client -> Server (Dump)",
-	"Login Server",
-	"Client Login",
-	"Headless Client",
-	"HP Update",
-	"FixZ",
-	"Food",
-	"Traps",
-	"NATS"
-};
+	/* If you add to this, make sure you update LogCategory */
+	static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
+		"",
+		"AA",
+		"AI",
+		"Aggro",
+		"Attack",
+		"Packet :: Client -> Server",
+		"Combat",
+		"Commands",
+		"Crash",
+		"Database",
+		"Debug",
+		"Doors",
+		"Error",
+		"Guilds",
+		"Inventory",
+		"Launcher",
+		"LoginServer",
+		"Netcode",
+		"Normal",
+		"Object",
+		"Pathing",
+		"QS Server",
+		"Quests",
+		"Rules",
+		"Skills",
+		"Spawns",
+		"Spells",
+		"Status",
+		"TCP Connection",
+		"Tasks",
+		"Tradeskills",
+		"Trading",
+		"Tribute",
+		"UCS Server",
+		"WebInterface Server",
+		"World Server",
+		"Zone Server",
+		"MySQLError",
+		"MySQLQuery",
+		"Mercenaries",
+		"Quest Debug",
+		"Packet :: Server -> Client",
+		"Packet :: Client -> Server Unhandled",
+		"Packet :: Server -> Client (Dump)",
+		"Packet :: Client -> Server (Dump)",
+	};
 }
 
-#define Log(debug_level, log_category, message, ...) do {\
-	if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-		LogSys.Out(debug_level, log_category, message, ##__VA_ARGS__);\
-} while (0)
-
-#define LogF(debug_level, log_category, message, ...) do {\
-	if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-		LogSys.OutF(debug_level, log_category, message, ##__VA_ARGS__);\
-} while (0)
-
 class EQEmuLogSys {
 public:
 	EQEmuLogSys();
@@ -181,13 +158,6 @@ public:
 	void SetCurrentTimeStamp(char* time_stamp); /* Used in file logs to prepend a timestamp entry for logs */ 
 	void StartFileLogs(const std::string &log_name = ""); /* Used to declare the processes file log and to keep it open for later use */
 
-	template <typename... Args>
-	void OutF(Logs::DebugLevel debug_level, uint16 log_category, const char *fmt, const Args&... args)
-	{
-		std::string log_str = fmt::format(fmt, args...);
-		Out(debug_level, log_category, log_str);
-	}
-
 	/*
 		LogSettings Struct
 
@@ -228,11 +198,11 @@ private:
 
 	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */
 
-	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log */
-	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log */
-	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log */
+	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log.Out */
+	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log.Out */
+	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log.Out */
 };
 
-extern EQEmuLogSys LogSys;
+extern EQEmuLogSys Log;
 
 #endif

common/eqtime.cpp

@@ -43,19 +43,19 @@ EQTime::EQTime(TimeOfDay_Struct start_eq, time_t start_real)
 
 EQTime::EQTime()
 {
-	timezone = 0;
+	timezone=0;
 	memset(&eqTime, 0, sizeof(eqTime));
 	//Defaults for time
 	TimeOfDay_Struct start;
-	start.day = 1;
-	start.hour = 9;
-	start.minute = 0;
-	start.month = 1;
-	start.year = 3100;
+	start.day=1;
+	start.hour=9;
+	start.minute=0;
+	start.month=1;
+	start.year=3100;
 	//Set default time zone
-	timezone = 0;
+	timezone=0;
 	//Start EQTimer
-	SetCurrentEQTimeOfDay(start, time(0));
+	setEQTimeOfDay(start, time(0));
 }
 
 EQTime::~EQTime()
@@ -67,10 +67,10 @@ EQTime::~EQTime()
 //Input: Current Time (as a time_t), a pointer to the TimeOfDay_Struct that will be written to.
 //Output: 0=Error, 1=Sucess
 
-int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *eqTimeOfDay)
+int EQTime::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeOfDay )
 {
 	/* check to see if we have a reference time to go by. */
-	if (eqTime.start_realtime == 0)
+	if( eqTime.start_realtime == 0 )
 		return 0;
 
 	unsigned long diff = timeConvert - eqTime.start_realtime;
@@ -83,7 +83,7 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 	int32 ntz = timezone;
 
 	/* The minutes range from 0 - 59 */
-	diff += eqTime.start_eqtime.minute + (ntz % 60);
+	diff += eqTime.start_eqtime.minute + (ntz%60);
 	eqTimeOfDay->minute = diff % 60;
 	diff /= 60;
 	ntz /= 60;
@@ -97,24 +97,24 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 	//
 	// Modify it so that it works from
 	// 0-23 for our calculations
-	diff += (eqTime.start_eqtime.hour - 1) + (ntz % 24);
-	eqTimeOfDay->hour = (diff % 24) + 1;
+	diff += ( eqTime.start_eqtime.hour - 1) + (ntz%24);
+	eqTimeOfDay->hour = (diff%24) + 1;
 	diff /= 24;
 	ntz /= 24;
 
 	// The days range from 1-28
 	// Modify it so that it works from
 	// 0-27 for our calculations
-	diff += (eqTime.start_eqtime.day - 1) + (ntz % 28);
-	eqTimeOfDay->day = (diff % 28) + 1;
+	diff += ( eqTime.start_eqtime.day - 1 ) + (ntz%28);
+	eqTimeOfDay->day = (diff%28) + 1;
 	diff /= 28;
 	ntz /= 28;
 
 	// The months range from 1-12
 	// Modify it so that it works from
 	// 0-11 for our calculations
-	diff += (eqTime.start_eqtime.month - 1) + (ntz % 12);
-	eqTimeOfDay->month = (diff % 12) + 1;
+	diff += ( eqTime.start_eqtime.month - 1 ) + (ntz%12);
+	eqTimeOfDay->month = (diff%12) + 1;
 	diff /= 12;
 	ntz /= 12;
 
@@ -124,34 +124,100 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 }
 
 //setEQTimeOfDay
-int EQTime::SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real)
+int EQTime::setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real)
 {
-	if (start_real == 0)
+	if(start_real==0)
 		return 0;
-	eqTime.start_eqtime = start_eq;
-	eqTime.start_realtime = start_real;
+	eqTime.start_eqtime=start_eq;
+	eqTime.start_realtime=start_real;
 	return 1;
 }
 
+//saveFile and loadFile need to use long for the save datatype...
+//For some reason, ifstream/ofstream have problems with EQEmu datatypes in files.
+bool EQTime::saveFile(const char *filename)
+{
+	std::ofstream of;
+	of.open(filename);
+	if(!of)
+	{
+		Log.Out(Logs::General, Logs::Error, "EQTime::saveFile failed: Unable to open file '%s'", filename);
+		return false;
+	}
+	//Enable for debugging
+	of << EQT_VERSION << std::endl;
+	of << (long)eqTime.start_eqtime.day << std::endl;
+	of << (long)eqTime.start_eqtime.hour << std::endl;
+	of << (long)eqTime.start_eqtime.minute << std::endl;
+	of << (long)eqTime.start_eqtime.month << std::endl;
+	of << eqTime.start_eqtime.year << std::endl;
+	of << eqTime.start_realtime << std::endl;
+	of.close();
+	return true;
+}
+
+bool EQTime::loadFile(const char *filename)
+{
+	int version=0;
+	long in_data=0;
+	std::ifstream in;
+	in.open(filename);
+	if(!in)
+	{
+		Log.Out(Logs::General, Logs::Error, "Could not load EQTime file %s", filename);
+		return false;
+	}
+	in >> version;
+	in.ignore(80, '\n');
+	if(version != EQT_VERSION)
+	{
+		Log.Out(Logs::General, Logs::Error, "'%s' is NOT a valid EQTime file. File version is %i, EQTime version is %i", filename, version, EQT_VERSION);
+		return false;
+	}
+	//in >> eqTime.start_eqtime.day;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.day = in_data;
+	//in >> eqTime.start_eqtime.hour;
+	in >> in_data;
+	eqTime.start_eqtime.hour = in_data;
+	in.ignore(80, '\n');
+	//in >> eqTime.start_eqtime.minute;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.minute = in_data;
+	//in >> eqTime.start_eqtime.month;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.month = in_data;
+	in >> eqTime.start_eqtime.year;
+	in.ignore(80, '\n');
+	in >> eqTime.start_realtime;
+	//Enable for debugging...
+	in.close();
+	return true;
+}
+
+
 bool EQTime::IsTimeBefore(TimeOfDay_Struct *base, TimeOfDay_Struct *test) {
-	if (base->year > test->year)
+	if(base->year > test->year)
 		return(true);
-	if (base->year < test->year)
+	if(base->year < test->year)
 		return(false);
 	//same years
-	if (base->month > test->month)
+	if(base->month > test->month)
 		return(true);
-	if (base->month < test->month)
+	if(base->month < test->month)
 		return(false);
 	//same month
-	if (base->day > test->day)
+	if(base->day > test->day)
 		return(true);
-	if (base->day < test->day)
+	if(base->day < test->day)
 		return(false);
 	//same day
-	if (base->hour > test->hour)
+	if(base->hour > test->hour)
 		return(true);
-	if (base->hour < test->hour)
+	if(base->hour < test->hour)
 		return(false);
 	//same hour...
 	return(base->minute > test->minute);
@@ -164,7 +230,7 @@ void EQTime::AddMinutes(uint32 minutes, TimeOfDay_Struct *to) {
 	//minutes start at 0, everything else starts at 1
 	cur = to->minute;
 	cur += minutes;
-	if (cur < 60) {
+	if(cur < 60) {
 		to->minute = cur;
 		return;
 	}
@@ -172,29 +238,29 @@ void EQTime::AddMinutes(uint32 minutes, TimeOfDay_Struct *to) {
 	//carry hours
 	cur /= 60;
 	cur += to->hour;
-	if (cur <= 24) {
+	if(cur <= 24) {
 		to->hour = cur;
 		return;
 	}
-	to->hour = ((cur - 1) % 24) + 1;
+	to->hour = ((cur-1) % 24) + 1;
 	//carry days
-	cur = (cur - 1) / 24;
+	cur = (cur-1) / 24;
 	cur += to->day;
-	if (cur <= 28) {
+	if(cur <= 28) {
 		to->day = cur;
 		return;
 	}
-	to->day = ((cur - 1) % 28) + 1;
+	to->day = ((cur-1) % 28) + 1;
 	//carry months
-	cur = (cur - 1) / 28;
+	cur = (cur-1) / 28;
 	cur += to->month;
-	if (cur <= 12) {
+	if(cur <= 12) {
 		to->month = cur;
 		return;
 	}
-	to->month = ((cur - 1) % 12) + 1;
+	to->month = ((cur-1) % 12) + 1;
 	//carry years
-	to->year += (cur - 1) / 12;
+	to->year += (cur-1) / 12;
 }
 
 void EQTime::ToString(TimeOfDay_Struct *t, std::string &str) {
@@ -203,4 +269,5 @@ void EQTime::ToString(TimeOfDay_Struct *t, std::string &str) {
 		t->month, t->day, t->year, t->hour, t->minute);
 	buf[127] = '\0';
 	str = buf;
-}
+}
+

common/eqtime.h

@@ -21,8 +21,8 @@ public:
 	~EQTime();
 
 	//Get functions
-	int GetCurrentEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(GetCurrentEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
-	int GetCurrentEQTimeOfDay( time_t timeConvert, TimeOfDay_Struct *eqTimeOfDay );
+	int getEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(getEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
+	int getEQTimeOfDay( time_t timeConvert, TimeOfDay_Struct *eqTimeOfDay );
 	TimeOfDay_Struct getStartEQTime() { return eqTime.start_eqtime; }
 	time_t getStartRealTime() { return eqTime.start_realtime; }
 	uint32 getEQTimeZone() { return timezone; }
@@ -30,7 +30,7 @@ public:
 	uint32 getEQTimeZoneMin() { return timezone%60; }
 
 	//Set functions
-	int SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
+	int setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
 	void setEQTimeZone(int32 in_timezone) { timezone=in_timezone; }
 
 	//Time math/logic functions
@@ -39,6 +39,12 @@ public:
 
 	static void ToString(TimeOfDay_Struct *t, std::string &str);
 
+	//Database functions
+	//bool loadDB(Database q);
+	//bool setDB(Database q);
+	bool loadFile(const char *filename);
+	bool saveFile(const char *filename);
+
 private:
 	//This is our reference clock.
 	eqTimeOfDay eqTime;

common/event/background_task.h

@@ -1,39 +0,0 @@
-#pragma once
-#include <functional>
-#include "event_loop.h"
-
-namespace EQ {
-	class BackgroundTask
-	{
-	public:
-		typedef std::function<void(void)> BackgroundTaskFunction;
-		struct BackgroundTaskBaton
-		{
-			BackgroundTaskFunction fn;
-			BackgroundTaskFunction on_finish;
-		};
-
-		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish) {
-			uv_work_t *m_work = new uv_work_t;
-			memset(m_work, 0, sizeof(uv_work_t));
-			BackgroundTaskBaton *baton = new BackgroundTaskBaton();
-			baton->fn = fn;
-			baton->on_finish = on_finish;
-		
-			m_work->data = baton;
-			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->fn();
-			}, [](uv_work_t* req, int status) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->on_finish();
-				delete baton;
-				delete req;
-			});
-		}
-
-		~BackgroundTask() {
-
-		}
-	};
-}

common/event/event_loop.h

@@ -1,37 +0,0 @@
-#pragma once
-#include <functional>
-#include <uv.h>
-#include <cstring>
-
-namespace EQ
-{
-	class EventLoop
-	{
-	public:
-		static EventLoop &Get() {
-			static EventLoop inst;
-			return inst;
-		}
-
-		~EventLoop() {
-			uv_loop_close(&m_loop);
-		}
-
-		void Process() {
-			uv_run(&m_loop, UV_RUN_NOWAIT);
-		}
-
-		uv_loop_t* Handle() { return &m_loop; }
-
-	private:
-		EventLoop() {
-			memset(&m_loop, 0, sizeof(uv_loop_t));
-			uv_loop_init(&m_loop);
-		}
-		
-		EventLoop(const EventLoop&);
-		EventLoop& operator=(const EventLoop&);
-	
-		uv_loop_t m_loop;
-	};
-}

common/event/timer.h

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

common/event_sub.cpp

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

common/event_sub.h

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

common/extprofile.cpp

@@ -26,6 +26,7 @@ void InitExtendedProfile(ExtendedProfile_Struct *p) {
 }
 
 bool SetExtendedProfile(ExtendedProfile_Struct *to, char *old, unsigned int len) {
+	_eqp
 	if(len == 0 || old == nullptr) {
 		//handle old chars without an extended profile...
 		InitExtendedProfile(to);

common/extprofile.h

@@ -19,7 +19,7 @@
 #define EXTENDED_PROFILE_H
 
 #include "eq_packet_structs.h"
-#include "inventory_profile.h"
+#include "item.h"
 
 #pragma pack(1)
 
@@ -40,7 +40,7 @@ struct ExtendedProfile_Struct {
 	uint16				old_pet_hp; /* Not Used */
 	uint16				old_pet_mana; /* Not Used */
 	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
-	EQEmu::TextureMaterialProfile	pet_items; /* Not Used */
+	uint32				pet_items[_MaterialCount]; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */
@@ -54,8 +54,6 @@ struct ExtendedProfile_Struct {
 	uint32				mercTimerRemaining; /* Not Used */
 	uint8				mercGender; /* Not Used */
 	int32				mercState; /* Not Used */
-	uint32				last_invsnapshot_time; /* Used */
-	uint32				next_invsnapshot_time; /* Used */
 };
 
 #pragma pack()

common/faction.cpp

@@ -21,6 +21,7 @@
 
 const char *FactionValueToString(FACTION_VALUE fv)
 {
+	_eqp
 	switch (fv) {
 		case FACTION_ALLY:
 			return ("Ally");
@@ -55,6 +56,7 @@ const char *FactionValueToString(FACTION_VALUE fv)
 //o--------------------------------------------------------------
 FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 {
+	_eqp
 	int32 character_value = tmpCharacter_value;
 	if (fm) {
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
@@ -92,6 +94,7 @@ FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 // this function should check if some races have more than one race define
 bool IsOfEqualRace(int r1, int r2)
 {
+	_eqp
 	if (r1 == r2) {
 		return true;
 	}
@@ -113,6 +116,7 @@ bool IsOfEqualRace(int r1, int r2)
 // trolls endure ogres, dark elves, ...
 bool IsOfIndiffRace(int r1, int r2)
 {
+	_eqp
 	if (r1 == r2) {
 		return true;
 	}

common/features.h

@@ -111,6 +111,9 @@ Zone extensions and features
 //path to where sql logs should be placed
 #define SQL_LOG_PATH "sql_logs/"
 
+//New aggro system to reduce overhead.
+#define REVERSE_AGGRO
+
 //The highest you can #setskill / #setallskill
 #define HIGHEST_CAN_SET_SKILL 400
 
@@ -151,15 +154,15 @@ enum {	//reuse times
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
 	AIthink_duration = 150,
-	AIscanarea_delay = 6000,
+	AIscanarea_delay = 500,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
-	// AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
+	AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
-	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed
 	ClientProximity_interval = 150,
 	CombatEventTimer_expire = 12000,
 	Tribute_duration = 600000,
+	ZoneTimerResolution = 3,			//sleep time between zone main loop runs (milliseconds)
 	FeignMemoryDuration = 120000, // Duration player must feign death to clear zonewide agro.
 	EnragedTimer = 360000,
 	EnragedDurationTimer = 10000
@@ -209,8 +212,8 @@ enum {	//some random constants
 #define MAX_NPC_FACTIONS 20
 
 //individual faction pool
-#define MAX_PERSONAL_FACTION 2000
-#define MIN_PERSONAL_FACTION -2000
+#define MAX_PERSONAL_FACTION 1200
+#define MIN_PERSONAL_FACTION -3000
 
 //The Level Cap:
 //#define LEVEL_CAP RuleI(Character, MaxLevel)	//hard cap is 127
@@ -219,9 +222,6 @@ enum {	//some random constants
 //the square of the maximum range at whihc you could possibly use NPC services (shop, tribute, etc)
 #define USE_NPC_RANGE2 200*200		//arbitrary right now
 
-// Squared range for rampage 75.0 * 75.0 for now
-#define NPC_RAMPAGE_RANGE2 5625.0f
-
 //the formula for experience for killing a mob.
 //level is the only valid variable to use
 #define EXP_FORMULA level*level*75*35/10
@@ -232,11 +232,6 @@ enum {	//some random constants
 #define GROUP_EXP_PER_POINT 1000
 #define RAID_EXP_PER_POINT 2000
 
-#define ZONE_CONTROLLER_NPC_ID 10
-
-// Timer to update aggrometer
-#define AGGRO_METER_UPDATE_MS 1000
-
 //Some hard coded statuses from commands and other places:
 enum {
 	minStatusToBeGM = 40,
@@ -275,14 +270,6 @@ enum {
 #define NPC_DEFAULT_LOGGING_ENABLED false
 
 
-// This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
-#define SAYLINK_ITEM_ID 0xFFFFF
-
-
-// consumption timers for food/drink here instead of rules because the client
-// uses these. Times in ms.
-#define CONSUMPTION_TIMER 46000
-#define CONSUMPTION_MNK_TIMER 92000
 
 /*
 

common/glm/copying.txt

@@ -1,39 +1,6 @@
-================================================================================
-OpenGL Mathematics (GLM)
---------------------------------------------------------------------------------
-GLM can be distributed and/or modified under the terms of either
-a) The Happy Bunny License, or b) the MIT License.
-
-================================================================================
-The Happy Bunny License (Modified MIT License)
---------------------------------------------------------------------------------
-Copyright (c) 2005 - 2016 G-Truc Creation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-Restrictions: By making use of the Software for military purposes, you choose
-to make a Bunny unhappy.
-
-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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-================================================================================
 The MIT License
---------------------------------------------------------------------------------
-Copyright (c) 2005 - 2016 G-Truc Creation
+
+Copyright (c) 2005 - 2013 G-Truc Creation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

common/glm/glm/CMakeLists.txt

@@ -1,9 +1,9 @@
+set(NAME glm_dummy)
+
 file(GLOB ROOT_SOURCE *.cpp)
 file(GLOB ROOT_INLINE *.inl)
 file(GLOB ROOT_HEADER *.hpp)
 file(GLOB ROOT_TEXT ../*.txt)
-file(GLOB ROOT_MD ../*.md)
-file(GLOB ROOT_NAT ../util/glm.natvis)
 
 file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
 file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
@@ -17,11 +17,7 @@ file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
 file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
 file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
 
-file(GLOB_RECURSE SIMD_SOURCE ./simd/*.cpp)
-file(GLOB_RECURSE SIMD_INLINE ./simd/*.inl)
-file(GLOB_RECURSE SIMD_HEADER ./simd/*.h)
-
-source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD})
+source_group("Text Files" FILES ${ROOT_TEXT})
 source_group("Core Files" FILES ${CORE_SOURCE})
 source_group("Core Files" FILES ${CORE_INLINE})
 source_group("Core Files" FILES ${CORE_HEADER})
@@ -31,37 +27,16 @@ source_group("GTC Files" FILES ${GTC_HEADER})
 source_group("GTX Files" FILES ${GTX_SOURCE})
 source_group("GTX Files" FILES ${GTX_INLINE})
 source_group("GTX Files" FILES ${GTX_HEADER})
-source_group("SIMD Files" FILES ${SIMD_SOURCE})
-source_group("SIMD Files" FILES ${SIMD_INLINE})
-source_group("SIMD Files" FILES ${SIMD_HEADER})
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-if(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	if(GLM_STATIC_LIBRARY_ENABLE)
-		add_library(glm_static STATIC ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_STATIC_LIBRARY_ENABLE)
-
-	if(GLM_DYNAMIC_LIBRARY_ENABLE)
-		add_library(glm_shared SHARED ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_DYNAMIC_LIBRARY_ENABLE)
-
-else(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	add_executable(glm_dummy ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
+if(GLM_TEST_ENABLE)
+	add_executable(${NAME} ${ROOT_TEXT}
 		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
 		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
 		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-		${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+endif(GLM_TEST_ENABLE)
 
-endif(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
+#add_library(glm STATIC glm.cpp)
+#add_library(glm_shared SHARED glm.cpp)

common/glm/glm/common.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/common.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/_features.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/_features.hpp
+/// @date 2013-02-20 / 2013-02-20
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 
@@ -255,7 +284,7 @@
 #		define GLM_CXX11_STATIC_ASSERT
 #	endif
 
-#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
 #	if(__has_feature(cxx_exceptions))
 #		define GLM_CXX98_EXCEPTIONS
 #	endif
@@ -396,4 +425,4 @@
 #		define GLM_CXX11_VARIADIC_TEMPLATES
 #	endif
 
-#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
+#endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))

common/glm/glm/detail/_fixes.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/_fixes.hpp
+/// @date 2011-02-21 / 2011-11-22
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #include <cmath>
 

common/glm/glm/detail/_noise.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/_noise.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/_swizzle_func.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/_swizzle_func.hpp
+/// @date 2011-10-16 / 2011-10-16
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/_vectorize.hpp

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/_vectorize.hpp
+/// @date 2011-10-14 / 2011-10-14
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/dummy.cpp

@@ -1,13 +1,40 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/core/dummy.cpp
+/// @date 2011-01-19 / 2011-06-15
+/// @author Christophe Riccio
 ///
 /// GLM is a header only library. There is nothing to compile. 
 /// dummy.cpp exist only a wordaround for CMake file.
+///////////////////////////////////////////////////////////////////////////////////
 
-/*
 #define GLM_MESSAGES
-#include <glm/glm.hpp>
-#include <glm/ext.hpp>
+#include "../glm.hpp"
 #include <limits>
 
 struct material
@@ -121,8 +148,6 @@ struct intersection
 	glm::vec4 position;
 	glm::vec3 normal;
 };
-*/
-
 
 /*
 // Sample 4
@@ -165,7 +190,7 @@ glm::vec3 lighting
 }
 */
 
-/*
+
 template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
 T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
 {
@@ -185,23 +210,13 @@ typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
 {
 	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
 }
-*/
+
 int main()
 {
-/*
-	glm::vec1 o(1);
-	glm::vec2 a(1);
-	glm::vec3 b(1);
-	glm::vec4 c(1);
+	glm::vec4 v(1);
+	float a = normalizeDotA(v, v);
+	float b = normalizeDotB(v, v);
+	float c = normalizeDotC(v, v);
 
-	glm::quat q;
-	glm::dualquat p;
-
-	glm::mat4 m(1);
-
-	float a0 = normalizeDotA(a, a);
-	float b0 = normalizeDotB(b, b);
-	float c0 = normalizeDotC(c, c);
-*/
 	return 0;
 }

common/glm/glm/detail/func_common.hpp

@@ -1,5 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_common.hpp
+/// @date 2008-03-08 / 2010-01-26
+/// @author Christophe Riccio
 /// 
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 ///
@@ -7,6 +35,7 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/func_common.inl

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_common.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_vector_relational.hpp"
 #include "type_vec2.hpp"
@@ -8,24 +37,142 @@
 #include "_vectorize.hpp"
 #include <limits>
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	// min
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs");
-		return x < y ? x : y;
-	}
+	template <typename genFIType, bool /*signed*/>
+	struct compute_abs
+	{};
 
-	// max
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
+	template <typename genFIType>
+	struct compute_abs<genFIType, true>
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs");
+		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
 
-		return x > y ? x : y;
-	}
+			return x >= genFIType(0) ? x : -x;
+			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+		}
+	};
+
+	template <typename genFIType>
+	struct compute_abs<genFIType, false>
+	{
+		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+			return x;
+		}
+	};
+
+	template <typename T, typename U, precision P, template <class, precision> class vecType>
+	struct compute_mix_vector
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_mix_vector<T, bool, P, vecType>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
+		{
+			vecType<T, P> Result(uninitialize);
+			for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+				Result[i] = a[i] ? y[i] : x[i];
+			return Result;
+		}
+	};
+
+	template <typename T, typename U, precision P, template <class, precision> class vecType>
+	struct compute_mix_scalar
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_mix_scalar<T, bool, P, vecType>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template <typename T, typename U>
+	struct compute_mix
+	{
+		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
+		}
+	};
+
+	template <typename T>
+	struct compute_mix<T, bool>
+	{
+		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true, bool isSigned = true>
+	struct compute_sign
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_sign<T, P, vecType, false, false>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return vecType<T, P>(glm::greaterThan(x , vecType<T, P>(0)));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_sign<T, P, vecType, false, true>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
+			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
+
+			return (x >> Shift) | y;
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType, typename genType, bool isFloat = true>
+	struct compute_mod
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, genType const & b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+			return a - b * floor(a / b);
+		}
+	};
+}//namespace detail
 
 	// abs
 	template <>
@@ -35,6 +182,67 @@ namespace glm
 		return (x ^ y) - y;
 	}
 
+	template <typename genFIType>
+	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
+	{
+		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(abs, x);
+	}
+
+	// sign
+	// fast and works for any type
+	template <typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+			"'sign' only accept signed inputs");
+		
+		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559>::call(tvec1<genFIType>(x)).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+	}
+
+	// floor
+	using ::std::floor;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(floor, x);
+	}
+
+	// trunc
+#	if GLM_HAS_CXX11_STL
+		using ::std::trunc;
+#	else
+		template <typename genType>
+		GLM_FUNC_QUALIFIER genType trunc(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? -floor(-x) : floor(x);
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(trunc, x);
+	}
+
 	// round
 #	if GLM_HAS_CXX11_STL
 		using ::std::round;
@@ -48,318 +256,10 @@ namespace glm
 		}
 #	endif
 
-	// trunc
-#	if GLM_HAS_CXX11_STL
-		using ::std::trunc;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType trunc(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
-
-			return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
-		}
-#	endif
-
-}//namespace glm
-
-namespace glm{
-namespace detail
-{
-	template <typename genFIType, bool /*signed*/>
-	struct compute_abs
-	{};
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, true>
-	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed || GLM_UNRESTRICTED_GENTYPE,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
-
-			return x >= genFIType(0) ? x : -x;
-			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
-		}
-	};
-
-	#if GLM_COMPILER & GLM_COMPILER_CUDA
-	template <>
-	struct compute_abs<float, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(float x)
-		{
-			return fabsf(x);
-		}
-	};
-	#endif
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, false>
-	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				(!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer) || GLM_UNRESTRICTED_GENTYPE,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
-			return x;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_abs_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(abs, x);
-		}
-	};
-
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_vector<T, bool, P, vecType, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
-		{
-			vecType<T, P> Result(uninitialize);
-			for(length_t i = 0; i < x.length(); ++i)
-				Result[i] = a[i] ? y[i] : x[i];
-			return Result;
-		}
-	};
-
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_scalar
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_scalar<T, bool, P, vecType, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, typename U>
-	struct compute_mix
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
-		}
-	};
-
-	template <typename T>
-	struct compute_mix<T, bool>
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool isFloat, bool Aligned>
-	struct compute_sign
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
-		}
-	};
-
-#	if GLM_ARCH == GLM_ARCH_X86
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_sign<T, P, vecType, false, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
-			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
-
-			return (x >> Shift) | y;
-		}
-	};
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_floor
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::floor, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_ceil
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::ceil, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_fract
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return x - floor(x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_trunc
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(trunc, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_round
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(round, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mod
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, vecType<T, P> const & b)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
-			return a - b * floor(a / b);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_min_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
-		{
-			return detail::functor2<T, P, vecType>::call(min, x, y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_max_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
-		{
-			return detail::functor2<T, P, vecType>::call(max, x, y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_clamp_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
-		{
-			return min(max(x, minVal), maxVal);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_step_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge, vecType<T, P> const & x)
-		{
-			return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_smoothstep_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'step' only accept floating-point inputs");
-			vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
-			return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
-		}
-	};
-}//namespace detail
-
-	template <typename genFIType>
-	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
-	{
-		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
-	{
-		return detail::compute_abs_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// sign
-	// fast and works for any type
-	template <typename genFIType> 
-	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
-			"'sign' only accept signed inputs");
-		
-		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559, highp>::call(tvec1<genFIType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
-			"'sign' only accept signed inputs");
-
-		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// floor
-	using ::std::floor;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
-		return detail::compute_floor<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
-		return detail::compute_trunc<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> round(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
-		return detail::compute_round<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::functor1<T, T, P, vecType>::call(round, x);
 	}
 
 /*
@@ -408,7 +308,6 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> roundEven(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
 		return detail::functor1<T, T, P, vecType>::call(roundEven, x);
 	}
 
@@ -417,47 +316,41 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> ceil(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
-		return detail::compute_ceil<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return detail::functor1<T, T, P, vecType>::call(ceil, x);
 	}
 
 	// fract
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType fract(genType x)
 	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fract' only accept floating-point inputs");
+
 		return fract(tvec1<genType>(x)).x;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> fract(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
-		return detail::compute_fract<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return x - floor(x);
 	}
 
 	// mod
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
 	{
-#		if GLM_COMPILER & GLM_COMPILER_CUDA
-			// Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
-			tvec1<genType, defaultp> Result(mod(tvec1<genType, defaultp>(x), y));
-			return Result.x;
-#		else
-			return mod(tvec1<genType, defaultp>(x), y).x;
-#		endif
+		return mod(tvec1<genType>(x), y).x;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, T y)
 	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(y));
+		return detail::compute_mod<T, P, vecType, T, std::numeric_limits<T>::is_iec559>::call(x, y);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, y);
+		return detail::compute_mod<T, P, vecType, vecType<T, P>, std::numeric_limits<T>::is_iec559>::call(x, y);
 	}
 
 	// modf
@@ -465,6 +358,7 @@ namespace detail
 	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
+
 		return std::modf(x, &i);
 	}
 
@@ -511,53 +405,70 @@ namespace detail
 	//CHAR_BIT - 1)));
 
 	// min
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
+
+		return x < y ? x : y;
+	}
+
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, T b)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point inputs for the interpolator a");
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
+		return detail::functor2_vec_sca<T, P, vecType>::call(min, a, b);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, vecType<T, P> const & b)
 	{
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
+		return detail::functor2<T, P, vecType>::call(min, a, b);
 	}
 
 	// max
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
+
+		return x > y ? x : y;
+	}
+
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, T b)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point inputs for the interpolator a");
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
+		return detail::functor2_vec_sca<T, P, vecType>::call(max, a, b);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, vecType<T, P> const & b)
 	{
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
+		return detail::functor2<T, P, vecType>::call(max, a, b);
 	}
 
 	// clamp
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType clamp(genType x, genType minVal, genType maxVal)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		
 		return min(max(x, minVal), maxVal);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(minVal), vecType<T, P>(maxVal));
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+
+		return min(max(x, minVal), maxVal);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, minVal, maxVal);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+
+		return min(max(x, minVal), maxVal);
 	}
 
 	template <typename genTypeT, typename genTypeU>
@@ -569,13 +480,13 @@ namespace detail
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a)
 	{
-		return detail::compute_mix_scalar<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
+		return detail::compute_mix_scalar<T, U, P, vecType>::call(x, y, a);
 	}
 	
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
 	{
-		return detail::compute_mix_vector<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
+		return detail::compute_mix_vector<T, U, P, vecType>::call(x, y, a);
 	}
 
 	// step
@@ -588,20 +499,22 @@ namespace detail
 	template <template <typename, precision> class vecType, typename T, precision P>
 	GLM_FUNC_QUALIFIER vecType<T, P> step(T edge, vecType<T, P> const & x)
 	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge), x);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'step' only accept floating-point inputs");
+
+		return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge)));
 	}
 
 	template <template <typename, precision> class vecType, typename T, precision P>
 	GLM_FUNC_QUALIFIER vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x)
 	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge, x);
+		return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
 	}
 
 	// smoothstep
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
 		genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
 		return tmp * tmp * (genType(3) - genType(2) * tmp);
@@ -610,13 +523,19 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x)
 	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge0), vecType<T, P>(edge1), x);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
+
+		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
 	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge0, edge1, x);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
+
+		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
 	}
 
 #	if GLM_HAS_CXX11_STL
@@ -629,16 +548,14 @@ namespace detail
 
 #			if GLM_HAS_CXX11_STL
 				return std::isnan(x);
-#			elif GLM_COMPILER & GLM_COMPILER_VC
+#			elif GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)
 				return _isnan(x) != 0;
-#			elif GLM_COMPILER & GLM_COMPILER_INTEL
-#				if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#				if GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L
 					return _isnan(x) != 0;
 #				else
-					return ::isnan(x) != 0;
+					return std::isnan(x);
 #				endif
-#			elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L
-				return _isnan(x) != 0;
 #			elif GLM_COMPILER & GLM_COMPILER_CUDA
 				return isnan(x) != 0;
 #			else
@@ -666,12 +583,8 @@ namespace detail
 #			if GLM_HAS_CXX11_STL
 				return std::isinf(x);
 #			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
-#				if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
-					return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-#				else
-					return ::isinf(x);
-#				endif
-#			elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+				return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
 #				if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
 					return _isinf(x) != 0;
 #				else
@@ -747,23 +660,23 @@ namespace detail
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType frexp(genType x, int & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return std::frexp(x, &exp);
+		return std::frexp(x, exp);
 	}
 
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> frexp(tvec1<T, P> const & x, tvec1<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return tvec1<T, P>(std::frexp(x.x, &exp.x));
+		return tvec1<T, P>(std::frexp(x.x, exp.x));
 	}
 
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> frexp(tvec2<T, P> const & x, tvec2<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
 		return tvec2<T, P>(
 			frexp(x.x, exp.x),
@@ -773,7 +686,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> frexp(tvec3<T, P> const & x, tvec3<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
 		return tvec3<T, P>(
 			frexp(x.x, exp.x),
@@ -784,7 +697,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> frexp(tvec4<T, P> const & x, tvec4<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
 		return tvec4<T, P>(
 			frexp(x.x, exp.x),
@@ -793,10 +706,10 @@ namespace detail
 			frexp(x.w, exp.w));
 	}
 
-	template <typename genType>
+	template <typename genType, precision P>
 	GLM_FUNC_QUALIFIER genType ldexp(genType const & x, int const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
 
 		return std::ldexp(x, exp);
 	}
@@ -804,7 +717,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp(tvec1<T, P> const & x, tvec1<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
 		return tvec1<T, P>(
 			ldexp(x.x, exp.x));
@@ -813,7 +726,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp(tvec2<T, P> const & x, tvec2<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
 		return tvec2<T, P>(
 			ldexp(x.x, exp.x),
@@ -823,7 +736,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp(tvec3<T, P> const & x, tvec3<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
 		return tvec3<T, P>(
 			ldexp(x.x, exp.x),
@@ -834,7 +747,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp(tvec4<T, P> const & x, tvec4<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
 		return tvec4<T, P>(
 			ldexp(x.x, exp.x),
@@ -843,7 +756,3 @@ namespace detail
 			ldexp(x.w, exp.w));
 	}
 }//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_common_simd.inl"
-#endif

common/glm/glm/detail/func_common_simd.inl

@@ -1,231 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_common_simd.inl
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-#include "../simd/common.h"
-
-#include <immintrin.h>
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_abs_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_abs_vector<int, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v)
-		{
-			tvec4<int, P> result(uninitialize);
-			result.data = glm_ivec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_floor<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_floor(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_ceil<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_ceil(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_fract<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_fract(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_round<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_round(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_mod<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_mod(x.data, y.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_min_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_min_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_min_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_max_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_max_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_max_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & minVal, tvec4<float, P> const & maxVal)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & x, tvec4<int32, P> const & minVal, tvec4<int32, P> const & maxVal)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & x, tvec4<uint32, P> const & minVal, tvec4<uint32, P> const & maxVal)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_mix_vector<float, bool, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y, tvec4<bool, P> const & a)
-		{
-			__m128i const Load = _mm_set_epi32(-(int)a.w, -(int)a.z, -(int)a.y, -(int)a.x);
-			__m128 const Mask = _mm_castsi128_ps(Load);
-
-			tvec4<float, P> Result(uninitialize);
-#			if 0 && GLM_ARCH & GLM_ARCH_AVX
-				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
-#			else
-				Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
-#			endif
-			return Result;
-		}
-	};
-/* FIXME
-	template <precision P>
-	struct compute_step_vector<float, P, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge, tvec4<float, P> const& x)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_step(edge.data, x.data);
-			return result;
-		}
-	};
-*/
-	template <precision P>
-	struct compute_smoothstep_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge0, tvec4<float, P> const& edge1, tvec4<float, P> const& x)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_exponential.hpp

@@ -1,5 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_exponential.hpp
+/// @date 2008-08-08 / 2011-06-14
+/// @author Christophe Riccio
 /// 
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 ///
@@ -7,6 +35,7 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

common/glm/glm/detail/func_exponential.inl

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_exponential.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"
@@ -20,7 +49,7 @@ namespace detail
 		}
 #	endif
 
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat, bool Aligned>
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
 	struct compute_log2
 	{
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
@@ -29,16 +58,7 @@ namespace detail
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_sqrt
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::sqrt, x);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template <template <class, precision> class vecType, typename T, precision P>
 	struct compute_inversesqrt
 	{
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
@@ -47,8 +67,8 @@ namespace detail
 		}
 	};
 		
-	template <template <class, precision> class vecType, bool Aligned>
-	struct compute_inversesqrt<vecType, float, lowp, Aligned>
+	template <template <class, precision> class vecType>
+	struct compute_inversesqrt<vecType, float, lowp>
 	{
 		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
 		{
@@ -113,7 +133,7 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
 	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
 	}
 
 	// sqrt
@@ -122,7 +142,7 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
 	}
 
 	// inversesqrt
@@ -136,11 +156,6 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_inversesqrt<vecType, T, P>::call(x);
 	}
 }//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_exponential_simd.inl"
-#endif
-

common/glm/glm/detail/func_exponential_simd.inl

@@ -1,35 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_exponential_simd.inl
-
-#include "../simd/exponential.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_sqrt<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_sqrt_ps(v.data);
-			return result;
-		}
-	};
-
-	template <>
-	struct compute_sqrt<tvec4, float, aligned_lowp, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, aligned_lowp> call(tvec4<float, aligned_lowp> const & v)
-		{
-			tvec4<float, aligned_lowp> result(uninitialize);
-			result.data = glm_vec4_sqrt_lowp(v.data);
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_geometric.hpp

@@ -1,5 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_geometric.hpp
+/// @date 2008-08-03 / 2011-06-14
+/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 /// 
@@ -7,6 +35,7 @@
 /// @ingroup core
 /// 
 /// These operate on vectors as vectors, not component-wise.
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 
@@ -75,11 +104,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> faceforward(
-		vecType<T, P> const & N,
-		vecType<T, P> const & I,
-		vecType<T, P> const & Nref);
+	template <typename genType>
+	GLM_FUNC_DECL genType faceforward(
+		genType const & N,
+		genType const & I,
+		genType const & Nref);
 
 	/// For the incident vector I and surface orientation N, 
 	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.

common/glm/glm/detail/func_geometric.inl

@@ -1,5 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_geometric.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_exponential.hpp"
 #include "func_common.hpp"
@@ -10,29 +39,11 @@
 namespace glm{
 namespace detail
 {
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_length
-	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & v)
-		{
-			return sqrt(dot(v, v));
-		}
-	};
-
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_distance
-	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & p0, vecType<T, P> const & p1)
-		{
-			return length(p1 - p0);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template <template <class, precision> class vecType, typename T, precision P>
 	struct compute_dot{};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec1, T, P, Aligned>
+	template <typename T, precision P>
+	struct compute_dot<tvec1, T, P>
 	{
 		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
 		{
@@ -40,8 +51,8 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec2, T, P, Aligned>
+	template <typename T, precision P>
+	struct compute_dot<tvec2, T, P>
 	{
 		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
 		{
@@ -50,8 +61,8 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec3, T, P, Aligned>
+	template <typename T, precision P>
+	struct compute_dot<tvec3, T, P>
 	{
 		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
 		{
@@ -60,8 +71,8 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec4, T, P, Aligned>
+	template <typename T, precision P>
+	struct compute_dot<tvec4, T, P>
 	{
 		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
 		{
@@ -69,69 +80,13 @@ namespace detail
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_cross
-	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(tvec3<T, P> const & x, tvec3<T, P> const & y)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
-
-			return tvec3<T, P>(
-				x.y * y.z - y.y * x.z,
-				x.z * y.x - y.z * x.x,
-				x.x * y.y - y.x * x.y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_normalize
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return v * inversesqrt(dot(v, v));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_faceforward
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return dot(Nref, I) < static_cast<T>(0) ? N : -N;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_reflect
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N)
-		{
-			return I - N * dot(N, I) * static_cast<T>(2);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_refract
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
-		{
-			T const dotValue(dot(N, I));
-			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-			return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
-		}
-	};
 }//namespace detail
 
 	// length
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType length(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
 
 		return abs(x);
 	}
@@ -139,16 +94,16 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
-		return detail::compute_length<vecType, T, P, detail::is_aligned<P>::value>::call(v);
+		return sqrt(dot(v, v));
 	}
 
 	// distance
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
 
 		return length(p1 - p0);
 	}
@@ -156,36 +111,41 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
 	{
-		return detail::compute_distance<vecType, T, P, detail::is_aligned<P>::value>::call(p0, p1);
+		return length(p1 - p0);
 	}
 
 	// dot
 	template <typename T>
 	GLM_FUNC_QUALIFIER T dot(T x, T y)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
 		return x * y;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return detail::compute_dot<vecType, T, P, detail::is_aligned<P>::value>::call(x, y);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
+		return detail::compute_dot<vecType, T, P>::call(x, y);
 	}
 
 	// cross
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
 	{
-		return detail::compute_cross<T, P, detail::is_aligned<P>::value>::call(x, y);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
+
+		return tvec3<T, P>(
+			x.y * y.z - y.y * x.z,
+			x.z * y.x - y.z * x.x,
+			x.x * y.y - y.x * x.y);
 	}
 
 	// normalize
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
 
 		return x < genType(0) ? genType(-1) : genType(1);
 	}
@@ -193,9 +153,9 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
 
-		return detail::compute_normalize<T, P, vecType, detail::is_aligned<P>::value>::call(x);
+		return x * inversesqrt(dot(x, x));
 	}
 
 	// faceforward
@@ -205,30 +165,19 @@ namespace detail
 		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> faceforward(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
-	{
-		return detail::compute_faceforward<T, P, vecType, detail::is_aligned<P>::value>::call(N, I, Nref);
-	}
-
 	// reflect
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
 	{
-		return I - N * dot(N, I) * genType(2);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> reflect(vecType<T, P> const & I, vecType<T, P> const & N)
-	{
-		return detail::compute_reflect<T, P, vecType, detail::is_aligned<P>::value>::call(I, N);
+		return I - N * dot(N, I) * static_cast<genType>(2);
 	}
 
 	// refract
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType eta)
+	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
+
 		genType const dotValue(dot(N, I));
 		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
 		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
@@ -237,11 +186,10 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
-		return detail::compute_refract<T, P, vecType, detail::is_aligned<P>::value>::call(I, N, eta);
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
+
+		T const dotValue(dot(N, I));
+		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
 	}
 }//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_geometric_simd.inl"
-#endif

common/glm/glm/detail/func_geometric_simd.inl

@@ -1,99 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_geometric_simd.inl
-
-#include "../simd/geometric.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_length<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & v)
-		{
-			return _mm_cvtss_f32(glm_vec4_length(v.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_distance<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1)
-		{
-			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_dot<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const& x, tvec4<float, P> const& y)
-		{
-			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_cross<float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec3<float, P> call(tvec3<float, P> const & a, tvec3<float, P> const & b)
-		{
-			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
-			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
-			__m128 const xpd0 = glm_vec4_cross(set0, set1);
-
-			tvec4<float, P> result(uninitialize);
-			result.data = xpd0;
-			return tvec3<float, P>(result);
-		}
-	};
-
-	template <precision P>
-	struct compute_normalize<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_normalize(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_faceforward<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_reflect<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_reflect(I.data, N.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_refract<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_integer.hpp

@@ -1,5 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
 /// @ref core
 /// @file glm/detail/func_integer.hpp
+/// @date 2010-03-17 / 2011-06-18
+/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 /// 
@@ -9,6 +37,7 @@
 /// These all operate component-wise. The description is per component. 
 /// The notation [a, b] means the set of bits from bit-number a through bit-number 
 /// b, inclusive. The lowest-order bit is bit 0.
+///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once