Changes to UF and above clients on how spell buff tics are synced.

FreeBSD Compile Fixes

.travis.yml

@@ -1,11 +1,17 @@
 language: cpp
 compiler: gcc
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -y libmysqlclient-dev libperl-dev libboost-dev liblua5.1-0-dev zlib1g-dev
+sudo: false
+addons:
+  apt:
+    packages:
+    - libmysqlclient-dev
+    - libperl-dev
+    - libboost-dev
+    - liblua5.1-0-dev
+    - zlib1g-dev
 script:
   - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
-  - make
+  - make -j8
   - ./bin/tests
 branches:
   only:

CMakeLists.txt

@@ -31,7 +31,6 @@
 #EQEMU_SANITIZE_LUA_LIBS
 #EQEMU_BUILD_CLIENT_FILES
 #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!
@@ -258,7 +257,6 @@ 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)
@@ -333,16 +331,6 @@ 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)
 	ADD_SUBDIRECTORY(common)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)

client_files/export/CMakeLists.txt

@@ -11,17 +11,15 @@ ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
 
 INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(export_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(export_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
-	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)
@@ -32,7 +30,6 @@ IF(UNIX)
 		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)
 

client_files/export/main.cpp

@@ -32,6 +32,7 @@ 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);
@@ -44,12 +45,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	const EQEmuConfig *config = EQEmuConfig::get();
+	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
-		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+	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;
@@ -62,6 +63,7 @@ int main(int argc, char **argv) {
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
+	ExportDBStrings(&database);
 
 	Log.CloseFileLogs();
 
@@ -194,7 +196,38 @@ void ExportBaseData(SharedDatabase *db) {
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	} else {
+	}
+
+	fclose(f);
+}
+
+void ExportDBStrings(SharedDatabase *db) {
+	Log.Out(Logs::General, Logs::Status, "Exporting DB Strings...");
+
+	FILE *f = fopen("export/dbstr_us.txt", "w");
+	if(!f) {
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
+		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());
+		}
 	}
 
 	fclose(f);

client_files/import/CMakeLists.txt

@@ -11,17 +11,15 @@ ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
 
 INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(import_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(import_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
-	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)
@@ -32,7 +30,6 @@ IF(UNIX)
 		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)
 

client_files/import/main.cpp

@@ -30,6 +30,7 @@ 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);
@@ -42,12 +43,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	const EQEmuConfig *config = EQEmuConfig::get();
+	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
-		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+	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;
@@ -59,6 +60,7 @@ int main(int argc, char **argv) {
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
+	ImportDBStrings(&database);
 
 	Log.CloseFileLogs();
 	
@@ -202,7 +204,6 @@ 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());
@@ -262,3 +263,56 @@ void ImportBaseData(SharedDatabase *db) {
 
 	fclose(f);
 }
+
+void ImportDBStrings(SharedDatabase *db) {
+	Log.Out(Logs::General, Logs::Status, "Importing DB Strings...");
+
+	FILE *f = fopen("import/dbstr_us.txt", "r");
+	if(!f) {
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
+		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,6 +21,12 @@ 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
@@ -30,49 +36,46 @@ ELSE(MYSQL_ROOT)
 ENDIF(MYSQL_ROOT)
 
 # Library
-SET(MySQL_NAMES mysqlclient_r mysqlclient)
+SET(MySQL_NAMES libmysql)
 IF(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
+	FIND_LIBRARY(MySQL_LIBRARY
 		NAMES ${MySQL_NAMES}
-		PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATHS ${MYSQL_ROOT}/lib
 		PATH_SUFFIXES mysql
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
 	)
-
-	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
+	
+	FIND_LIBRARY(MySQL_LIBRARY
 		NAMES ${MySQL_NAMES}
-		PATHS ${MYSQL_ROOT}/lib /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
-		NAMES ${MySQL_NAMES}
-		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
-		PATH_SUFFIXES mysql
-	)
-
-	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
-		NAMES ${MySQL_NAMES}
+	FIND_LIBRARY(MySQL_LIBRARY
+		NAMES ${MySQL_NAMES} mysqlclient_r mysqlclient
 		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ENDIF(MYSQL_ROOT)
 
-IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
+IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
 	SET(MySQL_FOUND TRUE)
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
-ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY} )
+ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
 	SET(MySQL_FOUND FALSE)
 	SET( MySQL_LIBRARIES )
-ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
+ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
 
 
 # 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_DEBUG MySQL_LIBRARY_RELEASE MySQL_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
 
 IF(MySQL_FOUND)
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
+	SET( MySQL_LIBRARY_RELEASE ${MySQL_LIBRARY} )
+	SET( MySQL_LIBRARY_DEBUG ${MySQL_LIBRARY} )
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_RELEASE} ${MySQL_LIBRARY_DEBUG} )
 ELSE(MySQL_FOUND)
 	SET( MySQL_LIBRARIES )
 ENDIF(MySQL_FOUND)

common/CMakeLists.txt

@@ -3,6 +3,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
+	client_version.cpp
 	condition.cpp
 	crash.cpp
 	crc16.cpp
@@ -11,15 +12,19 @@ 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_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
@@ -30,8 +35,11 @@ SET(common_sources
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
+	inventory_version.cpp
 	ipc_mutex.cpp
 	item.cpp
+	item_struct.cpp
+	light_source.cpp
 	md5.cpp
 	memory_mapped_file.cpp
 	misc.cpp
@@ -39,6 +47,7 @@ SET(common_sources
 	mutex.cpp
 	mysql_request_result.cpp
 	mysql_request_row.cpp
+	opcode_map.cpp
 	opcodemgr.cpp
 	packet_dump.cpp
 	packet_dump_file.cpp
@@ -48,7 +57,9 @@ SET(common_sources
 	proc_launcher.cpp
 	ptimer.cpp
 	races.cpp
+	rdtsc.cpp
 	rulesys.cpp
+	say_link.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -60,17 +71,22 @@ SET(common_sources
 	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
-	uuid.cpp
 	worldconn.cpp
 	xml_parser.cpp
 	platform.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
@@ -95,6 +111,7 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
+	client_version.h
 	condition.h
 	crash.h
 	crc16.h
@@ -103,12 +120,14 @@ 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_tcp_connection.h
 	emu_tcp_server.h
 	eq_constants.h
-	eq_dictionary.h
 	eq_packet_structs.h
 	eqdb.h
 	eqdb_res.h
@@ -116,6 +135,7 @@ 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
@@ -134,11 +154,13 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
+	inventory_version.h
 	ipc_mutex.h
 	item.h
 	item_fieldlist.h
 	item_struct.h
 	languages.h
+	light_source.h
 	linked_list.h
 	loottable.h
 	mail_oplist.h
@@ -157,12 +179,15 @@ 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
@@ -179,44 +204,44 @@ SET(common_headers
 	types.h
 	unix.h
 	useperl.h
-	uuid.h
 	version.h
 	worldconn.h
 	xml_parser.h
 	zone_numbers.h
 	patches/patches.h
 	patches/sod.h
-	patches/sod_constants.h
-	patches/sod_itemfields.h
+#	patches/sod_itemfields.h
+	patches/sod_limits.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_constants.h
-	patches/sof_itemfields.h
-	patches/sof_opcode_list.h
+#	patches/sof_itemfields.h
+	patches/sof_limits.h
+#	patches/sof_opcode_list.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_constants.h
-	patches/rof_itemfields.h
+#	patches/rof_itemfields.h
+	patches/rof_limits.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_constants.h
-	patches/rof2_itemfields.h
+#	patches/rof2_itemfields.h
+	patches/rof2_limits.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_constants.h
-	patches/titanium_itemfields.h
+#	patches/titanium_itemfields_a.h
+#	patches/titanium_itemfields_b.h
+	patches/titanium_limits.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_constants.h
-	patches/uf_itemfields.h
+#	patches/uf_itemfields.h
+	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
 	SocketLib/Base64.h
@@ -239,46 +264,53 @@ SET(common_headers
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-	patches/sod_itemfields.h
+#	patches/sod_itemfields.h
+	patches/sod_limits.h
 	patches/sod_ops.h
-	patches/sod_constants.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_itemfields.h
-	patches/sof_opcode_list.h
+#	patches/sof_itemfields.h
+	patches/sof_limits.h
+#	patches/sof_opcode_list.h
 	patches/sof_ops.h
-	patches/sof_constants.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_itemfields.h
+#	patches/rof_itemfields.h
+	patches/rof_limits.h
 	patches/rof_ops.h
-	patches/rof_constants.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_itemfields.h
+#	patches/rof2_itemfields.h
+	patches/rof2_limits.h
 	patches/rof2_ops.h
-	patches/rof2_constants.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_itemfields.h
+#	patches/titanium_itemfields_a.h
+#	patches/titanium_itemfields_b.h
+	patches/titanium_limits.h
 	patches/titanium_ops.h
-	patches/titanium_constants.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_itemfields.h
+#	patches/uf_itemfields.h
+	patches/uf_limits.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

common/base_packet.h

@@ -22,10 +22,10 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifdef WIN32
+#ifdef _WINDOWS
 	#include <time.h>
-	#include <windows.h>
 	#include <winsock2.h>
+	#include <windows.h>
 #else
 	#include <sys/time.h>
 	#include <netinet/in.h>
@@ -63,9 +63,12 @@ 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/classes.cpp

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) 2001-2016 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,275 +18,576 @@
 #include "../common/global_define.h"
 #include "../common/classes.h"
 
-const char* GetEQClassName(uint8 class_, uint8 level) {
-	switch(class_) {
-		case WARRIOR:
-			if (level >= 70)
-				return "Vanquisher";
-			else if (level >= 65)
-				return "Overlord"; //Baron-Sprite: LEAVE MY CLASSES ALONE.
-			else if (level >= 60)
-				return "Warlord";
-			else if (level >= 55)
-				return "Myrmidon";
-			else if (level >= 51)
-				return "Champion";
-			else
-				return "Warrior";
-		case CLERIC:
-			if (level >= 70)
-				return "Prelate";
-			else if (level >= 65)
-				return "Archon";
-			else if (level >= 60)
-				return "High Priest";
-			else if (level >= 55)
-				return "Templar";
-			else if (level >= 51)
-				return "Vicar";
-			else
-				return "Cleric";
-		case PALADIN:
-			if (level >= 70)
-				return "Lord";
-			else if (level >= 65)
-				return "Lord Protector";
-			else if (level >= 60)
-				return "Crusader";
-			else if (level >= 55)
-				return "Knight";
-			else if (level >= 51)
-				return "Cavalier";
-			else
-				return "Paladin";
-		case RANGER:
-			if (level >= 70)
-				return "Plainswalker";
-			else if (level >= 65)
-				return "Forest Stalker";
-			else if (level >= 60)
-				return "Warder";
-			else if (level >= 55)
-				return "Outrider";
-			else if (level >= 51)
-				return "Pathfinder";
-			else
-				return "Ranger";
-		case SHADOWKNIGHT:
-			if (level >= 70)
-				return "Scourge Knight";
-			else if (level >= 65)
-				return "Dread Lord";
-			else if (level >= 60)
-				return "Grave Lord";
-			else if (level >= 55)
-				return "Revenant";
-			else if (level >= 51)
-				return "Reaver";
-			else
-				return "Shadowknight";
-		case DRUID:
-			if (level >= 70)
-				return "Natureguard";
-			else if (level >= 65)
-				return "Storm Warden";
-			else if (level >= 60)
-				return "Hierophant";
-			else if (level >= 55)
-				return "Preserver";
-			else if (level >= 51)
-				return "Wanderer";
-			else
-				return "Druid";
-		case MONK:
-			if (level >= 70)
-				return "Stone Fist";
-			else if (level >= 65)
-				return "Transcendent";
-			else if (level >= 60)
-				return "Grandmaster";
-			else if (level >= 55)
-				return "Master";
-			else if (level >= 51)
-				return "Disciple";
-			else
-				return "Monk";
-		case BARD:
-			if (level >= 70)
-				return "Performer";
-			else if (level >= 65)
-				return "Maestro";
-			else if (level >= 60)
-				return "Virtuoso";
-			else if (level >= 55)
-				return "Troubadour";
-			else if (level >= 51)
-				return "Minstrel";
-			else
-				return "Bard";
-		case ROGUE:
-			if (level >= 70)
-				return "Nemesis";
-			else if (level >= 65)
-				return "Deceiver";
-			else if (level >= 60)
-				return "Assassin";
-			else if (level >= 55)
-				return "Blackguard";
-			else if (level >= 51)
-				return "Rake";
-			else
-				return "Rogue";
-		case SHAMAN:
-			if (level >= 70)
-				return "Soothsayer";
-			else if (level >= 65)
-				return "Prophet";
-			else if (level >= 60)
-				return "Oracle";
-			else if (level >= 55)
-				return "Luminary";
-			else if (level >= 51)
-				return "Mystic";
-			else
-				return "Shaman";
-		case NECROMANCER:
-			if (level >= 70)
-				return "Wraith";
-			else if (level >= 65)
-				return "Arch Lich";
-			else if (level >= 60)
-				return "Warlock";
-			else if (level >= 55)
-				return "Defiler";
-			else if (level >= 51)
-				return "Heretic";
-			else
-				return "Necromancer";
-		case WIZARD:
-			if (level >= 70)
-				return "Grand Arcanist";
-			else if (level >= 65)
-				return "Arcanist";
-			else if (level >= 60)
-				return "Sorcerer";
-			else if (level >= 55)
-				return "Evoker";
-			else if (level >= 51)
-				return "Channeler";
-			else
-				return "Wizard";
-		case MAGICIAN:
-			if (level >= 70)
-				return "Arch Magus";
-			else if (level >= 65)
-				return "Arch Convoker";
-			else if (level >= 60)
-				return "Arch Mage";
-			else if (level >= 55)
-				return "Conjurer";
-			if (level >= 51)
-				return "Elementalist";
-			else
-				return "Magician";
-		case ENCHANTER:
-			if (level >= 70)
-				return "Bedazzler";
-			else if (level >= 65)
-				return "Coercer";
-			else if (level >= 60)
-				return "Phantasmist";
-			else if (level >= 55)
-				return "Beguiler";
-			else if (level >= 51)
-				return "Illusionist";
-			else
-				return "Enchanter";
-		case BEASTLORD:
-			if (level >= 70)
-				return "Wildblood";
-			else if (level >= 65)
-				return "Feral Lord";
-			else if (level >= 60)
-				return "Savage Lord";
-			else if (level >= 55)
-				return "Animist";
-			else if (level >= 51)
-				return "Primalist";
-			else
-				return "Beastlord";
-		case BERSERKER:
-			if (level >= 70)
-				return "Ravager";
-			else if (level >= 65)
-				return "Fury";
-			else if (level >= 60)
-				return "Rager";
-			else if (level >= 55)
-				return "Vehement";
-			else if (level >= 51)
-				return "Brawler";
-			else
-				return "Berserker";
-		case BANKER:
-			if (level >= 70)
-				return "Master Banker";
-			else if (level >= 65)
-				return "Elder Banker";
-			else if (level >= 60)
-				return "Oldest Banker";
-			else if (level >= 55)
-				return "Older Banker";
-			else if (level >= 51)
-				return "Old Banker";
-			else
-				return "Banker";
-		case WARRIORGM:
-			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* 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* 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-2002 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) 2001-2016 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,26 +17,25 @@
 */
 #ifndef CLASSES_CH
 #define CLASSES_CH
+
 #include "../common/types.h"
 
-#define Array_Class_UNKNOWN 0
-#define WARRIOR			1
-#define CLERIC			2
-#define PALADIN			3
-#define RANGER			4
-#define SHADOWKNIGHT	5
-#define DRUID			6
-#define MONK			7
-#define BARD			8
-#define ROGUE			9
-#define SHAMAN			10
-#define NECROMANCER		11
-#define WIZARD			12
-#define MAGICIAN		13
-#define ENCHANTER		14
-#define BEASTLORD		15
-#define BERSERKER		16
-#define PLAYER_CLASS_COUNT	16 // used for array defines, must be the count of playable classes
+#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 WARRIORGM 20
 #define CLERICGM 21
 #define PALADINGM 22
@@ -58,33 +57,92 @@
 #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
 
-const char* GetEQClassName(uint8 class_, uint8 level = 0);
+
+// 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);
+
 #endif
-

common/client_version.cpp

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

common/client_version.h

@@ -0,0 +1,78 @@
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef COMMON_CLIENT_VERSION_H
+#define COMMON_CLIENT_VERSION_H
+
+#include "types.h"
+
+#include <stdlib.h>
+
+
+namespace EQEmu
+{
+	namespace versions {
+		enum class ClientVersion {
+			Unknown = 0,
+			Client62,	// Build: 'Aug  4 2005 15:40:59'
+			Titanium,	// Build: 'Oct 31 2005 10:33:37'
+			SoF,		// Build: 'Sep  7 2007 09:11:49'
+			SoD,		// Build: 'Dec 19 2008 15:22:49'
+			UF,			// Build: 'Jun  8 2010 16:44:32'
+			RoF,		// Build: 'Dec 10 2012 17:35:44'
+			RoF2		// Build: 'May 10 2013 23:30:08'
+		};
+
+		enum ClientVersionBit : uint32 {
+			bit_Unknown = 0,
+			bit_Client62 = 0x00000001, // unsupported (placeholder for scripts)
+			bit_Titanium = 0x00000002,
+			bit_SoF = 0x00000004,
+			bit_SoD = 0x00000008,
+			bit_UF = 0x00000010,
+			bit_RoF = 0x00000020,
+			bit_RoF2 = 0x00000040,
+			bit_TitaniumAndEarlier = 0x00000003,
+			bit_SoFAndEarlier = 0x00000007,
+			bit_SoDAndEarlier = 0x0000000F,
+			bit_UFAndEarlier = 0x0000001F,
+			bit_RoFAndEarlier = 0x0000003F,
+			bit_SoFAndLater = 0xFFFFFFFC,
+			bit_SoDAndLater = 0xFFFFFFF8,
+			bit_UFAndLater = 0xFFFFFFF0,
+			bit_RoFAndLater = 0xFFFFFFE0,
+			bit_RoF2AndLater = 0xFFFFFFC0,
+			bit_AllClients = 0xFFFFFFFF
+		};
+
+		static const ClientVersion LastClientVersion = ClientVersion::RoF2;
+		static const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
+
+		extern bool IsValidClientVersion(ClientVersion client_version);
+		extern ClientVersion ValidateClientVersion(ClientVersion client_version);
+		extern const char* ClientVersionName(ClientVersion client_version);
+		extern uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
+		extern ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
+		extern uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
+	
+	} /*versions*/
+
+} /*EQEmu*/
+
+#endif /*COMMON_CLIENT_VERSION_H*/

common/clientversions.h

@@ -1,77 +0,0 @@
-#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/database.cpp

@@ -23,6 +23,7 @@
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <algorithm>
 #include <mysqld_error.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -48,7 +49,6 @@
 extern Client client;
 
 Database::Database () {
-	DBInitVars();
 }
 
 /*
@@ -57,13 +57,10 @@ Establish a connection to a mysql database with the supplied parameters
 
 Database::Database(const char* host, const char* user, const char* passwd, const char* database, uint32 port)
 {
-	_eqp
-	DBInitVars();
 	Connect(host, user, passwd, database, port);
 }
 
 bool Database::Connect(const char* host, const char* user, const char* passwd, const char* database, uint32 port) {
-	_eqp
 	uint32 errnum= 0;
 	char errbuf[MYSQL_ERRMSG_SIZE];
 	if (!Open(host, user, passwd, database, port, &errnum, errbuf)) {
@@ -76,27 +73,12 @@ bool Database::Connect(const char* host, const char* user, const char* passwd, c
 	}
 }
 
-void Database::DBInitVars() { 
-	_eqp
-	varcache_array = 0;
-	varcache_max = 0;
-	varcache_lastupdate = 0;
-}
-
 /*
 	Close the connection to the database
 */
 
 Database::~Database()
 {
-	_eqp
-	unsigned int x;
-	if (varcache_array) {
-		for (x=0; x<varcache_max; x++) {
-			safe_delete_array(varcache_array[x]);
-		}
-		safe_delete_array(varcache_array);
-	}
 }
 
 /*
@@ -105,7 +87,7 @@ Database::~Database()
 	Zero will also be returned if there is a database error.
 */
 uint32 Database::CheckLogin(const char* name, const char* password, int16* oStatus) {
-	_eqp
+
 	if(strlen(name) >= 50 || strlen(password) >= 50)
 		return(0);
 
@@ -141,7 +123,6 @@ uint32 Database::CheckLogin(const char* name, const char* password, int16* oStat
 //Get Banned IP Address List - Only return false if the incoming connection's IP address is not present in the banned_ips table.
 bool Database::CheckBannedIPs(const char* loginIP)
 {
-	_eqp
 	std::string query = StringFormat("SELECT ip_address FROM Banned_IPs WHERE ip_address='%s'", loginIP);
 
 	auto results = QueryDatabase(query);
@@ -158,7 +139,6 @@ bool Database::CheckBannedIPs(const char* loginIP)
 }
 
 bool Database::AddBannedIP(char* bannedIP, const char* notes) {
-	_eqp
 	std::string query = StringFormat("INSERT into Banned_IPs SET ip_address='%s', notes='%s'", bannedIP, notes); 
 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -168,7 +148,6 @@ bool Database::AddBannedIP(char* bannedIP, const char* notes) {
 }
 
  bool Database::CheckGMIPs(const char* ip_address, uint32 account_id) {
- 	_eqp
 	std::string query = StringFormat("SELECT * FROM `gm_ips` WHERE `ip_address` = '%s' AND `account_id` = %i", ip_address, account_id); 
 	auto results = QueryDatabase(query);
 
@@ -182,20 +161,17 @@ bool Database::AddBannedIP(char* bannedIP, const char* notes) {
 }
 
 bool Database::AddGMIP(char* ip_address, char* name) {
-	_eqp
 	std::string query = StringFormat("INSERT into `gm_ips` SET `ip_address` = '%s', `name` = '%s'", ip_address, name); 
 	auto results = QueryDatabase(query); 
 	return results.Success();
 }
 
 void Database::LoginIP(uint32 AccountID, const char* LoginIP) {
-	_eqp
 	std::string query = StringFormat("INSERT INTO account_ip SET accid=%i, ip='%s' ON DUPLICATE KEY UPDATE count=count+1, lastused=now()", AccountID, LoginIP); 
 	QueryDatabase(query); 
 }
 
 int16 Database::CheckStatus(uint32 account_id) {
-	_eqp
 	std::string query = StringFormat("SELECT `status`, UNIX_TIMESTAMP(`suspendeduntil`) as `suspendeduntil`, UNIX_TIMESTAMP() as `current`"
 							" FROM `account` WHERE `id` = %i", account_id);
 
@@ -225,7 +201,6 @@ int16 Database::CheckStatus(uint32 account_id) {
 }
 
 uint32 Database::CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id) {
-	_eqp
 	std::string query;
 
 	if (password)
@@ -249,7 +224,6 @@ uint32 Database::CreateAccount(const char* name, const char* password, int16 sta
 }
 
 bool Database::DeleteAccount(const char* name) {
-	_eqp
 	std::string query = StringFormat("DELETE FROM account WHERE name='%s';",name); 
 	Log.Out(Logs::General, Logs::World_Server, "Account Attempting to be deleted:'%s'", name);
 
@@ -262,7 +236,6 @@ bool Database::DeleteAccount(const char* name) {
 }
 
 bool Database::SetLocalPassword(uint32 accid, const char* password) {
-	_eqp
 	std::string query = StringFormat("UPDATE account SET password=MD5('%s') where id=%i;", EscapeString(password).c_str(), accid);
 
 	auto results = QueryDatabase(query);
@@ -275,7 +248,6 @@ bool Database::SetLocalPassword(uint32 accid, const char* password) {
 }
 
 bool Database::SetAccountStatus(const char* name, int16 status) {
-	_eqp
 	std::string query = StringFormat("UPDATE account SET status=%i WHERE name='%s';", status, name);
 
 	std::cout << "Account being GM Flagged:" << name << ", Level: " << (int16) status << std::endl;
@@ -296,7 +268,6 @@ bool Database::SetAccountStatus(const char* name, int16 status) {
 
 /* This initially creates the character during character create */
 bool Database::ReserveName(uint32 account_id, char* name) {
-	_eqp
 	std::string query = StringFormat("SELECT `account_id`, `name` FROM `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) {
@@ -317,7 +288,6 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 	returns false on failure, true otherwise
 */
 bool Database::DeleteCharacter(char *name) {
-	_eqp
 	uint32 charid = 0;
 	if(!name ||	!strlen(name)) {
 		Log.Out(Logs::General, Logs::World_Server, "DeleteCharacter: request to delete without a name (empty char slot)");
@@ -329,7 +299,10 @@ bool Database::DeleteCharacter(char *name) {
 	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-	if (charid <= 0){ std::cerr << "Database::DeleteCharacter :: Character not found, stopping delete...\n"; return false; }
+	if (charid <= 0){ 
+		Log.Out(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
+		return false; 
+	}
 
 	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
@@ -364,18 +337,17 @@ bool Database::DeleteCharacter(char *name) {
 	query = StringFormat("DELETE FROM `character_inspect_messages` WHERE `id` = %u", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_leadership_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_alt_currency` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-#ifdef BOTS																														 
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid);
-#else																															 
+#ifdef BOTS
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid); // note: only use of GetMobTypeById()
+#else
 	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
-#endif																															 
+#endif
 	QueryDatabase(query);
 	
 	return true;
 }
 
 bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp){
-	_eqp
 	std::string query = StringFormat(
 		"REPLACE INTO `character_data` ("
 		"id,"
@@ -653,12 +625,18 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 	);
 	auto results = QueryDatabase(query);
 	/* Save Bind Points */
-	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, is_home)"
+	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
+		"(%u, %u, %u, %f, %f, %f, %f, %i), ",
+		"(%u, %u, %u, %f, %f, %f, %f, %i), ",
+		"(%u, %u, %u, %f, %f, %f, %f, %i), ",
 		"(%u, %u, %u, %f, %f, %f, %f, %i)",
 		character_id, pp->binds[0].zoneId, 0, pp->binds[0].x, pp->binds[0].y, pp->binds[0].z, pp->binds[0].heading, 0,
-		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 1
-	); results = QueryDatabase(query); 
+		character_id, pp->binds[1].zoneId, 0, pp->binds[1].x, pp->binds[1].y, pp->binds[1].z, pp->binds[1].heading, 1,
+		character_id, pp->binds[2].zoneId, 0, pp->binds[2].x, pp->binds[2].y, pp->binds[2].z, pp->binds[2].heading, 2,
+		character_id, pp->binds[3].zoneId, 0, pp->binds[3].x, pp->binds[3].y, pp->binds[3].z, pp->binds[3].heading, 3,
+		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 4
+	); results = QueryDatabase(query);
 
 	/* Save Skills */
 	int firstquery = 0;
@@ -695,7 +673,6 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 
 /* This only for new Character creation storing */
 bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv) {
-	_eqp
 	uint32 charid = 0; 
 	char zone[50]; 
 	float x, y, z; 
@@ -723,7 +700,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i=EmuConstants::EQUIPMENT_BEGIN; i<=EmuConstants::BANK_BAGS_END;) {
+	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
 		const ItemInst* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
@@ -732,16 +709,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == MainCursor) { 
-			i = EmuConstants::GENERAL_BAGS_BEGIN; 
+		if (i == EQEmu::legacy::SlotCursor) {
+			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EmuConstants::CURSOR_BAG_END) { 
-			i = EmuConstants::BANK_BEGIN; 
+		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
+			i = EQEmu::legacy::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EmuConstants::BANK_END) { 
-			i = EmuConstants::BANK_BAGS_BEGIN; 
+		else if (i == EQEmu::legacy::BANK_END) { 
+			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -750,7 +727,6 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 }
 
 uint32 Database::GetCharacterID(const char *name) {
-	_eqp
 	std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	auto row = results.begin();
@@ -767,7 +743,6 @@ uint32 Database::GetCharacterID(const char *name) {
 	Zero will also be returned if there is a database error.
 */
 uint32 Database::GetAccountIDByChar(const char* charname, uint32* oCharID) {
-	_eqp
 	std::string query = StringFormat("SELECT `account_id`, `id` FROM `character_data` WHERE name='%s'", EscapeString(charname).c_str());
 
 	auto results = QueryDatabase(query);
@@ -792,7 +767,6 @@ uint32 Database::GetAccountIDByChar(const char* charname, uint32* oCharID) {
 
 // Retrieve account_id for a given char_id
 uint32 Database::GetAccountIDByChar(uint32 char_id) {
-	_eqp
 	std::string query = StringFormat("SELECT `account_id` FROM `character_data` WHERE `id` = %i LIMIT 1", char_id); 
 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -807,7 +781,6 @@ uint32 Database::GetAccountIDByChar(uint32 char_id) {
 }
 
 uint32 Database::GetAccountIDByName(const char* accname, int16* status, uint32* lsid) {
-	_eqp
 	if (!isAlphaNumeric(accname))
 		return 0;
 
@@ -839,7 +812,6 @@ uint32 Database::GetAccountIDByName(const char* accname, int16* status, uint32*
 }
 
 void Database::GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID) {
-	_eqp
 	std::string query = StringFormat("SELECT `name`, `lsaccount_id` FROM `account` WHERE `id` = '%i'", accountid); 
 	auto results = QueryDatabase(query);
 
@@ -859,8 +831,7 @@ void Database::GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID
 
 }
 
-void Database::GetCharName(uint32 char_id, char* name) { 
-	_eqp
+void Database::GetCharName(uint32 char_id, char* name) {
 	std::string query = StringFormat("SELECT `name` FROM `character_data` WHERE id='%i'", char_id);
 	auto results = QueryDatabase(query);
 
@@ -875,156 +846,75 @@ void Database::GetCharName(uint32 char_id, char* name) {
 }
 
 bool Database::LoadVariables() {
-	_eqp
-	char *query = nullptr;
-
-	auto results = QueryDatabase(query, LoadVariables_MQ(&query));
+	auto results = QueryDatabase(StringFormat("SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache.last_update));
 
 	if (!results.Success())
-	{
-		safe_delete_array(query);
 		return false;
-	}
-
-	safe_delete_array(query);
-	return LoadVariables_result(std::move(results));
-}
-
-uint32 Database::LoadVariables_MQ(char** query)
-{
-	_eqp
-	return MakeAnyLenString(query, "SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache_lastupdate);
-}
-
-// always returns true? not sure about this.
-bool Database::LoadVariables_result(MySQLRequestResult results)
-{
-	_eqp
-	uint32 i = 0;
-	LockMutex lock(&Mvarcache);
 
 	if (results.RowCount() == 0)
 		return true;
 
-	if (!varcache_array) {
-		varcache_max = results.RowCount();
-		varcache_array = new VarCache_Struct*[varcache_max];
-		for (i=0; i<varcache_max; i++)
-			varcache_array[i] = 0;
-	}
-	else {
-		uint32 tmpnewmax = varcache_max + results.RowCount();
-		VarCache_Struct** tmp = new VarCache_Struct*[tmpnewmax];
-		for (i=0; i<tmpnewmax; i++)
-			tmp[i] = 0;
-		for (i=0; i<varcache_max; i++)
-			tmp[i] = varcache_array[i];
-		VarCache_Struct** tmpdel = varcache_array;
-		varcache_array = tmp;
-		varcache_max = tmpnewmax;
-		delete [] tmpdel;
-	}
+	LockMutex lock(&Mvarcache);
 
-	for (auto row = results.begin(); row != results.end(); ++row)
-	{
-		varcache_lastupdate = atoi(row[2]);
-		for (i=0; i<varcache_max; i++) {
-			if (varcache_array[i]) {
-				if (strcasecmp(varcache_array[i]->varname, row[0]) == 0) {
-					delete varcache_array[i];
-					varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
-					strn0cpy(varcache_array[i]->varname, row[0], sizeof(varcache_array[i]->varname));
-					strcpy(varcache_array[i]->value, row[1]);
-					break;
-				}
-			}
-			else {
-				varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
-				strcpy(varcache_array[i]->varname, row[0]);
-				strcpy(varcache_array[i]->value, row[1]);
-				break;
-			}
-		}
+	std::string key, value;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		varcache.last_update = atoi(row[2]); // ahh should we be comparing if this is newer?
+		key = row[0];
+		value = row[1];
+		std::transform(std::begin(key), std::end(key), std::begin(key), ::tolower); // keys are lower case, DB doesn't have to be
+		varcache.Add(key, value);
 	}
 
-	uint32 max_used = 0;
-	for (i=0; i<varcache_max; i++) {
-		if (varcache_array[i]) {
-			if (i > max_used)
-				max_used = i;
-		}
-	}
-
-	varcache_max = max_used + 1;
-
 	return true;
 }
 
 // Gets variable from 'variables' table
-bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
-	_eqp
-	varvalue[0] = '\0';
+bool Database::GetVariable(std::string varname, std::string &varvalue)
+{
+	varvalue.clear();
 
 	LockMutex lock(&Mvarcache);
-	if (strlen(varname) <= 1)
-		return false;
-	for (uint32 i=0; i<varcache_max; i++) {
 
-		if (varcache_array[i]) {
-			if (strcasecmp(varcache_array[i]->varname, varname) == 0) {
-				snprintf(varvalue, varvalue_len, "%s", varcache_array[i]->value);
-				varvalue[varvalue_len-1] = 0;
-				return true;
-			}
-		}
-		else
-			return false;
+	if (varname.empty())
+		return false;
+
+	std::transform(std::begin(varname), std::end(varname), std::begin(varname), ::tolower); // all keys are lower case
+	auto tmp = varcache.Get(varname);
+	if (tmp) {
+		varvalue = *tmp;
+		return true;
 	}
 	return false;
 }
 
-bool Database::SetVariable(const char* varname_in, const char* varvalue_in) {
-	_eqp
-	char *varname,*varvalue;
-
-	varname=(char *)malloc(strlen(varname_in)*2+1);
-	varvalue=(char *)malloc(strlen(varvalue_in)*2+1);
-	DoEscapeString(varname, varname_in, strlen(varname_in));
-	DoEscapeString(varvalue, varvalue_in, strlen(varvalue_in));
-
-	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", varvalue, varname);
+bool Database::SetVariable(const std::string varname, const std::string &varvalue)
+{
+	std::string escaped_name = EscapeString(varname);
+	std::string escaped_value = EscapeString(varvalue);
+	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", escaped_value.c_str(), escaped_name.c_str());
 	auto results = QueryDatabase(query);
 
 	if (!results.Success())
-	{
-		free(varname);
-		free(varvalue);
 		return false;
-	}
 
 	if (results.RowsAffected() == 1)
 	{
 		LoadVariables(); // refresh cache
-		free(varname);
-		free(varvalue);
 		return true;
 	}
 
-	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", varname, varvalue);
+	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", escaped_name.c_str(), escaped_value.c_str());
 	results = QueryDatabase(query);
-	free(varname);
-	free(varvalue);
 
 	if (results.RowsAffected() != 1)
 		return false;
-	
+
 	LoadVariables(); // refresh cache
 	return true;
 }
 
 uint32 Database::GetMiniLoginAccount(char* ip)
 {
-	_eqp
 	std::string query = StringFormat("SELECT `id` FROM `account` WHERE `minilogin_ip` = '%s'", ip);
 	auto results = QueryDatabase(query);
 
@@ -1037,7 +927,7 @@ uint32 Database::GetMiniLoginAccount(char* ip)
 
 // Get zone starting points from DB
 bool Database::GetSafePoints(const char* short_name, uint32 version, float* safe_x, float* safe_y, float* safe_z, int16* minstatus, uint8* minlevel, char *flag_needed) {
-	_eqp
+	
 	std::string query = StringFormat("SELECT safe_x, safe_y, safe_z, min_status, min_level, flag_needed FROM zone "
 		" WHERE short_name='%s' AND (version=%i OR version=0) ORDER BY version DESC", short_name, version);
 	auto results = QueryDatabase(query);
@@ -1067,7 +957,7 @@ bool Database::GetSafePoints(const char* short_name, uint32 version, float* safe
 }
 
 bool Database::GetZoneLongName(const char* short_name, char** long_name, char* file_name, float* safe_x, float* safe_y, float* safe_z, uint32* graveyard_id, uint32* maxclients) {
-	_eqp
+	
 	std::string query = StringFormat("SELECT long_name, file_name, safe_x, safe_y, safe_z, graveyard_id, maxclients FROM zone WHERE short_name='%s' AND version=0", short_name);
 	auto results = QueryDatabase(query);
 
@@ -1105,7 +995,7 @@ bool Database::GetZoneLongName(const char* short_name, char** long_name, char* f
 }
 
 uint32 Database::GetZoneGraveyardID(uint32 zone_id, uint32 version) {
-	_eqp
+
 	std::string query = StringFormat("SELECT graveyard_id FROM zone WHERE zoneidnumber='%u' AND (version=%i OR version=0) ORDER BY version DESC", zone_id, version);
 	auto results = QueryDatabase(query);
 
@@ -1120,7 +1010,7 @@ uint32 Database::GetZoneGraveyardID(uint32 zone_id, uint32 version) {
 }
 
 bool Database::GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid, float* graveyard_x, float* graveyard_y, float* graveyard_z, float* graveyard_heading) {
-	_eqp
+	
 	std::string query = StringFormat("SELECT zone_id, x, y, z, heading FROM graveyard WHERE id=%i", graveyard_id);
 	auto results = QueryDatabase(query);
 
@@ -1148,7 +1038,6 @@ bool Database::GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zon
 }
 
 bool Database::LoadZoneNames() {
-	_eqp
 	std::string query("SELECT zoneidnumber, short_name FROM zone");
 
 	auto results = QueryDatabase(query);
@@ -1169,7 +1058,7 @@ bool Database::LoadZoneNames() {
 }
 
 uint32 Database::GetZoneID(const char* zonename) {
-	_eqp
+
 	if (zonename == nullptr)
 		return 0;
 
@@ -1181,7 +1070,6 @@ uint32 Database::GetZoneID(const char* zonename) {
 }
 
 const char* Database::GetZoneName(uint32 zoneID, bool ErrorUnknown) {
-	_eqp
 	auto iter = zonename_array.find(zoneID);
 
 	if (iter != zonename_array.end())
@@ -1194,7 +1082,7 @@ const char* Database::GetZoneName(uint32 zoneID, bool ErrorUnknown) {
 }
 
 uint8 Database::GetPEQZone(uint32 zoneID, uint32 version){
-	_eqp
+	
 	std::string query = StringFormat("SELECT peqzone from zone where zoneidnumber='%i' AND (version=%i OR version=0) ORDER BY version DESC", zoneID, version);
 	auto results = QueryDatabase(query);
 
@@ -1212,24 +1100,18 @@ uint8 Database::GetPEQZone(uint32 zoneID, uint32 version){
 
 bool Database::CheckNameFilter(const char* name, bool surname)
 {
-	_eqp
 	std::string str_name = name;
 
-	if(surname)
+	// the minimum 4 is enforced by the client too
+	if (!name || strlen(name) < 4)
 	{
-		// the minimum 4 is enforced by the client too
-		if(!name || strlen(name) < 3)
-		{
-			return false;
-		}
+		return false;
 	}
-	else
+
+	// Given name length is enforced by the client too
+	if (!surname && strlen(name) > 15)
 	{
-		// the minimum 4 is enforced by the client too
-		if(!name || strlen(name) < 4 || strlen(name) > 15)
-		{
-			return false;
-		}
+		return false;
 	}
 
 	for (size_t i = 0; i < str_name.size(); i++)
@@ -1289,7 +1171,7 @@ bool Database::CheckNameFilter(const char* name, bool surname)
 }
 
 bool Database::AddToNameFilter(const char* name) {
-	_eqp
+	
 	std::string query = StringFormat("INSERT INTO name_filter (name) values ('%s')", name);
 	auto results = QueryDatabase(query);
 
@@ -1305,7 +1187,6 @@ bool Database::AddToNameFilter(const char* name) {
 }
 
 uint32 Database::GetAccountIDFromLSID(uint32 iLSID, char* oAccountName, int16* oStatus) {
-	_eqp
 	uint32 account_id = 0;
 	std::string query = StringFormat("SELECT id, name, status FROM account WHERE lsaccount_id=%i", iLSID);
 	auto results = QueryDatabase(query);
@@ -1330,7 +1211,7 @@ uint32 Database::GetAccountIDFromLSID(uint32 iLSID, char* oAccountName, int16* o
 }
 
 void Database::GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus) {
-	_eqp
+	
 	std::string query = StringFormat("SELECT name, status FROM account WHERE id=%i", id);
 	auto results = QueryDatabase(query);
 
@@ -1350,12 +1231,10 @@ void Database::GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus) {
 }
 
 void Database::ClearMerchantTemp(){
-	_eqp
 	QueryDatabase("DELETE FROM merchantlist_temp");
 }
 
 bool Database::UpdateName(const char* oldname, const char* newname) { 
-	_eqp
 	std::cout << "Renaming " << oldname << " to " << newname << "..." << std::endl; 
 	std::string query = StringFormat("UPDATE `character_data` SET `name` = '%s' WHERE `name` = '%s';", newname, oldname);
 	auto results = QueryDatabase(query);
@@ -1371,7 +1250,6 @@ bool Database::UpdateName(const char* oldname, const char* newname) {
 
 // If the name is used or an error occurs, it returns false, otherwise it returns true
 bool Database::CheckUsedName(const char* name) {
-	_eqp
 	std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -1385,7 +1263,6 @@ bool Database::CheckUsedName(const char* name) {
 }
 
 uint8 Database::GetServerType() {
-	_eqp
 	std::string query("SELECT `value` FROM `variables` WHERE `varname` = 'ServerType' LIMIT 1");
 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -1400,7 +1277,6 @@ uint8 Database::GetServerType() {
 }
 
 bool Database::MoveCharacterToZone(const char* charname, const char* zonename, uint32 zoneid) {
-	_eqp
 	if(zonename == nullptr || strlen(zonename) == 0)
 		return false;
 
@@ -1418,13 +1294,11 @@ bool Database::MoveCharacterToZone(const char* charname, const char* zonename, u
 }
 
 bool Database::MoveCharacterToZone(const char* charname, const char* zonename) {
-	_eqp
 	return MoveCharacterToZone(charname, zonename, GetZoneID(zonename));
 }
 
 bool Database::MoveCharacterToZone(uint32 iCharID, const char* iZonename) { 
-	_eqp
-	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", iZonename, GetZoneID(iZonename), iCharID);
+	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", GetZoneID(iZonename), iCharID);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()) {
@@ -1435,7 +1309,6 @@ bool Database::MoveCharacterToZone(uint32 iCharID, const char* iZonename) {
 }
 
 bool Database::SetHackerFlag(const char* accountname, const char* charactername, const char* hacked) { 
-	_eqp
 	std::string query = StringFormat("INSERT INTO `hackers` (account, name, hacked) values('%s','%s','%s')", accountname, charactername, hacked);
 	auto results = QueryDatabase(query);
 
@@ -1447,7 +1320,6 @@ bool Database::SetHackerFlag(const char* accountname, const char* charactername,
 }
 
 bool Database::SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone) { 
-	_eqp
 	//Utilize the "hacker" table, but also give zone information.
 	std::string query = StringFormat("INSERT INTO hackers(account,name,hacked,zone) values('%s','%s','%s','%s')", accountname, charactername, hacked, zone);
 	auto results = QueryDatabase(query);
@@ -1462,7 +1334,6 @@ bool Database::SetMQDetectionFlag(const char* accountname, const char* character
 
 uint8 Database::GetRaceSkill(uint8 skillid, uint8 in_race)
 {
-	_eqp
 	uint16 race_cap = 0;
 	
 	//Check for a racial cap!
@@ -1481,7 +1352,6 @@ uint8 Database::GetRaceSkill(uint8 skillid, uint8 in_race)
 
 uint8 Database::GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level)
 {
-	_eqp
 	uint8 skill_level = 0, skill_formula = 0;
 	uint16 base_cap = 0, skill_cap = 0, skill_cap2 = 0, skill_cap3 = 0;
 	
@@ -1531,7 +1401,6 @@ uint8 Database::GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16
 }
 
 uint32 Database::GetCharacterInfo(const char* iName, uint32* oAccID, uint32* oZoneID, uint32* oInstanceID, float* oX, float* oY, float* oZ) { 
-	_eqp
 	std::string query = StringFormat("SELECT `id`, `account_id`, `zone_id`, `zone_instance`, `x`, `y`, `z` FROM `character_data` WHERE `name` = '%s'", iName);
 	auto results = QueryDatabase(query);
 
@@ -1555,7 +1424,7 @@ uint32 Database::GetCharacterInfo(const char* iName, uint32* oAccID, uint32* oZo
 }
 
 bool Database::UpdateLiveChar(char* charname,uint32 lsaccount_id) {
-	_eqp
+
 	std::string query = StringFormat("UPDATE account SET charname='%s' WHERE id=%i;",charname, lsaccount_id);
 	auto results = QueryDatabase(query);
 
@@ -1567,7 +1436,7 @@ bool Database::UpdateLiveChar(char* charname,uint32 lsaccount_id) {
 }
 
 bool Database::GetLiveChar(uint32 account_id, char* cname) {
-	_eqp
+
 	std::string query = StringFormat("SELECT charname FROM account WHERE id=%i", account_id);
 	auto results = QueryDatabase(query);
 
@@ -1586,41 +1455,36 @@ bool Database::GetLiveChar(uint32 account_id, char* cname) {
 }
 
 void Database::SetLFP(uint32 CharID, bool LFP) { 
-	_eqp
 	std::string query = StringFormat("UPDATE `character_data` SET `lfp` = %i WHERE `id` = %i",LFP, CharID);
 	QueryDatabase(query); 
 }
 
 void Database::SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon) { 
-	_eqp
 	std::string query = StringFormat("update `character_data` SET `lfp` = %i, `lfg` = %i, `firstlogon` = %i WHERE `id` = %i",LFP, LFG, firstlogon, CharID);
 	QueryDatabase(query); 
 }
 
 void Database::SetLFG(uint32 CharID, bool LFG) { 
-	_eqp
 	std::string query = StringFormat("update `character_data` SET `lfg` = %i WHERE `id` = %i",LFG, CharID);
 	QueryDatabase(query); 
 }
 
 void Database::SetFirstLogon(uint32 CharID, uint8 firstlogon) { 
-	_eqp
 	std::string query = StringFormat( "UPDATE `character_data` SET `firstlogon` = %i WHERE `id` = %i",firstlogon, CharID);
 	QueryDatabase(query); 
 }
 
-void Database::AddReport(std::string who, std::string against, std::string lines) { 
-	_eqp
-	char *escape_str = new char[lines.size()*2+1];
+void Database::AddReport(std::string who, std::string against, std::string lines)
+{
+	auto escape_str = new char[lines.size() * 2 + 1];
 	DoEscapeString(escape_str, lines.c_str(), lines.size());
 
-	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", who.c_str(), against.c_str(), escape_str);
+	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", EscapeString(who).c_str(), EscapeString(against).c_str(), escape_str);
 	QueryDatabase(query);
 	safe_delete_array(escape_str);
 }
 
 void Database::SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc) {
-	_eqp
 	std::string query;
 	if (id == 0) {
 		// removing from group
@@ -1640,14 +1504,12 @@ void Database::SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ism
 
 void Database::ClearAllGroups(void)
 {
-	_eqp
 	std::string query("DELETE FROM `group_id`");
 	QueryDatabase(query);
 	return;
 }
 
 void Database::ClearGroup(uint32 gid) {
-	_eqp
 	ClearGroupLeader(gid);
 	
 	if(gid == 0)
@@ -1663,7 +1525,6 @@ void Database::ClearGroup(uint32 gid) {
 }
 
 uint32 Database::GetGroupID(const char* name){ 
-	_eqp
 	std::string query = StringFormat("SELECT groupid from group_id where name='%s'", name);
 	auto results = QueryDatabase(query);
 
@@ -1674,7 +1535,7 @@ uint32 Database::GetGroupID(const char* name){
 	if (results.RowCount() == 0)
 	{
 		// Commenting this out until logging levels can prevent this from going to console
-		//Log.Out(Logs::General, Logs::None, "Character not in a group: %s", name);
+		//Log.Out(Logs::General, Logs::None,, "Character not in a group: %s", name);
 		return 0;
 	}
 
@@ -1685,7 +1546,6 @@ uint32 Database::GetGroupID(const char* name){
 
 /* Is this really getting used properly... A half implementation ? Akkadius */
 char* Database::GetGroupLeaderForLogin(const char* name, char* leaderbuf) {
-	_eqp
 	strcpy(leaderbuf, "");
 	uint32 group_id = 0;
 
@@ -1710,7 +1570,6 @@ char* Database::GetGroupLeaderForLogin(const char* name, char* leaderbuf) {
 }
 
 void Database::SetGroupLeaderName(uint32 gid, const char* name) { 
-	_eqp
 	std::string query = StringFormat("UPDATE group_leaders SET leadername = '%s' WHERE gid = %u", EscapeString(name).c_str(), gid);
 	auto result = QueryDatabase(query);
 
@@ -1729,7 +1588,6 @@ void Database::SetGroupLeaderName(uint32 gid, const char* name) {
 
 char *Database::GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank, char* assist, char* puller, char *marknpc, char *mentoree, int *mentor_percent, GroupLeadershipAA_Struct* GLAA)
 {
-	_eqp
 	std::string query = StringFormat("SELECT `leadername`, `maintank`, `assist`, `puller`, `marknpc`, `mentoree`, `mentor_percent`, `leadershipaa` FROM `group_leaders` WHERE `gid` = %lu",(unsigned long)gid);
 	auto results = QueryDatabase(query);
 
@@ -1789,7 +1647,6 @@ char *Database::GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* mainta
 
 // Clearing all group leaders
 void Database::ClearAllGroupLeaders(void) {
-	_eqp
 	std::string query("DELETE from group_leaders");
 	auto results = QueryDatabase(query);
 
@@ -1800,7 +1657,7 @@ void Database::ClearAllGroupLeaders(void) {
 }
 
 void Database::ClearGroupLeader(uint32 gid) {
-	_eqp
+	
 	if(gid == 0)
 	{
 		ClearAllGroupLeaders();
@@ -1815,7 +1672,7 @@ void Database::ClearGroupLeader(uint32 gid) {
 }
 
 uint8 Database::GetAgreementFlag(uint32 acctid) {
-	_eqp
+
 	std::string query = StringFormat("SELECT rulesflag FROM account WHERE id=%i",acctid);
 	auto results = QueryDatabase(query);
 
@@ -1831,13 +1688,11 @@ uint8 Database::GetAgreementFlag(uint32 acctid) {
 }
 
 void Database::SetAgreementFlag(uint32 acctid) {
-	_eqp
 	std::string query = StringFormat("UPDATE account SET rulesflag=1 where id=%i", acctid);
 	QueryDatabase(query);
 }
 
 void Database::ClearRaid(uint32 rid) {
-	_eqp
 	if(rid == 0)
 	{
 		//clear all raids
@@ -1854,7 +1709,7 @@ void Database::ClearRaid(uint32 rid) {
 }
 
 void Database::ClearAllRaids(void) {
-	_eqp
+
 	std::string query("delete from raid_members");
 	auto results = QueryDatabase(query);
 
@@ -1864,7 +1719,7 @@ void Database::ClearAllRaids(void) {
 
 void Database::ClearAllRaidDetails(void)
 {
-	_eqp
+
 	std::string query("delete from raid_details");
 	auto results = QueryDatabase(query);
 
@@ -1873,7 +1728,7 @@ void Database::ClearAllRaidDetails(void)
 }
 
 void Database::ClearRaidDetails(uint32 rid) {
-	_eqp
+	
 	if(rid == 0)
 	{
 		//clear all raids
@@ -1892,8 +1747,7 @@ void Database::ClearRaidDetails(uint32 rid) {
 // returns 0 on error or no raid for that character, or
 // the raid id that the character is a member of.
 uint32 Database::GetRaidID(const char* name)
-{
-	_eqp
+{ 
 	std::string query = StringFormat("SELECT `raidid` FROM `raid_members` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 
@@ -1914,7 +1768,6 @@ uint32 Database::GetRaidID(const char* name)
 
 const char* Database::GetRaidLeaderName(uint32 raid_id)
 {
-	_eqp
 	// Would be a good idea to fix this to be a passed in variable and
 	// make the caller responsible. static local variables like this are
 	// not guaranteed to be thread safe (nor is the internal guard
@@ -1946,7 +1799,6 @@ const char* Database::GetRaidLeaderName(uint32 raid_id)
 void Database::GetGroupLeadershipInfo(uint32 gid, uint32 rid, char *maintank,
 		char *assist, char *puller, char *marknpc, char *mentoree, int *mentor_percent, GroupLeadershipAA_Struct *GLAA)
 {
-	_eqp
 	std::string query = StringFormat(
 			"SELECT maintank, assist, puller, marknpc, mentoree, mentor_percent, leadershipaa FROM raid_leaders WHERE gid = %lu AND rid = %lu",
 			(unsigned long)gid, (unsigned long)rid);
@@ -2004,7 +1856,6 @@ void Database::GetGroupLeadershipInfo(uint32 gid, uint32 rid, char *maintank,
 void Database::GetRaidLeadershipInfo(uint32 rid, char *maintank,
 		char *assist, char *puller, char *marknpc, RaidLeadershipAA_Struct *RLAA)
 {
-	_eqp
 	std::string query = StringFormat(
 			"SELECT maintank, assist, puller, marknpc, leadershipaa FROM raid_leaders WHERE gid = %lu AND rid = %lu",
 			(unsigned long)0xFFFFFFFF, (unsigned long)rid);
@@ -2048,7 +1899,6 @@ void Database::GetRaidLeadershipInfo(uint32 rid, char *maintank,
 
 void Database::SetRaidGroupLeaderInfo(uint32 gid, uint32 rid)
 {
-	_eqp
 	std::string query = StringFormat("UPDATE raid_leaders SET leadershipaa = '' WHERE gid = %lu AND rid = %lu",
 			(unsigned long)gid, (unsigned long)rid);
 	auto results = QueryDatabase(query);
@@ -2066,7 +1916,6 @@ void Database::SetRaidGroupLeaderInfo(uint32 gid, uint32 rid)
 // Clearing all raid leaders
 void Database::ClearAllRaidLeaders(void)
 {
-	_eqp
 	std::string query("DELETE from raid_leaders");
 	QueryDatabase(query);
 	return;
@@ -2074,7 +1923,6 @@ void Database::ClearAllRaidLeaders(void)
 
 void Database::ClearRaidLeader(uint32 gid, uint32 rid)
 {
-	_eqp
 	if (rid == 0) {
 		ClearAllRaidLeaders();
 		return;
@@ -2086,7 +1934,7 @@ void Database::ClearRaidLeader(uint32 gid, uint32 rid)
 
 void Database::UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win)
 {
-	_eqp
+
 	std::string field;
 
 	switch(theme)
@@ -2139,7 +1987,6 @@ void Database::UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win)
 
 bool Database::GetAdventureStats(uint32 char_id, AdventureStats_Struct *as)
 {
-	_eqp
 	std::string query = StringFormat(
 		"SELECT "
 		"`guk_wins`, "
@@ -2186,7 +2033,6 @@ bool Database::GetAdventureStats(uint32 char_id, AdventureStats_Struct *as)
 
 uint32 Database::GetGuildIDByCharID(uint32 character_id) 
 {
-	_eqp
 	std::string query = StringFormat("SELECT guild_id FROM guild_members WHERE char_id='%i'", character_id);
 	auto results = QueryDatabase(query);
 
@@ -2202,7 +2048,6 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)
 
 void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 {
-	_eqp
 	std::string query = 
 		"SELECT "
 		"log_category_id, "
@@ -2243,3 +2088,51 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 		}
 	}
 }
+
+void Database::ClearInvSnapshots(bool use_rule)
+{
+	uint32 del_time = time(nullptr);
+	if (use_rule) { del_time -= RuleI(Character, InvSnapshotHistoryD) * 86400; }
+
+	std::string query = StringFormat("DELETE FROM inventory_snapshots WHERE time_index <= %lu", (unsigned long)del_time);
+	QueryDatabase(query);
+}
+
+struct TimeOfDay_Struct Database::LoadTime(time_t &realtime)
+{
+
+	TimeOfDay_Struct eqTime;
+	std::string query = StringFormat("SELECT minute,hour,day,month,year,realtime FROM eqtime limit 1");
+	auto results = QueryDatabase(query);
+
+	if (!results.Success() || results.RowCount() == 0){
+		Log.Out(Logs::Detail, Logs::World_Server, "Loading EQ time of day failed. Using defaults.");
+		eqTime.minute = 0;
+		eqTime.hour = 9;
+		eqTime.day = 1;
+		eqTime.month = 1;
+		eqTime.year = 3100;
+		realtime = time(0);
+	}
+	else{
+		auto row = results.begin();
+
+		eqTime.minute = atoi(row[0]);
+		eqTime.hour = atoi(row[1]);
+		eqTime.day = atoi(row[2]);
+		eqTime.month = atoi(row[3]);
+		eqTime.year = atoi(row[4]);
+		realtime = atoi(row[5]);
+	}
+
+	return eqTime;
+}
+
+bool Database::SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year)
+{
+	std::string query = StringFormat("UPDATE eqtime set minute = %d, hour = %d, day = %d, month = %d, year = %d, realtime = %d limit 1", minute, hour, day, month, year, time(0));
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+
+}

common/database.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -23,6 +23,7 @@
 
 #include "global_define.h"
 #include "eqemu_logsys.h"
+
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
@@ -66,8 +67,14 @@ struct npcDecayTimes_Struct {
 
 
 struct VarCache_Struct {
-	char varname[26];	
-	char value[0];
+	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);
+	}
 };
 
 class PTimerList;
@@ -87,7 +94,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 */
@@ -209,17 +216,14 @@ public:
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
-	bool	CheckDatabaseConvertBotsPostPPDeblob();
 	bool	CheckDatabaseConvertCorpseDeblob();
 	bool	CheckDatabaseConvertPPDeblob();
 
 	/* Database Variables */
 
-	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
-	bool	SetVariable(const char* varname, const char* varvalue);
+	bool	GetVariable(std::string varname, std::string &varvalue);
+	bool	SetVariable(const std::string varname, const std::string &varvalue);
 	bool	LoadVariables();
-	uint32	LoadVariables_MQ(char** query);
-	bool	LoadVariables_result(MySQLRequestResult results);
 
 	/* General Queries */
 
@@ -241,6 +245,8 @@ 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);
@@ -248,18 +254,16 @@ 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;
-	uint32				varcache_max;
-	VarCache_Struct**	varcache_array;
-	uint32				varcache_lastupdate;
+	Mutex Mvarcache;
+	VarCache_Struct varcache;
 
 	/* Groups, utility methods. */
 	void    ClearAllGroupLeaders();

common/database_conversions.cpp

@@ -157,25 +157,36 @@ 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 item_id;
-		uint32 icon;
-		char item_name[64];
+		uint32 ID;
+		uint32 Icon;
+		char Name[64];
 	};
 	struct Bandolier_Struct {
-		char name[32];
-		Convert::BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
+		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];
 	};
 	struct PotionBelt_Struct {
-		Convert::BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
+		Convert::PotionBeltItem_Struct Items[Convert::POTION_BELT_ITEM_COUNT];
 	};
+
 	struct SuspendedMinion_Struct
 	{
 		/*000*/	uint16 SpellID;
 		/*002*/	uint32 HP;
 		/*006*/	uint32 Mana;
 		/*010*/	Convert::SpellBuff_Struct Buffs[BUFF_COUNT];
-		/*510*/	uint32 Items[_MaterialCount];
+		/*510*/	uint32 Items[EQEmu::legacy::MaterialCount];
 		/*546*/	char Name[64];
 		/*610*/
 	};
@@ -216,9 +227,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[_MaterialCount];	// Item texture/material of worn/held items
+		/*0312*/	uint32							item_material[EQEmu::legacy::MaterialCount];	// Item texture/material of worn/held items
 		/*0348*/	uint8							unknown0348[44];
-		/*0392*/	Convert::Color_Struct			item_tint[_MaterialCount];
+		/*0392*/	Convert::Color_Struct			item_tint[EQEmu::legacy::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
@@ -319,7 +330,7 @@ namespace Convert {
 		/*7212*/	uint32							tribute_points;
 		/*7216*/	uint32							unknown7252;
 		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EmuConstants::TRIBUTE_SIZE];
+		/*7224*/	Convert::Tribute_Struct			tributes[EQEmu::legacy::TRIBUTE_SIZE];
 		/*7264*/	Convert::Disciplines_Struct		disciplines;
 		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 		/*7744*/	char							unknown7780[160];
@@ -346,7 +357,7 @@ namespace Convert {
 		/*12800*/	uint32							expAA;
 		/*12804*/	uint32							aapoints;			//avaliable, unspent
 		/*12808*/	uint8							unknown12844[36];
-		/*12844*/	Convert::Bandolier_Struct		bandoliers[EmuConstants::BANDOLIERS_COUNT];
+		/*12844*/	Convert::Bandolier_Struct		bandoliers[Convert::BANDOLIERS_SIZE];
 		/*14124*/	uint8							unknown14160[4506];
 		/*18630*/	Convert::SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 		/*19240*/	uint32							timeentitledonaccount;
@@ -459,7 +470,6 @@ static inline void loadbar(unsigned int x, unsigned int n, unsigned int w = 50)
 
 bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertPPDeblob();
-	CheckDatabaseConvertBotsPostPPDeblob();
 	CheckDatabaseConvertCorpseDeblob();
 
 	/* Fetch Automatic Upgrade Script */
@@ -483,7 +493,7 @@ bool Database::CheckDatabaseConversions() {
 	/* 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"); 
+	system("perl eqemu_update.pl V 14"); 
 
 	/* Run Automatic Database Upgrade Script */
 	system("perl eqemu_update.pl ran_from_world");
@@ -1406,7 +1416,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Material Color Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < _MaterialCount; i++){
+				for (i = 0; i < EQEmu::legacy::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);
@@ -1418,7 +1428,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Tribute Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EmuConstants::TRIBUTE_SIZE; i++){
+				for (i = 0; i < EQEmu::legacy::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);
@@ -1430,15 +1440,15 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Bandolier Convert */
 				first_entry = 0; rquery = "";
-				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){
+				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){
 								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].item_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].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].item_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].ID, pp->bandoliers[i].Items[si].Icon, pp->bandoliers[i].Name);
 							}
 						}
 					}
@@ -1446,13 +1456,13 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Potion Belt Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EmuConstants::POTION_BELT_SIZE; i++){
-					if (pp->potionbelt.items[i].item_id > 0){
+				for (i = 0; i < Convert::POTION_BELT_ITEM_COUNT; i++){
+					if (pp->potionbelt.Items[i].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].item_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].ID, pp->potionbelt.Items[i].Icon);
 							first_entry = 1;
 						}
-						rquery = rquery + StringFormat(", (%i, %u, %u, %u)", character_id, i, pp->potionbelt.items[i].item_id, pp->potionbelt.items[i].icon);
+						rquery = rquery + StringFormat(", (%i, %u, %u, %u)", character_id, i, pp->potionbelt.Items[i].ID, pp->potionbelt.Items[i].Icon);
 
 					}
 				}
@@ -1480,163 +1490,6 @@ 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,14 +98,14 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			pStatus = Error;
 
-			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+			auto 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);
 		}
 
-		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 		/* Implement Logging at the Root */
@@ -128,7 +128,12 @@ 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 (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
-		Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
+	{
+		if ((strncasecmp(query, "select", 6) == 0))
+			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
+		else
+			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+	}
 
 	return requestResult;
 }

common/dbcore.h

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

common/deity.cpp

@@ -0,0 +1,149 @@
+/*	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,5 +1,6 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
+
+	Copyright (C) 2001-2016 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
@@ -13,154 +14,67 @@
 
 	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 DEITY_H
-#define DEITY_H
+
+#ifndef COMMON_DEITY_H
+#define COMMON_DEITY_H
 
 #include "types.h"
-#include <string>
 
-// NOTE: This code is not fully implemented since there are no references in the existing code
 
-/*
-**	Diety types
-**
-**	(ref: eqstr_us.txt)
-**
-**	(Another orphaned enumeration...)
-*/
-enum DeityTypes
+namespace EQEmu
 {
-/*----*/	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
-};
+	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
+		};
 
-/*
-**	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
-};
+		enum DeityTypeBit : uint32 {
+			bit_DeityAll = 0x00000000,
+			bit_DeityAgnostic = 0x00000001,
+			bit_DeityBertoxxulous = 0x00000002,
+			bit_DeityBrellSirilis = 0x00000004,
+			bit_DeityCazicThule = 0x00000008,
+			bit_DeityErollisiMarr = 0x00000010,
+			bit_DeityBristlebane = 0x00000020,
+			bit_DeityInnoruuk = 0x00000040,
+			bit_DeityKarana = 0x00000080,
+			bit_DeityMithanielMarr = 0x00000100,
+			bit_DeityPrexus = 0x00000200,
+			bit_DeityQuellious = 0x00000400,
+			bit_DeityRallosZek = 0x00000800,
+			bit_DeityRodcetNife = 0x00001000,
+			bit_DeitySolusekRo = 0x00002000,
+			bit_DeityTheTribunal = 0x00004000,
+			bit_DeityTunare = 0x00008000,
+			bit_DeityVeeshan = 0x00010000
+		};
 
-static DeityTypeBits ConvertDeityToBitDeity(DeityTypes deity)
-{
-	switch(deity)
-	{
-		case DeityBertoxxulous:		{ return BIT_DeityBertoxxulous; }
-		case DeityBrellSirilis:		{ return BIT_DeityBrellSirilis; }
-		case DeityCazicThule:		{ return BIT_DeityCazicThule; }
-		case DeityErollisiMarr:		{ return BIT_DeityErollisiMarr; }
-		case DeityBristlebane:		{ return BIT_DeityBristlebane; }
-		case DeityInnoruuk:			{ return BIT_DeityInnoruuk; }
-		case DeityKarana:			{ return BIT_DeityKarana; }
-		case DeityMithanielMarr:	{ return BIT_DeityMithanielMarr; }
-		case DeityPrexus:			{ return BIT_DeityPrexus; }
-		case DeityQuellious:		{ return BIT_DeityQuellious; }
-		case DeityRallosZek:		{ return BIT_DeityRallosZek; }
-		case DeityRodcetNife:		{ return BIT_DeityRodcetNife; }
-		case DeitySolusekRo:		{ return BIT_DeitySolusekRo; }
-		case DeityTheTribunal:		{ return BIT_DeityTheTribunal; }
-		case DeityTunare:			{ return BIT_DeityTunare; }
-		case DeityVeeshan:			{ return BIT_DeityVeeshan; }
-		case DeityAgnostic_LB:
-		case DeityAgnostic:			{ return BIT_DeityAgnostic; }
-		default: { break; }
-	};
+		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);
+		extern DeityType ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit);
+		extern const char* DeityName(DeityType deity_type);
 
-	return BIT_DeityAll;
-};
+	} /*deity*/
 
-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; }
-	};
+} /*EQEmu*/
 
-	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
+#endif /* COMMON_DEITY_H */

common/emu_constants.cpp

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

common/emu_constants.h

@@ -0,0 +1,52 @@
+/*	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 "inventory_version.h"
+//#include "deity.h"
+//#include "say_link.h"
+
+#include <string>
+
+
+namespace EQEmu
+{
+	namespace inventory {
+		//using namespace RoF2::invtype;
+		//using namespace RoF2::invslot;
+		//using namespace RoF2::invbag;
+		//using namespace RoF2::invaug;
+
+	} /*inventory*/
+
+	namespace constants {
+		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
+		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
+
+		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
+
+	} /*constants*/
+
+} /*EQEmu*/
+
+#endif /*COMMON_EMU_CONSTANTS_H*/

common/emu_legacy.cpp

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

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

common/emu_limits.cpp

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

@@ -0,0 +1,56 @@
+/*	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 };
+	}
+
+	namespace merc {
+		enum : int { Invalid = -1, Null, Safety };
+
+		enum : bool { False = false, True = true };
+	}
+
+	namespace bot {
+		enum : int { Invalid = -1, Null, Safety };
+
+		enum : bool { False = false, True = true };
+	}
+
+	namespace pet {
+		enum : int { Invalid = -1, Null, Safety };
+
+		enum : bool { False = false, True = true };
+	}
+
+}; /*EntityLimits*/
+
+#endif /*COMMON_EMU_LIMITS_H*/

common/emu_oplist.h

@@ -164,6 +164,7 @@ N(OP_FinishTrade),
 N(OP_FinishWindow),
 N(OP_FinishWindow2),
 N(OP_Fishing),
+N(OP_Fling),
 N(OP_FloatListThing),
 N(OP_Forage),
 N(OP_ForceFindPerson),
@@ -215,6 +216,7 @@ N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
+N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -348,6 +350,7 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
+N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
 N(OP_PetitionCheckIn),
@@ -364,6 +367,8 @@ 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),
@@ -519,8 +524,6 @@ 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),
@@ -534,6 +537,8 @@ 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),
@@ -547,4 +552,5 @@ 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

@@ -50,7 +50,6 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_s
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
-	_eqp
 	id = 0;
 	Server = nullptr;
 	pOldFormat = iOldFormat;
@@ -77,7 +76,6 @@ EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer,
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
-	_eqp
 	Server = iRelayServer;
 	if (Server)
 		RelayServer = true;
@@ -100,7 +98,6 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConne
 	keepalive_timer(SERVER_TIMEOUT),
 	timeout_timer(SERVER_TIMEOUT * 2)
 {
-	_eqp
 	Server = iServer;
 	RelayLink = iRelayLink;
 	RelayServer = true;
@@ -120,7 +117,6 @@ EmuTCPConnection::~EmuTCPConnection() {
 }
 
 EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32 iDestination) {
-	_eqp
 	int32 size = sizeof(EmuTCPNetPacket_Struct) + pack->size;
 	if (pack->compressed) {
 		size += 4;
@@ -148,7 +144,6 @@ EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32
 }
 
 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);
@@ -159,7 +154,6 @@ SPackSendQueue* EmuTCPConnection::MakeOldPacket(ServerPacket* pack) {
 }
 
 bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
-	_eqp
 	if (!Connected())
 		return false;
 	eTCPMode tmp = GetMode();
@@ -220,7 +214,6 @@ bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
 }
 
 bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
-	_eqp
 	if (RemoteID)
 		return false;
 	if (!Connected())
@@ -261,7 +254,6 @@ bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
 }
 
 ServerPacket* EmuTCPConnection::PopPacket() {
-	_eqp
 	ServerPacket* ret;
 	if (!MOutQueueLock.trylock())
 		return nullptr;
@@ -271,14 +263,12 @@ ServerPacket* EmuTCPConnection::PopPacket() {
 }
 
 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();
@@ -286,7 +276,6 @@ void EmuTCPConnection::OutQueuePush(ServerPacket* pack) {
 
 
 bool EmuTCPConnection::LineOutQueuePush(char* line) {
-	_eqp
 	#if defined(GOTFRAGS) && 0
 		if (strcmp(line, "**CRASHME**") == 0) {
 			int i = 0;
@@ -380,7 +369,6 @@ bool EmuTCPConnection::LineOutQueuePush(char* line) {
 }
 
 void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
-	_eqp
 	TCPConnection::Disconnect();
 
 	if (RelayLink) {
@@ -390,7 +378,6 @@ void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
 }
 
 bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
-	_eqp
 	if(!TCPConnection::ConnectIP(irIP, irPort, errbuf))
 		return(false);
 
@@ -445,7 +432,6 @@ bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
 }
 
 void EmuTCPConnection::ClearBuffers() {
-	_eqp
 	TCPConnection::ClearBuffers();
 
 	LockMutex lock2(&MOutQueueLock);
@@ -462,7 +448,6 @@ void EmuTCPConnection::ClearBuffers() {
 }
 
 void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
-	_eqp
 	#if TCPC_DEBUG >= 1
 		struct in_addr	in;
 		in.s_addr = GetrIP();
@@ -471,22 +456,21 @@ void EmuTCPConnection::SendNetErrorPacket(const char* 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);
+		auto pack = new ServerPacket(0);
+		pack->size = 1;
+		if (reason)
+			pack->size += strlen(reason) + 1;
+		pack->pBuffer = new uchar[pack->size];
+		memset(pack->pBuffer, 0, pack->size);
+		pack->pBuffer[0] = 255;
+		strcpy((char *)&pack->pBuffer[1], reason);
+		SendPacket(pack);
+		safe_delete(pack);
 }
 
 void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect) {
-	_eqp
 	if (iSendRelayDisconnect) {
-		ServerPacket* pack = new ServerPacket(0, 5);
+		auto pack = new ServerPacket(0, 5);
 		pack->pBuffer[0] = 3;
 		*((uint32*) &pack->pBuffer[1]) = relay->GetRemoteID();
 		SendPacket(pack);
@@ -498,7 +482,6 @@ void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisco
 
 
 bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
-	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	timeout_timer.Start();
@@ -522,7 +505,6 @@ bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
 
 
 bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
-	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	int32 base = 0;
@@ -627,7 +609,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 		if (base >= recvbuf_used) {
 			safe_delete_array(recvbuf);
 		} else {
-			uchar* tmpbuf = new uchar[recvbuf_size - base];
+			auto tmpbuf = new uchar[recvbuf_size - base];
 			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
 			safe_delete_array(recvbuf);
 			recvbuf = tmpbuf;
@@ -639,7 +621,6 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 }
 
 bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
-	_eqp
 	int32 base = 0;
 	int32 size = 4;
 	uchar* buffer;
@@ -702,7 +683,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 			safe_delete_array(recvbuf);
 		}
 		else {
-			uchar* tmpbuf = new uchar[recvbuf_size - base];
+			auto tmpbuf = new uchar[recvbuf_size - base];
 			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
 			safe_delete_array(recvbuf);
 			recvbuf = tmpbuf;
@@ -714,7 +695,6 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 }
 
 void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
-	_eqp
 	uint8 opcode = pack->pBuffer[0];
 	uint8* data = &pack->pBuffer[1];
 	switch (opcode) {
@@ -759,7 +739,8 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
 				break;
 			}
-			EmuTCPConnection* con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32*) data), *((uint32*) &data[4]), *((uint16*) &data[8]));
+			auto con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32 *)data),
+							*((uint32 *)&data[4]), *((uint16 *)&data[8]));
 			Server->AddConnection(con);
 			RelayCount++;
 			break;
@@ -800,7 +781,6 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 }
 
 bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
-	_eqp
 	sent_something = false;
 	if(!TCPConnection::SendData(sent_something, errbuf))
 		return(false);
@@ -808,7 +788,7 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 	if(sent_something)
 		keepalive_timer.Start();
 	else if (TCPMode == modePacket && keepalive_timer.Check()) {
-		ServerPacket* pack = new ServerPacket(0, 0);
+		auto pack = new ServerPacket(0, 0);
 		SendPacket(pack);
 		safe_delete(pack);
 		#if TCPN_DEBUG >= 5
@@ -820,7 +800,6 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 }
 
 bool EmuTCPConnection::RecvData(char* errbuf) {
-	_eqp
 	if(!TCPConnection::RecvData(errbuf)) {
 		if (OutQueue.count())
 			return(true);

common/emu_tcp_server.cpp

@@ -9,7 +9,6 @@ EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
 }
 
 EmuTCPServer::~EmuTCPServer() {
-	_eqp
 	MInQueue.lock();
 	while(!m_InQueue.empty()) {
 		delete m_InQueue.front();
@@ -19,27 +18,23 @@ EmuTCPServer::~EmuTCPServer() {
 }
 
 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);
+	auto 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();
@@ -47,7 +42,6 @@ void EmuTCPServer::SendPacket(EmuTCPNetPacket_Struct** tnps) {
 }
 
 void EmuTCPServer::CheckInQueue() {
-	_eqp
 	EmuTCPNetPacket_Struct* tnps = 0;
 
 	while (( tnps = InQueuePop() )) {
@@ -63,7 +57,6 @@ void EmuTCPServer::CheckInQueue() {
 }
 
 EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
-	_eqp
 	EmuTCPNetPacket_Struct* ret = nullptr;
 	MInQueue.lock();
 	if(!m_InQueue.empty()) {
@@ -76,7 +69,6 @@ EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
 
 
 EmuTCPConnection *EmuTCPServer::FindConnection(uint32 iID) {
-	_eqp
 	vitr cur, end;
 	cur = m_list.begin();
 	end = m_list.end();

common/eq_constants.h

@@ -1,5 +1,6 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+
+	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
@@ -13,360 +14,57 @@
 
 	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 EQ_CONSTANTS_H
-#define EQ_CONSTANTS_H
+
+#ifndef COMMON_EQ_CONSTANTS_H
+#define COMMON_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
-};
 
-/*
-**	Item class types
-**
-*/
-enum ItemClassTypes
-{
-	ItemClassCommon = 0,
-	ItemClassContainer,
-	ItemClassBook,
-	_ItemClassCount
-};
+//SpawnAppearance types: (compared two clients for server-originating types: SoF & RoF2)
+#define AT_Die 0			// this causes the client to keel over and zone to bind point (default action)
+#define AT_WhoLevel 1		// the level that shows up on /who
+//#define AT_2 2			// unknown
+#define AT_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_27 27			// unknown
+#define AT_Split 28			// 0 = normal, 1 = autosplit on (not showing in SoF+) (client-to-server only)
+#define AT_Size 29			// spawn's size (present: SoF, absent: RoF2)
+//#define AT_30 30			// unknown
+#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name
+//#define AT_32 32			// unknown
+//#define AT_33 33			// unknown
+//#define AT_34 34			// unknown (present: SoF, absent: RoF2)
+//#define AT_35 35			// unknown
+//#define AT_36 36			// unknown
+//#define AT_37 37			// unknown
+//#define AT_38 38			// unknown
+//#define AT_39 39			// unknown
+#define AT_ShowHelm 43		// 0 = hide graphic, 1 = show graphic
+#define AT_DamageState 44	// The damage state of a destructible object (0 through 4)
+//#define AT_46 46			// unknown
+//#define AT_48 48			// unknown
+//#define AT_49 49			// unknown
+//#define AT_52 52			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
+//#define AT_53 53			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
 
-/*
-**	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
+//#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
 
 // animations for AT_Anim
 #define ANIM_FREEZE	102
@@ -472,15 +170,40 @@ 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,
@@ -676,7 +399,7 @@ static const uint8 DamageTypeUnknown	= 0xFF;
 **
 **	(indexed by 'Skill' of SkillUseTypes)
 */
-static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
+static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
 {
 /*1HBlunt*/					0,
 /*1HSlashing*/				1,
@@ -752,29 +475,10 @@ static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServ
 /*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)
-};
-
-/*
-**	Material use slots
-**
-*/
-enum MaterialUseSlots : uint8
-{
-	MaterialHead = 0,
-	MaterialChest,
-	MaterialArms,
-	MaterialWrist,
-	MaterialHands,
-	MaterialLegs,
-	MaterialFeet,
-	MaterialPrimary,
-	MaterialSecondary,
-	_MaterialCount,
-	_MaterialInvalid = 255
+/*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)
 };
 
 /*
@@ -811,164 +515,17 @@ enum MaterialUseSlots : uint8
 **
 */
 
-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;
-}
+#define TYPE_BEGIN	0
+#define SLOT_BEGIN	0
+#define SUB_INDEX_BEGIN	0
+#define AUG_INDEX_BEGIN	0
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
-#endif
+#endif /*COMMON_EQ_CONSTANTS_H*/

common/eq_dictionary.cpp

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

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

@@ -0,0 +1,521 @@
+/*	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"
+
+
+size_t EQEmu::constants::CharacterCreationLimit(versions::ClientVersion client_version)
+{
+	static const size_t local[versions::ClientVersionCount] = {
+		ClientUnknown::Null,
+		Client62::Null,
+		Titanium::constants::CharacterCreationLimit,
+		SoF::constants::CharacterCreationLimit,
+		SoD::constants::CharacterCreationLimit,
+		UF::constants::CharacterCreationLimit,
+		RoF::constants::CharacterCreationLimit,
+		RoF2::constants::CharacterCreationLimit
+	};
+
+	return local[static_cast<size_t>(versions::ValidateClientVersion(client_version))];
+}
+
+uint16 EQEmu::inventory::InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type)
+{
+	static const uint16 local[legacy::TypeCount][versions::InventoryVersionCount] = {
+		{ // local[TypePossessions]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE,
+			legacy::TYPE_POSSESSIONS_SIZE
+		},
+		{ // local[TypeBank]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::invtype::InvTypeBankSize,
+			legacy::TYPE_BANK_SIZE,
+			legacy::TYPE_BANK_SIZE,
+			legacy::TYPE_BANK_SIZE,
+			legacy::TYPE_BANK_SIZE,
+			legacy::TYPE_BANK_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeSharedBank]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			legacy::TYPE_SHARED_BANK_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeTrade]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_TRADE_SIZE,
+			legacy::TYPE_TRADE_SIZE,
+			legacy::TYPE_TRADE_SIZE,
+			legacy::TYPE_TRADE_SIZE,
+			legacy::TYPE_TRADE_SIZE,
+			legacy::TYPE_TRADE_SIZE,
+			4,
+			4,
+			legacy::TYPE_TRADE_SIZE, // client thinks this is another client
+			4
+		},
+		{ // local[TypeWorld]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_WORLD_SIZE,
+			legacy::TYPE_WORLD_SIZE,
+			legacy::TYPE_WORLD_SIZE,
+			legacy::TYPE_WORLD_SIZE,
+			legacy::TYPE_WORLD_SIZE,
+			legacy::TYPE_WORLD_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeLimbo]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_LIMBO_SIZE,
+			legacy::TYPE_LIMBO_SIZE,
+			legacy::TYPE_LIMBO_SIZE,
+			legacy::TYPE_LIMBO_SIZE,
+			legacy::TYPE_LIMBO_SIZE,
+			legacy::TYPE_LIMBO_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeTribute]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_TRIBUTE_SIZE,
+			legacy::TYPE_TRIBUTE_SIZE,
+			legacy::TYPE_TRIBUTE_SIZE,
+			legacy::TYPE_TRIBUTE_SIZE,
+			legacy::TYPE_TRIBUTE_SIZE,
+			legacy::TYPE_TRIBUTE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeTrophyTribute]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_TROPHY_TRIBUTE_SIZE,
+			legacy::TYPE_TROPHY_TRIBUTE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeGuildTribute]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_GUILD_TRIBUTE_SIZE,
+			legacy::TYPE_GUILD_TRIBUTE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeMerchant]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_MERCHANT_SIZE,
+			legacy::TYPE_MERCHANT_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeDeleted]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_DELETED_SIZE,
+			legacy::TYPE_DELETED_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeCorpse]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::invtype::InvTypeCorpseSize,
+			SoF::invtype::InvTypeCorpseSize,
+			SoD::invtype::InvTypeCorpseSize,
+			UF::invtype::InvTypeCorpseSize,
+			RoF::invtype::InvTypeCorpseSize,
+			RoF2::invtype::InvTypeCorpseSize,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeBazaar]
+			ClientUnknown::Null,
+			Client62::Null,
+			legacy::TYPE_BAZAAR_SIZE,
+			legacy::TYPE_BAZAAR_SIZE,
+			legacy::TYPE_BAZAAR_SIZE,
+			legacy::TYPE_BAZAAR_SIZE,
+			legacy::TYPE_BAZAAR_SIZE,
+			legacy::TYPE_BAZAAR_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeInspect]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::invtype::InvTypeInspectSize,
+			SoF::invtype::InvTypeInspectSize,
+			SoD::invtype::InvTypeInspectSize,
+			UF::invtype::InvTypeInspectSize,
+			RoF::invtype::InvTypeInspectSize,
+			RoF2::invtype::InvTypeInspectSize,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeRealEstate]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_REAL_ESTATE_SIZE,
+			legacy::TYPE_REAL_ESTATE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeViewMODPC]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_VIEW_MOD_PC_SIZE,
+			legacy::TYPE_VIEW_MOD_PC_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeViewMODBank]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_VIEW_MOD_BANK_SIZE,
+			legacy::TYPE_VIEW_MOD_BANK_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeViewMODSharedBank]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_VIEW_MOD_SHARED_BANK_SIZE,
+			legacy::TYPE_VIEW_MOD_SHARED_BANK_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeViewMODLimbo]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_VIEW_MOD_LIMBO_SIZE,
+			legacy::TYPE_VIEW_MOD_LIMBO_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeAltStorage]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_ALT_STORAGE_SIZE,
+			legacy::TYPE_ALT_STORAGE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeArchived]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_ARCHIVED_SIZE,
+			legacy::TYPE_ARCHIVED_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeMail]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_MAIL_SIZE,
+			legacy::TYPE_MAIL_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeGuildTrophyTribute]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_GUILD_TROPHY_TRIBUTE_SIZE,
+			legacy::TYPE_GUILD_TROPHY_TRIBUTE_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeKrono]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_KRONO_SIZE,
+			legacy::TYPE_KRONO_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		},
+		{ // local[TypeOther]
+			ClientUnknown::Null,
+			Client62::Null,
+			Titanium::Null,
+			SoF::Null,
+			SoD::Null,
+			UF::Null,
+			legacy::TYPE_OTHER_SIZE,
+			legacy::TYPE_OTHER_SIZE,
+			EntityLimits::npc::Null,
+			EntityLimits::merc::Null,
+			EntityLimits::bot::Null,
+			EntityLimits::pet::Null
+		}
+	};
+
+	if ((uint16)inv_type < legacy::TypeCount)
+		return local[inv_type][static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+
+	return NOT_USED;
+}
+
+uint64 EQEmu::inventory::PossessionsBitmask(versions::InventoryVersion inventory_version)
+{
+	static const uint64 local[versions::InventoryVersionCount] = {
+		ClientUnknown::Null,
+		Client62::Null,
+		0x000000027FDFFFFF,
+		0x000000027FFFFFFF,
+		0x000000027FFFFFFF,
+		0x000000027FFFFFFF,
+		0x00000003FFFFFFFF,
+		0x00000003FFFFFFFF,
+		EntityLimits::npc::Null,
+		EntityLimits::merc::Null,
+		EntityLimits::bot::Null,
+		EntityLimits::pet::Null
+	};
+
+	return NOT_USED;
+	//return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}
+
+bool EQEmu::inventory::AllowEmptyBagInBag(versions::InventoryVersion inventory_version)
+{
+	static const bool local[versions::InventoryVersionCount] = {
+		ClientUnknown::False,
+		Client62::False,
+		Titanium::behavior::AllowEmptyBagInBag,
+		SoF::behavior::AllowEmptyBagInBag,
+		SoD::behavior::AllowEmptyBagInBag,
+		UF::behavior::AllowEmptyBagInBag,
+		RoF::behavior::AllowEmptyBagInBag,
+		RoF2::behavior::AllowEmptyBagInBag,
+		EntityLimits::npc::False,
+		EntityLimits::merc::False,
+		EntityLimits::bot::False,
+		EntityLimits::pet::False
+	};
+
+	return false;
+	//return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}
+
+bool EQEmu::inventory::AllowClickCastFromBag(versions::InventoryVersion inventory_version)
+{
+	static const bool local[versions::InventoryVersionCount] = {
+		ClientUnknown::False,
+		Client62::False,
+		Titanium::behavior::AllowClickCastFromBag,
+		SoF::behavior::AllowClickCastFromBag,
+		SoD::behavior::AllowClickCastFromBag,
+		UF::behavior::AllowClickCastFromBag,
+		RoF::behavior::AllowClickCastFromBag,
+		RoF2::behavior::AllowClickCastFromBag,
+		EntityLimits::npc::False,
+		EntityLimits::merc::False,
+		EntityLimits::bot::False,
+		EntityLimits::pet::False
+	};
+
+	return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}
+
+uint16 EQEmu::inventory::ItemAugSize(versions::InventoryVersion inventory_version)
+{
+	static const uint16 local[versions::InventoryVersionCount] = {
+		ClientUnknown::Null,
+		Client62::Null,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE,
+		legacy::ITEM_COMMON_SIZE
+	};
+
+	return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}
+
+uint16 EQEmu::inventory::ItemBagSize(versions::InventoryVersion inventory_version)
+{
+	static const uint16 local[versions::InventoryVersionCount] = {
+		ClientUnknown::Null,
+		Client62::Null,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE,
+		legacy::ITEM_CONTAINER_SIZE
+	};
+
+	return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}
+
+bool EQEmu::profile::CoinHasWeight(versions::InventoryVersion inventory_version)
+{
+	static const bool local[versions::InventoryVersionCount] = {
+		ClientUnknown::True,
+		Client62::True,
+		Titanium::behavior::CoinHasWeight,
+		SoF::behavior::CoinHasWeight,
+		SoD::behavior::CoinHasWeight,
+		UF::behavior::CoinHasWeight,
+		RoF::behavior::CoinHasWeight,
+		RoF::behavior::CoinHasWeight,
+		EntityLimits::npc::True,
+		EntityLimits::merc::True,
+		EntityLimits::bot::True,
+		EntityLimits::pet::True
+	};
+
+	return local[static_cast<size_t>(versions::ValidateInventoryVersion(inventory_version))];
+}

common/eq_limits.h

@@ -0,0 +1,80 @@
+/*	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 "types.h"
+#include "eq_constants.h"
+#include "inventory_version.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 {
+		extern size_t CharacterCreationLimit(versions::ClientVersion client_version);
+
+	} /*constants*/
+	
+	namespace inventory {
+		extern uint16 InventoryTypeSize(versions::InventoryVersion inventory_version, int16 inv_type);
+		extern uint64 PossessionsBitmask(versions::InventoryVersion inventory_version);
+
+		extern bool AllowEmptyBagInBag(versions::InventoryVersion inventory_version);
+		extern bool AllowClickCastFromBag(versions::InventoryVersion inventory_version);
+
+		extern uint16 ItemAugSize(versions::InventoryVersion inventory_version);
+		extern uint16 ItemBagSize(versions::InventoryVersion inventory_version);
+
+		extern bool ConcatenateInvTypeLimbo(versions::InventoryVersion inventory_version);
+
+		extern bool AllowOverLevelEquipment(versions::InventoryVersion inventory_version);
+
+	} /*inventory*/
+	
+	namespace profile {
+		extern bool CoinHasWeight(versions::InventoryVersion inventory_version);
+
+	} /*profile*/
+
+} /*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,11 +40,9 @@ 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);
 
@@ -53,20 +51,17 @@ 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);
@@ -81,7 +76,6 @@ 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);
 
@@ -90,7 +84,6 @@ 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);
@@ -98,13 +91,11 @@ 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);
@@ -119,7 +110,6 @@ 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);
 
@@ -132,7 +122,6 @@ 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);
@@ -140,7 +129,6 @@ 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
@@ -150,7 +138,6 @@ void EQApplicationPacket::build_header_dump(char *buffer) const
 
 void EQApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 {
-	_eqp
 	if (src_ip) {
 		std::string sIP,dIP;;
 		sIP=long2ip(src_ip);
@@ -169,7 +156,6 @@ 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);
 
@@ -182,7 +168,6 @@ 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);
@@ -190,7 +175,6 @@ 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
@@ -200,7 +184,6 @@ 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);
@@ -219,7 +202,6 @@ void EQRawApplicationPacket::DumpRawHeaderNoTime(uint16 seq, FILE *to) const
 
 uint32 EQProtocolPacket::serialize(unsigned char *dest) const
 {
-	_eqp
 	if (opcode>0xff) {
 		*(uint16 *)dest=opcode;
 	} else {
@@ -233,7 +215,6 @@ 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)
@@ -255,12 +236,31 @@ 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)
 {
-	_eqp
-	bool result=false;
+bool result=false;
 	if (opcode==OP_Combined && size+rhs->size+5<256) {
-		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+3];
+		auto tmpbuffer = new unsigned char[size + rhs->size + 3];
 		memcpy(tmpbuffer,pBuffer,size);
 		uint32 offset=size;
 		tmpbuffer[offset++]=rhs->Size();
@@ -270,7 +270,7 @@ bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 		pBuffer=tmpbuffer;
 		result=true;
 	} else if (size+rhs->size+7<256) {
-		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+6];
+		auto tmpbuffer = new unsigned char[size + rhs->size + 6];
 		uint32 offset=0;
 		tmpbuffer[offset++]=Size();
 		offset+=serialize(tmpbuffer+offset);
@@ -284,12 +284,61 @@ bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 	}
 
 	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)
 {
-	_eqp
-	bool valid=false;
+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;
@@ -308,9 +357,8 @@ bool EQProtocolPacket::ValidateCRC(const unsigned char *buffer, int length, uint
 
 uint32 EQProtocolPacket::Decompress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize)
 {
-	_eqp
-	uint32 newlen=0;
-	uint32 flag_offset=0;
+uint32 newlen=0;
+uint32 flag_offset=0;
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0x00) {
 		flag_offset=2;
@@ -334,8 +382,7 @@ uint32 EQProtocolPacket::Decompress(const unsigned char *buffer, const uint32 le
 }
 
 uint32 EQProtocolPacket::Compress(const unsigned char *buffer, const uint32 length, unsigned char *newbuf, uint32 newbufsize) {
-	_eqp
-	uint32 flag_offset=1,newlength;
+uint32 flag_offset=1,newlength;
 	//dump_message_column(buffer,length,"Before: ");
 	newbuf[0]=buffer[0];
 	if (buffer[0]==0) {
@@ -358,7 +405,6 @@ uint32 EQProtocolPacket::Compress(const unsigned char *buffer, const uint32 leng
 
 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);
@@ -384,7 +430,6 @@ 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);
@@ -408,13 +453,11 @@ void EQProtocolPacket::ChatEncode(unsigned char *buffer, int size, int EncodeKey
 }
 
 EQApplicationPacket *EQApplicationPacket::Copy() const {
-	_eqp
 	return(new EQApplicationPacket(*this));
 }
 
 EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	_eqp
-	EQRawApplicationPacket *res = new EQRawApplicationPacket(opcode, pBuffer, size);
+	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
 	res->copyInfo(this);
 	return(res);
 }
@@ -423,13 +466,10 @@ 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)
@@ -463,17 +503,16 @@ 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; }
+	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf, len), opcode(op) { acked = false; sent_time = 0; }
 //	EQProtocolPacket(const unsigned char *buf, uint32 len);
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
@@ -70,6 +70,7 @@ 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;

common/eq_packet_structs.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -15,6 +15,7 @@
 	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_PACKET_STRUCTS_H
 #define EQ_PACKET_STRUCTS_H
 
@@ -32,8 +33,7 @@ static const uint32 MAX_MERC_GRADES = 10;
 static const uint32 MAX_MERC_STANCES = 10;
 static const uint32 BLOCKED_BUFF_COUNT = 20;
 
-//#include "eq_constants.h"
-#include "eq_dictionary.h"
+#include "emu_constants.h"
 
 /*
 ** Compiler override to ensure
@@ -123,83 +123,81 @@ struct LDoNTrapTemplate
 ///////////////////////////////////////////////////////////////////////////////
 
 
-/*
-** Color_Struct
-** Size: 4 bytes
-** Used for convenience
-** Merth: Gave struct a name so gcc 2.96 would compile
-**
-*/
+// All clients translate the character select information to some degree
+
 struct Color_Struct
 {
-	union
-	{
-		struct
-		{
-			uint8	blue;
-			uint8	green;
-			uint8	red;
-			uint8	use_tint;	// if there's a tint this is FF
-		} rgb;
-		uint32 color;
+	union {
+		struct {
+			uint8 Blue;
+			uint8 Green;
+			uint8 Red;
+			uint8 UseTint;	// if there's a tint this is FF
+		} RGB;
+		uint32 Color;
 	};
 };
 
-/*
-* Visible equiptment.
-* Size: 20 Octets
-*/
-struct EquipStruct {
-	/*00*/ uint32 material;
-	/*04*/ uint32 unknown1;
-	/*08*/ uint32 elitematerial;
-	/*12*/ uint32 heroforgemodel;
-	/*16*/ uint32 material2;	// Same as material?
-	/*20*/
+struct EquipStruct
+{
+	uint32 Material;
+	uint32 Unknown1;
+	uint32 EliteMaterial;
+	uint32 HeroForgeModel;
+	uint32 Material2;	// Same as material?
 };
 
-struct CharSelectEquip {
-	uint32 material;
-	uint32 unknown1;
-	uint32 elitematerial;
-	uint32 heroforgemodel;
-	uint32 material2;
-	Color_Struct color;
+struct CharSelectEquip
+{
+	uint32 Material;
+	uint32 Unknown1;
+	uint32 EliteMaterial;
+	uint32 HeroForgeModel;
+	uint32 Material2;
+	Color_Struct Color;
 };
 
-/*
-** Character Selection Struct
-** Length: 1704 Bytes
-**
-*/
-struct CharacterSelect_Struct {
-/*0000*/	uint32	race[10];				// Characters Race
-/*0040*/	//Color_Struct	cs_colors[10][9];	// Characters Equipment Colors
-/*0400*/	uint8	beardcolor[10];			// Characters beard Color
-/*0410*/	uint8	hairstyle[10];			// Characters hair style
-/*0420*/	//uint32	equip[10][9];			// 0=helm, 1=chest, 2=arm, 3=bracer, 4=hand, 5=leg, 6=boot, 7=melee1, 8=melee2 (Might not be)
-/*0000*/	CharSelectEquip	equip[10][9];
-/*0780*/	uint32	secondary[10];			// Characters secondary IDFile number
-/*0820*/	uint32	drakkin_heritage[10];		// added for SoF
-/*0860*/	uint32	drakkin_tattoo[10];			// added for SoF
-/*0900*/	uint32	drakkin_details[10];		// added for SoF
-/*0940*/	uint32	deity[10];				// Characters Deity
-/*0980*/	uint8	gohome[10];				// 1=Go Home available, 0=not
-/*0990*/	uint8	tutorial[10];			// 1=Tutorial available, 0=not
-/*1000*/	uint8	beard[10];				// Characters Beard Type
-/*1010*/	uint8	unknown902[10];			// 10x ff
-/*1020*/	uint32	primary[10];			// Characters primary IDFile number
-/*1060*/	uint8	haircolor[10];			// Characters Hair Color
-/*1070*/	uint8	unknown0962[2];			// 2x 00
-/*1072*/	uint32	zone[10];				// Characters Current Zone
-/*1112*/	uint8	class_[10];				// Characters Classes
-/*1022*/	uint8	face[10];				// Characters Face Type
-/*1032*/	char	name[10][64];			// Characters Names
-/*1672*/	uint8	gender[10];				// Characters Gender
-/*1682*/	uint8	eyecolor1[10];			// Characters Eye Color
-/*1692*/	uint8	eyecolor2[10];			// Characters Eye 2 Color
-/*1702*/	uint8	level[10];				// Characters Levels
-/*1712*/
+// RoF2-based hybrid struct
+struct CharacterSelectEntry_Struct
+{
+	char Name[64];
+	uint8 Class;
+	uint32 Race;
+	uint8 Level;
+	uint8 ShroudClass;
+	uint32 ShroudRace;
+	uint16 Zone;
+	uint16 Instance;
+	uint8 Gender;
+	uint8 Face;
+	CharSelectEquip	Equip[9];
+	uint8 Unknown15;			// Seen FF
+	uint8 Unknown19;			// Seen FF
+	uint32 DrakkinTattoo;
+	uint32 DrakkinDetails;
+	uint32 Deity;
+	uint32 PrimaryIDFile;
+	uint32 SecondaryIDFile;
+	uint8 HairColor;
+	uint8 BeardColor;
+	uint8 EyeColor1;
+	uint8 EyeColor2;
+	uint8 HairStyle;
+	uint8 Beard;
+	uint8 GoHome;				// Seen 0 for new char and 1 for existing
+	uint8 Tutorial;				// Seen 1 for new char or 0 for existing
+	uint32 DrakkinHeritage;
+	uint8 Unknown1;				// Seen 0
+	uint8 Enabled;				// Originally labeled as 'CharEnabled' - unknown purpose and setting
+	uint32 LastLogin;
+	uint8 Unknown2;				// Seen 0
+};
+
+struct CharacterSelect_Struct
+{
+	uint32 CharCount;	//number of chars in this packet
+	uint32 TotalChars;	//total number of chars allowed?
+	CharacterSelectEntry_Struct Entries[0];
 };
 
 /*
@@ -274,7 +272,8 @@ struct Spawn_Struct {
 /*0146*/ uint8	beard;				// Beard style (not totally, sure but maybe!)
 /*0147*/ uint8	unknown0147[4];
 /*0151*/ uint8	level;				// Spawn Level
-/*0152*/ uint8	unknown0259[4];		// ***Placeholder
+// None = 0, Open = 1, WeaponSheathed = 2, Aggressive = 4, ForcedAggressive = 8, InstrumentEquipped = 16, Stunned = 32, PrimaryWeaponEquipped = 64, SecondaryWeaponEquipped = 128
+/*0152*/ uint32 PlayerState;           // Controls animation stuff
 /*0156*/ uint8	beardcolor;			// Beard color
 /*0157*/ char	suffix[32];			// Player's suffix (of Veeshan, etc.)
 /*0189*/ uint32	petOwnerId;			// If this is a pet, the spawn id of owner
@@ -294,7 +293,7 @@ struct Spawn_Struct {
 		/*0000*/ EquipStruct equip_primary;    // Equipment: Main visual
 		/*0000*/ EquipStruct equip_secondary;  // Equipment: Off visual
 	} equip;
-	/*0000*/ EquipStruct equipment[_MaterialCount];
+	/*0000*/ EquipStruct equipment[EQEmu::legacy::MaterialCount];
 };
 /*0233*/ float	runspeed;		// Speed when running
 /*0036*/ uint8	afk;			// 0=no, 1=afk
@@ -340,7 +339,7 @@ union
 				/*0376*/ Color_Struct color_primary;	// Color of primary item
 				/*0380*/ Color_Struct color_secondary;	// Color of secondary item
 			} equipment_colors;
-			/*0348*/ Color_Struct colors[_MaterialCount]; // Array elements correspond to struct equipment_colors above
+			/*0348*/ Color_Struct colors[EQEmu::legacy::MaterialCount]; // Array elements correspond to struct equipment_colors above
 		 };
 /*0384*/ uint8	lfg;			// 0=off, 1=lfg on
 /*0385*/
@@ -367,6 +366,11 @@ union
 
 };
 
+struct PlayerState_Struct {
+/*00*/	uint32 spawn_id;
+/*04*/	uint32 state;
+};
+
 /*
 ** New Spawn
 ** Length: 176 Bytes
@@ -548,7 +552,7 @@ struct SpellBuff_Struct
 /*002*/	uint8	bard_modifier;
 /*003*/	uint8	effect;			//not real
 /*004*/	uint32	spellid;
-/*008*/ uint32	duration;
+/*008*/ int32	duration;
 /*012*/	uint32	counters;
 /*016*/	uint32	player_id;	//'global' ID of the caster, for wearoff messages
 /*020*/
@@ -561,7 +565,7 @@ struct SpellBuffFade_Struct {
 /*006*/	uint8 effect;
 /*007*/	uint8 unknown7;
 /*008*/	uint32 spellid;
-/*012*/	uint32 duration;
+/*012*/	int32 duration;
 /*016*/	uint32 num_hits;
 /*020*/	uint32 unknown020;	//prolly global player ID
 /*024*/	uint32 slotid;
@@ -579,14 +583,8 @@ struct BuffRemoveRequest_Struct
 
 struct PetBuff_Struct {
 /*000*/ uint32 petid;
-/*004*/ uint32 spellid[BUFF_COUNT];
-/*104*/ uint32 unknown700;
-/*108*/ uint32 unknown701;
-/*112*/ uint32 unknown702;
-/*116*/ uint32 unknown703;
-/*120*/ uint32 unknown704;
-/*124*/ uint32 ticsremaining[BUFF_COUNT];
-/*224*/ uchar unknown705[20];
+/*004*/ uint32 spellid[BUFF_COUNT+5];
+/*124*/ int32 ticsremaining[BUFF_COUNT+5];
 /*244*/ uint32 buffcount;
 };
 
@@ -727,6 +725,7 @@ struct AA_Array
 {
 	uint32 AA;
 	uint32 value;
+	uint32 charges;
 };
 
 
@@ -756,29 +755,46 @@ struct Tribute_Struct {
 	uint32 tier;
 };
 
-//len = 72
-struct BandolierItem_Struct {
-	uint32 item_id;
-	uint32 icon;
-	char item_name[64];
-};
-
-//len = 320
-enum { //bandolier item positions
-	bandolierMainHand = 0,
-	bandolierOffHand,
+// Bandolier item positions
+enum
+{
+	bandolierPrimary = 0,
+	bandolierSecondary,
 	bandolierRange,
 	bandolierAmmo
 };
-struct Bandolier_Struct {
-	char name[32];
-	BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
-};
-struct PotionBelt_Struct {
-	BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
+
+//len = 72
+struct BandolierItem_Struct
+{
+	uint32 ID;
+	uint32 Icon;
+	char Name[64];
 };
 
-struct MovePotionToBelt_Struct {
+//len = 320
+struct Bandolier_Struct
+{
+	char Name[32];
+	BandolierItem_Struct Items[EQEmu::legacy::BANDOLIER_ITEM_COUNT];
+};
+
+//len = 72
+struct PotionBeltItem_Struct
+{
+	uint32 ID;
+	uint32 Icon;
+	char Name[64];
+};
+
+//len = 288
+struct PotionBelt_Struct
+{
+	PotionBeltItem_Struct Items[EQEmu::legacy::POTION_BELT_ITEM_COUNT];
+};
+
+struct MovePotionToBelt_Struct
+{
 	uint32	Action;
 	uint32	SlotNumber;
 	uint32	ItemID;
@@ -865,7 +881,7 @@ struct SuspendedMinion_Struct
 	/*002*/	uint32 HP;
 	/*006*/	uint32 Mana;
 	/*010*/	SpellBuff_Struct Buffs[BUFF_COUNT];
-	/*510*/	uint32 Items[_MaterialCount];
+	/*510*/	uint32 Items[EQEmu::legacy::MaterialCount];
 	/*546*/	char Name[64];
 	/*610*/
 };
@@ -973,9 +989,9 @@ struct PlayerProfile_Struct
 /*0304*/	uint8				ability_time_minutes;
 /*0305*/	uint8				ability_time_hours;	//place holder
 /*0306*/	uint8				unknown0306[6];		// @bp Spacer/Flag?
-/*0312*/	uint32				item_material[_MaterialCount];	// Item texture/material of worn/held items
+/*0312*/	uint32				item_material[EQEmu::legacy::MaterialCount];	// Item texture/material of worn/held items
 /*0348*/	uint8				unknown0348[44];
-/*0392*/	Color_Struct		item_tint[_MaterialCount];
+/*0392*/	Color_Struct		item_tint[EQEmu::legacy::MaterialCount];
 /*0428*/	AA_Array			aa_array[MAX_PP_AA_ARRAY];
 /*2348*/	float				unknown2384;		//seen ~128, ~47
 /*2352*/	char				servername[32];		// length probably not right
@@ -1076,7 +1092,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[EmuConstants::TRIBUTE_SIZE];
+/*7224*/	Tribute_Struct		tributes[EQEmu::legacy::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1103,7 +1119,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[EmuConstants::BANDOLIERS_COUNT];
+/*12844*/	Bandolier_Struct	bandoliers[EQEmu::legacy::BANDOLIERS_SIZE];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -1144,7 +1160,7 @@ struct TargetReject_Struct {
 
 struct PetCommand_Struct {
 /*000*/ uint32	command;
-/*004*/ uint32	unknown;
+/*004*/ uint32	target;
 };
 
 /*
@@ -1249,7 +1265,7 @@ struct ZoneChange_Struct {
 
 // Whatever you send to the client in RequestClientZoneChange_Struct.type, the client will send back
 // to the server in ZoneChange_Struct.zone_reason. My guess is this is a memo field of sorts.
-// WildcardX 27 January 2008
+// 27 January 2008
 
 struct RequestClientZoneChange_Struct {
 /*00*/	uint16	zone_id;
@@ -1263,8 +1279,8 @@ struct RequestClientZoneChange_Struct {
 
 struct Animation_Struct {
 /*00*/	uint16 spawnid;
-/*02*/	uint8 action;
-/*03*/	uint8 value;
+/*02*/	uint8 speed;
+/*03*/	uint8 action;
 /*04*/
 };
 
@@ -1302,10 +1318,10 @@ struct CombatDamage_Struct
 /* 04 */	uint8	type; //slashing, etc. 231 (0xE7) for spells
 /* 05 */	uint16	spellid;
 /* 07 */	uint32	damage;
-/* 11 */	uint32 unknown11;
-/* 15 */	uint32 sequence;	// see above notes in Action_Struct
-/* 19 */	uint32	unknown19;
-/* 23 */
+/* 11 */	float force;
+/* 15 */	float meleepush_xy;	// see above notes in Action_Struct
+/* 19 */	float meleepush_z;
+/* 23 */	uint32 special; // 2 = Rampage, 1 = Wild Rampage
 };
 
 /*
@@ -1501,17 +1517,38 @@ struct ExpUpdate_Struct
 enum ItemPacketType
 {
 	ItemPacketViewLink			= 0x00,
+	ItemPacketMerchant			= 0x64,
 	ItemPacketTradeView			= 0x65,
 	ItemPacketLoot				= 0x66,
 	ItemPacketTrade				= 0x67,
 	ItemPacketCharInventory		= 0x69,
 	ItemPacketSummonItem		= 0x6A,
-	ItemPacketTributeItem		= 0x6C,
-	ItemPacketMerchant			= 0x64,
 	ItemPacketWorldContainer	= 0x6B,
-	ItemPacketCharmUpdate		= 0x6E,
+	ItemPacketTributeItem		= 0x6C,
+	ItemPacketGuildTribute		= 0x6D,
+	ItemPacketCharmUpdate		= 0x6E, // noted as incorrect
 	ItemPacketInvalid			= 0xFF
 };
+
+//enum ItemPacketType
+//{
+//	ItemPacketMerchant			= /*100*/ 0x64, // Titanium+
+//	ItemPacketTradeView			= /*101*/ 0x65,
+//	ItemPacketLoot				= /*102*/ 0x66,
+//	ItemPacketTrade				= /*103*/ 0x67,
+//	ItemPacketCharInventory		= /*105*/ 0x69,
+//	ItemPacketLimbo				= /*106*/ 0x6A, // name change
+//	ItemPacketWorldContainer	= /*107*/ 0x6B,
+//	ItemPacketTributeItem		= /*108*/ 0x6C,
+//	ItemPacketGuildTribute		= /*109*/ 0x6D, // missing from EQEmu
+//	ItemPacket10				= /*110*/ 0x6E,
+//	ItemPacket11				= /*111*/ 0x6F, // UF+ (equipment slots only) (RoF+ checks '(WORD*)slot + 4 != -1' [(WORD*)]slot + 2 would be bag index - if used) (guess)
+//	ItemPacket12				= /*112*/ 0x70, // RoF+ (causes stat update) (could be TrophyTribute and GuildTrophyTribute together - two case methodology - is it checking for GuildID?)
+//	ItemPacketRecovery			= /*113*/ 0x71, (same handler as merchant..exception: parameter is '1' versus merchant '0' looks like tab id)
+//	ItemPacket14				= /*115*/ 0x73, (real estate/moving crate?)
+//	ItemPacket__				= /*xxx*/ 0xXX // switch 'default' - all clients
+//};
+
 struct ItemPacket_Struct
 {
 /*00*/	ItemPacketType	PacketType;
@@ -2082,7 +2119,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	Item_Struct item;
+	EQEmu::Item_Struct item;
 	uint8 iss_unknown001[6];
 };*/
 
@@ -2108,7 +2145,7 @@ struct Illusion_Struct { //size: 256 - SoF
 /*092*/	uint32	drakkin_heritage;	//
 /*096*/	uint32	drakkin_tattoo;		//
 /*100*/	uint32	drakkin_details;	//
-/*104*/	uint32	armor_tint[_MaterialCount];	//
+/*104*/	uint32	armor_tint[EQEmu::legacy::MaterialCount];	//
 /*140*/	uint8	eyecolor1;		// Field Not Identified in any Illusion Struct
 /*141*/	uint8	eyecolor2;		// Field Not Identified in any Illusion Struct
 /*142*/	uint8	unknown138[114];	//
@@ -2132,24 +2169,24 @@ struct Illusion_Struct_Old {
 // OP_Sound - Size: 68
 struct QuestReward_Struct
 {
-/*000*/ uint32	from_mob;	// ID of mob awarding the client
-/*004*/ uint32	unknown004;
-/*008*/ uint32	unknown008;
-/*012*/ uint32	unknown012;
-/*016*/ uint32	unknown016;
-/*020*/ uint32	unknown020;
-/*024*/ uint32	silver;		// Gives silver to the client
-/*028*/ uint32	gold;		// Gives gold to the client
-/*032*/ uint32	platinum;	// Gives platinum to the client
-/*036*/ uint32	unknown036;
-/*040*/ uint32	unknown040;
-/*044*/ uint32	unknown044;
-/*048*/ uint32	unknown048;
-/*052*/ uint32	unknown052;
-/*056*/ uint32	unknown056;
-/*060*/ uint32	unknown060;
-/*064*/ uint32	unknown064;
-/*068*/
+	/*000*/ uint32	mob_id;	// ID of mob awarding the client
+	/*004*/ uint32	target_id;
+	/*008*/ uint32	exp_reward;
+	/*012*/ uint32	faction;
+	/*016*/ int32	faction_mod;
+	/*020*/ uint32	copper;		// Gives copper to the client
+	/*024*/ uint32	silver;		// Gives silver to the client
+	/*028*/ uint32	gold;		// Gives gold to the client
+	/*032*/ uint32	platinum;	// Gives platinum to the client
+	/*036*/ uint32	item_id;
+	/*040*/ uint32	unknown040;
+	/*044*/ uint32	unknown044;
+	/*048*/ uint32	unknown048;
+	/*052*/ uint32	unknown052;
+	/*056*/ uint32	unknown056;
+	/*060*/ uint32	unknown060;
+	/*064*/ uint32	unknown064;
+	/*068*/
 };
 
 // Size: 8
@@ -2405,11 +2442,11 @@ struct InspectResponse_Struct {
 /*004*/	uint32 playerid;
 /*008*/	char itemnames[23][64];
 /*1480*/uint32 itemicons[23];
-/*1572*/char text[288];	// Max number of chars in Inspect Window appears to be 254 // Msg struct property is 256 (254 + '\0' is my guess) -U
+/*1572*/char text[288];	// Max number of chars in Inspect Window appears to be 254 // Msg struct property is 256 (254 + '\0' is my guess)
 /*1860*/
 };
 
-//OP_InspectMessageUpdate - Size: 256 (SoF+ clients after self-inspect window is closed) -U
+//OP_InspectMessageUpdate - Size: 256 (SoF+ clients after self-inspect window is closed)
 struct InspectMessage_Struct {
 /*000*/ char text[256];
 /*256*/
@@ -2518,9 +2555,9 @@ struct BookRequest_Struct {
 **
 */
 struct Object_Struct {
-/*00*/	uint32	linked_list_addr[2];// <Zaphod> They are, get this, prev and next, ala linked list
-/*08*/	uint16	unknown008;			//
-/*10*/	uint16	unknown010;			//
+/*00*/	uint32	linked_list_addr[2];// They are, get this, prev and next, ala linked list
+/*08*/	uint16	size;				//
+/*10*/	uint16	solidtype;			//
 /*12*/	uint32	drop_id;			// Unique object id for zone
 /*16*/	uint16	zone_id;			// Redudant, but: Zone the object appears in
 /*18*/	uint16	zone_instance;		//
@@ -2537,8 +2574,8 @@ struct Object_Struct {
 /*88*/	uint32	spawn_id;			// Spawn Id of client interacting with object
 /*92*/
 };
-//<Zaphod> 01 = generic drop, 02 = armor, 19 = weapon
-//[13:40] <Zaphod> and 0xff seems to be indicative of the tradeskill/openable items that end up returning the old style item type in the OP_OpenObject
+// 01 = generic drop, 02 = armor, 19 = weapon
+//[13:40] and 0xff seems to be indicative of the tradeskill/openable items that end up returning the old style item type in the OP_OpenObject
 
 /*
 ** Click Object Struct
@@ -2595,7 +2632,7 @@ struct CloseContainer_Struct {
 */
 struct Door_Struct
 {
-/*0000*/ char	name[32];		// Filename of Door // Was 10char long before... added the 6 in the next unknown to it: Daeken M. BlackBlade //changed both to 32: Trevius
+/*0000*/ char	name[32];		// Filename of Door // Was 10char long before... added the 6 in the next unknown to it //changed both to 32
 /*0032*/ float	yPos;			// y loc
 /*0036*/ float	xPos;			// x loc
 /*0040*/ float	zPos;			// z loc
@@ -2761,7 +2798,8 @@ struct BazaarWelcome_Struct {
 	BazaarWindowStart_Struct Beginning;
 	uint32	Traders;
 	uint32	Items;
-	uint8	Unknown012[8];
+	uint32	Unknown012;
+	uint32	Unknown016;
 };
 
 struct BazaarSearch_Struct {
@@ -3146,6 +3184,7 @@ struct Trader_ShowItems_Struct{
 /*000*/	uint32 Code;
 /*004*/	uint32 TraderID;
 /*008*/	uint32 Unknown08[3];
+/*020*/
 };
 
 struct TraderBuy_Struct{
@@ -3191,9 +3230,10 @@ struct TraderDelItem_Struct{
 
 struct TraderClick_Struct{
 /*000*/	uint32 TraderID;
-/*004*/	uint32 Unknown004;
+/*004*/	uint32 Code;
 /*008*/	uint32 Unknown008;
 /*012*/	uint32 Approval;
+/*016*/
 };
 
 struct FormattedMessage_Struct{
@@ -3392,7 +3432,7 @@ struct DyeStruct
 			struct Color_Struct secondary;	// or this
 		}
 		dyes;
-		struct Color_Struct dye[_MaterialCount];
+		struct Color_Struct dye[EQEmu::legacy::MaterialCount];
 	};
 };
 
@@ -3453,8 +3493,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EmuConstants::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EmuConstants::TRIBUTE_SIZE];		//all 00's
+	uint32	tributes[EQEmu::legacy::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EQEmu::legacy::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -4011,7 +4051,7 @@ struct MarkNPC_Struct
 
 struct InspectBuffs_Struct {
 /*000*/ uint32 spell_id[BUFF_COUNT];
-/*100*/ uint32 tics_remaining[BUFF_COUNT];
+/*100*/ int32 tics_remaining[BUFF_COUNT];
 };
 
 struct RaidGeneral_Struct {
@@ -4104,30 +4144,35 @@ struct DynamicWall_Struct {
 /*80*/
 };
 
-enum {	//bandolier actions
-	BandolierCreate = 0,
-	BandolierRemove = 1,
-	BandolierSet = 2
+// Bandolier actions
+enum
+{
+	bandolierCreate = 0,
+	bandolierRemove,
+	bandolierSet
 };
 
-struct BandolierCreate_Struct {
-/*00*/	uint32	action;	//0 for create
-/*04*/	uint8	number;
-/*05*/	char	name[32];
-/*37*/	uint16	unknown37;	//seen 0x93FD
-/*39*/	uint8	unknown39;	//0
+struct BandolierCreate_Struct
+{
+/*00*/	uint32 Action;		//0 for create
+/*04*/	uint8 Number;
+/*05*/	char Name[32];
+/*37*/	uint16 Unknown37;	//seen 0x93FD
+/*39*/	uint8 Unknown39;	//0
 };
 
-struct BandolierDelete_Struct {
-/*00*/	uint32	action;
-/*04*/	uint8	number;
-/*05*/	uint8	unknown05[35];
+struct BandolierDelete_Struct
+{
+/*00*/	uint32 Action;
+/*04*/	uint8 Number;
+/*05*/	uint8 Unknown05[35];
 };
 
-struct BandolierSet_Struct {
-/*00*/	uint32	action;
-/*04*/	uint8	number;
-/*05*/	uint8	unknown05[35];
+struct BandolierSet_Struct
+{
+/*00*/	uint32 Action;
+/*04*/	uint8 Number;
+/*05*/	uint8 Unknown05[35];
 };
 
 struct Arrow_Struct {
@@ -4194,6 +4239,52 @@ struct UseAA_Struct {
 	uint32 end;
 };
 
+//new AA stuff
+//reference only
+struct AARankInfo_Struct
+{
+	uint32 id;
+	int32 upper_hotkey_sid;
+	int32 lower_hotkey_sid;
+	int32 title_sid;
+	int32 desc_sid;
+	int32 level_req;
+	int32 cost;
+	uint32 seq;
+	uint32 current_level;
+	uint32 type;
+	int32 spell;
+	int32 spell_type;
+	int32 spell_refresh;
+	int32 classes;
+	int32 max_level;
+	int32 prev_id;
+	int32 next_id;
+	int32 total_cost;
+	int32 expansion;
+	int32 category;
+	uint32 charges;
+	uint8 grant_only;
+	uint32 total_effects;
+	uint32 total_prereqs;
+};
+
+struct AARankPrereq_Struct
+{
+	int32 aa_id;
+	int32 points;
+};
+
+struct AARankEffect_Struct
+{
+	int32 effect_id;
+	int32 base1;
+	int32 base2;
+	int32 slot;
+};
+
+//old AA stuff
+
 struct AA_Ability {
 /*00*/	uint32 skill_id;
 /*04*/	uint32 base1;
@@ -4248,18 +4339,10 @@ struct SendAA_Struct {
 struct AA_Action {
 /*00*/	uint32	action;
 /*04*/	uint32	ability;
-/*08*/	uint32	unknown08;
+/*08*/	uint32	target_id;
 /*12*/	uint32	exp_value;
 };
 
-
-struct AA_Skills {		//this should be removed and changed to AA_Array
-/*00*/	uint32	aa_skill;						// Total AAs Spent
-/*04*/	uint32	aa_value;
-/*08*/	uint32	unknown08;
-/*12*/
-};
-
 struct AAExpUpdate_Struct {
 /*00*/	uint32 unknown00;	//seems to be a value from AA_Action.ability
 /*04*/	uint32 aapoints_unspent;
@@ -4277,12 +4360,12 @@ struct AltAdvStats_Struct {
 };
 
 struct PlayerAA_Struct {						// Is this still used?
-	AA_Skills aa_list[MAX_PP_AA_ARRAY];
+	AA_Array aa_list[MAX_PP_AA_ARRAY];
 };
 
 struct AATable_Struct {
 /*00*/ int32		aa_spent;					// Total AAs Spent
-/*04*/ AA_Skills	aa_list[MAX_PP_AA_ARRAY];
+/*04*/ AA_Array	aa_list[MAX_PP_AA_ARRAY];
 };
 
 struct Weather_Struct {
@@ -4530,19 +4613,12 @@ struct InternalVeteranReward
 /*012*/	InternalVeteranRewardItem items[8];
 };
 
-struct VeteranClaimReply
+struct VeteranClaim
 {
-/*000*/	char name[64];
-/*064*/	uint32 claim_id;
-/*068*/	uint32 reject_field;
-/*072*/	uint32 unknown072;
-};
-
-struct VeteranClaimRequest
-{
-/*000*/	char name_data[64]; //name + other data
+/*000*/	char name[64]; //name + other data
 /*064*/	uint32 claim_id;
 /*068*/	uint32 unknown068;
+/*072*/	uint32 action;
 };
 
 struct GMSearchCorpse_Struct
@@ -4668,6 +4744,22 @@ struct GuildBankItemUpdate_Struct
 /*226*/	uint16	Unknown226;
 };
 
+// newer clients (RoF+) send a list that contains 240 entries
+// The packets don't actually use all 64 chars in the strings, but we'll just overallocate for these
+struct GuildBankItemListEntry_Struct
+{
+	uint8 vaild;
+	uint32 permissions;
+	char whofor[64];
+	char donator[64];
+	uint32 item_id;
+	uint32 item_icon;
+	uint32 quantity;
+	uint8 allow_merge; // 1 here for non-full stacks
+	uint8 usable;
+	char item_name[64];
+};
+
 struct GuildBankClear_Struct
 {
 /*00*/	uint32	Action;
@@ -4714,7 +4806,7 @@ struct BuffIconEntry_Struct
 {
 	uint32 buff_slot;
 	uint32 spell_id;
-	uint32 tics_remaining;
+	int32 tics_remaining;
 	uint32 num_hits;
 };
 
@@ -4723,6 +4815,8 @@ struct BuffIcon_Struct
 	uint32 entity_id;
 	uint8  all_buffs;
 	uint16 count;
+	uint8 type; // 0 = self buff window, 1 = self target window, 4 = group, 5 = PC, 7 = NPC
+	int32 tic_timer;
 	BuffIconEntry_Struct entries[0];
 };
 
@@ -5269,21 +5363,18 @@ struct ClientMarqueeMessage_Struct {
 
 typedef std::list<ServerLootItem_Struct*> ItemList;
 
-struct TextLinkBody_Struct {
-	// Current server mask: EQClientRoF2
-	uint8 unknown_1;		/* %1X */
-	uint32 item_id;			/* %05X */
-	uint32 augment_1;		/* %05X */
-	uint32 augment_2;		/* %05X */
-	uint32 augment_3;		/* %05X */
-	uint32 augment_4;		/* %05X */
-	uint32 augment_5;		/* %05X */
-	uint32 augment_6;		/* %05X */
-	uint8 is_evolving;		/* %1X */
-	uint32 evolve_group;	/* %05X */
-	uint8 evolve_level;		/* %02X */
-	uint32 ornament_icon;	/* %05X */
-	int hash;				/* %08X */
+
+struct fling_struct {
+/* 00 */ uint32 collision; // 0 collision is off, anything else it's on
+/* 04 */ int32 travel_time; // ms -- UF we need to calc this, RoF+ -1 auto calcs
+/* 08 */ uint8 unk3; // bool, set to 1 has something to do with z-axis or something weird things happen if the new Z is above or equal to yours
+/* 09 */ uint8 disable_fall_damage; // 1 you take no fall damage, 0 you take fall damage
+/* 10 */ uint8 padding[2];
+/* 12 */ float speed_z;
+/* 16 */ float new_y;
+/* 20 */ float new_x;
+/* 24 */ float new_z;
+/* 28 */
 };
 
 // Restore structure packing to default

common/eq_stream.cpp

@@ -50,7 +50,6 @@
 uint16 EQStream::MaxWindowSize=2048;
 
 void EQStream::init(bool resetSession) {
-	_eqp
 	// we only reset these statistics if it is a 'new' connection
 	if ( resetSession )
 	{
@@ -73,8 +72,10 @@ void EQStream::init(bool resetSession) {
 	RateThreshold=RATEBASE/250;
 	DecayRate=DECAYBASE/250;
 	BytesWritten=0;
+	sent_packet_count = 0;
+	received_packet_count = 0;
 	SequencedBase = 0;
-	NextSequencedSend = 0;
+	AverageDelta = 500;
 
 	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 		retransmittimer = Timer::GetCurrentTime();
@@ -85,15 +86,10 @@ void EQStream::init(bool resetSession) {
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 		Log.Out(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
-	
-	if(NextSequencedSend > SequencedQueue.size()) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-	}
 }
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
-	_eqp
 	EQRawApplicationPacket *ap=nullptr;
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
 	// _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
@@ -103,7 +99,6 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
 {
-	_eqp
 	EQRawApplicationPacket *ap=nullptr;
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
 	ap = new EQRawApplicationPacket(buf, len);
@@ -111,7 +106,6 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf
 }
 
 EQProtocolPacket *EQStream::MakeProtocolPacket(const unsigned char *buf, uint32 len) {
-	_eqp
 	uint16 proto_opcode = ntohs(*(const uint16 *)buf);
 
 	//advance over opcode.
@@ -123,7 +117,6 @@ EQProtocolPacket *EQStream::MakeProtocolPacket(const unsigned char *buf, uint32
 
 void EQStream::ProcessPacket(EQProtocolPacket *p)
 {
-	_eqp
 	uint32 processed=0, subpacket_length=0;
 	if (p == nullptr)
 		return;
@@ -295,10 +288,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_KeepAlive: {
-#ifndef COLLECTOR
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
-#endif
 		}
 		break;
 		case OP_Ack: {
@@ -307,14 +298,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			AckPackets(seq);
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 				retransmittimer = Timer::GetCurrentTime();
 			}
-#endif
 		}
 		break;
 		case OP_SessionRequest: {
@@ -323,7 +312,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			if (GetState()==ESTABLISHED) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
 
@@ -336,7 +324,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					break;
 				}
 			}
-#endif
 			sessionAttempts++;
 			// we set established below, so statistics will not be reset for session attempts/stream active.
 			init(GetState()!=ESTABLISHED);
@@ -346,10 +333,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SetMaxLen(ntohl(Request->MaxLength));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
-#ifndef COLLECTOR
 			Key=0x11223344;
 			SendSessionResponse();
-#endif
 		}
 		break;
 		case OP_SessionResponse: {
@@ -415,7 +400,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();
 
@@ -423,36 +407,30 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
 			if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
-					seq, SequencedBase, SequencedBase+NextSequencedSend);
+					seq, SequencedBase, SequencedBase+SequencedQueue.size());
 
-				bool retransmit_acked_packets = false;
-				if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-					retransmit_acked_packets = RETRANSMIT_ACKED_PACKETS;
-				}
-
-				if(!retransmit_acked_packets) {
-					uint16 sqsize = SequencedQueue.size();
-					uint16 index = seq - SequencedBase;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
-					if (index < sqsize) {
-						std::deque<EQProtocolPacket *>::iterator sitr;
-						sitr = SequencedQueue.begin();
-						sitr += index;
-						(*sitr)->acked = true;
+				uint16 sqsize = SequencedQueue.size();
+				uint16 index = seq - SequencedBase;
+				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+				if (index < sqsize) {
+					SequencedQueue[index]->acked = true;
+					// flag packets for a resend
+					uint16 count = 0;
+					uint32 timeout = AverageDelta * 2 + 100;
+					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
+						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
+							(*sitr)->sent_time = 0;
+							Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
+						}
 					}
 				}
 
 				if(RETRANSMIT_TIMEOUT_MULT) {
 					retransmittimer = Timer::GetCurrentTime();
 				}
-
-				NextSequencedSend = 0;
 			} else {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
 			}
@@ -461,46 +439,49 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 			MOutboundQueue.unlock();
-#endif
 		}
 		break;
 		case OP_SessionStatRequest: {
-			if(p->Size() < sizeof(SessionStats))
+			if(p->Size() < sizeof(ClientSessionStats))
 			{
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
-			SessionStats *Stats=(SessionStats *)p->pBuffer;
+			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
-				(unsigned long)ntohl(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta),
-				(unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta),
-				(unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta));
-			uint64 x=Stats->packets_received;
-			Stats->packets_received=Stats->packets_sent;
-			Stats->packets_sent=x;
-			NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse,p->pBuffer,p->size));
-			AdjustRates(ntohl(Stats->average_delta));
+				(unsigned long)ntohl(ClientStats->packets_received), (unsigned long)ntohl(ClientStats->packets_sent), (unsigned long)ntohl(ClientStats->last_local_delta),
+				(unsigned long)ntohl(ClientStats->low_delta), (unsigned long)ntohl(ClientStats->average_delta),
+				(unsigned long)ntohl(ClientStats->high_delta), (unsigned long)ntohl(ClientStats->last_remote_delta));
+			
+			AdjustRates(ntohl(ClientStats->average_delta));
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if(RETRANSMIT_TIMEOUT_MULT && ntohl(Stats->average_delta)) {
+				if (RETRANSMIT_TIMEOUT_MULT && ntohl(ClientStats->average_delta)) {
 					//recalculate retransmittimeout using the larger of the last rtt or average rtt, which is multiplied by the rule value
-					if((ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) > (ntohl(Stats->average_delta) * 2)) {
-						retransmittimeout = (ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) 
+					if ((ntohl(ClientStats->last_local_delta) + ntohl(ClientStats->last_remote_delta)) > (ntohl(ClientStats->average_delta) * 2)) {
+						retransmittimeout = (ntohl(ClientStats->last_local_delta) + ntohl(ClientStats->last_remote_delta))
 							* RETRANSMIT_TIMEOUT_MULT;
 					} else {
-						retransmittimeout = ntohl(Stats->average_delta) * 2 * RETRANSMIT_TIMEOUT_MULT;
+						retransmittimeout = ntohl(ClientStats->average_delta) * 2 * RETRANSMIT_TIMEOUT_MULT;
 					}
+					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
 				}
 			}
-#endif
+
+			ServerSessionStats *ServerStats = (ServerSessionStats *)p->pBuffer;
+
+			//ServerStats->RequestID = ClientStats->RequestID; // no change
+			ServerStats->ServerTime = htonl(Timer::GetCurrentTime());
+			ServerStats->packets_sent_echo = ClientStats->packets_sent; // still in htonll format
+			ServerStats->packets_received_echo = ClientStats->packets_received; // still in htonll format
+			ServerStats->packets_sent = htonll(GetPacketsSent());
+			ServerStats->packets_received = htonll(GetPacketsReceived());
+
+			NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse, p->pBuffer, p->size));
 		}
 		break;
 		case OP_SessionStatResponse: {
@@ -521,7 +502,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 
 void EQStream::QueuePacket(const EQApplicationPacket *p, bool ack_req)
 {
-	_eqp
 	if(p == nullptr)
 		return;
 
@@ -533,7 +513,6 @@ void EQStream::QueuePacket(const EQApplicationPacket *p, bool ack_req)
 
 void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 {
-	_eqp
 	EQApplicationPacket *pack=*p;
 	*p = nullptr;		//clear caller's pointer.. effectively takes ownership
 
@@ -563,7 +542,6 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 
 void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 {
-	_eqp
 	uint32 chunksize, used;
 	uint32 length;
 
@@ -581,16 +559,18 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 
 	// Convert the EQApplicationPacket to 1 or more EQProtocolPackets
 	if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->size);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
 
-		unsigned char *tmpbuff=new unsigned char[p->size+3];
+		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
+		if (length != p->Size())
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
 
-		EQProtocolPacket *out=new EQProtocolPacket(OP_Fragment,nullptr,MaxLen-4);
-		*(uint32 *)(out->pBuffer+2)=htonl(p->Size());
+		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
+		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
 		SequencedPush(out);
 
 
@@ -601,16 +581,16 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
 	} else {
 
-		unsigned char *tmpbuff=new unsigned char[p->Size()+3];
+		auto tmpbuff = new unsigned char[p->Size() + 3];
 		length=p->serialize(opcode, tmpbuff+2) + 2;
 
-		EQProtocolPacket *out=new EQProtocolPacket(OP_Packet,tmpbuff,length);
+		auto out = new EQProtocolPacket(OP_Packet, tmpbuff, length);
 
 		delete[] tmpbuff;
 		SequencedPush(out);
@@ -620,50 +600,37 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 
 void EQStream::SequencedPush(EQProtocolPacket *p)
 {
-	_eqp
-#ifdef COLLECTOR
-	delete p;
-#else
 	MOutboundQueue.lock();
-	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-	}
-	if(NextSequencedSend > SequencedQueue.size()) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase);
-	*(uint16 *)(p->pBuffer)=htons(NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
+		NextOutSeq, p->size, SequencedBase);
+	*(uint16 *)(p->pBuffer) = htons(NextOutSeq);
 	SequencedQueue.push_back(p);
 	NextOutSeq++;
 
-	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-	}
-	if(NextSequencedSend > SequencedQueue.size()) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
+
 	MOutboundQueue.unlock();
-#endif
 }
 
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
-	_eqp
-#ifdef COLLECTOR
-	delete p;
-#else
 	MOutboundQueue.lock();
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
 	NonSequencedQueue.push(p);
 	MOutboundQueue.unlock();
-#endif
 }
 
 void EQStream::SendAck(uint16 seq)
 {
-	_eqp
-	uint16 Seq=htons(seq);
+uint16 Seq=htons(seq);
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
 	SetLastAckSent(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
@@ -671,9 +638,8 @@ void EQStream::SendAck(uint16 seq)
 
 void EQStream::SendOutOfOrderAck(uint16 seq)
 {
-	_eqp
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
-	uint16 Seq=htons(seq);
+uint16 Seq=htons(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16)));
 }
 
@@ -703,21 +669,15 @@ void EQStream::Write(int eq_fd)
 	// Place to hold the base packet t combine into
 	EQProtocolPacket *p=nullptr;
 
-	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-		// if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue
-		if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend &&
-			(GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
-				"buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend);
-			NextSequencedSend = 0;
-			retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet
-		}
-	}
-
 	// Find the next sequenced packet to send from the "queue"
 	sitr = SequencedQueue.begin();
-	if (sitr!=SequencedQueue.end())
-	sitr += NextSequencedSend;
+
+	uint16 count = 0;
+	// get to start of packets
+	while (sitr != SequencedQueue.end() && (*sitr)->sent_time > 0) {
+		++sitr;
+		++count;
+	}
 
 	// Loop until both are empty or MaxSends is reached
 	while(!SeqEmpty || !NonSeqEmpty) {
@@ -731,7 +691,7 @@ void EQStream::Write(int eq_fd)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
-				// Tryint to combine this packet with the base didn't work (too big maybe)
+				// Trying to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
@@ -754,16 +714,9 @@ void EQStream::Write(int eq_fd)
 			NonSeqEmpty=true;
 		}
 
-		if (sitr!=SequencedQueue.end()) {
-			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
-			}
+		if (sitr != SequencedQueue.end()) {
+			uint16 seq_send = SequencedBase + count;	//just for logging...
 
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
-			uint16 seq_send = SequencedBase + NextSequencedSend;	//just for logging...
-			
 			if(SequencedQueue.empty()) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
@@ -771,26 +724,32 @@ void EQStream::Write(int eq_fd)
 			}
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
+				if ((*sitr)->acked || (*sitr)->sent_time != 0) {
+					++sitr;
+					++count;
+					if (p) {
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						ReadyToSend.push(p);
+						BytesWritten += p->size;
+						p = nullptr;
+					}
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
-					sitr++;
-					NextSequencedSend++;
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
-
-					if (BytesWritten > threshold) {
+					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
 						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
@@ -798,17 +757,28 @@ void EQStream::Write(int eq_fd)
 				} else {
 					// Combine worked
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				}
 			} else {
-				if (!p) {
+				if ((*sitr)->sent_time != 0) {
+					++sitr;
+					++count;
+					if (p) {
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						ReadyToSend.push(p);
+						BytesWritten += p->size;
+						p = nullptr;
+					}
+				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
@@ -824,18 +794,16 @@ void EQStream::Write(int eq_fd)
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				}
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 		} else {
 			// No more sequenced packets
 			SeqEmpty=true;
@@ -874,9 +842,8 @@ void EQStream::Write(int eq_fd)
 
 void EQStream::WritePacket(int eq_fd, EQProtocolPacket *p)
 {
-	_eqp
-	uint32 length;
-	sockaddr_in address;
+uint32 length;
+sockaddr_in address;
 	address.sin_family = AF_INET;
 	address.sin_addr.s_addr=remote_ip;
 	address.sin_port=remote_port;
@@ -895,9 +862,11 @@ void EQStream::WritePacket(int eq_fd, EQProtocolPacket *p)
 	length=p->serialize(buffer);
 	if (p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
 		if (compressed) {
+			BytesWritten -= p->size;
 			uint32 newlen=EQProtocolPacket::Compress(buffer,length, _tempBuffer, 2048);
 			memcpy(buffer,_tempBuffer,newlen);
 			length=newlen;
+			BytesWritten += newlen;
 		}
 		if (encoded) {
 			EQProtocolPacket::ChatEncode(buffer,length,Key);
@@ -913,8 +882,7 @@ void EQStream::WritePacket(int eq_fd, EQProtocolPacket *p)
 
 void EQStream::SendSessionResponse()
 {
-	_eqp
-	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(SessionResponse));
+	auto out = new EQProtocolPacket(OP_SessionResponse, nullptr, sizeof(SessionResponse));
 	SessionResponse *Response=(SessionResponse *)out->pBuffer;
 	Response->Session=htonl(Session);
 	Response->MaxLength=htonl(MaxLen);
@@ -936,8 +904,7 @@ void EQStream::SendSessionResponse()
 
 void EQStream::SendSessionRequest()
 {
-	_eqp
-	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(SessionRequest));
+	auto out = new EQProtocolPacket(OP_SessionRequest, nullptr, sizeof(SessionRequest));
 	SessionRequest *Request=(SessionRequest *)out->pBuffer;
 	memset(Request,0,sizeof(SessionRequest));
 	Request->Session=htonl(time(nullptr));
@@ -950,11 +917,10 @@ void EQStream::SendSessionRequest()
 
 void EQStream::_SendDisconnect()
 {
-	_eqp
 	if(GetState() == CLOSED)
 		return;
 
-	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionDisconnect,nullptr,sizeof(uint32));
+	auto out = new EQProtocolPacket(OP_SessionDisconnect, nullptr, sizeof(uint32));
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
@@ -963,7 +929,6 @@ void EQStream::_SendDisconnect()
 
 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
 {
-	_eqp
 	MInboundQueue.lock();
 	InboundQueue.push_back(p);
 	MInboundQueue.unlock();
@@ -971,12 +936,11 @@ void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
 
 EQApplicationPacket *EQStream::PopPacket()
 {
-	_eqp
-	EQRawApplicationPacket *p=nullptr;
+EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -997,12 +961,11 @@ EQApplicationPacket *EQStream::PopPacket()
 
 EQRawApplicationPacket *EQStream::PopRawPacket()
 {
-	_eqp
-	EQRawApplicationPacket *p=nullptr;
+EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -1025,12 +988,11 @@ EQRawApplicationPacket *EQStream::PopRawPacket()
 
 EQRawApplicationPacket *EQStream::PeekPacket()
 {
-	_eqp
-	EQRawApplicationPacket *p=nullptr;
+EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 	}
 	MInboundQueue.unlock();
@@ -1040,8 +1002,7 @@ EQRawApplicationPacket *EQStream::PeekPacket()
 
 void EQStream::InboundQueueClear()
 {
-	_eqp
-	EQApplicationPacket *p=nullptr;
+EQApplicationPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
 
@@ -1059,8 +1020,7 @@ void EQStream::InboundQueueClear()
 
 bool EQStream::HasOutgoingData()
 {
-	_eqp
-	bool flag;
+bool flag;
 
 	//once closed, we have nothing more to say
 	if(CheckClosed())
@@ -1085,8 +1045,7 @@ bool EQStream::HasOutgoingData()
 
 void EQStream::OutboundQueueClear()
 {
-	_eqp
-	EQProtocolPacket *p=nullptr;
+EQProtocolPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
 
@@ -1108,8 +1067,7 @@ void EQStream::OutboundQueueClear()
 
 void EQStream::PacketQueueClear()
 {
-	_eqp
-	EQProtocolPacket *p=nullptr;
+EQProtocolPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
 
@@ -1125,7 +1083,6 @@ void EQStream::PacketQueueClear()
 
 void EQStream::Process(const unsigned char *buffer, const uint32 length)
 {
-	_eqp
 	static unsigned char newbuffer[2048];
 	uint32 newlength=0;
 	if (EQProtocolPacket::ValidateCRC(buffer,length,Key)) {
@@ -1150,7 +1107,6 @@ void EQStream::Process(const unsigned char *buffer, const uint32 length)
 
 long EQStream::GetNextAckToSend()
 {
-	_eqp
 	MAcks.lock();
 	long l=NextAckToSend;
 	MAcks.unlock();
@@ -1160,7 +1116,6 @@ long EQStream::GetNextAckToSend()
 
 long EQStream::GetLastAckSent()
 {
-	_eqp
 	MAcks.lock();
 	long l=LastAckSent;
 	MAcks.unlock();
@@ -1170,17 +1125,9 @@ long EQStream::GetLastAckSent()
 
 void EQStream::AckPackets(uint16 seq)
 {
-	_eqp
-	std::deque<EQProtocolPacket *>::iterator itr, tmp;
+std::deque<EQProtocolPacket *>::iterator itr, tmp;
 
 	MOutboundQueue.lock();
-	//do a bit of sanity checking.
-	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Ack Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-	}
-	if(NextSequencedSend > SequencedQueue.size()) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-	}
 
 	SeqOrder ord = CompareSequence(SequencedBase, seq);
 	if(ord == SeqInOrder) {
@@ -1197,27 +1144,20 @@ void EQStream::AckPackets(uint16 seq)
 		seq++;	//we stop at the block right after their ack, counting on the wrap of both numbers.
 		while(SequencedBase != seq) {
 			if(SequencedQueue.empty()) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, SequencedQueue.size());
 				SequencedBase = NextOutSeq;
-				NextSequencedSend = 0;
 				break;
 			}
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
-			//adjust our "next" pointer
-			if(NextSequencedSend > 0)
-				NextSequencedSend--;
 			//advance the base sequence number to the seq of the block after the one we just got rid of.
 			SequencedBase++;
 		}
 		if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
 		}
-		if(NextSequencedSend > SequencedQueue.size()) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-		}
 	}
 
 	MOutboundQueue.unlock();
@@ -1225,7 +1165,6 @@ void EQStream::AckPackets(uint16 seq)
 
 void EQStream::SetNextAckToSend(uint32 seq)
 {
-	_eqp
 	MAcks.lock();
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
 	NextAckToSend=seq;
@@ -1234,7 +1173,6 @@ void EQStream::SetNextAckToSend(uint32 seq)
 
 void EQStream::SetLastAckSent(uint32 seq)
 {
-	_eqp
 	MAcks.lock();
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
 	LastAckSent=seq;
@@ -1243,7 +1181,6 @@ void EQStream::SetLastAckSent(uint32 seq)
 
 void EQStream::ProcessQueue()
 {
-	_eqp
 	if(PacketQueue.empty()) {
 		return;
 	}
@@ -1259,9 +1196,8 @@ void EQStream::ProcessQueue()
 
 EQProtocolPacket *EQStream::RemoveQueue(uint16 seq)
 {
-	_eqp
-	std::map<unsigned short,EQProtocolPacket *>::iterator itr;
-	EQProtocolPacket *qp=nullptr;
+std::map<unsigned short,EQProtocolPacket *>::iterator itr;
+EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
@@ -1272,7 +1208,6 @@ EQProtocolPacket *EQStream::RemoveQueue(uint16 seq)
 
 void EQStream::SetStreamType(EQStreamType type)
 {
-	_eqp
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
 	StreamType=type;
 	switch (StreamType) {
@@ -1303,7 +1238,6 @@ void EQStream::SetStreamType(EQStreamType type)
 
 const char *EQStream::StreamTypeString(EQStreamType t)
 {
-	_eqp
 	switch (t) {
 		case LoginStream:
 			return "Login";
@@ -1333,7 +1267,6 @@ const char *EQStream::StreamTypeString(EQStreamType t)
 //returns SeqFuture if `seq` is later than `expected_seq`
 EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)
 {
-	_eqp
 	if (expected_seq==seq) {
 		// Curent
 		return SeqInOrder;
@@ -1347,7 +1280,6 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)
 }
 
 void EQStream::SetState(EQStreamState state) {
-	_eqp
 	MState.lock();
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
 	State=state;
@@ -1356,7 +1288,7 @@ void EQStream::SetState(EQStreamState state) {
 
 
 void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
-	_eqp
+
 	bool outgoing_data = HasOutgoingData();	//up here to avoid recursive locking
 
 	EQStreamState orig_state = GetState();
@@ -1395,7 +1327,6 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
 
 void EQStream::Decay()
 {
-	_eqp
 	MRate.lock();
 	uint32 rate=DecayRate;
 	MRate.unlock();
@@ -1404,26 +1335,43 @@ void EQStream::Decay()
 		if (BytesWritten<0)
 			BytesWritten=0;
 	}
+	// check for any timed out acks
+	if ((GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) && RETRANSMIT_TIMEOUT_MULT && retransmittimeout) {
+		int count = 0;
+		MOutboundQueue.lock();
+		for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end(); ++sitr, count++) {
+			if (!(*sitr)->acked && (*sitr)->sent_time > 0 && ((*sitr)->sent_time + retransmittimeout) < Timer::GetCurrentTime()) {
+				(*sitr)->sent_time = 0;
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
+			}
+		}
+		MOutboundQueue.unlock();
+	}
 }
 
 void EQStream::AdjustRates(uint32 average_delta)
 {
-	_eqp
 	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 		if (average_delta && (average_delta <= AVERAGE_DELTA_MAX)) {
 			MRate.lock();
+			AverageDelta = average_delta;
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
+			if (BytesWritten > RateThreshold)
+				BytesWritten = RateThreshold + DecayRate;
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
 				RateThreshold, DecayRate, average_delta);
 			MRate.unlock();
 		} else {
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
 				average_delta, AVERAGE_DELTA_MAX);
+			AverageDelta = AVERAGE_DELTA_MAX;
 		}
 	} else {
 		if (average_delta) {
 			MRate.lock();
+			AverageDelta = average_delta;
+			BytesWritten = 0;
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
@@ -1434,7 +1382,6 @@ void EQStream::AdjustRates(uint32 average_delta)
 }
 
 void EQStream::Close() {
-	_eqp
 	if(HasOutgoingData()) {
 		//there is pending data, wait for it to go out.
 		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
@@ -1451,7 +1398,6 @@ void EQStream::Close() {
 //this could be expanded to check more than the fitst opcode if
 //we needed more complex matching
 EQStream::MatchState EQStream::CheckSignature(const Signature *sig) {
-	_eqp
 	EQRawApplicationPacket *p = nullptr;
 	MatchState res = MatchNotReady;
 

common/eq_stream.h

@@ -71,7 +71,7 @@ struct SessionResponse {
 };
 
 //Deltas are in ms, representing round trip times
-struct SessionStats {
+struct ClientSessionStats {
 /*000*/	uint16 RequestID;
 /*002*/	uint32 last_local_delta;
 /*006*/	uint32 average_delta;
@@ -83,6 +83,16 @@ struct SessionStats {
 /*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;
@@ -143,7 +153,6 @@ 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
@@ -158,10 +167,13 @@ class EQStream : public EQStreamInterface {
 
 		int32 BytesWritten;
 
+		uint64 sent_packet_count;
+		uint64 received_packet_count;
+
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
-
+		uint32 AverageDelta;
 
 		OpcodeManager **OpMgr;
 
@@ -265,11 +277,13 @@ 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; }
@@ -288,6 +302,9 @@ 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
 		class Signature {
 		public:

common/eq_stream_factory.cpp

@@ -3,7 +3,7 @@
 #include "eq_stream_factory.h"
 
 #ifdef _WINDOWS
-	#include <winsock.h>
+	#include <winsock2.h>
 	#include <process.h>
 	#include <io.h>
 	#include <stdio.h>
@@ -23,8 +23,7 @@
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-	_eqp
-	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
+EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
 	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
@@ -41,8 +40,7 @@ ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 
 ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
-	_eqp
-	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
+	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
 	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
@@ -60,7 +58,6 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 	: Timeoutable(5000), stream_timeout(timeout)
 {
-	_eqp
 	StreamType=type;
 	Port=port;
 	sock=-1;
@@ -68,7 +65,6 @@ EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 
 void EQStreamFactory::Close()
 {
-	_eqp
 	Stop();
 
 #ifdef _WINDOWS
@@ -81,8 +77,7 @@ void EQStreamFactory::Close()
 
 bool EQStreamFactory::Open()
 {
-	_eqp
-	struct sockaddr_in address;
+struct sockaddr_in address;
 #ifndef WIN32
 	pthread_t t1,t2;
 #endif
@@ -123,10 +118,9 @@ bool EQStreamFactory::Open()
 
 std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
-	_eqp
 	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
-	if (NewStreams.size()) {
+	if (!NewStreams.empty()) {
 		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
@@ -138,7 +132,6 @@ std::shared_ptr<EQStream> EQStreamFactory::Pop()
 
 void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
-	_eqp
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
@@ -146,7 +139,6 @@ 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;
@@ -224,7 +216,6 @@ void EQStreamFactory::ReaderLoop()
 
 void EQStreamFactory::CheckTimeout()
 {
-	_eqp
 	//lock streams the entire time were checking timeouts, it should be fast.
 	MStreams.lock();
 
@@ -244,7 +235,7 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
+				auto temp = stream_itr;
 				++stream_itr;
 				temp->second = nullptr;
 				Streams.erase(temp);
@@ -259,9 +250,7 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-	_eqp
-	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-	bool havework=true;
+	bool havework = true;
 	std::vector<std::shared_ptr<EQStream>> wants_write;
 	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
 	bool decay = false;
@@ -270,7 +259,7 @@ void EQStreamFactory::WriterLoop()
 	WriterRunning = true;
 	DecayTimer.Enable();
 
-	while(sock!=-1) {
+	while (sock != -1) {
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -279,34 +268,36 @@ 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(stream_itr=Streams.begin();stream_itr!=Streams.end();++stream_itr) {
+		for (auto 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,3 +1,5 @@
+#include <utility>
+
 #include "global_define.h"
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
@@ -25,7 +27,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 }
 
 void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
-	Patch *p = new Patch;
+	auto p = new Patch;
 	p->signature = sig;
 	p->name = name;
 	p->opcodes = opcodes;
@@ -156,7 +158,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 }
 
 EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
-:	stream(s),
+:	stream(std::move(s)),
 	expire(STREAM_IDENT_WAIT_MS)
 {
 }

common/eq_stream_intf.h

@@ -4,7 +4,7 @@
 //this is the only part of an EQStream that is seen by the application.
 
 #include <string>
-#include "clientversions.h"
+#include "client_version.h" // inv2 watch
 
 typedef enum {
 	ESTABLISHED,
@@ -35,7 +35,7 @@ public:
 	virtual const uint32 GetBytesRecieved() const { return 0; }
 	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
 	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
-	virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
+	virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -21,9 +21,9 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const ClientVersion EQStreamProxy::GetClientVersion() const
+const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
 {
-	return m_structs->GetClientVersion();
+	return m_structs->ClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {

common/eq_stream_proxy.h

@@ -28,7 +28,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const ClientVersion GetClientVersion() const;
+	virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 
 	virtual const uint32 GetBytesSent() const;
 	virtual const uint32 GetBytesRecieved() const;

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);
-	char *res = new char[len*2+1];
+	auto res = new char[len * 2 + 1];
 
 	mysql_real_escape_string(mysql_ref,res,from,len);
 

common/eqemu_config.cpp

@@ -28,7 +28,6 @@ EQEmuConfig *EQEmuConfig::_config = nullptr;
 
 void EQEmuConfig::do_world(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	TiXmlElement * sub_ele;;
 	text = ParseTextBlock(ele, "shortname");
@@ -81,7 +80,7 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 			sprintf(str, "loginserver%i", ++LoginCount);
 			sub_ele = ele->FirstChildElement(str);
 			if (sub_ele) {
-				LoginConfig* loginconfig = new LoginConfig;
+				auto loginconfig = new LoginConfig;
 				text = ParseTextBlock(sub_ele, "host", true);
 				if (text) {
 					loginconfig->LoginHost = text;
@@ -146,7 +145,6 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 
 void EQEmuConfig::do_chatserver(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -160,7 +158,6 @@ void EQEmuConfig::do_chatserver(TiXmlElement *ele)
 
 void EQEmuConfig::do_mailserver(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -174,7 +171,6 @@ void EQEmuConfig::do_mailserver(TiXmlElement *ele)
 
 void EQEmuConfig::do_database(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -201,7 +197,6 @@ void EQEmuConfig::do_database(TiXmlElement *ele)
 
 void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -227,7 +222,6 @@ void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
 
 void EQEmuConfig::do_zones(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	TiXmlElement *sub_ele;
 //	TiXmlNode *node,*sub_node;
@@ -251,7 +245,6 @@ void EQEmuConfig::do_zones(TiXmlElement *ele)
 
 void EQEmuConfig::do_files(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "spells", true);
 	if (text) {
@@ -261,33 +254,62 @@ void EQEmuConfig::do_files(TiXmlElement *ele)
 	if (text) {
 		OpCodesFile = text;
 	}
-	text = ParseTextBlock(ele, "eqtime", true);
+	text = ParseTextBlock(ele, "plugin.pl", true);
 	if (text) {
-		EQTimeFile = text;
+		PluginPlFile = text;
 	}
 }
 
 void EQEmuConfig::do_directories(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "maps", true);
 	if (text) {
 		MapDir = text;
+		if ( MapDir.back() != '/' )
+			MapDir += '/';
 	}
 	text = ParseTextBlock(ele, "quests", true);
 	if (text) {
 		QuestDir = text;
+		if ( QuestDir.back() != '/' )
+			QuestDir += '/';
 	}
 	text = ParseTextBlock(ele, "plugins", true);
 	if (text) {
 		PluginDir = text;
+		if ( PluginDir.back() != '/' )
+			PluginDir += '/';
+	}
+	text = ParseTextBlock(ele, "lua_modules", true);
+	if (text) {
+		LuaModuleDir = text;
+		if ( LuaModuleDir.back() != '/' )
+			LuaModuleDir += '/';
+	}
+	text = ParseTextBlock(ele, "patches", true);
+	if (text) {
+		PatchDir = text;
+		if ( PatchDir.back() != '/' )
+			PatchDir += '/';
+	}
+	text = ParseTextBlock(ele, "shared_memory", true);
+	if (text) {
+		SharedMemDir = text;
+		if ( SharedMemDir.back() != '/' )
+			SharedMemDir += '/';
+	}
+	//Not Fully Implemented yet LogDir
+	text = ParseTextBlock(ele, "logs", true);
+	if (text) {
+		LogDir = text;
+		if ( LogDir.back() != '/' )
+			LogDir += '/';
 	}
 }
 
 void EQEmuConfig::do_launcher(TiXmlElement *ele)
 {
-	_eqp
 	const char *text;
 	TiXmlElement *sub_ele;
 	text = ParseTextBlock(ele, "logprefix", true);
@@ -327,7 +349,6 @@ void EQEmuConfig::do_launcher(TiXmlElement *ele)
 
 std::string EQEmuConfig::GetByName(const std::string &var_name) const
 {
-	_eqp
 	if (var_name == "ShortName") {
 		return (ShortName);
 	}
@@ -418,8 +439,8 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "OpCodesFile") {
 		return (OpCodesFile);
 	}
-	if (var_name == "EQTimeFile") {
-		return (EQTimeFile);
+	if (var_name == "PluginPlFile") {
+		return (PluginPlFile);
 	}
 	if (var_name == "MapDir") {
 		return (MapDir);
@@ -430,6 +451,18 @@ 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);
 	}
@@ -455,7 +488,6 @@ 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;
@@ -486,10 +518,14 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
-	std::cout << "EQTimeFile = " << EQTimeFile << std::endl;
+	std::cout << "PluginPlFile = " << PluginPlFile << 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;

common/eqemu_config.h

@@ -79,12 +79,16 @@ class EQEmuConfig : public XMLParser
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;
-		std::string EQTimeFile;
+		std::string PluginPlFile;
 
 		// 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;
@@ -154,11 +158,16 @@ class EQEmuConfig : public XMLParser
 			// Files
 			SpellsFile = "spells_us.txt";
 			OpCodesFile = "opcodes.conf";
-			EQTimeFile = "eqtime.cfg";
+			PluginPlFile = "plugin.pl";
 			// Dirs
-			MapDir = "Maps";
-			QuestDir = "quests";
-			PluginDir = "plugins";
+			MapDir = "Maps/";
+			QuestDir = "quests/";
+			PluginDir = "plugins/";
+			LuaModuleDir = "lua_modules/";
+			PatchDir = "./";
+			SharedMemDir = "shared/";
+			LogDir = "logs/";
+
 			// Launcher
 			LogPrefix = "logs/zone-";
 			LogSuffix = ".log";

common/eqemu_logsys.cpp

@@ -96,13 +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;
 
 	/*	Declare process file names for log writing
 		If there is no process_file_name declared, no log file will be written, simply
@@ -273,14 +273,12 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 
 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
-	_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) 
-		return;
+	if (nothing_to_log) return;
 
 	va_list args;
 	va_start(args, message);

common/eqemu_logsys.h

@@ -48,14 +48,12 @@ namespace Logs {
 		Combat,
 		Commands,
 		Crash,
-		Database,
 		Debug,
 		Doors,
 		Error,
 		Guilds,
 		Inventory,
 		Launcher,
-		LoginServer,
 		Netcode,
 		Normal,
 		Object,
@@ -84,6 +82,7 @@ namespace Logs {
 		Client_Server_Packet_Unhandled,
 		Server_Client_Packet_With_Dump,
 		Client_Server_Packet_With_Dump,
+		Login_Server,
 		MaxCategoryID	/* Don't Remove this*/
 	};
 
@@ -98,14 +97,12 @@ namespace Logs {
 		"Combat",
 		"Commands",
 		"Crash",
-		"Database",
 		"Debug",
 		"Doors",
 		"Error",
 		"Guilds",
 		"Inventory",
 		"Launcher",
-		"LoginServer",
 		"Netcode",
 		"Normal",
 		"Object",
@@ -126,14 +123,15 @@ namespace Logs {
 		"WebInterface Server",
 		"World Server",
 		"Zone Server",
-		"MySQLError",
-		"MySQLQuery",
+		"MySQL Error",
+		"MySQL Query",
 		"Mercenaries",
 		"Quest Debug",
 		"Packet :: Server -> Client",
 		"Packet :: Client -> Server Unhandled",
 		"Packet :: Server -> Client (Dump)",
 		"Packet :: Client -> Server (Dump)",
+		"Login Server"
 	};
 }
 

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
-	setEQTimeOfDay(start, time(0));
+	SetCurrentEQTimeOfDay(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::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeOfDay )
+int EQTime::GetCurrentEQTimeOfDay(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::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeO
 	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::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeO
 	//
 	// 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,100 +124,34 @@ int EQTime::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeO
 }
 
 //setEQTimeOfDay
-int EQTime::setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real)
+int EQTime::SetCurrentEQTimeOfDay(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);
@@ -230,7 +164,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;
 	}
@@ -238,29 +172,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) {
@@ -269,5 +203,4 @@ 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 getEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(getEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
-	int getEQTimeOfDay( time_t timeConvert, TimeOfDay_Struct *eqTimeOfDay );
+	int GetCurrentEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(GetCurrentEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
+	int GetCurrentEQTimeOfDay( 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 setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
+	int SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
 	void setEQTimeZone(int32 in_timezone) { timezone=in_timezone; }
 
 	//Time math/logic functions
@@ -39,12 +39,6 @@ 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/extprofile.cpp

@@ -26,7 +26,6 @@ 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

@@ -40,7 +40,7 @@ struct ExtendedProfile_Struct {
 	uint16				old_pet_hp; /* Not Used */
 	uint16				old_pet_mana; /* Not Used */
 	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
-	uint32				pet_items[_MaterialCount]; /* Not Used */
+	uint32				pet_items[EQEmu::legacy::MaterialCount]; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */
@@ -54,6 +54,8 @@ 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,7 +21,6 @@
 
 const char *FactionValueToString(FACTION_VALUE fv)
 {
-	_eqp
 	switch (fv) {
 		case FACTION_ALLY:
 			return ("Ally");
@@ -56,7 +55,6 @@ 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;
@@ -94,7 +92,6 @@ 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;
 	}
@@ -116,7 +113,6 @@ 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

@@ -154,11 +154,12 @@ enum {	//reuse times
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
 	AIthink_duration = 150,
-	AIscanarea_delay = 500,
+	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
 	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,
@@ -232,6 +233,8 @@ enum {	//some random constants
 #define GROUP_EXP_PER_POINT 1000
 #define RAID_EXP_PER_POINT 2000
 
+#define ZONE_CONTROLLER_NPC_ID 10
+
 //Some hard coded statuses from commands and other places:
 enum {
 	minStatusToBeGM = 40,
@@ -270,6 +273,9 @@ 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
+
 
 /*
 

common/global_define.h

@@ -16,6 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+// WHY IS THIS UP HERE
 #if defined(_DEBUG) && defined(WIN32)
 	#ifndef _CRTDBG_MAP_ALLOC
 		#include <stdlib.h>
@@ -26,16 +27,9 @@
 #ifndef EQDEBUG_H
 #define EQDEBUG_H
 
-#define _WINSOCKAPI_	//stupid windows, trying to fix the winsock2 vs. winsock issues
-#if defined(WIN32) && ( defined(PACKETCOLLECTOR) || defined(COLLECTOR) )
-	// Packet Collector on win32 requires winsock.h due to latest pcap.h
-	// winsock.h must come before windows.h
-	#include <winsock.h>
-#endif
-
 #ifdef _WINDOWS
-	#include <windows.h>
 	#include <winsock2.h>
+	#include <windows.h>
 #endif
 
 #endif

common/guild_base.cpp

@@ -39,8 +39,10 @@ BaseGuildManager::~BaseGuildManager() {
 	ClearGuilds();
 }
 
+
+
 bool BaseGuildManager::LoadGuilds() {
-	_eqp
+
 	ClearGuilds();
 
 	if(m_db == nullptr) {
@@ -102,7 +104,6 @@ bool BaseGuildManager::LoadGuilds() {
 }
 
 bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id);
 		return(false);
@@ -168,7 +169,6 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 
 BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, const char *guild_name, uint32 leader_char_id, uint8 minstatus, const char *guild_motd, const char *motd_setter, const char *Channel, const char *URL)
 {
-	_eqp
 	std::map<uint32, GuildInfo *>::iterator res;
 
 	//remove any old entry.
@@ -179,7 +179,7 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 	}
 
 	//make the new entry and store it into the map.
-	GuildInfo *info = new GuildInfo;
+	auto info = new GuildInfo;
 	info->name = guild_name;
 	info->leader_char_id = leader_char_id;
 	info->minstatus = minstatus;
@@ -213,7 +213,6 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 }
 
 bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to store guild %d when we have no database object.", guild_id);
 		return(false);
@@ -237,9 +236,9 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	results = m_db->QueryDatabase(query);
 
 	//escape our strings.
-	char *name_esc = new char[info->name.length()*2+1];
-	char *motd_esc = new char[info->motd.length()*2+1];
-	char *motd_set_esc = new char[info->motd_setter.length()*2+1];
+	auto name_esc = new char[info->name.length() * 2 + 1];
+	auto motd_esc = new char[info->motd.length() * 2 + 1];
+	auto motd_set_esc = new char[info->motd_setter.length() * 2 + 1];
 	m_db->DoEscapeString(name_esc, info->name.c_str(), info->name.length());
 	m_db->DoEscapeString(motd_esc, info->motd.c_str(), info->motd.length());
 	m_db->DoEscapeString(motd_set_esc, info->motd_setter.c_str(), info->motd_setter.length());
@@ -265,7 +264,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	for(rank = 0; rank <= GUILD_MAX_RANK; rank++) {
 		const RankInfo &rankInfo = info->ranks[rank];
 
-		char *title_esc = new char[rankInfo.name.length()*2+1];
+		auto title_esc = new char[rankInfo.name.length() * 2 + 1];
 		m_db->DoEscapeString(title_esc, rankInfo.name.c_str(), rankInfo.name.length());
 
         query = StringFormat("INSERT INTO guild_ranks "
@@ -296,7 +295,6 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 }
 
 uint32 BaseGuildManager::_GetFreeGuildID() {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested find a free guild ID when we have no database object.");
 		return(GUILD_NONE);
@@ -344,7 +342,6 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
 
 
 uint32 BaseGuildManager::CreateGuild(const char* name, uint32 leader_char_id) {
-	_eqp
 	uint32 gid = DBCreateGuild(name, leader_char_id);
 	if(gid == GUILD_NONE)
 		return(GUILD_NONE);
@@ -356,7 +353,6 @@ uint32 BaseGuildManager::CreateGuild(const char* name, uint32 leader_char_id) {
 }
 
 bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
-	_eqp
 	if(!DBDeleteGuild(guild_id))
 		return(false);
 
@@ -366,7 +362,6 @@ bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
 }
 
 bool BaseGuildManager::RenameGuild(uint32 guild_id, const char* name) {
-	_eqp
 	if(!DBRenameGuild(guild_id, name))
 		return(false);
 
@@ -376,7 +371,6 @@ bool BaseGuildManager::RenameGuild(uint32 guild_id, const char* name) {
 }
 
 bool BaseGuildManager::SetGuildLeader(uint32 guild_id, uint32 leader_char_id) {
-	_eqp
 	//get old leader first.
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
@@ -396,7 +390,6 @@ bool BaseGuildManager::SetGuildLeader(uint32 guild_id, uint32 leader_char_id) {
 }
 
 bool BaseGuildManager::SetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
-	_eqp
 	if(!DBSetGuildMOTD(guild_id, motd, setter))
 		return(false);
 
@@ -407,7 +400,6 @@ bool BaseGuildManager::SetGuildMOTD(uint32 guild_id, const char* motd, const cha
 
 bool BaseGuildManager::SetGuildURL(uint32 GuildID, const char* URL)
 {
-	_eqp
 	if(!DBSetGuildURL(GuildID, URL))
 		return(false);
 
@@ -418,7 +410,6 @@ bool BaseGuildManager::SetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::SetGuildChannel(uint32 GuildID, const char* Channel)
 {
-	_eqp
 	if(!DBSetGuildChannel(GuildID, Channel))
 		return(false);
 
@@ -428,7 +419,6 @@ bool BaseGuildManager::SetGuildChannel(uint32 GuildID, const char* Channel)
 }
 
 bool BaseGuildManager::SetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
-	_eqp
 	if(rank > GUILD_MAX_RANK && guild_id != GUILD_NONE)
 		return(false);
 
@@ -449,7 +439,6 @@ bool BaseGuildManager::SetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 
 //changes rank, but not guild.
 bool BaseGuildManager::SetGuildRank(uint32 charid, uint8 rank) {
-	_eqp
 	if(rank > GUILD_MAX_RANK)
 		return(false);
 
@@ -463,7 +452,6 @@ bool BaseGuildManager::SetGuildRank(uint32 charid, uint8 rank) {
 
 
 bool BaseGuildManager::SetBankerFlag(uint32 charid, bool is_banker) {
-	_eqp
 	if(!DBSetBankerFlag(charid, is_banker))
 		return(false);
 
@@ -473,14 +461,12 @@ bool BaseGuildManager::SetBankerFlag(uint32 charid, bool is_banker) {
 }
 
 bool BaseGuildManager::ForceRankUpdate(uint32 charid) {
-	_eqp
 	SendRankUpdate(charid);
 	return(true);
 }
 
 bool BaseGuildManager::SetAltFlag(uint32 charid, bool is_alt)
 {
-	_eqp
 	if(!DBSetAltFlag(charid, is_alt))
 		return(false);
 
@@ -490,7 +476,6 @@ bool BaseGuildManager::SetAltFlag(uint32 charid, bool is_alt)
 }
 
 bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
-	_eqp
 	if(!DBSetTributeFlag(charid, enabled))
 		return(false);
 
@@ -500,7 +485,6 @@ bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
 }
 
 bool BaseGuildManager::SetPublicNote(uint32 charid, const char *note) {
-	_eqp
 	if(!DBSetPublicNote(charid, note))
 		return(false);
 
@@ -510,7 +494,6 @@ bool BaseGuildManager::SetPublicNote(uint32 charid, const char *note) {
 }
 
 uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
-	_eqp
 	//first try to find a free ID.
 	uint32 new_id = _GetFreeGuildID();
 	if(new_id == GUILD_NONE)
@@ -532,7 +515,6 @@ uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
 }
 
 bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
-	_eqp
 
 	//remove the local entry
 	std::map<uint32, GuildInfo *>::iterator res;
@@ -569,7 +551,6 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
 }
 
 bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to rename guild %d when we have no database object.", guild_id);
 		return false;
@@ -583,7 +564,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 	//escape our strings.
 	uint32 len = strlen(name);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, name, len);
 
 	//insert the new `guilds` entry
@@ -606,7 +587,6 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 }
 
 bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id);
 		return false;
@@ -642,7 +622,6 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
 }
 
 bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id);
 		return(false);
@@ -657,8 +636,8 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 	//escape our strings.
 	uint32 len = strlen(motd);
 	uint32 len2 = strlen(setter);
-	char *esc = new char[len*2+1];
-	char *esc_set = new char[len2*2+1];
+	auto esc = new char[len * 2 + 1];
+	auto esc_set = new char[len2 * 2 + 1];
 	m_db->DoEscapeString(esc, motd, len);
 	m_db->DoEscapeString(esc_set, setter, len2);
 
@@ -685,7 +664,6 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 
 bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 {
-	_eqp
 	if(m_db == nullptr)
 		return false;
 
@@ -697,7 +675,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 	//escape our strings.
 	uint32 len = strlen(URL);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, URL, len);
 
     std::string query = StringFormat("UPDATE guilds SET url='%s' WHERE id=%d", esc, GuildID);
@@ -719,7 +697,6 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 {
-	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -732,7 +709,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 
 	//escape our strings.
 	uint32 len = strlen(Channel);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, Channel, len);
 
     std::string query = StringFormat("UPDATE guilds SET channel='%s' WHERE id=%d", esc, GuildID);
@@ -753,7 +730,6 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 }
 
 bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id);
 		return(false);
@@ -782,13 +758,11 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 }
 
 bool BaseGuildManager::DBSetGuildRank(uint32 charid, uint8 rank) {
-	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET rank=%d WHERE char_id=%d", rank, charid);
 	return(QueryWithLogging(query, "setting a guild member's rank"));
 }
 
 bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
-	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET banker=%d WHERE char_id=%d",
 		is_banker? 1: 0, charid);
 	return(QueryWithLogging(query, "setting a guild member's banker flag"));
@@ -796,7 +770,6 @@ bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
 
 bool BaseGuildManager::GetBankerFlag(uint32 CharID)
 {
-	_eqp
 	if(!m_db)
 		return false;
 
@@ -819,7 +792,6 @@ bool BaseGuildManager::GetBankerFlag(uint32 CharID)
 
 bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
 {
-	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET alt=%d WHERE char_id=%d",
 		is_alt ? 1: 0, charid);
 
@@ -828,7 +800,6 @@ bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
 
 bool BaseGuildManager::GetAltFlag(uint32 CharID)
 {
-	_eqp
     if(!m_db)
 		return false;
 
@@ -850,20 +821,18 @@ bool BaseGuildManager::GetAltFlag(uint32 CharID)
 }
 
 bool BaseGuildManager::DBSetTributeFlag(uint32 charid, bool enabled) {
-	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET tribute_enable=%d WHERE char_id=%d",
 		enabled ? 1: 0, charid);
 	return(QueryWithLogging(query, "setting a guild member's tribute flag"));
 }
 
 bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
-	_eqp
 	if(m_db == nullptr)
 		return(false);
 
 	//escape our strings.
 	uint32 len = strlen(note);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, note, len);
 
 	//insert the new `guilds` entry
@@ -882,7 +851,6 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 }
 
 bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
-	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -899,19 +867,18 @@ bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
 //factored out so I dont have to copy this crap.
 #ifdef BOTS
 #define GuildMemberBaseQuery \
-"SELECT c.id,c.name,c.class,c.level,c.timelaston,c.zoneid," \
-" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
-" g.banker,g.public_note,g.alt" \
-" FROM vwBotCharacterMobs AS c LEFT JOIN vwGuildMembers AS g ON c.id=g.char_id AND c.mobtype = g.mobtype "
+"SELECT c.`id`, c.`name`, c.`class`, c.`level`, c.`last_login`, c.`zone_id`," \
+" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
+" g.`banker`, g.`public_note`, g.`alt`" \
+" FROM `vw_bot_character_mobs` AS c LEFT JOIN `vw_guild_members` AS g ON c.`id` = g.`char_id` AND c.`mob_type` = g.`mob_type` "
 #else
 #define GuildMemberBaseQuery \
-"SELECT c.id,c.name,c.class,c.level,c.last_login,c.zone_id," \
-" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
-" g.banker,g.public_note,g.alt " \
-" FROM `character_data` AS c LEFT JOIN guild_members AS g ON c.id=g.char_id "
+"SELECT c.`id`, c.`name`, c.`class`, c.`level`, c.`last_login`, c.`zone_id`," \
+" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
+" g.`banker`, g.`public_note`, g.`alt` " \
+" FROM `character_data` AS c LEFT JOIN `guild_members` AS g ON c.`id` = g.`char_id` "
 #endif
 static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
-	_eqp
 	//fields from `characer_`
 	into.char_id		= atoi(row[0]);
 	into.char_name		= row[1];
@@ -939,7 +906,6 @@ static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
 
 
 bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo *> &members) {
-	_eqp
 	members.clear();
 
 	if(m_db == nullptr)
@@ -952,8 +918,8 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		return false;
 	}
 
-    for (auto row = results.begin(); row != results.end(); ++row) {
-		CharGuildInfo *ci = new CharGuildInfo;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		auto ci = new CharGuildInfo;
 		ProcessGuildMember(row, *ci);
 		members.push_back(ci);
 	}
@@ -964,7 +930,6 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 }
 
 bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested char info on %s when we have no database object.", char_name);
 		return(false);
@@ -972,7 +937,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 
 	//escape our strings.
 	uint32 nl = strlen(char_name);
-	char *esc = new char[nl*2+1];
+	auto esc = new char[nl * 2 + 1];
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
@@ -996,7 +961,6 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 }
 
 bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
-	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested char info on %d when we have no database object.", char_id);
 		return false;
@@ -1005,7 +969,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 	//load up the rank info for each guild.
 	std::string query;
 #ifdef BOTS
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C'", char_id);
 #else
     query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
 #endif
@@ -1027,11 +991,10 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 
 //returns ownership of the buffer.
 uint8 *BaseGuildManager::MakeGuildList(const char *head_name, uint32 &length) const {
-	_eqp
 	//dynamic structs will make this a lot less painful.
 
 	length = sizeof(GuildsList_Struct);
-	uint8 *buffer = new uint8[length];
+	auto buffer = new uint8[length];
 
 	//a bit little better than memsetting the whole thing...
 	uint32 r,pos;
@@ -1055,7 +1018,6 @@ uint8 *BaseGuildManager::MakeGuildList(const char *head_name, uint32 &length) co
 }
 
 const char *BaseGuildManager::GetRankName(uint32 guild_id, uint8 rank) const {
-	_eqp
 	if(rank > GUILD_MAX_RANK)
 		return("Invalid Rank");
 	std::map<uint32, GuildInfo *>::const_iterator res;
@@ -1066,7 +1028,6 @@ const char *BaseGuildManager::GetRankName(uint32 guild_id, uint8 rank) const {
 }
 
 const char *BaseGuildManager::GetGuildName(uint32 guild_id) const {
-	_eqp
 	if(guild_id == GUILD_NONE)
 		return("");
 	std::map<uint32, GuildInfo *>::const_iterator res;
@@ -1077,7 +1038,6 @@ const char *BaseGuildManager::GetGuildName(uint32 guild_id) const {
 }
 
 bool BaseGuildManager::GetGuildNameByID(uint32 guild_id, std::string &into) const {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1088,7 +1048,6 @@ bool BaseGuildManager::GetGuildNameByID(uint32 guild_id, std::string &into) cons
 
 uint32 BaseGuildManager::GetGuildIDByName(const char *GuildName)
 {
-	_eqp
 	std::map<uint32, GuildInfo *>::iterator Iterator;
 
 	for(Iterator = m_guilds.begin(); Iterator != m_guilds.end(); ++Iterator)
@@ -1101,7 +1060,6 @@ uint32 BaseGuildManager::GetGuildIDByName(const char *GuildName)
 }
 
 bool BaseGuildManager::GetGuildMOTD(uint32 guild_id, char *motd_buffer, char *setter_buffer) const {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1113,7 +1071,6 @@ bool BaseGuildManager::GetGuildMOTD(uint32 guild_id, char *motd_buffer, char *se
 
 bool BaseGuildManager::GetGuildURL(uint32 GuildID, char *URLBuffer) const
 {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(GuildID);
 	if(res == m_guilds.end())
@@ -1125,7 +1082,6 @@ bool BaseGuildManager::GetGuildURL(uint32 GuildID, char *URLBuffer) const
 
 bool BaseGuildManager::GetGuildChannel(uint32 GuildID, char *ChannelBuffer) const
 {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(GuildID);
 	if(res == m_guilds.end())
@@ -1135,14 +1091,12 @@ bool BaseGuildManager::GetGuildChannel(uint32 GuildID, char *ChannelBuffer) cons
 }
 
 bool BaseGuildManager::GuildExists(uint32 guild_id) const {
-	_eqp
 	if(guild_id == GUILD_NONE)
 		return(false);
 	return(m_guilds.find(guild_id) != m_guilds.end());
 }
 
 bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
-	_eqp
 	if(guild_id == GUILD_NONE) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check leader for char %d: not a guild.", char_id);
 		return(false);
@@ -1158,7 +1112,6 @@ bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
 }
 
 uint32 BaseGuildManager::FindGuildByLeader(uint32 leader) const {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator cur, end;
 	cur = m_guilds.begin();
 	end = m_guilds.end();
@@ -1171,7 +1124,6 @@ uint32 BaseGuildManager::FindGuildByLeader(uint32 leader) const {
 
 //returns the rank to be sent to the client for display purposes, given their eqemu rank.
 uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 char_id) const {
-	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1184,7 +1136,6 @@ uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 cha
 }
 
 bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
-	_eqp
 	if(status >= 250) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status);
 		return(true);	//250+ as allowed anything
@@ -1206,7 +1157,6 @@ bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
 }
 
 bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const {
-	_eqp
 	if(rank > GUILD_MAX_RANK) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.",
 			guild_id, rank, GuildActionNames[act], act);
@@ -1232,7 +1182,6 @@ bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction
 }
 
 bool BaseGuildManager::LocalDeleteGuild(uint32 guild_id) {
-	_eqp
 	std::map<uint32, GuildInfo *>::iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1252,21 +1201,18 @@ void BaseGuildManager::ClearGuilds() {
 }
 
 BaseGuildManager::RankInfo::RankInfo() {
-	_eqp
 	uint8 r;
 	for(r = 0; r < _MaxGuildAction; r++)
 		permissions[r] = false;
 }
 
 BaseGuildManager::GuildInfo::GuildInfo() {
-	_eqp
 	leader_char_id = 0;
 	minstatus = 0;
 }
 
 uint32 BaseGuildManager::DoesAccountContainAGuildLeader(uint32 AccountID)
 {
-	_eqp
 	std::string query = StringFormat("SELECT guild_id FROM guild_members WHERE char_id IN "
 		"(SELECT id FROM `character_data` WHERE account_id = %i) AND rank = 2",
                                     AccountID);

common/inventory_version.cpp

@@ -0,0 +1,147 @@
+/*	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 "inventory_version.h"
+
+
+bool EQEmu::versions::IsValidInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
+		return false;
+
+	return true;
+}
+
+bool EQEmu::versions::IsValidPCInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
+		return false;
+
+	return true;
+}
+
+bool EQEmu::versions::IsValidNonPCInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
+		return false;
+
+	return true;
+}
+
+EQEmu::versions::InventoryVersion EQEmu::versions::ValidateInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
+		return InventoryVersion::Unknown;
+
+	return inventory_version;
+}
+
+EQEmu::versions::InventoryVersion EQEmu::versions::ValidatePCInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
+		return InventoryVersion::Unknown;
+
+	return inventory_version;
+}
+
+EQEmu::versions::InventoryVersion EQEmu::versions::ValidateNonPCInventoryVersion(InventoryVersion inventory_version)
+{
+	if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
+		return InventoryVersion::Unknown;
+
+	return inventory_version;
+}
+
+const char* EQEmu::versions::InventoryVersionName(InventoryVersion inventory_version)
+{
+	switch (inventory_version) {
+	case InventoryVersion::Unknown:
+		return "Unknown Version";
+	case InventoryVersion::Client62:
+		return "Client 6.2";
+	case InventoryVersion::Titanium:
+		return "Titanium";
+	case InventoryVersion::SoF:
+		return "SoF";
+	case InventoryVersion::SoD:
+		return "SoD";
+	case InventoryVersion::UF:
+		return "UF";
+	case InventoryVersion::RoF:
+		return "RoF";
+	case InventoryVersion::RoF2:
+		return "RoF2";
+	case InventoryVersion::NPC:
+		return "NPC";
+	case InventoryVersion::Merc:
+		return "Merc";
+	case InventoryVersion::Bot:
+		return "Bot";
+	case InventoryVersion::Pet:
+		return "Pet";
+	default:
+		return "Invalid Version";
+	};
+}
+
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version)
+{
+	switch (inventory_version) {
+	case InventoryVersion::Unknown:
+	case InventoryVersion::Client62:
+		return ClientVersion::Unknown;
+	case InventoryVersion::Titanium:
+		return ClientVersion::Titanium;
+	case InventoryVersion::SoF:
+		return ClientVersion::SoF;
+	case InventoryVersion::SoD:
+		return ClientVersion::SoD;
+	case InventoryVersion::UF:
+		return ClientVersion::UF;
+	case InventoryVersion::RoF:
+		return ClientVersion::RoF;
+	case InventoryVersion::RoF2:
+		return ClientVersion::RoF2;
+	default:
+		return ClientVersion::Unknown;
+	}
+}
+
+EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion client_version)
+{
+	switch (client_version) {
+	case ClientVersion::Unknown:
+	case ClientVersion::Client62:
+		return InventoryVersion::Unknown;
+	case ClientVersion::Titanium:
+		return InventoryVersion::Titanium;
+	case ClientVersion::SoF:
+		return InventoryVersion::SoF;
+	case ClientVersion::SoD:
+		return InventoryVersion::SoD;
+	case ClientVersion::UF:
+		return InventoryVersion::UF;
+	case ClientVersion::RoF:
+		return InventoryVersion::RoF;
+	case ClientVersion::RoF2:
+		return InventoryVersion::RoF2;
+	default:
+		return InventoryVersion::Unknown;
+	}
+}

common/inventory_version.h

@@ -0,0 +1,63 @@
+/*	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_INVENTORY_VERSION_H
+#define COMMON_INVENTORY_VERSION_H
+
+#include "client_version.h"
+
+
+namespace EQEmu
+{
+	namespace versions {
+		enum class InventoryVersion {
+			Unknown = 0,
+			Client62,
+			Titanium,
+			SoF,
+			SoD,
+			UF,
+			RoF,
+			RoF2,
+			NPC,
+			Merc,
+			Bot,
+			Pet
+		};
+
+		static const InventoryVersion LastInventoryVersion = InventoryVersion::Pet;
+		static const InventoryVersion LastPCInventoryVersion = InventoryVersion::RoF2;
+		static const InventoryVersion LastNonPCInventoryVersion = InventoryVersion::Pet;
+		static const size_t InventoryVersionCount = (static_cast<size_t>(LastInventoryVersion) + 1);
+
+		extern bool IsValidInventoryVersion(InventoryVersion inventory_version);
+		extern bool IsValidPCInventoryVersion(InventoryVersion inventory_version);
+		extern bool IsValidNonPCInventoryVersion(InventoryVersion inventory_version);
+		extern InventoryVersion ValidateInventoryVersion(InventoryVersion inventory_version);
+		extern InventoryVersion ValidatePCInventoryVersion(InventoryVersion inventory_version);
+		extern InventoryVersion ValidateNonPCInventoryVersion(InventoryVersion inventory_version);
+		extern const char* InventoryVersionName(InventoryVersion inventory_version);
+		extern ClientVersion ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version);
+		extern InventoryVersion ConvertClientVersionToInventoryVersion(ClientVersion client_version);
+	
+	} /*versions*/
+
+} /*EQEmu*/
+
+#endif /*COMMON_INVENTORY_VERSION_H*/

common/ipc_mutex.cpp

@@ -18,7 +18,9 @@
 
 #include "ipc_mutex.h"
 #ifdef _WINDOWS
+#define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
+#undef WIN32_LEAN_AND_MEAN
 #else
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -27,7 +29,7 @@
 #endif
 #include "types.h"
 #include "eqemu_exception.h"
-
+#include "eqemu_config.h"
 
 namespace EQEmu {
 	struct IPCMutex::Implementation {
@@ -41,7 +43,8 @@ namespace EQEmu {
 	IPCMutex::IPCMutex(std::string name) : locked_(false) {
 		imp_ = new Implementation;
 #ifdef _WINDOWS
-		std::string final_name = "EQEmuMutex_";
+		auto Config = EQEmuConfig::get();
+		std::string final_name = Config->SharedMemDir + "EQEmuMutex_";
 		final_name += name;
 
 		imp_->mut_ = CreateMutex(nullptr,
@@ -52,7 +55,8 @@ namespace EQEmu {
 			EQ_EXCEPT("IPC Mutex", "Could not create mutex.");
 		}
 #else
-		std::string final_name = name;
+		auto Config = EQEmuConfig::get();
+		std::string final_name = Config->SharedMemDir + name;
 		final_name += ".lock";
 
 #ifdef __DARWIN

common/item.h

@@ -1,5 +1,6 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+
+	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
@@ -13,15 +14,16 @@
 
 	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  04111-1307  USA
 */
 
 // @merth notes:
 // These classes could be optimized with database reads/writes by storing
 // a status flag indicating how object needs to interact with database
 
-#ifndef __ITEM_H
-#define __ITEM_H
+#ifndef COMMON_ITEM_H
+#define COMMON_ITEM_H
+
 
 class ItemParse;			// Parses item packets
 class EvolveInfo;			// Stores information about an evolving item family
@@ -29,9 +31,14 @@ class EvolveInfo;			// Stores information about an evolving item family
 #include "../common/eq_constants.h"
 #include "../common/item_struct.h"
 #include "../common/timer.h"
+#include "../common/bodytypes.h"
+#include "../common/deity.h" // aren't we already in '/common'?
+
+#include "string_util.h"
 
 #include <list>
 #include <map>
+//#include <sstream>
 
 
 namespace ItemField
@@ -71,6 +78,7 @@ enum {
 	invWhereCursor		= 0x20
 };
 
+class ItemInst;
 
 // ########################################
 // Class: Queue
@@ -113,22 +121,23 @@ public:
 	///////////////////////////////
 	// Public Methods
 	///////////////////////////////
-
-	Inventory() { m_version = ClientVersion::Unknown; m_versionset = false; }
+	
+	Inventory() { m_inventory_version = EQEmu::versions::InventoryVersion::Unknown; m_inventory_version_set = false; }
 	~Inventory();
 
-	// Inventory v2 creep
-	bool SetInventoryVersion(ClientVersion version) {
-		if (!m_versionset) {
-			m_version = version;
-			return (m_versionset = true);
+	// inv2 creep
+	bool SetInventoryVersion(EQEmu::versions::InventoryVersion inventory_version) {
+		if (!m_inventory_version_set) {
+			m_inventory_version = EQEmu::versions::ValidateInventoryVersion(inventory_version);
+			return (m_inventory_version_set = true);
 		}
 		else {
 			return false;
 		}
 	}
+	bool SetInventoryVersion(EQEmu::versions::ClientVersion client_version) { return SetInventoryVersion(EQEmu::versions::ConvertClientVersionToInventoryVersion(client_version)); }
 
-	ClientVersion GetInventoryVersion() { return m_version; }
+	EQEmu::versions::InventoryVersion InventoryVersion() { return m_inventory_version; }
 
 	static void CleanDirty();
 	static void MarkDirty(ItemInst *inst);
@@ -168,7 +177,7 @@ public:
 	ItemInst* PopItem(int16 slot_id);
 
 	// Check whether there is space for the specified number of the specified item.
-	bool HasSpaceForItem(const Item_Struct *ItemToTry, int16 Quantity);
+	bool HasSpaceForItem(const EQEmu::Item_Struct *ItemToTry, int16 Quantity);
 
 	// Check whether item exists in inventory
 	// where argument specifies OR'd list of invWhere constants to look
@@ -193,7 +202,7 @@ public:
 	static int16 CalcSlotFromMaterial(uint8 material);
 	static uint8 CalcMaterialFromSlot(int16 equipslot);
 
-	static bool CanItemFitInContainer(const Item_Struct *ItemToTry, const Item_Struct *Container);
+	static bool CanItemFitInContainer(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container);
 
 	//  Test for valid inventory casting slot
 	bool SupportsClickCasting(int16 slot_id);
@@ -204,7 +213,7 @@ public:
 
 	int GetSlotByItemInst(ItemInst *inst);
 
-	uint8 FindHighestLightValue();
+	uint8 FindBrightestLightType();
 
 	void dumpEntireInventory();
 	void dumpWornItems();
@@ -251,8 +260,8 @@ protected:
 
 private:
 	// Active inventory version
-	ClientVersion m_version;
-	bool m_versionset;
+	EQEmu::versions::InventoryVersion m_inventory_version;
+	bool m_inventory_version_set;
 };
 
 class SharedDatabase;
@@ -270,7 +279,7 @@ public:
 	/////////////////////////
 
 	// Constructors/Destructor
-	ItemInst(const Item_Struct* item = nullptr, int16 charges = 0);
+	ItemInst(const EQEmu::Item_Struct* item = nullptr, int16 charges = 0);
 
 	ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0);
 
@@ -281,7 +290,15 @@ public:
 	~ItemInst();
 
 	// Query item type
-	bool IsType(ItemClassTypes item_class) const;
+	bool IsType(EQEmu::item::ItemClass item_class) const;
+
+	bool IsClassCommon();
+	bool IsClassBag();
+	bool IsClassBook();
+
+	bool IsClassCommon() const { return const_cast<ItemInst*>(this)->IsClassCommon(); }
+	bool IsClassBag() const { return const_cast<ItemInst*>(this)->IsClassBag(); }
+	bool IsClassBook() const { return const_cast<ItemInst*>(this)->IsClassBook(); }
 
 	// Can item be stacked?
 	bool IsStackable() const;
@@ -300,7 +317,7 @@ public:
 	bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
 	inline int32 GetAugmentType() const { return ((m_item) ? m_item->AugType : NO_ITEM); }
 
-	inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == ET_Expendable ) || (m_item->ItemType == ItemTypePotion)) : false); }
+	inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == EQEmu::item::ItemEffectExpendable) || (m_item->ItemType == EQEmu::item::ItemTypePotion)) : false); }
 
 	//
 	// Contents
@@ -331,7 +348,7 @@ public:
 	bool IsAugmented();
 	ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const;
 	bool UpdateOrnamentationInfo();
-	static bool CanTransform(const Item_Struct *ItemToTry, const Item_Struct *Container, bool AllowAll = false);
+	static bool CanTransform(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container, bool AllowAll = false);
 	
 	// Has attack/delay?
 	bool IsWeapon() const;
@@ -340,8 +357,8 @@ public:
 	// Accessors
 	const uint32 GetID() const { return ((m_item) ? m_item->ID : NO_ITEM); }
 	const uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : NO_ITEM); }
-	const Item_Struct* GetItem() const;
-	const Item_Struct* GetUnscaledItem() const;
+	const EQEmu::Item_Struct* GetItem() const;
+	const EQEmu::Item_Struct* GetUnscaledItem() const;
 
 	int16 GetCharges() const				{ return m_charges; }
 	void SetCharges(int16 charges)			{ m_charges = charges; }
@@ -409,7 +426,9 @@ public:
 	int8 GetMaxEvolveLvl() const;
 	uint32 GetKillsNeeded(uint8 currentlevel);
 
-	std::string Serialize(int16 slot_id) const { InternalSerializedItem_Struct s; s.slot_id=slot_id; s.inst=(const void *)this; std::string ser; ser.assign((char *)&s,sizeof(InternalSerializedItem_Struct)); return ser; }
+	std::string Serialize(int16 slot_id) const { EQEmu::InternalSerializedItem_Struct s; s.slot_id = slot_id; s.inst = (const void*)this; std::string ser; ser.assign((char*)&s, sizeof(EQEmu::InternalSerializedItem_Struct)); return ser; }
+	void Serialize(EQEmu::OutBuffer& ob, int16 slot_id) const { EQEmu::InternalSerializedItem_Struct isi; isi.slot_id = slot_id; isi.inst = (const void*)this; ob.write((const char*)&isi, sizeof(isi)); }
+	
 	inline int32 GetSerialNumber() const { return m_SerialNumber; }
 	inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
 
@@ -418,6 +437,58 @@ public:
 	void StopTimer(std::string name);
 	void ClearTimers();
 
+	// Get a total of a stat, including augs
+	// These functions should be used in place of other code manually totaling
+	// to centralize where it is done to make future changes easier (ex. whenever powersources come around)
+	// and to minimize errors. CalcItemBonuses however doesn't use these in interest of performance
+	// by default these do not recurse into augs
+	int GetItemArmorClass(bool augments = false) const;
+	int GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments = false) const;
+	// These two differ in the fact that they're quick checks (they are checked BEFORE the one above
+	int GetItemElementalFlag(bool augments = false) const;
+	int GetItemElementalDamage(bool augments = false) const;
+	int GetItemRecommendedLevel(bool augments = false) const;
+	int GetItemRequiredLevel(bool augments = false) const;
+	int GetItemWeaponDamage(bool augments = false) const;
+	int GetItemBackstabDamage(bool augments = false) const;
+	// these two are just quick checks
+	int GetItemBaneDamageBody(bool augments = false) const;
+	int GetItemBaneDamageRace(bool augments = false) const;
+	int GetItemBaneDamageBody(bodyType against, bool augments = false) const;
+	int GetItemBaneDamageRace(uint16 against, bool augments = false) const;
+	int GetItemMagical(bool augments = false) const;
+	int GetItemHP(bool augments = false) const;
+	int GetItemMana(bool augments = false) const;
+	int GetItemEndur(bool augments = false) const;
+	int GetItemAttack(bool augments = false) const;
+	int GetItemStr(bool augments = false) const;
+	int GetItemSta(bool augments = false) const;
+	int GetItemDex(bool augments = false) const;
+	int GetItemAgi(bool augments = false) const;
+	int GetItemInt(bool augments = false) const;
+	int GetItemWis(bool augments = false) const;
+	int GetItemCha(bool augments = false) const;
+	int GetItemMR(bool augments = false) const;
+	int GetItemFR(bool augments = false) const;
+	int GetItemCR(bool augments = false) const;
+	int GetItemPR(bool augments = false) const;
+	int GetItemDR(bool augments = false) const;
+	int GetItemCorrup(bool augments = false) const;
+	int GetItemHeroicStr(bool augments = false) const;
+	int GetItemHeroicSta(bool augments = false) const;
+	int GetItemHeroicDex(bool augments = false) const;
+	int GetItemHeroicAgi(bool augments = false) const;
+	int GetItemHeroicInt(bool augments = false) const;
+	int GetItemHeroicWis(bool augments = false) const;
+	int GetItemHeroicCha(bool augments = false) const;
+	int GetItemHeroicMR(bool augments = false) const;
+	int GetItemHeroicFR(bool augments = false) const;
+	int GetItemHeroicCR(bool augments = false) const;
+	int GetItemHeroicPR(bool augments = false) const;
+	int GetItemHeroicDR(bool augments = false) const;
+	int GetItemHeroicCorrup(bool augments = false) const;
+	int GetItemHaste(bool augments = false) const;
+
 protected:
 	//////////////////////////
 	// Protected Members
@@ -431,7 +502,7 @@ protected:
 	void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; }
 
 	ItemInstTypes		m_use_type;	// Usage type for item
-	const Item_Struct*	m_item;		// Ptr to item data
+	const EQEmu::Item_Struct*	m_item;		// Ptr to item data
 	int16				m_charges;	// # of charges for chargeable items
 	uint32				m_price;	// Bazaar /trader price
 	uint32				m_color;
@@ -443,7 +514,7 @@ protected:
 	uint32				m_exp;
 	int8				m_evolveLvl;
 	bool				m_activated;
-	Item_Struct*		m_scaledItem;
+	EQEmu::Item_Struct*		m_scaledItem;
 	EvolveInfo*			m_evolveInfo;
 	bool				m_scaling;
 	uint32				m_ornamenticon;
@@ -472,4 +543,4 @@ public:
 	~EvolveInfo();
 };
 
-#endif // #define __ITEM_H
+#endif /*COMMON_ITEM_H*/

common/item_fieldlist.h

@@ -41,6 +41,7 @@ F(ac)
 F(deity)
 F(skillmodvalue)
 F(UNK033)
+F(skillmodmax)
 F(skillmodtype)
 F(banedmgrace)
 F(banedmgamt)
@@ -172,7 +173,10 @@ F(bardlevel)
 F(questitemflag)
 F(svcorruption)
 F(purity)
+F(evoitem)
+F(evoid)
 F(evolvinglevel)
+F(evomax)
 F(backstabdmg)
 F(dsmitigation)
 F(heroic_str)

common/item_struct.cpp

@@ -0,0 +1,209 @@
+/*	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 "item_struct.h"
+#include "classes.h"
+#include "races.h"
+//#include "deity.h"
+
+
+uint32 EQEmu::item::ConvertAugTypeToAugTypeBit(uint8 aug_type)
+{
+	switch (aug_type) {
+	case AugTypeGeneralSingleStat:
+		return bit_AugTypeGeneralSingleStat;
+	case AugTypeGeneralMultipleStat:
+		return bit_AugTypeGeneralMultipleStat;
+	case AugTypeGeneralSpellEffect:
+		return bit_AugTypeGeneralSpellEffect;
+	case AugTypeWeaponGeneral:
+		return bit_AugTypeWeaponGeneral;
+	case AugTypeWeaponElemDamage:
+		return bit_AugTypeWeaponElemDamage;
+	case AugTypeWeaponBaseDamage:
+		return bit_AugTypeWeaponBaseDamage;
+	case AugTypeGeneralGroup:
+		return bit_AugTypeGeneralGroup;
+	case AugTypeGeneralRaid:
+		return bit_AugTypeGeneralRaid;
+	case AugTypeGeneralDragonsPoints:
+		return bit_AugTypeGeneralDragonsPoints;
+	case AugTypeCraftedCommon:
+		return bit_AugTypeCraftedCommon;
+	case AugTypeCraftedGroup1:
+		return bit_AugTypeCraftedGroup1;
+	case AugTypeCraftedRaid1:
+		return bit_AugTypeCraftedRaid1;
+	case AugTypeEnergeiacGroup:
+		return bit_AugTypeEnergeiacGroup;
+	case AugTypeEnergeiacRaid:
+		return bit_AugTypeEnergeiacRaid;
+	case AugTypeEmblem:
+		return bit_AugTypeEmblem;
+	case AugTypeCraftedGroup2:
+		return bit_AugTypeCraftedGroup2;
+	case AugTypeCraftedRaid2:
+		return bit_AugTypeCraftedRaid2;
+	case AugTypeUnknown1:
+		return bit_AugTypeUnknown1;
+	case AugTypeUnknown2:
+		return bit_AugTypeUnknown2;
+	case AugTypeOrnamentation:
+		return bit_AugTypeOrnamentation;
+	case AugTypeSpecialOrnamentation:
+		return bit_AugTypeSpecialOrnamentation;
+	case AugTypeUnknown3:
+		return bit_AugTypeUnknown3;
+	case AugTypeUnknown4:
+		return bit_AugTypeUnknown4;
+	case AugTypeUnknown5:
+		return bit_AugTypeUnknown5;
+	case AugTypeUnknown6:
+		return bit_AugTypeUnknown6;
+	case AugTypeUnknown7:
+		return bit_AugTypeUnknown7;
+	case AugTypeUnknown8:
+		return bit_AugTypeUnknown8;
+	case AugTypeUnknown9:
+		return bit_AugTypeUnknown9;
+	case AugTypeUnknown10:
+		return bit_AugTypeUnknown10;
+	case AugTypeEpic2_5:
+		return bit_AugTypeEpic2_5;
+	case AugTypeTest:
+		return bit_AugTypeTest;
+	case AugTypeAll:
+		return bit_AugTypeAll;
+	default:
+		return bit_AugTypeNone;
+	}
+}
+
+uint8 EQEmu::item::ConvertAugTypeBitToAugType(uint32 aug_type_bit)
+{
+	switch (aug_type_bit) {
+	case bit_AugTypeGeneralSingleStat:
+		return AugTypeGeneralSingleStat;
+	case bit_AugTypeGeneralMultipleStat:
+		return AugTypeGeneralMultipleStat;
+	case bit_AugTypeGeneralSpellEffect:
+		return AugTypeGeneralSpellEffect;
+	case bit_AugTypeWeaponGeneral:
+		return AugTypeWeaponGeneral;
+	case bit_AugTypeWeaponElemDamage:
+		return AugTypeWeaponElemDamage;
+	case bit_AugTypeWeaponBaseDamage:
+		return AugTypeWeaponBaseDamage;
+	case bit_AugTypeGeneralGroup:
+		return AugTypeGeneralGroup;
+	case bit_AugTypeGeneralRaid:
+		return AugTypeGeneralRaid;
+	case bit_AugTypeGeneralDragonsPoints:
+		return AugTypeGeneralDragonsPoints;
+	case bit_AugTypeCraftedCommon:
+		return AugTypeCraftedCommon;
+	case bit_AugTypeCraftedGroup1:
+		return AugTypeCraftedGroup1;
+	case bit_AugTypeCraftedRaid1:
+		return AugTypeCraftedRaid1;
+	case bit_AugTypeEnergeiacGroup:
+		return AugTypeEnergeiacGroup;
+	case bit_AugTypeEnergeiacRaid:
+		return AugTypeEnergeiacRaid;
+	case bit_AugTypeEmblem:
+		return AugTypeEmblem;
+	case bit_AugTypeCraftedGroup2:
+		return AugTypeCraftedGroup2;
+	case bit_AugTypeCraftedRaid2:
+		return AugTypeCraftedRaid2;
+	case bit_AugTypeUnknown1:
+		return AugTypeUnknown1;
+	case bit_AugTypeUnknown2:
+		return AugTypeUnknown2;
+	case bit_AugTypeOrnamentation:
+		return AugTypeOrnamentation;
+	case bit_AugTypeSpecialOrnamentation:
+		return AugTypeSpecialOrnamentation;
+	case bit_AugTypeUnknown3:
+		return AugTypeUnknown3;
+	case bit_AugTypeUnknown4:
+		return AugTypeUnknown4;
+	case bit_AugTypeUnknown5:
+		return AugTypeUnknown5;
+	case bit_AugTypeUnknown6:
+		return AugTypeUnknown6;
+	case bit_AugTypeUnknown7:
+		return AugTypeUnknown7;
+	case bit_AugTypeUnknown8:
+		return AugTypeUnknown8;
+	case bit_AugTypeUnknown9:
+		return AugTypeUnknown9;
+	case bit_AugTypeUnknown10:
+		return AugTypeUnknown10;
+	case bit_AugTypeEpic2_5:
+		return AugTypeEpic2_5;
+	case bit_AugTypeTest:
+		return AugTypeTest;
+	case bit_AugTypeAll:
+		return AugTypeAll;
+	default:
+		return AugTypeNone;
+	}
+}
+
+bool EQEmu::Item_Struct::IsEquipable(uint16 race_id, uint16 class_id)
+{
+	if (!(Races & GetPlayerRaceBit(race_id)))
+		return false;
+
+	if (!(Classes & GetPlayerClassBit(GetPlayerClassValue(class_id))))
+		return false;
+
+	return true;
+}
+
+bool EQEmu::Item_Struct::IsClassCommon()
+{
+	return (ItemClass == item::ItemClassCommon);
+}
+
+bool EQEmu::Item_Struct::IsClassBag()
+{
+	return (ItemClass == item::ItemClassBag);
+}
+
+bool EQEmu::Item_Struct::IsClassBook()
+{
+	return (ItemClass == item::ItemClassBook);
+}
+
+bool EQEmu::Item_Struct::IsType1HWeapon()
+{
+	return ((ItemType == item::ItemType1HBlunt) || (ItemType == item::ItemType1HSlash) || (ItemType == item::ItemType1HPiercing));
+}
+
+bool EQEmu::Item_Struct::IsType2HWeapon()
+{
+	return ((ItemType == item::ItemType2HBlunt) || (ItemType == item::ItemType2HSlash) || (ItemType == item::ItemType2HPiercing));
+}
+
+bool EQEmu::Item_Struct::IsTypeShield()
+{
+	return (ItemType == item::ItemTypeShield);
+}

common/item_struct.h

@@ -1,5 +1,6 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+
+	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
@@ -13,11 +14,12 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
 */
 
-#ifndef ITEM_STRUCT_H
-#define ITEM_STRUCT_H
+#ifndef COMMON_ITEM_STRUCT_H
+#define COMMON_ITEM_STRUCT_H
+
 
 /*
  * Note: (Doodman)
@@ -42,210 +44,522 @@
  *	Made ya look! Ha!
  */
 
-//#include "eq_constants.h"
-#include "eq_dictionary.h"
+#include "emu_constants.h"
+
+
+namespace EQEmu
+{
+	namespace item {
+		enum ItemAttributeBit : uint32 {
+			bit_ItemAttributeNone = 0x00000000,
+			bit_ItemAttributeLore = 0x00000001,
+			bit_ItemAttributeArtifact = 0x00000002,
+			bit_ItemAttributeSummoned = 0x00000004,
+			bit_ItemAttributeMagic = 0x00000008,
+			bit_ItemAttributeAugment = 0x00000010,
+			bit_ItemAttributePendingLore = 0x00000020,
+			bit_ItemAttributeUnknown = 0xFFFFFFFF
+		};
+
+		enum ItemClass {
+			ItemClassCommon = 0,
+			ItemClassBag,
+			ItemClassBook,
+			ItemClassCount
+		};
+
+		enum ItemType : uint8 {
+/*9138*/	ItemType1HSlash = 0,
+/*9141*/	ItemType2HSlash,
+/*9140*/	ItemType1HPiercing,
+/*9139*/	ItemType1HBlunt,
+/*9142*/	ItemType2HBlunt,
+/*5504*/	ItemTypeBow, // 5
+/*----*/	ItemTypeUnknown1,
+/*----*/	ItemTypeLargeThrowing,
+/*5505*/	ItemTypeShield,
+/*5506*/	ItemTypeScroll,
+/*5507*/	ItemTypeArmor, // 10
+/*5508*/	ItemTypeMisc,			// a lot of random crap has this item use.
+/*7564*/	ItemTypeLockPick,
+/*----*/	ItemTypeUnknown2,
+/*5509*/	ItemTypeFood,
+/*5510*/	ItemTypeDrink, // 15
+/*5511*/	ItemTypeLight,
+/*5512*/	ItemTypeCombinable,		// not all stackable items are this use...
+/*5513*/	ItemTypeBandage,
+/*----*/	ItemTypeSmallThrowing,
+/*----*/	ItemTypeSpell, // 20	// spells and tomes
+/*5514*/	ItemTypePotion,
+/*----*/	ItemTypeUnknown3,
+/*0406*/	ItemTypeWindInstrument,
+/*0407*/	ItemTypeStringedInstrument,
+/*0408*/	ItemTypeBrassInstrument, // 25
+/*0405*/	ItemTypePercussionInstrument,
+/*5515*/	ItemTypeArrow,
+/*----*/	ItemTypeUnknown4,
+/*5521*/	ItemTypeJewelry,
+/*----*/	ItemTypeSkull, // 30
+/*5516*/	ItemTypeBook,			// skill-up tomes/books? (would probably need a pp flag if true...)
+/*5517*/	ItemTypeNote,
+/*5518*/	ItemTypeKey,
+/*----*/	ItemTypeCoin,
+/*5520*/	ItemType2HPiercing, // 35
+/*----*/	ItemTypeFishingPole,
+/*----*/	ItemTypeFishingBait,
+/*5519*/	ItemTypeAlcohol,
+/*----*/	ItemTypeKey2,			// keys and satchels?? (questable keys?)
+/*----*/	ItemTypeCompass, // 40
+/*----*/	ItemTypeUnknown5,
+/*----*/	ItemTypePoison,			// might be wrong, but includes poisons
+/*----*/	ItemTypeUnknown6,
+/*----*/	ItemTypeUnknown7,
+/*5522*/	ItemTypeMartial, // 45
+/*----*/	ItemTypeUnknown8,
+/*----*/	ItemTypeUnknown9,
+/*----*/	ItemTypeUnknown10,
+/*----*/	ItemTypeUnknown11,
+/*----*/	ItemTypeSinging, // 50
+/*5750*/	ItemTypeAllInstrumentTypes,
+/*5776*/	ItemTypeCharm,
+/*----*/	ItemTypeDye,
+/*----*/	ItemTypeAugmentation,
+/*----*/	ItemTypeAugmentationSolvent, // 55
+/*----*/	ItemTypeAugmentationDistiller,
+/*----*/	ItemTypeUnknown12,
+/*----*/	ItemTypeFellowshipKit,
+/*----*/	ItemTypeUnknown13,
+/*----*/	ItemTypeRecipe, // 60
+/*----*/	ItemTypeAdvancedRecipe,
+/*----*/	ItemTypeJournal,		// only one(1) database entry
+/*----*/	ItemTypeAltCurrency,	// alt-currency (as opposed to coinage)
+/*5881*/	ItemTypePerfectedAugmentationDistiller,
+/*----*/	ItemTypeCount
 
 /*
-** Child struct of Item_Struct:
-**	Effect data: Click, Proc, Focus, Worn, Scroll
-**
+			Unknowns:
+
+			Mounts?
+			Ornamentations?
+			GuildBanners?
+			Collectible? 
+			Placeable?
+			(others?)
 */
-struct ItemEffect_Struct {
-	int16	Effect;
-	uint8	Type;
-	uint8	Level;
-	uint8	Level2;
-	//MaxCharges
-	//CastTime
-	//RecastDelay
-	//RecastType
-	//ProcRate
-};
+		};
 
-class ItemInst;
+		enum AugTypeBit : uint32 {
+			bit_AugTypeNone = 0x00000000,
+			bit_AugTypeGeneralSingleStat = 0x00000001,		/*1^16^1 (General: Single Stat)^0*/
+			bit_AugTypeGeneralMultipleStat = 0x00000002,	/*2^16^2 (General: Multiple Stat)^0*/
+			bit_AugTypeGeneralSpellEffect = 0x00000004,		/*3^16^3 (General: Spell Effect)^0*/
+			bit_AugTypeWeaponGeneral = 0x00000008,			/*4^16^4 (Weapon: General)^0*/
+			bit_AugTypeWeaponElemDamage = 0x00000010,		/*5^16^5 (Weapon: Elem Damage)^0*/
+			bit_AugTypeWeaponBaseDamage = 0x00000020,		/*6^16^6 (Weapon: Base Damage)^0*/
+			bit_AugTypeGeneralGroup = 0x00000040,			/*7^16^7 (General: Group)^0*/
+			bit_AugTypeGeneralRaid = 0x00000080,			/*8^16^8 (General: Raid)^0*/
+			bit_AugTypeGeneralDragonsPoints = 0x00000100,	/*9^16^9 (General: Dragons Points)^0*/
+			bit_AugTypeCraftedCommon = 0x00000200,			/*10^16^10 (Crafted: Common)^0*/
+			bit_AugTypeCraftedGroup1 = 0x00000400,			/*11^16^11 (Crafted: Group)^0*/
+			bit_AugTypeCraftedRaid1 = 0x00000800,			/*12^16^12 (Crafted: Raid)^0*/
+			bit_AugTypeEnergeiacGroup = 0x00001000,			/*13^16^13 (Energeiac: Group)^0*/
+			bit_AugTypeEnergeiacRaid = 0x00002000,			/*14^16^14 (Energeiac: Raid)^0*/
+			bit_AugTypeEmblem = 0x00004000,					/*15^16^15 (Emblem)^0*/
+			bit_AugTypeCraftedGroup2 = 0x00008000,			/*16^16^16 (Crafted: Group)^0*/
+			bit_AugTypeCraftedRaid2 = 0x00010000,			/*17^16^17 (Crafted: Raid)^0*/
+			bit_AugTypeUnknown1 = 0x00020000,				/*18^16^18^0*/
+			bit_AugTypeUnknown2 = 0x00040000,				/*19^16^19^0*/
+			bit_AugTypeOrnamentation = 0x00080000,			/*20^16^20 (Ornamentation)^0*/
+			bit_AugTypeSpecialOrnamentation = 0x00100000,	/*21^16^21 (Special Ornamentation)^0*/
+			bit_AugTypeUnknown3 = 0x00200000,				/*22^16^22^0*/
+			bit_AugTypeUnknown4 = 0x00400000,				/*23^16^23^0*/
+			bit_AugTypeUnknown5 = 0x00800000,				/*24^16^24^0*/
+			bit_AugTypeUnknown6 = 0x01000000,				/*25^16^25^0*/
+			bit_AugTypeUnknown7 = 0x02000000,				/*26^16^26^0*/
+			bit_AugTypeUnknown8 = 0x04000000,				/*27^16^27^0*/
+			bit_AugTypeUnknown9 = 0x08000000,				/*28^16^28^0*/
+			bit_AugTypeUnknown10 = 0x10000000,				/*29^16^29^0*/
+			bit_AugTypeEpic2_5 = 0x20000000,				/*30^16^30^0*/
+			bit_AugTypeTest = 0x40000000,					/*31^16^Test^0*/ // listed as 31^16^31^0 in 5-10 client
+			bit_AugTypeAll = 0xFFFFFFFF
+		};
 
-struct InternalSerializedItem_Struct {
-	int16 slot_id;
-	const void * inst;
-};
+		enum AugType : uint8 {
+			AugTypeNone = 0,
+			AugTypeGeneralSingleStat,
+			AugTypeGeneralMultipleStat,
+			AugTypeGeneralSpellEffect,
+			AugTypeWeaponGeneral,
+			AugTypeWeaponElemDamage, // 5
+			AugTypeWeaponBaseDamage,
+			AugTypeGeneralGroup,
+			AugTypeGeneralRaid,
+			AugTypeGeneralDragonsPoints,
+			AugTypeCraftedCommon, // 10
+			AugTypeCraftedGroup1,
+			AugTypeCraftedRaid1,
+			AugTypeEnergeiacGroup,
+			AugTypeEnergeiacRaid,
+			AugTypeEmblem, // 15
+			AugTypeCraftedGroup2,
+			AugTypeCraftedRaid2,
+			AugTypeUnknown1,
+			AugTypeUnknown2,
+			AugTypeOrnamentation, // 20
+			AugTypeSpecialOrnamentation,
+			AugTypeUnknown3,
+			AugTypeUnknown4,
+			AugTypeUnknown5,
+			AugTypeUnknown6, // 25
+			AugTypeUnknown7,
+			AugTypeUnknown8,
+			AugTypeUnknown9,
+			AugTypeUnknown10,
+			AugTypeEpic2_5, // 30
+			AugTypeTest,
+			AugTypeCount,
+			AugTypeAll = 255
+		};
 
-// use EmuConstants::ITEM_COMMON_SIZE
-//#define MAX_AUGMENT_SLOTS 5
+		enum AugRestriction : uint8 {
+/*4690*/	AugRestrictionAny = 0,
+/*9134*/	AugRestrictionArmor,
+/*9135*/	AugRestrictionWeapons,
+/*9136*/	AugRestriction1HWeapons,
+/*9137*/	AugRestriction2HWeapons,
+/*9138*/	AugRestriction1HSlash, // 5
+/*9139*/	AugRestriction1HBlunt,
+/*9140*/	AugRestrictionPiercing,
+/*9148*/	AugRestrictionHandToHand,
+/*9141*/	AugRestriction2HSlash,
+/*9142*/	AugRestriction2HBlunt, // 10
+/*9143*/	AugRestriction2HPierce,
+/*9144*/	AugRestrictionBows,
+/*9145*/	AugRestrictionShields,
+/*8052*/	AugRestriction1HSlash1HBluntOrHandToHand,
+/*9200*/	AugRestriction1HBluntOrHandToHand, // 15	// no listed peq entries
 
-struct Item_Struct {
-	bool IsEquipable(uint16 Race, uint16 Class) const;
-	// Non packet based fields
-	uint8	MinStatus;
+		// these three appear to be post-RoF (12-10-2012) and can not be verified until RoF (05-10-2013) is supported
+/*????*/	AugRestrictionUnknown1,
+/*????*/	AugRestrictionUnknown2,
+/*????*/	AugRestrictionUnknown3,					// last value in peq entries
+			AugRestrictionCount
 
-	// Packet based fields
-	uint8	ItemClass;		// Item Type: 0=common, 1=container, 2=book
-	char	Name[64];		// Name
-	char	Lore[80];		// Lore Name: *=lore, &=summoned, #=artifact, ~=pending lore
-	char	IDFile[30];		// Visible model
-	uint32	ID;				// Unique ID (also PK for DB)
-	uint8	Weight;			// Item weight * 10
-	uint8	NoRent;			// No Rent: 0=norent, 255=not norent
-	uint8	NoDrop;			// No Drop: 0=nodrop, 255=not nodrop
-	uint8	Size;			// Size: 0=tiny, 1=small, 2=medium, 3=large, 4=giant
-	uint32	Slots;			// Bitfield for which slots this item can be used in
-	uint32	Price;			// Item cost (?)
-	uint32	Icon;			// Icon Number
-	uint32	LoreGroup;		// Later items use LoreGroup instead of LoreFlag. we might want to see about changing this to int32 since it is commonly -1 and is constantly being cast from signed (-1) to unsigned (4294967295)
-	bool	LoreFlag;		// This will be true if LoreGroup is non-zero
-	bool	PendingLoreFlag;
-	bool	ArtifactFlag;
-	bool	SummonedFlag;
-	uint8	FVNoDrop;		// Firiona Vie nodrop flag
-	uint32	Favor;			// Individual favor
-	uint32	GuildFavor;		// Guild favor
-	uint32	PointType;
+/*4687*/	//AugTypeAllItems, // ?? unknown atm
+/*4688*/	//AugTypePrestige, // ?? unknown atm
+/*4689*/	//AugTypeNonPrestige, // ?? unknown atm
+		};
 
-	//uint32	Unk117;
-	//uint32	Unk118;
-	//uint32	Unk121;
-	//uint32	Unk124;
+		enum BagType : uint8 {
+/*3400*/	BagTypeSmallBag = 0,
+/*3401*/	BagTypeLargeBag,
+/*3402*/	BagTypeQuiver,
+/*3403*/	BagTypeBeltPouch,
+/*3404*/	BagTypeWristPouch,
+/*3405*/	BagTypeBackPack, // 5
+/*3406*/	BagTypeSmallChest,
+/*3407*/	BagTypeLargeChest,
+/*----*/	BagTypeBandolier,				// <*Database Reference Only>
+/*3408*/	BagTypeMedicineBag,
+/*3409*/	BagTypeToolBox, // 10
+/*3410*/	BagTypeLexicon,
+/*3411*/	BagTypeMortar,
+/*3412*/	BagTypeSelfDusting,				// Quest container (Auto-clear contents?)
+/*3413*/	BagTypeMixingBowl,
+/*3414*/	BagTypeOven, // 15
+/*3415*/	BagTypeSewingKit,
+/*3416*/	BagTypeForge,
+/*3417*/	BagTypeFletchingKit,
+/*3418*/	BagTypeBrewBarrel,
+/*3419*/	BagTypeJewelersKit, // 20
+/*3420*/	BagTypePotteryWheel,
+/*3421*/	BagTypeKiln,
+/*3422*/	BagTypeKeymaker,				// (no database entries as of peq rev 69)
+/*3423*/	BagTypeWizardsLexicon,
+/*3424*/	BagTypeMagesLexicon, // 25
+/*3425*/	BagTypeNecromancersLexicon,
+/*3426*/	BagTypeEnchantersLexicon,
+/*----*/	BagTypeUnknown1,				// (a coin pouch/purse?) (no database entries as of peq rev 69)
+/*----*/	BagTypeConcordanceofResearch,	// <*Database Reference Only>
+/*3427*/	BagTypeAlwaysWorks, // 30		// Quest container (Never-fail combines?)
+/*3428*/	BagTypeKoadaDalForge,			// High Elf
+/*3429*/	BagTypeTeirDalForge,			// Dark Elf
+/*3430*/	BagTypeOggokForge,				// Ogre
+/*3431*/	BagTypeStormguardForge,			// Dwarf
+/*3432*/	BagTypeAkanonForge, // 35		// Gnome
+/*3433*/	BagTypeNorthmanForge,			// Barbarian
+/*----*/	BagTypeUnknown2,				// (no database entries as of peq rev 69)
+/*3434*/	BagTypeCabilisForge,			// Iksar
+/*3435*/	BagTypeFreeportForge,			// Human 1
+/*3436*/	BagTypeRoyalQeynosForge, // 40	// Human 2
+/*3439*/	BagTypeHalflingTailoringKit,
+/*3438*/	BagTypeErudTailoringKit,
+/*3440*/	BagTypeFierDalTailoringKit,		// Wood Elf
+/*3441*/	BagTypeFierDalFletchingKit,		// Wood Elf
+/*3437*/	BagTypeIksarPotteryWheel, // 45
+/*3442*/	BagTypeTackleBox,
+/*3443*/	BagTypeTrollForge,
+/*3445*/	BagTypeFierDalForge,			// Wood Elf
+/*3444*/	BagTypeValeForge,				// Halfling
+/*3446*/	BagTypeErudForge, // 50
+/*----*/	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, // 55	// Ornamentation
+/*6340*/	BagTypeDetransformationmold,	// Ornamentation Stripper
+/*5400*/	BagTypeUnattuner,
+/*7684*/	BagTypeTradeskillBag,
+/*7692*/	BagTypeCollectibleBag,
+/*----*/	BagTypeCount
+		};
 
-	uint8	BagType;		// 0:Small Bag, 1:Large Bag, 2:Quiver, 3:Belt Pouch ... there are 50 types
-	uint8	BagSlots;		// Number of slots: can only be 2, 4, 6, 8, or 10
-	uint8	BagSize;		// 0:TINY, 1:SMALL, 2:MEDIUM, 3:LARGE, 4:GIANT
-	uint8	BagWR;			// 0->100
+		enum ItemEffect {
+			ItemEffectCombatProc = 0,
+			ItemEffectClick,
+			ItemEffectWorn,
+			ItemEffectExpendable,
+			ItemEffectEquipClick,
+			ItemEffectClick2, //5		//name unknown
+			ItemEffectFocus,
+			ItemEffectScroll,
+			ItemEffectCount
+		};
 
-	bool	BenefitFlag;
-	bool	Tradeskills;	// Is this a tradeskill item?
-	int8	CR;				// Save vs Cold
-	int8	DR;				// Save vs Disease
-	int8	PR;				// Save vs Poison
-	int8	MR;				// Save vs Magic
-	int8	FR;				// Save vs Fire
-	int8	AStr;			// Strength
-	int8	ASta;			// Stamina
-	int8	AAgi;			// Agility
-	int8	ADex;			// Dexterity
-	int8	ACha;			// Charisma
-	int8	AInt;			// Intelligence
-	int8	AWis;			// Wisdom
-	int32	HP;				// HP
-	int32	Mana;			// Mana
-	int32	AC;				// AC
-	uint32	Deity;			// Bitmask of Deities that can equip this item
-	//uint32	Unk033
-	int32	SkillModValue;	// % Mod to skill specified in SkillModType
-	uint32	SkillModType;	// Type of skill for SkillModValue to apply to
-	uint32	BaneDmgRace;	// Bane Damage Race
-	int8	BaneDmgAmt;		// Bane Damage Body Amount
-	uint32	BaneDmgBody;	// Bane Damage Body
-	bool	Magic;			// True=Magic Item, False=not
-	int32	CastTime_;
-	uint8	ReqLevel;		// Required Level to use item
-	uint32	BardType;		// Bard Skill Type
-	int32	BardValue;		// Bard Skill Amount
-	int8	Light;			// Light
-	uint8	Delay;			// Delay * 10
-	uint8	RecLevel;		// Recommended level to use item
-	uint8	RecSkill;		// Recommended skill to use item (refers to primary skill of item)
-	uint8	ElemDmgType;	// Elemental Damage Type (1=magic, 2=fire)
-	uint8	ElemDmgAmt;		// Elemental Damage
-	uint8	Range;			// Range of item
-	uint32	Damage;			// Delay between item usage (in 0.1 sec increments)
-	uint32	Color;			// RR GG BB 00 <-- as it appears in pc
-	uint32	Classes;		// Bitfield of classes that can equip item (1 << class#)
-	uint32	Races;			// Bitfield of races that can equip item (1 << race#)
-	//uint32	Unk054;
-	int16	MaxCharges;		// Maximum charges items can hold: -1 if not a chargeable item
-	uint8	ItemType;		// Item Type/Skill (itemClass* from above)
-	uint8	Material;		// Item material type
-	uint32	HerosForgeModel;// Hero's Forge Armor Model Type (2-13?)
-	float	SellRate;		// Sell rate
-	//uint32	Unk059;
-	union {
-		uint32 Fulfilment;	// Food fulfilment (How long it lasts)
-		int16 CastTime;		// Cast Time for clicky effects, in milliseconds
+		enum ItemSize : uint8 {
+			ItemSizeTiny = 0,
+			ItemSizeSmall,
+			ItemSizeMedium,
+			ItemSizeLarge,
+			ItemSizeGiant,
+			ItemSizeCount
+		};
+
+		enum ItemDataType : uint8 {
+			ItemDataTypeBase = 0,
+			ItemDataTypeScaling,
+			ItemDataTypeEvolving,
+			ItemDataTypeCount
+		};
+
+		struct ItemEffect_Struct {
+			int16	Effect;
+			uint8	Type;
+			uint8	Level;
+			uint8	Level2;
+			//MaxCharges
+			//CastTime
+			//RecastDelay
+			//RecastType
+			//ProcRate
+		};
+
+		extern uint32 ConvertAugTypeToAugTypeBit(uint8 aug_type);
+		extern uint8 ConvertAugTypeBitToAugType(uint32 aug_type_bit);
+
+	} /*item*/
+
+	struct InternalSerializedItem_Struct {
+		int16 slot_id;
+		const void * inst;
 	};
-	uint32 EliteMaterial;
-	int32	ProcRate;
-	int8	CombatEffects;	// PoP: Combat Effects +
-	int8	Shielding;		// PoP: Shielding %
-	int8	StunResist;		// PoP: Stun Resist %
-	int8	StrikeThrough;	// PoP: Strike Through %
-	uint32	ExtraDmgSkill;
-	uint32	ExtraDmgAmt;
-	int8	SpellShield;	// PoP: Spell Shield %
-	int8	Avoidance;		// PoP: Avoidance +
-	int8	Accuracy;		// PoP: Accuracy +
-	uint32	CharmFileID;
-	int32	FactionMod1;	// Faction Mod 1
-	int32	FactionMod2;	// Faction Mod 2
-	int32	FactionMod3;	// Faction Mod 3
-	int32	FactionMod4;	// Faction Mod 4
-	int32	FactionAmt1;	// Faction Amt 1
-	int32	FactionAmt2;	// Faction Amt 2
-	int32	FactionAmt3;	// Faction Amt 3
-	int32	FactionAmt4;	// Faction Amt 4
-	char	CharmFile[32];	// ?
-	uint32	AugType;
-	uint8	AugSlotType[EmuConstants::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Type
-	uint8	AugSlotVisible[EmuConstants::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Visible
-	uint8	AugSlotUnk2[EmuConstants::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Unknown
-	uint32	LDoNTheme;
-	uint32	LDoNPrice;
-	uint32	LDoNSold;
-	uint32	BaneDmgRaceAmt;
-	uint32	AugRestrict;
-	uint32	Endur;
-	uint32	DotShielding;
-	uint32	Attack;
-	uint32	Regen;
-	uint32	ManaRegen;
-	uint32	EnduranceRegen;
-	uint32	Haste;
-	uint32	DamageShield;
-	uint32	RecastDelay;
-	uint32	RecastType;
-	uint32	AugDistiller;
-	bool	Attuneable;
-	bool	NoPet;
-	bool	PotionBelt;
-	bool	Stackable;
-	bool	NoTransfer;
-	bool	QuestItemFlag;
-	int16	StackSize;
-	uint8	PotionBeltSlots;
-	ItemEffect_Struct Click, Proc, Worn, Focus, Scroll, Bard;
 
-	uint8	Book;			// 0=Not book, 1=Book
-	uint32	BookType;
-	char	Filename[33];	// Filename for book data
-	// Begin SoF Fields
-	int32 SVCorruption;
-	uint32 Purity;
-	uint8 EvolvingLevel;
-	uint32 BackstabDmg;
-	uint32 DSMitigation;
-	int32 HeroicStr;
-	int32 HeroicInt;
-	int32 HeroicWis;
-	int32 HeroicAgi;
-	int32 HeroicDex;
-	int32 HeroicSta;
-	int32 HeroicCha;
-	int32 HeroicMR;
-	int32 HeroicFR;
-	int32 HeroicCR;
-	int32 HeroicDR;
-	int32 HeroicPR;
-	int32 HeroicSVCorrup;
-	int32 HealAmt;
-	int32 SpellDmg;
-	uint32 LDoNSellBackRate;
-	uint32 ScriptFileID;
-	uint16 ExpendableArrow;
-	uint32 Clairvoyance;
-	char	ClickName[65];
-	char	ProcName[65];
-	char	WornName[65];
-	char	FocusName[65];
-	char	ScrollName[65];
+	struct Item_Struct {
+		// Non packet based fields
+		uint8	MinStatus;
+		//uint8	ItemDataType;
 
-};
+		// Packet based fields
+		uint8	ItemClass;		// Item Type: 0=common, 1=container, 2=book
+		char	Name[64];		// Name
+		char	Lore[80];		// Lore Name: *=lore, &=summoned, #=artifact, ~=pending lore
+		char	IDFile[30];		// Visible model
+		uint32	ID;				// Unique ID (also PK for DB)
+		int32	Weight;			// Item weight * 10
+		uint8	NoRent;			// No Rent: 0=norent, 255=not norent
+		uint8	NoDrop;			// No Drop: 0=nodrop, 255=not nodrop
+		uint8	Size;			// Size: 0=tiny, 1=small, 2=medium, 3=large, 4=giant
+		uint32	Slots;			// Bitfield for which slots this item can be used in
+		uint32	Price;			// Item cost (?)
+		uint32	Icon;			// Icon Number
+		uint32	LoreGroup;		// Later items use LoreGroup instead of LoreFlag. we might want to see about changing this to int32 since it is commonly -1 and is constantly being cast from signed (-1) to unsigned (4294967295)
+		bool	LoreFlag;		// This will be true if LoreGroup is non-zero
+		bool	PendingLoreFlag;
+		bool	ArtifactFlag;
+		bool	SummonedFlag;
+		uint8	FVNoDrop;		// Firiona Vie nodrop flag
+		uint32	Favor;			// Individual favor
+		uint32	GuildFavor;		// Guild favor
+		uint32	PointType;
 
-#endif
+		//uint32	Unk117;
+		//uint32	Unk118;
+		//uint32	Unk121;
+		//uint32	Unk124;
+
+		uint8	BagType;		// 0:Small Bag, 1:Large Bag, 2:Quiver, 3:Belt Pouch ... there are 50 types
+		uint8	BagSlots;		// Number of slots: can only be 2, 4, 6, 8, or 10
+		uint8	BagSize;		// 0:TINY, 1:SMALL, 2:MEDIUM, 3:LARGE, 4:GIANT
+		uint8	BagWR;			// 0->100
+
+		bool	BenefitFlag;
+		bool	Tradeskills;	// Is this a tradeskill item?
+		int8	CR;				// Save vs Cold
+		int8	DR;				// Save vs Disease
+		int8	PR;				// Save vs Poison
+		int8	MR;				// Save vs Magic
+		int8	FR;				// Save vs Fire
+		int8	AStr;			// Strength
+		int8	ASta;			// Stamina
+		int8	AAgi;			// Agility
+		int8	ADex;			// Dexterity
+		int8	ACha;			// Charisma
+		int8	AInt;			// Intelligence
+		int8	AWis;			// Wisdom
+		int32	HP;				// HP
+		int32	Mana;			// Mana
+		int32	AC;				// AC
+		uint32	Deity;			// Bitmask of Deities that can equip this item
+		//uint32	Unk033
+		int32	SkillModValue;	// % Mod to skill specified in SkillModType
+		int32	SkillModMax;	// Max skill point modification
+		uint32	SkillModType;	// Type of skill for SkillModValue to apply to
+		uint32	BaneDmgRace;	// Bane Damage Race
+		int8	BaneDmgAmt;		// Bane Damage Body Amount
+		uint32	BaneDmgBody;	// Bane Damage Body
+		bool	Magic;			// True=Magic Item, False=not
+		int32	CastTime_;
+		uint8	ReqLevel;		// Required Level to use item
+		uint32	BardType;		// Bard Skill Type
+		int32	BardValue;		// Bard Skill Amount
+		int8	Light;			// Light
+		uint8	Delay;			// Delay * 10
+		uint8	RecLevel;		// Recommended level to use item
+		uint8	RecSkill;		// Recommended skill to use item (refers to primary skill of item)
+		uint8	ElemDmgType;	// Elemental Damage Type (1=magic, 2=fire)
+		uint8	ElemDmgAmt;		// Elemental Damage
+		uint8	Range;			// Range of item
+		uint32	Damage;			// Delay between item usage (in 0.1 sec increments)
+		uint32	Color;			// RR GG BB 00 <-- as it appears in pc
+		uint32	Classes;		// Bitfield of classes that can equip item (1 << class#)
+		uint32	Races;			// Bitfield of races that can equip item (1 << race#)
+		//uint32	Unk054;
+		int16	MaxCharges;		// Maximum charges items can hold: -1 if not a chargeable item
+		uint8	ItemType;		// Item Type/Skill (itemClass* from above)
+		uint8	Material;		// Item material type
+		uint32	HerosForgeModel;// Hero's Forge Armor Model Type (2-13?)
+		float	SellRate;		// Sell rate
+		//uint32	Unk059;
+		union {
+			uint32 Fulfilment;	// Food fulfilment (How long it lasts)
+			uint32 CastTime;		// Cast Time for clicky effects, in milliseconds
+		};
+		uint32 EliteMaterial;
+		int32	ProcRate;
+		int8	CombatEffects;	// PoP: Combat Effects +
+		int8	Shielding;		// PoP: Shielding %
+		int8	StunResist;		// PoP: Stun Resist %
+		int8	StrikeThrough;	// PoP: Strike Through %
+		uint32	ExtraDmgSkill;
+		uint32	ExtraDmgAmt;
+		int8	SpellShield;	// PoP: Spell Shield %
+		int8	Avoidance;		// PoP: Avoidance +
+		int8	Accuracy;		// PoP: Accuracy +
+		uint32	CharmFileID;
+		int32	FactionMod1;	// Faction Mod 1
+		int32	FactionMod2;	// Faction Mod 2
+		int32	FactionMod3;	// Faction Mod 3
+		int32	FactionMod4;	// Faction Mod 4
+		int32	FactionAmt1;	// Faction Amt 1
+		int32	FactionAmt2;	// Faction Amt 2
+		int32	FactionAmt3;	// Faction Amt 3
+		int32	FactionAmt4;	// Faction Amt 4
+		char	CharmFile[32];	// ?
+		uint32	AugType;
+		uint8	AugSlotType[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Type
+		uint8	AugSlotVisible[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Visible
+		uint8	AugSlotUnk2[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
+		uint32	LDoNTheme;
+		uint32	LDoNPrice;
+		uint32	LDoNSold;
+		uint32	BaneDmgRaceAmt;
+		uint32	AugRestrict;
+		uint32	Endur;
+		uint32	DotShielding;
+		uint32	Attack;
+		uint32	Regen;
+		uint32	ManaRegen;
+		uint32	EnduranceRegen;
+		uint32	Haste;
+		uint32	DamageShield;
+		uint32	RecastDelay;
+		uint32	RecastType;
+		uint32	AugDistiller;
+		bool	Attuneable;
+		bool	NoPet;
+		bool	PotionBelt;
+		bool	Stackable;
+		bool	NoTransfer;
+		bool	QuestItemFlag;
+		int16	StackSize;
+		uint8	PotionBeltSlots;
+		item::ItemEffect_Struct Click, Proc, Worn, Focus, Scroll, Bard;
+
+		uint8	Book;			// 0=Not book, 1=Book
+		uint32	BookType;
+		char	Filename[33];	// Filename for book data
+		// Begin SoF Fields
+		int32 SVCorruption;
+		uint32 Purity;
+		uint8 EvolvingItem;
+		uint32 EvolvingID;
+		uint8 EvolvingLevel;
+		uint8 EvolvingMax;
+		uint32 BackstabDmg;
+		uint32 DSMitigation;
+		int32 HeroicStr;
+		int32 HeroicInt;
+		int32 HeroicWis;
+		int32 HeroicAgi;
+		int32 HeroicDex;
+		int32 HeroicSta;
+		int32 HeroicCha;
+		int32 HeroicMR;
+		int32 HeroicFR;
+		int32 HeroicCR;
+		int32 HeroicDR;
+		int32 HeroicPR;
+		int32 HeroicSVCorrup;
+		int32 HealAmt;
+		int32 SpellDmg;
+		uint32 LDoNSellBackRate;
+		uint32 ScriptFileID;
+		uint16 ExpendableArrow;
+		uint32 Clairvoyance;
+		char	ClickName[65];
+		char	ProcName[65];
+		char	WornName[65];
+		char	FocusName[65];
+		char	ScrollName[65];
+		//BardName
+
+		bool IsEquipable(uint16 Race, uint16 Class);
+		bool IsClassCommon();
+		bool IsClassBag();
+		bool IsClassBook();
+		bool IsType1HWeapon();
+		bool IsType2HWeapon();
+		bool IsTypeShield();
+
+		bool IsEquipable(uint16 Race, uint16 Class) const { return const_cast<Item_Struct*>(this)->IsEquipable(Race, Class); }
+		bool IsClassCommon() const { return const_cast<Item_Struct*>(this)->IsClassCommon(); }
+		bool IsClassBag() const { return const_cast<Item_Struct*>(this)->IsClassBag(); }
+		bool IsClassBook() const { return const_cast<Item_Struct*>(this)->IsClassBook(); }
+		bool IsType1HWeapon() const { return const_cast<Item_Struct*>(this)->IsType1HWeapon(); }
+		bool IsType2HWeapon() const { return const_cast<Item_Struct*>(this)->IsType2HWeapon(); }
+		bool IsTypeShield() const { return const_cast<Item_Struct*>(this)->IsTypeShield(); }
+	};
+
+} /*EQEmu*/
+
+#endif /*COMMON_ITEM_STRUCT_H*/

common/light_source.cpp

@@ -0,0 +1,99 @@
+/*	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 "light_source.h"
+
+#include <string.h>
+
+
+uint8 EQEmu::lightsource::TypeToLevel(uint8 light_type)
+{
+	switch (light_type) {
+	case LightTypeGlobeOfStars:
+		return LightLevelBrilliant;		// 10
+	case LightTypeFlamelessLantern:
+	case LightTypeGreaterLightstone:
+		return LightLevelLargeMagic;	// 9
+	case LightTypeLargeLantern:
+		return LightLevelLargeLantern;	// 8
+	case LightTypeSteinOfMoggok:
+	case LightTypeLightstone:
+		return LightLevelMagicLantern;	// 7
+	case LightTypeSmallLantern:
+		return LightLevelSmallLantern;	// 6
+	case LightTypeColdlight:
+	case LightTypeUnknown2:
+		return LightLevelBlueLight;		// 5
+	case LightTypeFireBeetleEye:
+	case LightTypeUnknown1:
+		return LightLevelRedLight;		// 4
+	case LightTypeTinyGlowingSkull:
+	case LightTypeLightGlobe:
+		return LightLevelSmallMagic;	// 3
+	case LightTypeTorch:
+		return LightLevelTorch;			// 2
+	case LightTypeCandle:
+		return LightLevelCandle;		// 1
+	default:
+		return LightLevelUnlit;			// 0
+	}
+}
+
+bool EQEmu::lightsource::IsLevelGreater(uint8 left_type, uint8 right_type)
+{
+	static const uint8 light_levels[LightTypeCount] = {
+		LightLevelUnlit,			/* LightTypeNone */
+		LightLevelCandle,			/* LightTypeCandle */
+		LightLevelTorch,			/* LightTypeTorch */
+		LightLevelSmallMagic,		/* LightTypeTinyGlowingSkull */
+		LightLevelSmallLantern,		/* LightTypeSmallLantern */
+		LightLevelMagicLantern,		/* LightTypeSteinOfMoggok */
+		LightLevelLargeLantern,		/* LightTypeLargeLantern */
+		LightLevelLargeMagic,		/* LightTypeFlamelessLantern */
+		LightLevelBrilliant,		/* LightTypeGlobeOfStars */
+		LightLevelSmallMagic,		/* LightTypeLightGlobe */
+		LightLevelMagicLantern,		/* LightTypeLightstone */
+		LightLevelLargeMagic,		/* LightTypeGreaterLightstone */
+		LightLevelRedLight,			/* LightTypeFireBeetleEye */
+		LightLevelBlueLight,		/* LightTypeColdlight */
+		LightLevelRedLight,			/* LightTypeUnknown1 */
+		LightLevelBlueLight			/* LightTypeUnknown2 */
+	};
+
+	if (left_type >= LightTypeCount) { left_type = LightTypeNone; }
+	if (right_type >= LightTypeCount) { right_type = LightTypeNone; }
+
+	return (light_levels[left_type] > light_levels[right_type]);
+}
+
+EQEmu::lightsource::Light_Struct::Light_Struct()
+{
+	Clear();
+}
+
+void EQEmu::lightsource::Light_Struct::Clear()
+{
+	memset(&Slot, 0, (sizeof(uint8) * sizeof(Slot)));
+}
+
+void EQEmu::LightSourceProfile::Clear()
+{
+	Type.Clear();
+	Level.Clear();
+}

common/light_source.h

@@ -0,0 +1,116 @@
+/*	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_LIGHT_SOURCE_H
+#define COMMON_LIGHT_SOURCE_H
+
+#include "types.h"
+
+
+namespace EQEmu
+{
+	namespace lightsource {
+		enum LightSlot {
+			LightInnate = 0,	// Defined by db field `npc_types`.`light` - where appropriate
+			LightEquipment,		// Item_Struct::light value of worn/carried equipment
+			LightSpell,			// Set value of any light-producing spell (can be modded to mimic equip_light behavior)
+			LightActive,		// Highest value of all light sources
+			LightCount
+		};
+
+
+		enum LightType {
+			LightTypeNone = 0,
+			LightTypeCandle,
+			LightTypeTorch,
+			LightTypeTinyGlowingSkull,
+			LightTypeSmallLantern,
+			LightTypeSteinOfMoggok, // 5
+			LightTypeLargeLantern,
+			LightTypeFlamelessLantern,
+			LightTypeGlobeOfStars,
+			LightTypeLightGlobe,
+			LightTypeLightstone, // 10
+			LightTypeGreaterLightstone,
+			LightTypeFireBeetleEye,
+			LightTypeColdlight,
+			LightTypeUnknown1,
+			LightTypeUnknown2, // 15
+			LightTypeCount
+		};
+
+		enum LightLevel {
+			LightLevelUnlit = 0,
+			LightLevelCandle,
+			LightLevelTorch,
+			LightLevelSmallMagic,
+			LightLevelRedLight,
+			LightLevelBlueLight, // 5
+			LightLevelSmallLantern,
+			LightLevelMagicLantern,
+			LightLevelLargeLantern,
+			LightLevelLargeMagic,
+			LightLevelBrilliant, // 10
+			LightLevelCount
+		};
+
+		struct Light_Struct {
+			uint8 Slot[LightCount];
+
+			Light_Struct();
+
+			void Clear();
+
+			inline uint8& operator[](LightSlot index) { return Slot[index]; }
+		};
+
+		extern uint8 TypeToLevel(uint8 light_type);
+		extern bool IsLevelGreater(uint8 left_type, uint8 right_type);
+	
+	}; /*lightsource*/
+
+	struct LightSourceProfile {
+		/*
+		Current criteria (light types):
+		Equipment:	{ 0 .. 15 }
+		General:	{ 9 .. 13 }
+
+		Notes:
+		- Initial character load and item movement updates use different light source update behaviors
+		-- Server procedure matches the item movement behavior since most updates occur post-character load
+		- MainAmmo is not considered when determining light sources
+		- No 'Sub' or 'Aug' items are recognized as light sources
+		- Light types '< 9' and '> 13' are not considered for general (carried) light sources
+		- If values > 0x0F are valid, then assignment limiters will need to be removed
+		- MainCursor 'appears' to be a valid light source update slot..but, have not experienced updates during debug sessions
+		- All clients have a bug regarding stackable items (light and sound updates are not processed when picking up an item)
+		-- The timer-based update cancels out the invalid light source
+		*/
+
+		lightsource::Light_Struct Type; // Light types (classifications)
+		lightsource::Light_Struct Level; // Light levels (intensities) - used to determine which light source should be active
+
+		LightSourceProfile() { }
+
+		void Clear();
+	};
+
+} /*EQEmu*/
+
+#endif /*COMMON_LIGHT_SOURCE_H*/

common/misc.cpp

@@ -24,6 +24,36 @@
 
 std::map<int,std::string> DBFieldNames;
 
+#ifndef WIN32
+#if defined(FREEBSD) || defined(__CYGWIN__)
+int print_stacktrace()
+{
+	printf("Insert stack trace here...\n");
+	return(0);
+}
+#else //!WIN32 && !FREEBSD == linux
+#include <execinfo.h>
+int print_stacktrace()
+{
+	void *ba[20];
+	int n = backtrace (ba, 20);
+	if (n != 0)
+	{
+		char **names = backtrace_symbols (ba, n);
+		if (names != nullptr)
+		{
+			int i;
+			std::cerr << "called from " << (char*)names[0] << std::endl;
+			for (i = 1; i < n; ++i)
+				std::cerr << "            " << (char*)names[i] << std::endl;
+			free (names);
+		}
+	}
+	return(0);
+}
+#endif //!FREEBSD
+#endif //!WIN32
+
 void Unprotect(std::string &s, char what)
 {
 	if (s.length()) {
@@ -48,12 +78,12 @@ void Protect(std::string &s, char what)
 */
 bool ItemParse(const char *data, int length, std::map<int,std::map<int,std::string> > &items, int id_pos, int name_pos, int max_field, int level)
 {
-	int i;
-	char *end,*ptr;
-	std::map<int,std::string> field;
-	static char *buffer=nullptr;
-	static int buffsize=0;
-	static char *temp=nullptr;
+int i;
+char *end,*ptr;
+std::map<int,std::string> field;
+static char *buffer=nullptr;
+static int buffsize=0;
+static char *temp=nullptr;
 	if (!buffsize || buffsize<(length+1)) {
 		buffer=(char *)realloc(buffer,length+1);
 		temp=(char *)realloc(temp,length+1);
@@ -156,10 +186,10 @@ bool ItemParse(const char *data, int length, std::map<int,std::map<int,std::stri
 
 int Tokenize(std::string s,std::map<int,std::string> & tokens, char delim)
 {
-	int i,len;
-	std::string::size_type end;
-	//char temp[1024];
-	std::string x;
+int i,len;
+std::string::size_type end;
+//char temp[1024];
+std::string x;
 	tokens.clear();
 	i=0;
 	while(s.length()) {
@@ -305,14 +335,14 @@ void LoadItemDBFieldNames() {
 
 void encode_length(unsigned long length, char *out)
 {
-	char buf[4];
+char buf[4];
 	memcpy(buf,&length,sizeof(unsigned long));
 	encode_chunk(buf,3,out);
 }
 
 unsigned long encode(char *in, unsigned long length, char *out)
 {
-	unsigned long used=0,len=0;
+unsigned long used=0,len=0;
 	while(used<length) {
 		encode_chunk(in+used,length-used,out+len);
 		used+=3;
@@ -325,8 +355,8 @@ unsigned long encode(char *in, unsigned long length, char *out)
 
 unsigned long decode_length(char *in)
 {
-	int length;
-	char buf[4];
+int length;
+char buf[4];
 	decode_chunk(in,&buf[0]);
 	buf[3]=0;
 	memcpy(&length,buf,sizeof(unsigned long));
@@ -336,8 +366,8 @@ unsigned long decode_length(char *in)
 
 void decode(char *in, char *out)
 {
-	char *ptr=in;
-	char *outptr=out;
+char *ptr=in;
+char *outptr=out;
 	while(*ptr) {
 		decode_chunk(ptr,outptr);
 		ptr+=4;
@@ -363,8 +393,8 @@ void decode_chunk(char *in, char *out)
 
 void dump_message_column(unsigned char *buffer, unsigned long length, std::string leader, FILE *to)
 {
-	unsigned long i,j;
-	unsigned long rows,offset=0;
+unsigned long i,j;
+unsigned long rows,offset=0;
 	rows=(length/16)+1;
 	for(i=0;i<rows;i++) {
 		fprintf(to, "%s%05ld: ",leader.c_str(),i*16);
@@ -389,8 +419,8 @@ void dump_message_column(unsigned char *buffer, unsigned long length, std::strin
 
 std::string long2ip(unsigned long ip)
 {
-	char temp[16];
-	union { unsigned long ip; struct { unsigned char a,b,c,d; } octet;} ipoctet;
+char temp[16];
+union { unsigned long ip; struct { unsigned char a,b,c,d; } octet;} ipoctet;
 
 	ipoctet.ip=ip;
 	sprintf(temp,"%d.%d.%d.%d",ipoctet.octet.a,ipoctet.octet.b,ipoctet.octet.c,ipoctet.octet.d);
@@ -400,8 +430,8 @@ std::string long2ip(unsigned long ip)
 
 std::string string_from_time(std::string pattern, time_t now)
 {
-	struct tm *now_tm;
-	char time_string[51];
+struct tm *now_tm;
+char time_string[51];
 
 	if (!now)
 		time(&now);
@@ -420,9 +450,9 @@ std::string timestamp(time_t now)
 
 std::string pop_arg(std::string &s, std::string seps, bool obey_quotes)
 {
-	std::string ret;
-	unsigned long i;
-	bool in_quote=false;
+std::string ret;
+unsigned long i;
+bool in_quote=false;
 
 	unsigned long length=s.length();
 	for(i=0;i<length;i++) {
@@ -451,8 +481,8 @@ std::string pop_arg(std::string &s, std::string seps, bool obey_quotes)
 
 int EQsprintf(char *buffer, const char *pattern, const char *arg1, const char *arg2, const char *arg3, const char *arg4, const char *arg5, const char *arg6, const char *arg7, const char *arg8, const char *arg9)
 {
-	const char *args[9],*ptr;
-	char *bptr;
+const char *args[9],*ptr;
+char *bptr;
 	args[0]=arg1;
 	args[1]=arg2;
 	args[2]=arg3;
@@ -494,11 +524,11 @@ int EQsprintf(char *buffer, const char *pattern, const char *arg1, const char *a
 
 std::string generate_key(int length)
 {
-	std::string key;
-	//TODO: write this for win32...
+std::string key;
+//TODO: write this for win32...
 #ifndef WIN32
-	int i;
-	timeval now;
+int i;
+timeval now;
 	static const char *chars="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 	for(i=0;i<length;i++) {
 		gettimeofday(&now,nullptr);
@@ -520,9 +550,9 @@ void print_hex(const char *data, unsigned long length) {
 
 void build_hex_line(const char *buffer, unsigned long length, unsigned long offset, char *out_buffer, unsigned char padding)
 {
-	char *ptr=out_buffer;
-	int i;
-	char printable[17];
+char *ptr=out_buffer;
+int i;
+char printable[17];
 	ptr+=sprintf(ptr,"%0*lu:",padding,offset);
 	for(i=0;i<16; i++) {
 		if (i==8) {

common/misc.h

@@ -24,6 +24,10 @@ void decode(char *in, char *out);
 void encode_chunk(char *in, int len, char *out);
 void decode_chunk(char *in, char *out);
 
+#ifndef WIN32
+int print_stacktrace();
+#endif
+
 void dump_message_column(unsigned char *buffer, unsigned long length, std::string leader="", FILE *to = stdout);
 std::string string_from_time(std::string pattern, time_t now=0);
 std::string timestamp(time_t now=0);

common/mutex.h

@@ -18,7 +18,7 @@
 #ifndef MYMUTEX_H
 #define MYMUTEX_H
 #ifdef _WINDOWS
-	#include <winsock.h>
+	#include <winsock2.h>
 	#include <windows.h>
 #else
 	#include <pthread.h>

common/mysql_request_result.cpp

@@ -32,6 +32,7 @@ MySQLRequestResult::MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected, u
 
 void MySQLRequestResult::FreeInternals()
 {
+
 	safe_delete_array(m_ErrorBuffer);
 
 	if (m_Result != nullptr)

common/mysql_request_result.h

@@ -2,7 +2,7 @@
 #define MYSQL_REQUEST_RESULT_H
 
 #ifdef _WINDOWS
-	#include <winsock.h>
+	#include <winsock2.h>
 	#include <windows.h>
 #endif
 
@@ -10,6 +10,12 @@
 #include "types.h"
 #include "mysql_request_row.h"
 
+#ifdef __FreeBSD__
+	#include <string>
+	#include <sstream>
+	#include <iostream>
+#endif
+
 class MySQLRequestResult {
 private:
 	MYSQL_RES* m_Result;

common/mysql_request_row.h

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

common/opcode_dispatch.h

@@ -146,6 +146,7 @@ INr(OP_GuildDelete);	//?
 IN(OP_GuildPublicNote, GuildUpdate_PublicNote);
 INz(OP_GetGuildsList);	//?
 IN(OP_SetGuildMOTD, GuildMOTD_Struct);
+IN(OP_SetRunMode, SetRunMode_Struct);
 INz(OP_GuildPeace);		//?
 INz(OP_GuildWar);		//?
 IN(OP_GuildLeader, GuildMakeLeader);
@@ -180,7 +181,7 @@ IN(OP_GMLastName, GMLastName_Struct);
 IN(OP_GMToggle, GMToggle_Struct);
 IN(OP_LFGCommand, LFG_Struct);
 IN(OP_GMGoto, GMSummon_Struct);
-IN(OP_TraderShop, TraderClick_Struct);
+INv(OP_TraderShop, TraderClick_Struct);
 IN(OP_ShopRequest, Merchant_Click_Struct);
 IN(OP_Bazaar, BazaarSearch_Struct);
 //alt:IN(OP_Bazaar, BazaarWelcome_Struct);		//alternate structure for OP_Bazaar
@@ -399,7 +400,7 @@ OUT(OP_Weather, Weather_Struct);
 OUT(OP_ZoneChange, ZoneChange_Struct);
 OUT(OP_ZoneInUnknown, ZoneInUnknown_Struct);
 
-//this is the set of opcodes which are allready listed
+//this is the set of opcodes which are already listed
 //in the IN section above, but are also sent OUT
 #ifdef DISJOINT_DIRECTIONS
 OUTz(OP_ClientReady);		//follows OP_SetServerFilter
@@ -449,7 +450,7 @@ OUT(OP_Trader, TraderBuy_Struct);	//3 possible lengths
 //alt:OUT(OP_Trader, Trader_ShowItems_Struct);
 //alt:OUT(OP_Trader, Trader_Struct);
 OUT(OP_TraderBuy, TraderBuy_Struct);
-OUT(OP_TraderShop, TraderClick_Struct);
+OUTv(OP_TraderShop, TraderClick_Struct);
 OUT(OP_WearChange, WearChange_Struct);
 OUT(OP_ZoneEntry, ServerZoneEntry_Struct);
 #endif

common/opcode_map.cpp

@@ -0,0 +1,307 @@
+#include "global_define.h"
+#include <map>
+#include <string>
+
+std::map<unsigned long, std::string> opcode_map;
+
+std::string get_opcode_name(unsigned long opcode)
+{
+	std::map<unsigned long, std::string>::iterator itr;;
+	return (itr = opcode_map.find(opcode)) != opcode_map.end() ? itr->second : "OP_Unknown";
+}
+
+void load_opcode_names()
+{
+	opcode_map[0x0176] = "LiveOP_Heartbeat";
+	opcode_map[0x02d7] = "LiveOP_ReloadUI";
+	opcode_map[0x01eb] = "LiveOP_IncreaseStats";
+	opcode_map[0x0134] = "LiveOP_ApproveZone";
+	opcode_map[0x01d5] = "LiveOP_Dye";
+	opcode_map[0x0168] = "LiveOP_Stamina";
+	opcode_map[0x014d] = "LiveOP_ControlBoat";
+	opcode_map[0x003e] = "LiveOP_MobUpdate";
+	opcode_map[0x0027] = "LiveOP_ClientUpdate";
+	opcode_map[0x0024] = "LiveOP_ChannelMessage";
+	opcode_map[0x01d7] = "LiveOP_SimpleMessage";
+	opcode_map[0x01d8] = "LiveOP_FormattedMessage";
+	opcode_map[0x01c6] = "LiveOP_TGB";
+	opcode_map[0x0285] = "LiveOP_TestBuff";
+	opcode_map[0x012d] = "LiveOP_Bind_Wound";
+	opcode_map[0x01ab] = "LiveOP_Charm";
+	opcode_map[0x014c] = "LiveOP_Begging";
+	opcode_map[0x0152] = "LiveOP_MoveCoin";
+	opcode_map[0x0292] = "LiveOP_SpawnDoor";
+	opcode_map[0x009d] = "LiveOP_Sneak";
+	opcode_map[0x0079] = "LiveOP_ExpUpdate";
+	opcode_map[0x027d] = "LiveOP_DumpName";
+	opcode_map[0x01ea] = "LiveOP_RespondAA";
+	opcode_map[0x01c9] = "LiveOP_SendAAStats";
+	opcode_map[0x0366] = "LiveOP_SendAATable";
+	opcode_map[0x01e9] = "LiveOP_AAAction";
+	opcode_map[0x00bb] = "LiveOP_BoardBoat";
+	opcode_map[0x00bc] = "LiveOP_LeaveBoat";
+	opcode_map[0x02b8] = "LiveOP_AdventureInfoRequest";
+	opcode_map[0x02b9] = "LiveOP_AdventureInfo";
+	opcode_map[0x02a6] = "LiveOP_AdventureRequest";
+	opcode_map[0x02a8] = "LiveOP_AdventureDetails";
+	opcode_map[0x02a9] = "LiveOP_LDoNButton";
+	opcode_map[0x02ba] = "LiveOP_AdventureData";
+	opcode_map[0x02c9] = "LiveOP_AdventureFinish";
+	opcode_map[0x02c6] = "LiveOP_LeaveAdventure";
+	opcode_map[0x02ce] = "LiveOP_AdventureUpdate";
+	opcode_map[0x002b] = "LiveOP_SendExpZonein";
+	opcode_map[0x01e4] = "LiveOP_ZoneInSendName";
+	opcode_map[0x01bf] = "LiveOP_GuildLeader";
+	opcode_map[0x009a] = "LiveOP_GuildPeace";
+	opcode_map[0x0132] = "LiveOP_GuildRemove";
+	opcode_map[0x0059] = "LiveOP_GuildMemberList";
+	opcode_map[0x026e] = "LiveOP_GuildMemberUpdate";
+	opcode_map[0x0130] = "LiveOP_GuildInvite";
+	opcode_map[0x01c0] = "LiveOP_GuildMOTD";
+	opcode_map[0x003c] = "LiveOP_GuildPublicNote";
+	opcode_map[0x027e] = "LiveOP_GetGuildMOTD";
+	opcode_map[0x0277] = "LiveOP_GuildDemote";
+	opcode_map[0x0131] = "LiveOP_GuildInviteAccept";
+	opcode_map[0x00a4] = "LiveOP_GuildWar";
+	opcode_map[0x0133] = "LiveOP_GuildDelete";
+	opcode_map[0x0233] = "LiveOP_GuildManageRemove";
+	opcode_map[0x022d] = "LiveOP_GuildManageAdd";
+	opcode_map[0x0039] = "LiveOP_GuildManageStatus";
+	opcode_map[0x01e8] = "LiveOP_Trader";
+	opcode_map[0x01e7] = "LiveOP_Bazaar";
+	opcode_map[0x01c4] = "LiveOP_BecomeTrader";
+	opcode_map[0x01f4] = "LiveOP_BazaarInspect";
+	opcode_map[0x006e] = "LiveOP_TraderItemUpdate";
+	opcode_map[0x017c] = "LiveOP_TraderDelItem";
+	opcode_map[0x01eb] = "LiveOP_TraderShop";
+	opcode_map[0x01ca] = "LiveOP_TraderBuy";
+	opcode_map[0x01ac] = "LiveOP_PetCommands";
+	opcode_map[0x0042] = "LiveOP_TradeSkillCombine";
+	opcode_map[0x02e5] = "LiveOP_AugmentItem";
+	opcode_map[0x0367] = "LiveOP_ItemName";
+	opcode_map[0x02cd] = "LiveOP_ShopItem";
+	opcode_map[0x0065] = "LiveOP_ShopPlayerBuy";
+	opcode_map[0x006a] = "LiveOP_ShopPlayerSell";
+	opcode_map[0x006d] = "LiveOP_ShopDelItem";
+	opcode_map[0x0f6d] = "LiveOP_ShopEndConfirm";
+	opcode_map[0x00f7] = "LiveOP_ShopRequest";
+	opcode_map[0x006c] = "LiveOP_ShopEnd";
+	opcode_map[0x02d1] = "LiveOP_AdventureMerchantRequest";
+	opcode_map[0x02d2] = "LiveOP_AdventureMerchantResponse";
+	opcode_map[0x02d3] = "LiveOP_AdventureMerchantPurchase";
+	opcode_map[0x02e3] = "LiveOP_AdventurePointsUpdate";
+	opcode_map[0x0270] = "LiveOP_LFGCommand";
+	opcode_map[0x01d0] = "LiveOP_LFGAppearance";
+	opcode_map[0x01b5] = "LiveOP_MoneyUpdate";
+	opcode_map[0x0721] = "LiveOP_GroupDelete";
+	opcode_map[0x0272] = "LiveOP_GroupAcknowledge";
+	opcode_map[0x024a] = "LiveOP_GroupUpdate";
+	opcode_map[0x025f] = "LiveOP_GroupInvite";
+	opcode_map[0x00ff] = "LiveOP_GroupDisband";
+	opcode_map[0x00d5] = "LiveOP_GroupInvite2";
+	opcode_map[0x025e] = "LiveOP_GroupFollow";
+	opcode_map[0x00d7] = "LiveOP_GroupFollow2";
+	opcode_map[0x00d6] = "LiveOP_GroupCancelInvite";
+	opcode_map[0x0156] = "LiveOP_Split";
+	opcode_map[0x00d8] = "LiveOP_Jump";
+	opcode_map[0x01d6] = "LiveOP_ConsiderCorpse";
+	opcode_map[0x0064] = "LiveOP_SkillUpdate";
+	opcode_map[0x0178] = "LiveOP_GMEndTrainingResponse";
+	opcode_map[0x013c] = "LiveOP_GMEndTraining";
+	opcode_map[0x0175] = "LiveOP_GMTrainSkill";
+	opcode_map[0x013b] = "LiveOP_GMTraining";
+	opcode_map[0x017b] = "LiveOP_ConsumeAmmo";
+	opcode_map[0x0171] = "LiveOP_CombatAbility";
+	opcode_map[0x009c] = "LiveOP_TrackUnknown";
+	opcode_map[0x0234] = "LiveOP_TrackTarget";
+	opcode_map[0x0286] = "LiveOP_Track";
+	opcode_map[0x0297] = "LiveOP_ReadBook";
+	opcode_map[0x001f] = "LiveOP_ItemLinkClick";
+	opcode_map[0x01f4] = "LiveOP_ItemLinkResponse";
+	opcode_map[0x01d9] = "LiveOP_ItemLinkText";
+	opcode_map[0x0a41] = "LiveOP_RezzRequest";
+	opcode_map[0x00e5] = "LiveOP_RezzAnswer";
+	opcode_map[0x019b] = "LiveOP_RezzComplete";
+	opcode_map[0x0128] = "LiveOP_MoveDoor";
+	opcode_map[0x0127] = "LiveOP_ClickDoor";
+	opcode_map[0x0247] = "LiveOP_SendZonepoints";
+	opcode_map[0x008c] = "LiveOP_SetRunMode";
+	opcode_map[0x0248] = "LiveOP_InspectRequest";
+	opcode_map[0x0249] = "LiveOP_InspectAnswer";
+	opcode_map[0x0187] = "LiveOP_SenseTraps";
+	opcode_map[0x018e] = "LiveOP_DisarmTraps";
+	opcode_map[0x01bc] = "LiveOP_Assist";
+	opcode_map[0x0240] = "LiveOP_PickPocket";
+	opcode_map[0x0119] = "LiveOP_LootRequest";
+	opcode_map[0x011a] = "LiveOP_EndLootRequest";
+	opcode_map[0x011b] = "LiveOP_MoneyOnCorpse";
+	opcode_map[0x0179] = "LiveOP_LootComplete";
+	opcode_map[0x013f] = "LiveOP_LootItem";
+	opcode_map[0x0151] = "LiveOP_MoveItem";
+	opcode_map[0x0056] = "LiveOP_WhoAllRequest";
+	opcode_map[0x0229] = "LiveOP_WhoAllResponse";
+	opcode_map[0x0167] = "LiveOP_Consume";
+	opcode_map[0x0172] = "LiveOP_AutoAttack";
+	opcode_map[0x0186] = "LiveOP_AutoAttack2";
+	opcode_map[0x0173] = "LiveOP_TargetMouse";
+	opcode_map[0x01ba] = "LiveOP_TargetCommand";
+	opcode_map[0x01d8] = "LiveOP_TargetReject";
+	opcode_map[0x009e] = "LiveOP_Hide";
+	opcode_map[0x012e] = "LiveOP_Forage";
+	opcode_map[0x0077] = "LiveOP_Fishing";
+	opcode_map[0x0246] = "LiveOP_Bug";
+	opcode_map[0x00f2] = "LiveOP_Emote";
+	opcode_map[0x0140] = "LiveOP_EmoteAnim";
+	opcode_map[0x015c] = "LiveOP_Consider";
+	opcode_map[0x01cb] = "LiveOP_FaceChange";
+	opcode_map[0x0197] = "LiveOP_RandomReq";
+	opcode_map[0x0087] = "LiveOP_RandomReply";
+	opcode_map[0x01c3] = "LiveOP_Camp";
+	opcode_map[0x0192] = "LiveOP_YellForHelp";
+	opcode_map[0x00ef] = "LiveOP_SafePoint";
+	opcode_map[0x0157] = "LiveOP_Buff";
+	opcode_map[0x00c0] = "LiveOP_ColoredText";
+	opcode_map[0x0440] = "LiveOP_MultiLineMsg";
+	opcode_map[0x021c] = "LiveOP_SpecialMesg";
+	opcode_map[0x0013] = "LiveOP_Consent";
+	opcode_map[0x029d] = "LiveOP_ConsentResponse";
+	opcode_map[0x02d4] = "LiveOP_Deny";
+	opcode_map[0x016c] = "LiveOP_Stun";
+	opcode_map[0x0021] = "LiveOP_BeginCast";
+	opcode_map[0x00be] = "LiveOP_CastSpell";
+	opcode_map[0x01a8] = "LiveOP_InterruptCast";
+	opcode_map[0x0105] = "LiveOP_Death";
+	opcode_map[0x023f] = "LiveOP_FeignDeath";
+	opcode_map[0x012b] = "LiveOP_Illusion";
+	opcode_map[0x0078] = "LiveOP_LevelUpdate";
+	opcode_map[0x0371] = "LiveOP_LevelAppearance";
+	opcode_map[0x00c2] = "LiveOP_MemorizeSpell";
+	opcode_map[0x0244] = "LiveOP_HPUpdate";
+	opcode_map[0x022e] = "LiveOP_SendHPTarget";
+	opcode_map[0x007d] = "LiveOP_Mend";
+	opcode_map[0x0160] = "LiveOP_Taunt";
+	opcode_map[0x0199] = "LiveOP_GMDelCorpse";
+	opcode_map[0x0047] = "LiveOP_GMFind";
+	opcode_map[0x0020] = "LiveOP_GMServers";
+	opcode_map[0x010b] = "LiveOP_GMGoto";
+	opcode_map[0x028c] = "LiveOP_GMSummon";
+	opcode_map[0x010a] = "LiveOP_GMKick";
+	opcode_map[0x0109] = "LiveOP_GMKill";
+	opcode_map[0x0b40] = "LiveOP_GMNameChange";
+	opcode_map[0x00a3] = "LiveOP_GMLastName";
+	opcode_map[0x01b3] = "LiveOP_GMToggle";
+	opcode_map[0x028f] = "LiveOP_GMEmoteZone";
+	opcode_map[0x0074] = "LiveOP_GMBecomeNPC";
+	opcode_map[0x00de] = "LiveOP_GMHideMe";
+	opcode_map[0x0184] = "LiveOP_GMZoneRequest";
+	opcode_map[0x0239] = "LiveOP_GMZoneRequest2";
+	opcode_map[0x0068] = "LiveOP_Petition";
+	opcode_map[0x0085] = "LiveOP_PetitionRefresh";
+	opcode_map[0x01ee] = "LiveOP_PDeletePetition";
+	opcode_map[0x0092] = "LiveOP_PetitionBug";
+	opcode_map[0x0069] = "LiveOP_PetitionUpdate";
+	opcode_map[0x0076] = "LiveOP_PetitionCheckout";
+	opcode_map[0x0056] = "LiveOP_PetitionCheckout2";
+	opcode_map[0x0091] = "LiveOP_PetitionDelete";
+	opcode_map[0x02b4] = "LiveOP_PetitionResolve";
+	opcode_map[0x007e] = "LiveOP_PetitionCheckIn";
+	opcode_map[0x0090] = "LiveOP_PetitionUnCheckout";
+	opcode_map[0x01ec] = "LiveOP_PetitionQue";
+	opcode_map[0x01bb] = "LiveOP_SetServerFilter";
+	opcode_map[0x0218] = "LiveOP_NewSpawn";
+	opcode_map[0x0140] = "LiveOP_Animation";
+	opcode_map[0x0142] = "LiveOP_ZoneChange";
+	opcode_map[0x00f3] = "LiveOP_DeleteSpawn";
+	opcode_map[0x0265] = "LiveOP_CrashDump";
+	opcode_map[0x00e8] = "LiveOP_EnvDamage";
+	opcode_map[0x0101] = "LiveOP_Action";
+	opcode_map[0x00e2] = "LiveOP_Damage";
+	opcode_map[0x00bf] = "LiveOP_ManaChange";
+	opcode_map[0x027c] = "LiveOP_ClientError";
+	opcode_map[0x00fb] = "LiveOP_Save";
+	opcode_map[0x0316] = "LiveOP_LocInfo";
+	opcode_map[0x0188] = "LiveOP_Surname";
+	opcode_map[0x018f] = "LiveOP_SwapSpell";
+	opcode_map[0x01db] = "LiveOP_DeleteSpell";
+	opcode_map[0x029f] = "LiveOP_CloseContainer";
+	opcode_map[0x029f] = "LiveOP_ClickObjectAck";
+	opcode_map[0x00fa] = "LiveOP_CreateObject";
+	opcode_map[0x00f9] = "LiveOP_ClickObject";
+	opcode_map[0x01c1] = "LiveOP_ClearObject";
+	opcode_map[0x0265] = "LiveOP_ZoneUnavail";
+	opcode_map[0x02e0] = "LiveOP_ItemPacket";
+	opcode_map[0x029a] = "LiveOP_TradeRequest";
+	opcode_map[0x0037] = "LiveOP_TradeRequestAck";
+	opcode_map[0x002d] = "LiveOP_TradeAcceptClick";
+	opcode_map[0x0162] = "LiveOP_TradeMoneyUpdate";
+	opcode_map[0x0036] = "LiveOP_TradeCoins";
+	opcode_map[0x002e] = "LiveOP_CancelTrade";
+	opcode_map[0x002f] = "LiveOP_FinishTrade";
+	opcode_map[0x00a1] = "LiveOP_SaveOnZoneReq";
+	opcode_map[0x0185] = "LiveOP_Logout";
+	opcode_map[0x0298] = "LiveOP_RequestDuel";
+	opcode_map[0x0a5d] = "LiveOP_DuelResponse";
+	opcode_map[0x016e] = "LiveOP_DuelResponse2";
+	opcode_map[0x007c] = "LiveOP_InstillDoubt";
+	opcode_map[0x00ac] = "LiveOP_SafeFallSuccess";
+	opcode_map[0x02fb] = "LiveOP_DisciplineUpdate";
+	opcode_map[0x02f2] = "LiveOP_TributeUpdate";
+	opcode_map[0x02f3] = "LiveOP_TributeItem";
+	opcode_map[0x02f4] = "LiveOP_TributePointUpdate";
+	opcode_map[0x02f5] = "LiveOP_SendTributes";
+	opcode_map[0x02f6] = "LiveOP_TributeInfo";
+	opcode_map[0x02f7] = "LiveOP_SelectTribute";
+	opcode_map[0x02f8] = "LiveOP_TributeTimer";
+	opcode_map[0x02f9] = "LiveOP_StartTribute";
+	opcode_map[0x02fa] = "LiveOP_TributeNPC";
+	opcode_map[0x02fe] = "LiveOP_TributeMoney";
+	opcode_map[0x0364] = "LiveOP_TributeToggle";
+	opcode_map[0x0322] = "LiveOP_RecipesFavorite";
+	opcode_map[0x01f9] = "LiveOP_RecipesSearch";
+	opcode_map[0x01fa] = "LiveOP_RecipeReply";
+	opcode_map[0x01fb] = "LiveOP_RecipeDetails";
+	opcode_map[0x01fc] = "LiveOP_RecipeAutoCombine";
+	opcode_map[0x02db] = "LiveOP_FindPersonRequest";
+	opcode_map[0x02dc] = "LiveOP_FindPersonReply";
+	opcode_map[0x01dd] = "LiveOP_Shielding";
+	opcode_map[0x0198] = "LiveOP_SetDataRate";
+	opcode_map[0x023b] = "LiveOP_ZoneEntry";
+	opcode_map[0x006b] = "LiveOP_PlayerProfile";
+	opcode_map[0x0291] = "LiveOP_CharInventory";
+	opcode_map[0x0170] = "LiveOP_ZoneSpawns";
+	opcode_map[0x0026] = "LiveOP_TimeOfDay";
+	opcode_map[0x015b] = "LiveOP_Weather";
+	opcode_map[0x00ec] = "LiveOP_ReqNewZone";
+	opcode_map[0x00eb] = "LiveOP_NewZone";
+	opcode_map[0x00fd] = "LiveOP_ReqClientSpawn";
+	opcode_map[0x012F] = "LiveOP_SpawnAppearance";
+	opcode_map[0x0086] = "LiveOP_ClientReady";
+	opcode_map[0x0086] = "LiveOP_ZoneComplete";
+	opcode_map[0x02db] = "LiveOP_LoginComplete";
+	opcode_map[0x0195] = "LiveOP_ApproveWorld";
+	opcode_map[0x035f] = "LiveOP_LogServer";
+	opcode_map[0x01b2] = "LiveOP_MOTD";
+	opcode_map[0x0251] = "LiveOP_SendLoginInfo";
+	opcode_map[0x00ea] = "LiveOP_DeleteCharacter";
+	opcode_map[0x0102] = "LiveOP_SendCharInfo";
+	opcode_map[0x00e1] = "LiveOP_ExpansionInfo";
+	opcode_map[0x0104] = "LiveOP_CharacterCreate";
+	opcode_map[0x02ab] = "LiveOP_RandomNameGenerator";
+	opcode_map[0x005d] = "LiveOP_GuildsList";
+	opcode_map[0x0125] = "LiveOP_ApproveName";
+	opcode_map[0x0261] = "LiveOP_EnterWorld";
+	opcode_map[0x015a] = "LiveOP_World_Client_CRC1";
+	opcode_map[0x015e] = "LiveOP_World_Client_CRC2";
+	opcode_map[0x0269] = "LiveOP_SetChatServer";
+	opcode_map[0x0264] = "LiveOP_ZoneServerInfo";
+	opcode_map[0x0017] = "LiveOP_AckPacket";
+	opcode_map[0x012c] = "LiveOP_WearChange";
+	opcode_map[0x1FA1] = "LiveOP_WorldObjectsSent";
+	opcode_map[0x39C4] = "LiveOP_BlockedBuffs";
+	opcode_map[0x4656] = "LiveOP_SpawnPositionUpdate";
+	opcode_map[0x4b61] = "LiveOP_ManaUpdate";
+	opcode_map[0x02d6] = "LiveOP_EnduranceUpdate";
+	opcode_map[0x2ac1] = "LiveOP_MobManaUpdate";
+	opcode_map[0x6c5f] = "LiveOP_MobEnduranceUpdate";
+	opcode_map[0x73a8] = "LiveOP_SendMaxCharacters";
+}

common/packet_dump.cpp

@@ -54,7 +54,7 @@ void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
 	// Output as HEX
 	char output[4];
 	int j = 0;
-	char* ascii = new char[cols+1];
+	auto ascii = new char[cols + 1];
 	memset(ascii, 0, cols+1);
 	uint32 i;
 	for(i=skip; i<size; i++)
@@ -100,7 +100,7 @@ std::string DumpPacketHexToString(const uchar* buf, uint32 size, uint32 cols, ui
 	// Output as HEX
 	char output[4];
 	int j = 0;
-	char* ascii = new char[cols + 1];
+	auto ascii = new char[cols + 1];
 	memset(ascii, 0, cols + 1);
 	uint32 i;
 	for (i = skip; i < size; i++)

common/packet_dump_file.cpp

@@ -94,7 +94,9 @@ void FileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, uint
 	std::ofstream logfile(filename, std::ios::app);
 	// Output as HEX
 	char output[4];
-	int j = 0; char* ascii = new char[cols+1]; memset(ascii, 0, cols+1);
+	int j = 0;
+	auto ascii = new char[cols + 1];
+	memset(ascii, 0, cols + 1);
 	uint32 i;
 	for(i=skip; i<size; i++)
 	{

common/packetfile.cpp

@@ -0,0 +1,438 @@
+#ifndef WIN32
+#include <unistd.h>
+#else
+#include <winsock2.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <time.h>
+#include "packetfile.h"
+#include "../common/eq_opcodes.h"
+#include "../common/eq_packet_structs.h"
+#include "../common/misc.h"
+#include <map>
+
+PacketFileWriter::PacketFileWriter(bool _force_flush) {
+	out = NULL;
+	force_flush = _force_flush;
+}
+
+PacketFileWriter::~PacketFileWriter() {
+	CloseFile();
+}
+
+bool PacketFileWriter::SetPacketStamp(const char *name, uint32 stamp) {
+	FILE *in;
+	in = fopen(name, "r+b");
+	if(in == NULL) {
+		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
+		return(false);
+	}
+
+	unsigned long magic = 0;
+
+	if(fread(&magic, sizeof(magic), 1, in) != 1) {
+		fprintf(stderr, "Error reading header from packet file: %s\n", strerror(errno));
+		fclose(in);
+		return(false);
+	}
+
+	PacketFileReader *ret = NULL;
+	if(magic == OLD_PACKET_FILE_MAGIC) {
+		OldPacketFileHeader *pos = 0;
+		uint32 stamp_pos = (uint32) &pos->packet_file_stamp;
+		fseek(in, stamp_pos, SEEK_SET);
+		OldPacketFileHeader hdr;
+		hdr.packet_file_stamp = stamp;
+		if(fwrite(&hdr.packet_file_stamp, sizeof(hdr.packet_file_stamp), 1, in) != 1) {
+			fprintf(stderr, "Error writting to packet file: %s\n", strerror(errno));
+			fclose(in);
+			return(false);
+		}
+	} else if(magic == PACKET_FILE_MAGIC) {
+		PacketFileHeader *pos = 0;
+		uint32 stamp_pos = (uint32) &pos->packet_file_stamp;
+		fseek(in, stamp_pos, SEEK_SET);
+		PacketFileHeader hdr;
+		hdr.packet_file_stamp = stamp;
+		if(fwrite(&hdr.packet_file_stamp, sizeof(hdr.packet_file_stamp), 1, in) != 1) {
+			fprintf(stderr, "Error writting to packet file: %s\n", strerror(errno));
+			fclose(in);
+			return(false);
+		}
+	} else {
+		fprintf(stderr, "Unknown packet file type 0x%.8x\n", magic);
+		fclose(in);
+		return(false);
+	}
+
+	fclose(in);
+	return(true);
+}
+
+bool PacketFileWriter::OpenFile(const char *name) {
+	CloseFile();
+
+	printf("Opening packet file: %s\n", name);
+
+	out = fopen(name, "wb");
+	if(out == NULL) {
+		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
+		return(false);
+	}
+
+	PacketFileHeader head;
+	head.packet_file_magic = PACKET_FILE_MAGIC;
+	head.packet_file_version = PACKET_FILE_CURRENT_VERSION;
+	head.packet_file_stamp = time(NULL);
+
+	if(fwrite(&head, sizeof(head), 1, out) != 1) {
+		fprintf(stderr, "Error writting header to packet file: %s\n", strerror(errno));
+		fclose(out);
+		return(false);
+	}
+
+	return(true);
+}
+
+void PacketFileWriter::CloseFile() {
+	if(out != NULL) {
+		fclose(out);
+		out = NULL;
+		printf("Closed packet file.\n");
+	}
+}
+
+void PacketFileWriter::WritePacket(uint16 eq_op, uint32 packlen, const unsigned char *packet, bool to_server, const struct timeval &tv) {
+	if(out == NULL)
+		return;
+
+	_WriteBlock(eq_op, packet, packlen, to_server, tv);
+
+/*
+	Could log only the packets we care about, but this is most of the stream,
+	so just log them all...
+
+	switch(eq_op) {
+	case OP_NewZone:
+	case OP_ZoneSpawns:
+	case OP_NewSpawn:
+	case OP_MobUpdate:
+	case OP_ClientUpdate:
+	case OP_Death:
+	case OP_DeleteSpawn:
+	case OP_CastSpell:
+	case OP_ShopRequest:
+	case OP_ShopEndConfirm:
+	case OP_ItemPacket:
+		_WriteBlock(eq_op, packet, packlen);
+	default:
+		return;
+	}
+	*/
+}
+
+bool PacketFileWriter::_WriteBlock(uint16 eq_op, const void *d, uint16 len, bool to_server, const struct timeval &tv) {
+	if(out == NULL)
+		return(false);
+
+	PacketFileSection s;
+	s.opcode = eq_op;
+	s.len = len;
+	s.tv_sec = tv.tv_sec;
+	s.tv_msec = tv.tv_usec/1000;
+
+	if(to_server)
+		SetToServer(s);
+	else
+		SetToClient(s);
+
+	if(fwrite(&s, sizeof(s), 1, out) != 1) {
+		fprintf(stderr, "Error writting block header: %s\n", strerror(errno));
+		return(false);
+	}
+
+	if(fwrite(d, 1, len, out) != len) {
+		fprintf(stderr, "Error writting block body: %s\n", strerror(errno));
+		return(false);
+	}
+
+	if(force_flush)
+		fflush(out);
+
+	return(true);
+}
+
+
+
+
+
+
+PacketFileReader *PacketFileReader::OpenPacketFile(const char *name) {
+	FILE *in;
+	in = fopen(name, "rb");
+	if(in == NULL) {
+		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
+		return(NULL);
+	}
+
+	unsigned long magic = 0;
+
+	if(fread(&magic, sizeof(magic), 1, in) != 1) {
+		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
+		fclose(in);
+		return(NULL);
+	}
+
+	PacketFileReader *ret = NULL;
+	if(magic == OLD_PACKET_FILE_MAGIC) {
+		ret = new OldPacketFileReader();
+	} else if(magic == PACKET_FILE_MAGIC) {
+		ret = new NewPacketFileReader();
+	} else {
+		fprintf(stderr, "Unknown packet file type 0x%.8x\n", magic);
+		fclose(in);
+		return(NULL);
+	}
+
+	if(!ret->OpenFile(name)) {
+		safe_delete(ret);
+		return(NULL);
+	}
+
+	return(ret);
+}
+
+PacketFileReader::PacketFileReader() {
+	packet_file_stamp = 0;
+}
+
+OldPacketFileReader::OldPacketFileReader()
+: PacketFileReader()
+{
+	in = NULL;
+}
+
+OldPacketFileReader::~OldPacketFileReader() {
+	CloseFile();
+}
+
+bool OldPacketFileReader::OpenFile(const char *name) {
+	CloseFile();
+
+
+	in = fopen(name, "rb");
+	if(in == NULL) {
+		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
+		return(false);
+	}
+
+	OldPacketFileHeader head;
+
+	if(fread(&head, sizeof(head), 1, in) != 1) {
+		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
+		fclose(in);
+		return(false);
+	}
+
+	if(head.packet_file_magic != OLD_PACKET_FILE_MAGIC) {
+		fclose(in);
+		if(head.packet_file_magic > (OLD_PACKET_FILE_MAGIC)) {
+			fprintf(stderr, "Error: this is a build file, not a packet file, its allready processed!\n");
+		} else {
+			fprintf(stderr, "Error: this is not a packet file!\n");
+		}
+		return(false);
+	}
+
+	uint32 now = time(NULL);
+	if(head.packet_file_stamp > now) {
+		fprintf(stderr, "Error: invalid timestamp in file. Your clock or the collector's is wrong (%d sec ahead).\n", head.packet_file_stamp-now);
+		fclose(in);
+		return(false);
+	}
+
+	packet_file_stamp = head.packet_file_stamp;
+
+	return(true);
+}
+
+void OldPacketFileReader::CloseFile() {
+	if(in != NULL) {
+		fclose(in);
+		in = NULL;
+	}
+}
+
+bool OldPacketFileReader::ResetFile() {
+	if(in == NULL)
+		return(false);
+	rewind(in);
+
+	//gotta read past the header again
+	OldPacketFileHeader head;
+
+	if(fread(&head, sizeof(head), 1, in) != 1) {
+		return(false);
+	}
+
+	return(true);
+}
+
+bool OldPacketFileReader::ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) {
+	if(in == NULL)
+		return(false);
+	if(feof(in))
+		return(false);
+
+	OldPacketFileSection s;
+
+	if(fread(&s, sizeof(s), 1, in) != 1) {
+		if(!feof(in))
+			fprintf(stderr, "Error reading section header: %s\n", strerror(errno));
+		return(false);
+	}
+
+	eq_op = s.opcode;
+
+	if(packlen < s.len) {
+		fprintf(stderr, "Packet buffer is too small! %d < %d, skipping\n", packlen, s.len);
+		fseek(in, s.len, SEEK_CUR);
+		return(false);
+	}
+
+	if(fread(packet, 1, s.len, in) != s.len) {
+		if(feof(in))
+			fprintf(stderr, "Error: EOF encountered when expecting packet data.\n");
+		else
+			fprintf(stderr, "Error reading packet body: %s\n", strerror(errno));
+		return(false);
+	}
+
+	packlen = s.len;
+	to_server = false;
+	tv.tv_sec = 0;
+	tv.tv_usec = 0;
+
+	return(true);
+}
+
+
+NewPacketFileReader::NewPacketFileReader()
+: PacketFileReader()
+{
+	in = NULL;
+}
+
+NewPacketFileReader::~NewPacketFileReader() {
+	CloseFile();
+}
+
+bool NewPacketFileReader::OpenFile(const char *name) {
+	CloseFile();
+
+
+	in = fopen(name, "rb");
+	if(in == NULL) {
+		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
+		return(false);
+	}
+
+	PacketFileHeader head;
+
+	if(fread(&head, sizeof(head), 1, in) != 1) {
+		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
+		fclose(in);
+		return(false);
+	}
+
+	if(head.packet_file_magic != PACKET_FILE_MAGIC) {
+		fclose(in);
+		if(head.packet_file_magic == (PACKET_FILE_MAGIC+1)) {
+			fprintf(stderr, "Error: this is a build file, not a packet file, its allready processed!\n");
+		} else {
+			fprintf(stderr, "Error: this is not a packet file!\n");
+		}
+		return(false);
+	}
+
+	uint32 now = time(NULL);
+	if(head.packet_file_stamp > now) {
+		fprintf(stderr, "Error: invalid timestamp in file. Your clock or the collector's is wrong (%d sec ahead).\n", head.packet_file_stamp-now);
+		fclose(in);
+		return(false);
+	}
+
+	packet_file_stamp = head.packet_file_stamp;
+
+	return(true);
+}
+
+void NewPacketFileReader::CloseFile() {
+	if(in != NULL) {
+		fclose(in);
+		in = NULL;
+	}
+}
+
+bool NewPacketFileReader::ResetFile() {
+	if(in == NULL)
+		return(false);
+	rewind(in);
+
+	//gotta read past the header again
+	PacketFileHeader head;
+
+	if(fread(&head, sizeof(head), 1, in) != 1) {
+		return(false);
+	}
+
+	return(true);
+}
+
+bool NewPacketFileReader::ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) {
+	if(in == NULL)
+		return(false);
+	if(feof(in))
+		return(false);
+
+	PacketFileSection s;
+
+	if(fread(&s, sizeof(s), 1, in) != 1) {
+		if(!feof(in))
+			fprintf(stderr, "Error reading section header: %s\n", strerror(errno));
+		return(false);
+	}
+
+	eq_op = s.opcode;
+
+	if(packlen < s.len) {
+		fprintf(stderr, "Packet buffer is too small! %d < %d, skipping\n", packlen, s.len);
+		fseek(in, s.len, SEEK_CUR);
+		return(false);
+	}
+
+	if(fread(packet, 1, s.len, in) != s.len) {
+		if(feof(in))
+			fprintf(stderr, "Error: EOF encountered when expecting packet data.\n");
+		else
+			fprintf(stderr, "Error reading packet body: %s\n", strerror(errno));
+		return(false);
+	}
+
+	packlen = s.len;
+	to_server = IsToServer(s);
+	tv.tv_sec = s.tv_sec;
+	tv.tv_usec = 1000*s.tv_msec;
+
+	return(true);
+}
+
+
+
+
+
+
+
+

common/packetfile.h

@@ -0,0 +1,130 @@
+#ifndef PACKET_FILE_H
+#define PACKET_FILE_H
+
+#include "../common/types.h"
+#include <stdio.h>
+#include <time.h>
+//#include <zlib.h>
+
+//constants used in the packet file header
+#define PACKET_FILE_MAGIC 0x93a7b6f6
+#define OLD_PACKET_FILE_MAGIC 0x93a7b6f7
+
+#define PACKET_FILE_CURRENT_VERSION 1
+
+#pragma pack(1)
+//old structs from when I forgot to put the version number in
+struct OldPacketFileHeader {
+	uint32 packet_file_magic;
+	uint32 packet_file_stamp;
+};
+struct OldPacketFileSection {
+	uint16 opcode;
+	uint32 len;
+};
+
+struct PacketFileHeader {
+	uint32 packet_file_magic;
+	uint16 packet_file_version;
+	uint32 packet_file_stamp;
+};
+
+struct PacketFileSection {
+	uint16 opcode;
+	uint8 flags;	//mainly for client->server, but others could be added
+	uint32 tv_sec;
+	uint16 tv_msec;
+	uint32 len;
+};
+#pragma pack()
+
+#define TO_SERVER_FLAG 0x01
+#define SetToClient(pfs) pfs.flags = pfs.flags&~TO_SERVER_FLAG
+#define SetToServer(pfs) pfs.flags = pfs.flags|TO_SERVER_FLAG
+#define IsToClient(pfs) (pfs.flags&TO_SERVER_FLAG == 0)
+#define IsToServer(pfs) (pfs.flags&TO_SERVER_FLAG != 0)
+
+
+class PacketFileWriter {
+public:
+	PacketFileWriter(bool force_flush);
+	~PacketFileWriter();
+
+	bool OpenFile(const char *name);
+	void CloseFile();
+
+	void WritePacket(uint16 eq_op, uint32 packlen, const unsigned char *packet, bool to_server, const struct timeval &tv);
+
+	static bool SetPacketStamp(const char *file, uint32 stamp);
+
+protected:
+	bool _WriteBlock(uint16 eq_op, const void *d, uint16 len, bool to_server, const struct timeval &tv);
+
+	//gzFile out;
+	FILE *out;
+	bool force_flush;
+};
+
+
+class PacketFileReader {
+public:
+	PacketFileReader();
+
+	virtual bool OpenFile(const char *name) = 0;
+	virtual void CloseFile() = 0;
+	virtual bool ResetFile() = 0;	//aka rewind
+
+	virtual bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) = 0;
+
+	time_t GetStamp() { return(time_t(packet_file_stamp)); }
+
+	//factory method to open the right packet file.
+	static PacketFileReader *OpenPacketFile(const char *name);
+
+protected:
+
+	uint32 packet_file_stamp;
+};
+
+class OldPacketFileReader : public PacketFileReader {
+public:
+	OldPacketFileReader();
+	virtual ~OldPacketFileReader();
+
+	bool OpenFile(const char *name);
+	void CloseFile();
+	bool ResetFile();	//aka rewind
+
+	bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv);
+
+	time_t GetStamp() { return(time_t(packet_file_stamp)); }
+
+protected:
+
+	//gzFile in;
+	FILE *in;
+};
+
+class NewPacketFileReader: public PacketFileReader {
+public:
+	NewPacketFileReader();
+	virtual ~NewPacketFileReader();
+
+	bool OpenFile(const char *name);
+	void CloseFile();
+	bool ResetFile();	//aka rewind
+
+	bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv);
+
+	time_t GetStamp() { return(time_t(packet_file_stamp)); }
+
+protected:
+
+	//gzFile in;
+	FILE *in;
+};
+
+
+#endif
+
+

common/patches/deprecated_titanium_itemfields_a.h

@@ -0,0 +1,19 @@
+/*
+
+
+These fields must be in the order of how they are serialized!
+
+
+
+*/
+
+
+/* 000 */	//I(ItemClass) Leave this one off on purpose
+/* 001 */	S(Name)
+/* 002 */	S(Lore)
+/* 003 */	S(IDFile)
+/* 004 */	I(ID)
+
+/* 005 */	//I(Weight) handled manually
+
+// titanium_itemfields_b.h

common/patches/deprecated_titanium_itemfields_b.h

@@ -8,12 +8,10 @@ These fields must be in the order of how they are serialized!
 */
 
 
-/* 000 */	//I(ItemClass) Leave this one off on purpose
-/* 001 */	S(Name)
-/* 002 */	S(Lore)
-/* 003 */	S(IDFile)
-/* 004 */	I(ID)
-/* 005 */	I(Weight)
+// titanium_itemfields_a.h
+
+/* 005 */	//I(Weight) handled manually
+
 /* 006 */	I(NoRent)
 /* 007 */	I(NoDrop)
 /* 008 */	I(Size)
@@ -41,7 +39,7 @@ These fields must be in the order of how they are serialized!
 /* 030 */	I(AC)
 /* 031 */	I(Deity)
 /* 032 */	I(SkillModValue)
-/* 033 */	C("0")
+/* 033 */	I(SkillModMax)
 /* 034 */	I(SkillModType)
 /* 035 */	I(BaneDmgRace)
 /* 036 */	I(BaneDmgAmt)

common/patches/makepatch

@@ -5,7 +5,7 @@ if [ -z "$1" ]; then
 	exit 1
 fi
 
-for ext in .cpp .h _ops.h _constants.h _structs.h
+for ext in .cpp _limits.cpp .h _ops.h _limits.h _structs.h
 do
 	cp template$ext $1$ext
 	perl -pi -e "s/TEMPLATE/$1/g" $1$ext

common/patches/patches.cpp

@@ -1,3 +1,21 @@
+/*	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 "../global_define.h"
 #include "patches.h"
@@ -9,7 +27,9 @@
 #include "rof.h"
 #include "rof2.h"
 
-void RegisterAllPatches(EQStreamIdentifier &into) {
+
+void RegisterAllPatches(EQStreamIdentifier &into)
+{
 	Titanium::Register(into);
 	SoF::Register(into);
 	SoD::Register(into);
@@ -18,7 +38,8 @@ void RegisterAllPatches(EQStreamIdentifier &into) {
 	RoF2::Register(into);
 }
 
-void ReloadAllPatches() {
+void ReloadAllPatches()
+{
 	Titanium::Reload();
 	SoF::Reload();
 	SoD::Reload();

common/patches/patches.h

@@ -1,5 +1,25 @@
-#ifndef PATCHES_H_
-#define PATCHES_H_
+/*	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_PATCHES_H
+#define COMMON_PATCHES_H
+
 
 /*enum {
 	Patch_062,
@@ -12,4 +32,4 @@ class EQStreamIdentifier;
 void RegisterAllPatches(EQStreamIdentifier &into);
 void ReloadAllPatches();
 
-#endif /*PATCHES_H_*/
+#endif /*COMMON_PATCHES_H*/

common/patches/rof.h

@@ -1,11 +1,31 @@
-#ifndef ROF_H_
-#define ROF_H_
+/*	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_ROF_H
+#define COMMON_ROF_H
 
 #include "../struct_strategy.h"
 
 class EQStreamIdentifier;
 
-namespace RoF {
+namespace RoF
+{
 
 	//these are the only public member of this namespace.
 	extern void Register(EQStreamIdentifier &into);
@@ -23,13 +43,13 @@ namespace RoF {
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const ClientVersion GetClientVersion() const;
+		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof_ops.h"
 	};
 
-};
+}; /*RoF*/
 
-#endif /*ROF_H_*/
+#endif /*COMMON_ROF_H*/

common/patches/rof2.h

@@ -1,11 +1,31 @@
-#ifndef ROF2_H_
-#define ROF2_H_
+/*	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_ROF2_H
+#define COMMON_ROF2_H
 
 #include "../struct_strategy.h"
 
 class EQStreamIdentifier;
 
-namespace RoF2 {
+namespace RoF2
+{
 
 	//these are the only public member of this namespace.
 	extern void Register(EQStreamIdentifier &into);
@@ -23,13 +43,13 @@ namespace RoF2 {
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const ClientVersion GetClientVersion() const;
+		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof2_ops.h"
 	};
 
-};
+}; /*RoF2*/
 
-#endif /*ROF2_H_*/
+#endif /*COMMON_ROF2_H*/

common/patches/rof2_constants.h

@@ -1,219 +0,0 @@
-/*
-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 ROF2_CONSTANTS_H_
-#define ROF2_CONSTANTS_H_
-
-#include "../types.h"
-
-namespace RoF2 {
-	namespace maps {
-		typedef enum : 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
-		} InventoryMaps;
-	}
-
-	namespace slots {
-		typedef enum : int16 {
-			MainCharm = 0,
-			MainEar1,
-			MainHead,
-			MainFace,
-			MainEar2,
-			MainNeck,
-			MainShoulders,
-			MainArms,
-			MainBack,
-			MainWrist1,
-			MainWrist2,
-			MainRange,
-			MainHands,
-			MainPrimary,
-			MainSecondary,
-			MainFinger1,
-			MainFinger2,
-			MainChest,
-			MainLegs,
-			MainFeet,
-			MainWaist,
-			MainPowerSource,
-			MainAmmo,
-			MainGeneral1,
-			MainGeneral2,
-			MainGeneral3,
-			MainGeneral4,
-			MainGeneral5,
-			MainGeneral6,
-			MainGeneral7,
-			MainGeneral8,
-			MainGeneral9,
-			MainGeneral10,
-			MainCursor,
-			_MainCount,
-			_MainEquipmentBegin = MainCharm,
-			_MainEquipmentEnd = MainAmmo,
-			_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
-			_MainGeneralBegin = MainGeneral1,
-			_MainGeneralEnd = MainGeneral10,
-			_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
-		} EquipmentSlots;
-	}
-
-	namespace consts {
-		static const uint16	MAP_POSSESSIONS_SIZE = slots::_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 = 0; //?
-		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 = slots::_MainCount;
-		static const uint16 MAP_BAZAAR_SIZE = 200;
-		static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
-		static const uint16 MAP_REAL_ESTATE_SIZE = 0;
-		static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
-		static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
-		static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
-		static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
-		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 = NOT_USED;
-		static const uint16 MAP_OTHER_SIZE = 0;
-
-		// most of these definitions will go away with the structure-based system..this maintains compatibility for now
-		// (bag slots and main slots beyond Possessions are assigned for compatibility with current server coding)
-		static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
-		static const int16 EQUIPMENT_END = slots::MainAmmo;
-		static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
-
-		static const int16 GENERAL_BEGIN = slots::MainGeneral1;
-		static const int16 GENERAL_END = slots::MainGeneral10;
-		static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 99;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR = slots::MainCursor;
-		static const int16 CURSOR_BAG_BEGIN = 351;
-		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 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-
-		static const int16 CORPSE_BEGIN = slots::MainGeneral1;
-		static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
-
-		static const uint16 ITEM_COMMON_SIZE = 6;
-		static const uint16 ITEM_CONTAINER_SIZE = 255; // 255; (server max will be 255..unsure what actual client is - test)
-
-		static const uint32 BANDOLIERS_COUNT = 20;	// count = number of bandolier instances
-		static const uint32 BANDOLIER_SIZE = 4;		// size = number of equipment slots in bandolier instance
-		static const uint32 POTION_BELT_SIZE = 5;
-
-		static const size_t TEXT_LINK_BODY_LENGTH = 56;
-	}
-
-	namespace limits {
-		static const bool ALLOWS_EMPTY_BAG_IN_BAG = true;
-		static const bool ALLOWS_CLICK_CAST_FROM_BAG = true;
-		static const bool COIN_HAS_WEIGHT = false;
-	}
-
-};	//end namespace RoF2
-
-#endif /*ROF2_CONSTANTS_H_*/
-
-/*
-RoF2 Notes:
-	** Structure-based inventory **
-ok	Possessions: ( 0, { 0 .. 33 }, -1, -1 ) (Corpse: { 23 .. 56 } [Offset 23])
-ok		[Equipment: ( 0, { 0 .. 22 }, -1, -1 )]
-ok		[General: ( 0, { 23 .. 32 }, -1, -1 )]
-ok		[Cursor: ( 0, 33, -1, -1 )]
-	General Bags: ( 0, { 23 .. 32 }, { 0 .. (maxsize - 1) }, -1 )
-	Cursor Bags: ( 0, 33, { 0 .. (maxsize - 1) }, -1 )
-
-	Bank: ( 1, { 0 .. 23 }, -1, -1 )
-	Bank Bags: ( 1, { 0 .. 23 }, { 0 .. (maxsize - 1)}, -1 )
-
-	Shared Bank: ( 2, { 0 .. 1 }, -1, -1 )
-	Shared Bank Bags: ( 2, { 0 .. 1 }, { 0 .. (maxsize - 1) }, -1 )
-
-	Trade: ( 3, { 0 .. 8 }, -1, -1 )
-	(Trade Bags: 3031 - 3110 -- server values)
-
-	World: ( 4, { 0 .. 10 }, -1, -1 )
-
-*/

common/patches/rof2_limits.cpp

@@ -0,0 +1,266 @@
+/*	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 "rof2_limits.h"
+
+#include "../string_util.h"
+
+
+size_t RoF2::invtype::InvTypeSize(int inv_type)
+{
+	switch (inv_type) {
+	case invtype::InvTypePossessions:
+		return invtype::InvTypePossessionsSize;
+	case invtype::InvTypeBank:
+		return invtype::InvTypeBankSize;
+	case invtype::InvTypeSharedBank:
+		return invtype::InvTypeSharedBankSize;
+	case invtype::InvTypeTrade:
+		return invtype::InvTypeTradeSize;
+	case invtype::InvTypeWorld:
+		return invtype::InvTypeWorldSize;
+	case invtype::InvTypeLimbo:
+		return invtype::InvTypeLimboSize;
+	case invtype::InvTypeTribute:
+		return invtype::InvTypeTributeSize;
+	case invtype::InvTypeTrophyTribute:
+		return invtype::InvTypeTrophyTributeSize;
+	case invtype::InvTypeGuildTribute:
+		return invtype::InvTypeGuildTributeSize;
+	case invtype::InvTypeMerchant:
+		return invtype::InvTypeMerchantSize;
+	case invtype::InvTypeDeleted:
+		return invtype::InvTypeDeletedSize;
+	case invtype::InvTypeCorpse:
+		return invtype::InvTypeCorpseSize;
+	case invtype::InvTypeBazaar:
+		return invtype::InvTypeBazaarSize;
+	case invtype::InvTypeInspect:
+		return invtype::InvTypeInspectSize;
+	case invtype::InvTypeRealEstate:
+		return invtype::InvTypeRealEstateSize;
+	case invtype::InvTypeViewMODPC:
+		return invtype::InvTypeViewMODPCSize;
+	case invtype::InvTypeViewMODBank:
+		return invtype::InvTypeViewMODBankSize;
+	case invtype::InvTypeViewMODSharedBank:
+		return invtype::InvTypeViewMODSharedBankSize;
+	case invtype::InvTypeViewMODLimbo:
+		return invtype::InvTypeViewMODLimboSize;
+	case invtype::InvTypeAltStorage:
+		return invtype::InvTypeAltStorageSize;
+	case invtype::InvTypeArchived:
+		return invtype::InvTypeArchivedSize;
+	case invtype::InvTypeMail:
+		return invtype::InvTypeMailSize;
+	case invtype::InvTypeGuildTrophyTribute:
+		return invtype::InvTypeGuildTrophyTributeSize;
+	case invtype::InvTypeKrono:
+		return invtype::InvTypeKronoSize;
+	case invtype::InvTypeOther:
+		return invtype::InvTypeOtherSize;
+	default:
+		return 0;
+	}
+}
+
+const char* RoF2::invtype::InvTypeName(int inv_type)
+{
+	switch (inv_type) {
+	case invtype::InvTypeInvalid:
+		return "Invalid Type";
+	case invtype::InvTypePossessions:
+		return "Possessions";
+	case invtype::InvTypeBank:
+		return "Bank";
+	case invtype::InvTypeSharedBank:
+		return "Shared Bank";
+	case invtype::InvTypeTrade:
+		return "Trade";
+	case invtype::InvTypeWorld:
+		return "World";
+	case invtype::InvTypeLimbo:
+		return "Limbo";
+	case invtype::InvTypeTribute:
+		return "Tribute";
+	case invtype::InvTypeTrophyTribute:
+		return "Trophy Tribute";
+	case invtype::InvTypeGuildTribute:
+		return "Guild Tribute";
+	case invtype::InvTypeMerchant:
+		return "Merchant";
+	case invtype::InvTypeDeleted:
+		return "Deleted";
+	case invtype::InvTypeCorpse:
+		return "Corpse";
+	case invtype::InvTypeBazaar:
+		return "Bazaar";
+	case invtype::InvTypeInspect:
+		return "Inspect";
+	case invtype::InvTypeRealEstate:
+		return "Real Estate";
+	case invtype::InvTypeViewMODPC:
+		return "View MOD PC";
+	case invtype::InvTypeViewMODBank:
+		return "View MOD Bank";
+	case invtype::InvTypeViewMODSharedBank:
+		return "View MOD Shared Bank";
+	case invtype::InvTypeViewMODLimbo:
+		return "View MOD Limbo";
+	case invtype::InvTypeAltStorage:
+		return "Alt Storage";
+	case invtype::InvTypeArchived:
+		return "Archived";
+	case invtype::InvTypeMail:
+		return "Mail";
+	case invtype::InvTypeGuildTrophyTribute:
+		return "Guild Trophy Tribute";
+	case invtype::InvTypeKrono:
+		return "Krono";
+	case invtype::InvTypeOther:
+		return "Other";
+	default:
+		return "Unknown Type";
+	}
+}
+
+const char* RoF2::invslot::InvPossessionsSlotName(int inv_slot)
+{
+	switch (inv_slot) {
+	case invslot::InvSlotInvalid:
+		return "Invalid Slot";
+	case invslot::PossessionsCharm:
+		return "Charm";
+	case invslot::PossessionsEar1:
+		return "Ear 1";
+	case invslot::PossessionsHead:
+		return "Head";
+	case invslot::PossessionsFace:
+		return "Face";
+	case invslot::PossessionsEar2:
+		return "Ear 2";
+	case invslot::PossessionsNeck:
+		return "Neck";
+	case invslot::PossessionsShoulders:
+		return "Shoulders";
+	case invslot::PossessionsArms:
+		return "Arms";
+	case invslot::PossessionsBack:
+		return "Back";
+	case invslot::PossessionsWrist1:
+		return "Wrist 1";
+	case invslot::PossessionsWrist2:
+		return "Wrist 2";
+	case invslot::PossessionsRange:
+		return "Range";
+	case invslot::PossessionsHands:
+		return "Hands";
+	case invslot::PossessionsPrimary:
+		return "Primary";
+	case invslot::PossessionsSecondary:
+		return "Secondary";
+	case invslot::PossessionsFinger1:
+		return "Finger 1";
+	case invslot::PossessionsFinger2:
+		return "Finger 2";
+	case invslot::PossessionsChest:
+		return "Chest";
+	case invslot::PossessionsLegs:
+		return "Legs";
+	case invslot::PossessionsFeet:
+		return "Feet";
+	case invslot::PossessionsWaist:
+		return "Waist";
+	case invslot::PossessionsPowerSource:
+		return "Power Source";
+	case invslot::PossessionsAmmo:
+		return "Ammo";
+	case invslot::PossessionsGeneral1:
+		return "General 1";
+	case invslot::PossessionsGeneral2:
+		return "General 2";
+	case invslot::PossessionsGeneral3:
+		return "General 3";
+	case invslot::PossessionsGeneral4:
+		return "General 4";
+	case invslot::PossessionsGeneral5:
+		return "General 5";
+	case invslot::PossessionsGeneral6:
+		return "General 6";
+	case invslot::PossessionsGeneral7:
+		return "General 7";
+	case invslot::PossessionsGeneral8:
+		return "General 8";
+	case invslot::PossessionsGeneral9:
+		return "General 9";
+	case invslot::PossessionsGeneral10:
+		return "General 10";
+	case invslot::PossessionsCursor:
+		return "Cursor";
+	default:
+		return "Unknown Slot";
+	}
+}
+
+const char* RoF2::invslot::InvSlotName(int inv_type, int inv_slot)
+{
+	if (inv_type == invtype::InvTypePossessions)
+		return invslot::InvPossessionsSlotName(inv_slot);
+
+	size_t type_size = invtype::InvTypeSize(inv_type);
+
+	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+		return "Invalid Slot";
+
+	if ((size_t)(inv_slot + 1) >= type_size)
+		return "Unknown Slot";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Slot %i", (inv_slot + 1));
+
+	return ret_str.c_str();
+}
+
+const char* RoF2::invbag::InvBagIndexName(int bag_index)
+{
+	if (bag_index == invbag::InvBagInvalid)
+		return "Invalid Bag";
+
+	if ((size_t)bag_index >= invbag::ItemBagSize)
+		return "Unknown Bag";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Bag %i", (bag_index + 1));
+
+	return ret_str.c_str();
+}
+
+const char* RoF2::invaug::InvAugIndexName(int aug_index)
+{
+	if (aug_index == invaug::InvAugInvalid)
+		return "Invalid Augment";
+
+	if ((size_t)aug_index >= invaug::ItemAugSize)
+		return "Unknown Augment";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Augment %i", (aug_index + 1));
+
+	return ret_str.c_str();
+}

common/patches/rof2_limits.h

@@ -0,0 +1,285 @@
+/*	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_ROF2_LIMITS_H
+#define COMMON_ROF2_LIMITS_H
+
+#include "../types.h"
+#include "../client_version.h"
+#include "../skills.h"
+
+
+namespace RoF2
+{
+	enum : int { Invalid = -1, Null, Safety };
+
+	enum : bool { False = false, True = true };
+
+	// pre-declarations
+	namespace invtype {
+		inline EQEmu::versions::ClientVersion InvTypeRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+
+		enum InventoryType : int {
+			InvTypePossessions = InvTypeBegin,
+			InvTypeBank,
+			InvTypeSharedBank,
+			InvTypeTrade,
+			InvTypeWorld,
+			InvTypeLimbo,
+			InvTypeTribute,
+			InvTypeTrophyTribute,
+			InvTypeGuildTribute,
+			InvTypeMerchant,
+			InvTypeDeleted,
+			InvTypeCorpse,
+			InvTypeBazaar,
+			InvTypeInspect,
+			InvTypeRealEstate,
+			InvTypeViewMODPC,
+			InvTypeViewMODBank,
+			InvTypeViewMODSharedBank,
+			InvTypeViewMODLimbo,
+			InvTypeAltStorage,
+			InvTypeArchived,
+			InvTypeMail,
+			InvTypeGuildTrophyTribute,
+			InvTypeKrono,
+			InvTypeOther,
+			InvTypeCount
+		};
+
+	} /*invtype*/
+
+	namespace invslot {
+		inline EQEmu::versions::ClientVersion InvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+
+		enum PossessionsSlot : int {
+			PossessionsCharm = InvSlotBegin,
+			PossessionsEar1,
+			PossessionsHead,
+			PossessionsFace,
+			PossessionsEar2,
+			PossessionsNeck,
+			PossessionsShoulders,
+			PossessionsArms,
+			PossessionsBack,
+			PossessionsWrist1,
+			PossessionsWrist2,
+			PossessionsRange,
+			PossessionsHands,
+			PossessionsPrimary,
+			PossessionsSecondary,
+			PossessionsFinger1,
+			PossessionsFinger2,
+			PossessionsChest,
+			PossessionsLegs,
+			PossessionsFeet,
+			PossessionsWaist,
+			PossessionsPowerSource,
+			PossessionsAmmo,
+			PossessionsGeneral1,
+			PossessionsGeneral2,
+			PossessionsGeneral3,
+			PossessionsGeneral4,
+			PossessionsGeneral5,
+			PossessionsGeneral6,
+			PossessionsGeneral7,
+			PossessionsGeneral8,
+			PossessionsGeneral9,
+			PossessionsGeneral10,
+			PossessionsCursor,
+			PossessionsCount
+		};
+
+		const int EquipmentBegin = PossessionsCharm;
+		const int EquipmentEnd = PossessionsAmmo;
+		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+
+		const int GeneralBegin = PossessionsGeneral1;
+		const int GeneralEnd = PossessionsGeneral10;
+		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+	} /*invslot*/
+
+	namespace invbag {
+		inline EQEmu::versions::ClientVersion InvBagRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvBagInvalid = -1, InvBagBegin };
+
+	} /*invbag*/
+
+	namespace invaug {
+		inline EQEmu::versions::ClientVersion InvAugRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvAugInvalid = -1, InvAugBegin };
+
+	} /*invaug*/
+
+	namespace item {
+		inline EQEmu::versions::ClientVersion ItemRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		//enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF-
+		//	Unknown1 = 0,
+		//	Unknown2 = 1,
+		//	Unknown3 = 2,
+		//	Unknown4 = 5 // krono?
+		//};
+
+		enum ItemPacketType : int {
+			ItemPacketMerchant = 100,
+			ItemPacketTradeView = 101,
+			ItemPacketLoot = 102,
+			ItemPacketTrade = 103,
+			ItemPacketCharInventory = 105,
+			ItemPacketLimbo = 106,
+			ItemPacketWorldContainer = 107,
+			ItemPacketTributeItem = 108,
+			ItemPacketGuildTribute = 109,
+			ItemPacket10 = 110,
+			ItemPacket11 = 111,
+			ItemPacket12 = 112,
+			ItemPacketRecovery = 113,
+			ItemPacket14 = 115
+		};
+
+	} /*item*/
+
+	namespace profile {
+		inline EQEmu::versions::ClientVersion ProfileRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*profile*/
+
+	namespace constants {
+		inline EQEmu::versions::ClientVersion ConstantsRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*constants*/
+
+	namespace behavior {
+		inline EQEmu::versions::ClientVersion BehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*behavior*/
+
+	namespace skills {
+		inline EQEmu::versions::ClientVersion SkillsRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*skills*/
+
+
+	// declarations
+	namespace invtype {
+		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
+		const size_t InvTypeBankSize = 24;
+		const size_t InvTypeSharedBankSize = 2;
+		const size_t InvTypeTradeSize = 8;
+		const size_t InvTypeWorldSize = 10;
+		const size_t InvTypeLimboSize = 36;
+		const size_t InvTypeTributeSize = 5;
+		const size_t InvTypeTrophyTributeSize = 0;//unknown
+		const size_t InvTypeGuildTributeSize = 0;//unknown
+		const size_t InvTypeMerchantSize = 200;
+		const size_t InvTypeDeletedSize = 0;//unknown - "Recovery Tab"
+		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
+		const size_t InvTypeBazaarSize = 200;
+		const size_t InvTypeInspectSize = invslot::EquipmentCount;
+		const size_t InvTypeRealEstateSize = 0;//unknown
+		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
+		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
+		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
+		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
+		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
+		const size_t InvTypeArchivedSize = 0;//unknown
+		const size_t InvTypeMailSize = 0;//unknown
+		const size_t InvTypeGuildTrophyTributeSize = 0;//unknown
+		const size_t InvTypeKronoSize = 0;//unknown
+		const size_t InvTypeOtherSize = 0;//unknown
+
+		const size_t NPCTradeSize = 4;
+
+		extern size_t InvTypeSize(int inv_type);
+		extern const char* InvTypeName(int inv_type);
+
+	} /*invtype*/
+
+	namespace invslot {
+		extern const char* InvPossessionsSlotName(int inv_slot);
+		extern const char* InvSlotName(int inv_type, int inv_slot);
+
+	} /*invslot*/
+
+	namespace invbag {
+		const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
+
+		extern const char* InvBagIndexName(int bag_index);
+
+	} /*invbag*/
+
+	namespace invaug {
+		const size_t ItemAugSize = 6;
+
+		extern const char* InvAugIndexName(int aug_index);
+
+	} /*invaug*/
+
+	namespace item {
+
+	} /*item*/
+
+	namespace profile {
+		const size_t TributeSize = invtype::InvTypeTributeSize;
+
+		const size_t BandoliersSize = 20;		// number of bandolier instances
+		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
+
+		const size_t PotionBeltSize = 5;
+
+		const size_t SkillArraySize = 100;
+
+	} /*profile*/
+
+	namespace constants {
+		const size_t CharacterCreationLimit = 12;
+
+		const size_t SayLinkBodySize = 56;
+
+	} /*constants*/
+
+	namespace behavior {
+		const bool ConcatenateInvTypeLimbo = false;
+
+		const bool AllowOverLevelEquipment = true;
+
+		const bool AllowEmptyBagInBag = true;
+		const bool AllowClickCastFromBag = true;
+
+		const bool CoinHasWeight = false;
+
+	} /*behavior*/
+
+	namespace skills {
+		const size_t LastUsableSkill = EQEmu::skills::Skill2HPiercing;
+
+	} /*skills*/
+
+}; /*RoF2*/
+
+#endif /*COMMON_ROF2_LIMITS_H*/

common/patches/rof2_ops.h

@@ -1,11 +1,35 @@
+/*	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
+*/
+
+
 // out-going packets that require an ENCODE translation:
 // Begin RoF2 Encodes
 
 E(OP_SendMembershipDetails)
+E(OP_TraderShop)
+E(OP_TraderDelItem)
 
 // incoming packets that require a DECODE translation:
 // Begin RoF2 Decodes
 
+D(OP_TraderShop)
+
 // End RoF2 Encodes/Decodes
 
 // These require Encodes/Decodes for RoF, so they do for RoF2 as well
@@ -53,6 +77,7 @@ E(OP_GroupFollow)
 E(OP_GroupFollow2)
 E(OP_GroupInvite)
 E(OP_GroupUpdate)
+E(OP_GuildBank)
 E(OP_GuildMemberList)
 E(OP_GuildMemberUpdate)
 E(OP_GuildsList)
@@ -107,6 +132,7 @@ E(OP_Trader)
 E(OP_TraderBuy)
 E(OP_TributeInfo)
 E(OP_TributeItem)
+E(OP_VetClaimReply)
 E(OP_VetRewardsAvaliable)
 E(OP_WearChange)
 E(OP_WhoAllResponse)
@@ -119,6 +145,7 @@ E(OP_ZoneSpawns)
 D(OP_AdventureMerchantSell)
 D(OP_AltCurrencySell)
 D(OP_AltCurrencySellSelection)
+D(OP_Animation)
 D(OP_ApplyPoison)
 D(OP_AugmentInfo)
 D(OP_AugmentItem)
@@ -146,6 +173,7 @@ D(OP_GroupFollow)
 D(OP_GroupFollow2)
 D(OP_GroupInvite)
 D(OP_GroupInvite2)
+D(OP_GuildBank)
 D(OP_GuildDemote)
 D(OP_GuildRemove)
 D(OP_GuildStatus)
@@ -170,6 +198,7 @@ D(OP_Trader)
 D(OP_TraderBuy)
 D(OP_TradeSkillCombine)
 D(OP_TributeItem)
+D(OP_VetClaimRequest)
 D(OP_WhoAllRequest)
 D(OP_ZoneChange)
 D(OP_ZoneEntry)