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

.gitignore

@@ -35,8 +35,3 @@ Build_64/
 build_64/
 log/
 logs/
-
-submodules/
-.idea/
-cmake-build-debug
-EQEmu.cbp

.travis.yml

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

CMakeLists.txt

@@ -30,8 +30,8 @@
 #EQEMU_BUILD_LUA
 #EQEMU_SANITIZE_LUA_LIBS
 #EQEMU_BUILD_CLIENT_FILES
-#EQEMU_USE_MAP_MMFS
 #EQEMU_MAP_DIR
+#EQEMU_ENABLE_PROFILING
 
 #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
 #Can change this if you really want but you should upgrade!
@@ -258,6 +258,7 @@ 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)
@@ -276,11 +277,6 @@ IF(EQEMU_BUILD_LUA)
 	ADD_DEFINITIONS(-DLUA_EQEMU)
 ENDIF(EQEMU_BUILD_LUA)
 
-OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-IF(EQEMU_USE_MAP_MMFS)
-	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-ENDIF(EQEMU_USE_MAP_MMFS)
-
 SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
 
 ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
@@ -337,6 +333,16 @@ 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)

README.md

@@ -1,59 +1,53 @@
-# EQEmulator Core Server
-|Travis CI (Linux)|Appveyor (Windows)   |
-|:---:|:---:| 
-|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Windows CI](https://ci.appveyor.com/api/projects/status/d0cvokm7u732v8vl/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server/branch/master)   |
+EQEmu
+===
 
-***
+[![Build Status](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)
 
-**EQEmulator is a custom completely from-scratch open source server implementation for EverQuest built mostly on C++**
- * MySQL/MariaDB is used as the database engine (over 200+ tables)
- * Perl and LUA are both supported scripting languages for NPC/Player/Quest oriented events
- * Open source database (Project EQ) has content up to expansion GoD (included in server installs)
-  * Game server environments and databases can be heavily customized to create all new experiences
- * Hundreds of Quests/events created and maintained by Project EQ
+Overview
+---
 
-## Server Installs
-||Windows|Linux|
-|:---:|:---:|:---:|
-|**Install Count**|![Windows Install Count](http://analytics.akkadius.com/?install_count&windows_count)|![Linux Install Count](http://analytics.akkadius.com/?install_count&linux_count)| 
-### > Windows 
-* [Easy Install](http://wiki.eqemulator.org/p?Akkas_PEQ_Server_Installer&frm=Main#from-scratch-installation-instructions-windows)
-* [Advanced Setup](http://wiki.eqemulator.org/p?Complete_Windows-based_Server_Setup_Guide)
+EQEmu is a custom server implementation for EverQuest
 
-### > Debian/Ubuntu
+Dependencies
+---
 
-> wget --no-check-certificate https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh -O install.sh && chmod 755 install.sh && ./install.sh
+For Windows: http://eqemu.github.io
 
-### > CentOS/Fedora
+Login Server dependencies for Windows/Linux/OSX: http://eqemu.github.io
 
-> curl -O https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh install.sh && chmod 755 install.sh && ./install.sh
+For Debian based distros (adjust to your local flavor):
 
-## Supported Clients
+- libmysqlclient-dev
+- libperl-dev
+- liblua5.1-0-dev (5.2 should work as well)
+- libboost-dev
 
-|Titanium Edition|Secrets of Faydwer|Seeds of Destruction|Underfoot|Rain of Fear|
-|:---:|:---:|:---:|:---:|:---:|
-|<img src="http://i.imgur.com/hrwDxoM.jpg" height="150">|<img src="http://i.imgur.com/cRDW5tn.png" height="150">|<img src="http://i.imgur.com/V48kuVn.jpg" height="150">|<img src="http://i.imgur.com/IJQ0XMa.jpg" height="150">|<img src="http://i.imgur.com/OMpHkKa.png" height="100">|
+Further instructions on building the source can be found on the
+[wiki](http://wiki.eqemulator.org/i?M=Wiki).
 
-## Bug Reports <img src="http://i.imgur.com/daf1Vjw.png" height="20">
-* Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
+Bug reports
+---
+
+Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
 reports or feature requests.
-* The [EQEmu Forums](http://www.eqemulator.org/forums/) are also a place to submit and get help with bugs.
 
-## Contributions <img src="http://image.flaticon.com/icons/png/512/25/25231.png" width="20">
+The [EQEmu Forums](http://www.eqemulator.org/forums/) also have forums to submit
+bugs/get help with bugs.
 
-* The preferred way to contribute is to fork the repo and submit a pull request on
+Contributions
+---
+
+The preferred way to contribute is to fork the repo and submit a pull request on
 GitHub. If you need help with your changes, you can always post on the forums or
-try Discord. You can also post unified diffs (`git diff` should do the trick) on the
+try IRC. You can also post unified diffs (`git diff` should do the trick) on the
 [Server Code Submissions](http://www.eqemulator.org/forums/forumdisplay.php?f=669)
 forum, although pull requests will be much quicker and easier on all parties.
 
-## Contact <img src="http://gamerescape.com/wp-content/uploads/2015/06/discord.png" height="20">
-
- - Discord Channel: https://discord.gg/QHsm7CD
- - **User Discord Channel**: `#general`
- - **Developer Discord Channel**: `#eqemucoders`
-
-Resources
+Contact
 ---
+ - **User IRC Channel**: `#eqemu` on `irc.eqemulator.net`
+ - **Developer IRC Channel**: `#eqemucoders` on `irc.eqemulator.net`
+
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
 - [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)
+

client_files/export/CMakeLists.txt

@@ -11,15 +11,17 @@ ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})
 
 INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(export_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(export_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
 ENDIF(MSVC)
 
 IF(MINGW)
 	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(export_client_files "rpcrt4")
 ENDIF(MINGW)
 
 IF(UNIX)
@@ -30,6 +32,7 @@ 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,7 +32,6 @@ 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);
@@ -45,12 +44,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *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;
@@ -63,7 +62,6 @@ int main(int argc, char **argv) {
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
-	ExportDBStrings(&database);
 
 	Log.CloseFileLogs();
 
@@ -196,38 +194,7 @@ void ExportBaseData(SharedDatabase *db) {
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	}
-
-	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());
-		}
+	} else {
 	}
 
 	fclose(f);

client_files/import/CMakeLists.txt

@@ -11,15 +11,17 @@ ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})
 
 INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
-TARGET_LINK_LIBRARIES(import_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
+TARGET_LINK_LIBRARIES(import_client_files common ${PERF_LIBS} debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
 
 IF(MSVC)
 	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
 ENDIF(MSVC)
 
 IF(MINGW)
 	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
+	TARGET_LINK_LIBRARIES(import_client_files "rpcrt4")
 ENDIF(MINGW)
 
 IF(UNIX)
@@ -30,6 +32,7 @@ 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,7 +30,6 @@ 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);
@@ -43,12 +42,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *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;
@@ -60,7 +59,6 @@ int main(int argc, char **argv) {
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
-	ImportDBStrings(&database);
 
 	Log.CloseFileLogs();
 	
@@ -204,6 +202,7 @@ void ImportSkillCaps(SharedDatabase *db) {
 			continue;
 		}
 
+
 		int class_id, skill_id, level, cap;
 		class_id = atoi(split[0].c_str());
 		skill_id = atoi(split[1].c_str());
@@ -263,56 +262,3 @@ 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,12 +21,6 @@ IF(MYSQL_ROOT)
 		NAMES mysql.h
 		PATHS ${MYSQL_ROOT}/include
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
-	)
-	FIND_PATH(MySQL_INCLUDE_DIR
-		NAMES mysql.h
-		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
 	FIND_PATH(MySQL_INCLUDE_DIR
@@ -36,46 +30,49 @@ ELSE(MYSQL_ROOT)
 ENDIF(MYSQL_ROOT)
 
 # Library
-SET(MySQL_NAMES libmysql)
+SET(MySQL_NAMES mysqlclient_r mysqlclient)
 IF(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
 		NAMES ${MySQL_NAMES}
-		PATHS ${MYSQL_ROOT}/lib
+		PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
 	)
-	
-	FIND_LIBRARY(MySQL_LIBRARY
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
 		NAMES ${MySQL_NAMES}
+		PATHS ${MYSQL_ROOT}/lib /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY
-		NAMES ${MySQL_NAMES} mysqlclient_r mysqlclient
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
+		NAMES ${MySQL_NAMES}
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
+		NAMES ${MySQL_NAMES}
 		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ENDIF(MYSQL_ROOT)
 
-IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 	SET(MySQL_FOUND TRUE)
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY} )
-ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
+ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 	SET(MySQL_FOUND FALSE)
 	SET( MySQL_LIBRARIES )
-ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 
 
 # handle the QUIETLY and REQUIRED arguments and set MySQL_FOUND to TRUE if
 # all listed variables are TRUE
 INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY_DEBUG MySQL_LIBRARY_RELEASE MySQL_INCLUDE_DIR)
 
 IF(MySQL_FOUND)
-	SET( MySQL_LIBRARY_RELEASE ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARY_DEBUG ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_RELEASE} ${MySQL_LIBRARY_DEBUG} )
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
 ELSE(MySQL_FOUND)
 	SET( MySQL_LIBRARIES )
 ENDIF(MySQL_FOUND)

common/CMakeLists.txt

@@ -11,20 +11,15 @@ 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
-	emu_versions.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
@@ -35,21 +30,15 @@ SET(common_sources
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
-	inventory_profile.cpp
-	inventory_slot.cpp
 	ipc_mutex.cpp
-	item_data.cpp
-	item_instance.cpp
-	light_source.cpp
+	item.cpp
 	md5.cpp
-	memory_buffer.cpp
 	memory_mapped_file.cpp
 	misc.cpp
 	misc_functions.cpp
 	mutex.cpp
 	mysql_request_result.cpp
 	mysql_request_row.cpp
-	opcode_map.cpp
 	opcodemgr.cpp
 	packet_dump.cpp
 	packet_dump_file.cpp
@@ -59,9 +48,7 @@ SET(common_sources
 	proc_launcher.cpp
 	ptimer.cpp
 	races.cpp
-	rdtsc.cpp
 	rulesys.cpp
-	say_link.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -70,26 +57,20 @@ SET(common_sources
 	struct_strategy.cpp
 	tcp_connection.cpp
 	tcp_server.cpp
-	textures.cpp
 	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
@@ -122,15 +103,12 @@ SET(common_headers
 	database.h
 	dbcore.h
 	deity.h
-	emu_constants.h
-	emu_legacy.h
-	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
 	emu_tcp_connection.h
 	emu_tcp_server.h
-	emu_versions.h
 	eq_constants.h
+	eq_dictionary.h
 	eq_packet_structs.h
 	eqdb.h
 	eqdb_res.h
@@ -138,7 +116,6 @@ 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
@@ -157,19 +134,15 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
-	inventory_profile.h
-	inventory_slot.h
 	ipc_mutex.h
-	item_data.h
+	item.h
 	item_fieldlist.h
-	item_instance.h
+	item_struct.h
 	languages.h
-	light_source.h
 	linked_list.h
 	loottable.h
 	mail_oplist.h
 	md5.h
-	memory_buffer.h
 	memory_mapped_file.h
 	misc.h
 	misc_functions.h
@@ -184,15 +157,12 @@ SET(common_headers
 	packet_functions.h
 	platform.h
 	proc_launcher.h
-	profiler.h
 	ptimer.h
 	queue.h
 	races.h
 	random.h
-	rdtsc.h
 	rulesys.h
 	ruletypes.h
-	say_link.h
 	seperator.h
 	serverinfo.h
 	servertalk.h
@@ -204,42 +174,49 @@ SET(common_headers
 	tcp_basic_server.h
 	tcp_connection.h
 	tcp_server.h
-	textures.h
 	timeoutmgr.h
 	timer.h
 	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_limits.h
+	patches/sod_constants.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_limits.h
+	patches/sof_constants.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_limits.h
+	patches/rof_constants.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_limits.h
+	patches/rof2_constants.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_limits.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_limits.h
+	patches/uf_constants.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
 	patches/uf_structs.h
 	SocketLib/Base64.h
@@ -262,45 +239,46 @@ SET(common_headers
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-	patches/sod_limits.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
+	patches/sod_constants.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_limits.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
 	patches/sof_ops.h
+	patches/sof_constants.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_limits.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
+	patches/rof_constants.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_limits.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
+	patches/rof2_constants.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_limits.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
+	patches/titanium_constants.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_limits.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
+	patches/uf_constants.h
 	patches/uf_structs.h
 	patches/patches.cpp
 	patches/sod.cpp
-	patches/sod_limits.cpp
 	patches/sof.cpp
-	patches/sof_limits.cpp
 	patches/rof.cpp
-	patches/rof_limits.cpp
 	patches/rof2.cpp
-	patches/rof2_limits.cpp
 	patches/titanium.cpp
-	patches/titanium_limits.cpp
 	patches/uf.cpp
-	patches/uf_limits.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES

common/base_packet.h

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

common/classes.cpp

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -18,576 +18,275 @@
 #include "../common/global_define.h"
 #include "../common/classes.h"
 
-const char* GetClassIDName(uint8 class_id, uint8 level)
-{
-	switch (class_id) {
-	case WARRIOR:
-		if (level >= 70)
-			return "Vanquisher";
-		else if (level >= 65)
-			return "Overlord"; //Baron-Sprite: LEAVE MY CLASSES ALONE.
-		else if (level >= 60)
-			return "Warlord";
-		else if (level >= 55)
-			return "Myrmidon";
-		else if (level >= 51)
-			return "Champion";
-		else
-			return "Warrior";
-	case CLERIC:
-		if (level >= 70)
-			return "Prelate";
-		else if (level >= 65)
-			return "Archon";
-		else if (level >= 60)
-			return "High Priest";
-		else if (level >= 55)
-			return "Templar";
-		else if (level >= 51)
-			return "Vicar";
-		else
-			return "Cleric";
-	case PALADIN:
-		if (level >= 70)
-			return "Lord";
-		else if (level >= 65)
-			return "Lord Protector";
-		else if (level >= 60)
-			return "Crusader";
-		else if (level >= 55)
-			return "Knight";
-		else if (level >= 51)
-			return "Cavalier";
-		else
-			return "Paladin";
-	case RANGER:
-		if (level >= 70)
-			return "Plainswalker";
-		else if (level >= 65)
-			return "Forest Stalker";
-		else if (level >= 60)
-			return "Warder";
-		else if (level >= 55)
-			return "Outrider";
-		else if (level >= 51)
-			return "Pathfinder";
-		else
-			return "Ranger";
-	case SHADOWKNIGHT:
-		if (level >= 70)
-			return "Scourge Knight";
-		else if (level >= 65)
-			return "Dread Lord";
-		else if (level >= 60)
-			return "Grave Lord";
-		else if (level >= 55)
-			return "Revenant";
-		else if (level >= 51)
-			return "Reaver";
-		else
-			return "Shadowknight";
-	case DRUID:
-		if (level >= 70)
-			return "Natureguard";
-		else if (level >= 65)
-			return "Storm Warden";
-		else if (level >= 60)
-			return "Hierophant";
-		else if (level >= 55)
-			return "Preserver";
-		else if (level >= 51)
-			return "Wanderer";
-		else
-			return "Druid";
-	case MONK:
-		if (level >= 70)
-			return "Stone Fist";
-		else if (level >= 65)
-			return "Transcendent";
-		else if (level >= 60)
-			return "Grandmaster";
-		else if (level >= 55)
-			return "Master";
-		else if (level >= 51)
-			return "Disciple";
-		else
-			return "Monk";
-	case BARD:
-		if (level >= 70)
-			return "Performer";
-		else if (level >= 65)
-			return "Maestro";
-		else if (level >= 60)
-			return "Virtuoso";
-		else if (level >= 55)
-			return "Troubadour";
-		else if (level >= 51)
-			return "Minstrel";
-		else
-			return "Bard";
-	case ROGUE:
-		if (level >= 70)
-			return "Nemesis";
-		else if (level >= 65)
-			return "Deceiver";
-		else if (level >= 60)
-			return "Assassin";
-		else if (level >= 55)
-			return "Blackguard";
-		else if (level >= 51)
-			return "Rake";
-		else
-			return "Rogue";
-	case SHAMAN:
-		if (level >= 70)
-			return "Soothsayer";
-		else if (level >= 65)
-			return "Prophet";
-		else if (level >= 60)
-			return "Oracle";
-		else if (level >= 55)
-			return "Luminary";
-		else if (level >= 51)
-			return "Mystic";
-		else
-			return "Shaman";
-	case NECROMANCER:
-		if (level >= 70)
-			return "Wraith";
-		else if (level >= 65)
-			return "Arch Lich";
-		else if (level >= 60)
-			return "Warlock";
-		else if (level >= 55)
-			return "Defiler";
-		else if (level >= 51)
-			return "Heretic";
-		else
-			return "Necromancer";
-	case WIZARD:
-		if (level >= 70)
-			return "Grand Arcanist";
-		else if (level >= 65)
-			return "Arcanist";
-		else if (level >= 60)
-			return "Sorcerer";
-		else if (level >= 55)
-			return "Evoker";
-		else if (level >= 51)
-			return "Channeler";
-		else
-			return "Wizard";
-	case MAGICIAN:
-		if (level >= 70)
-			return "Arch Magus";
-		else if (level >= 65)
-			return "Arch Convoker";
-		else if (level >= 60)
-			return "Arch Mage";
-		else if (level >= 55)
-			return "Conjurer";
-		if (level >= 51)
-			return "Elementalist";
-		else
-			return "Magician";
-	case ENCHANTER:
-		if (level >= 70)
-			return "Bedazzler";
-		else if (level >= 65)
-			return "Coercer";
-		else if (level >= 60)
-			return "Phantasmist";
-		else if (level >= 55)
-			return "Beguiler";
-		else if (level >= 51)
-			return "Illusionist";
-		else
-			return "Enchanter";
-	case BEASTLORD:
-		if (level >= 70)
-			return "Wildblood";
-		else if (level >= 65)
-			return "Feral Lord";
-		else if (level >= 60)
-			return "Savage Lord";
-		else if (level >= 55)
-			return "Animist";
-		else if (level >= 51)
-			return "Primalist";
-		else
-			return "Beastlord";
-	case BERSERKER:
-		if (level >= 70)
-			return "Ravager";
-		else if (level >= 65)
-			return "Fury";
-		else if (level >= 60)
-			return "Rager";
-		else if (level >= 55)
-			return "Vehement";
-		else if (level >= 51)
-			return "Brawler";
-		else
-			return "Berserker";
-	case BANKER:
-		if (level >= 70)
-			return "Master Banker";
-		else if (level >= 65)
-			return "Elder Banker";
-		else if (level >= 60)
-			return "Oldest Banker";
-		else if (level >= 55)
-			return "Older Banker";
-		else if (level >= 51)
-			return "Old Banker";
-		else
-			return "Banker";
-	case WARRIORGM:
-		return "Warrior Guildmaster";
-	case CLERICGM:
-		return "Cleric Guildmaster";
-	case PALADINGM:
-		return "Paladin Guildmaster";
-	case RANGERGM:
-		return "Ranger Guildmaster";
-	case SHADOWKNIGHTGM:
-		return "Shadowknight Guildmaster";
-	case DRUIDGM:
-		return "Druid Guildmaster";
-	case MONKGM:
-		return "Monk Guildmaster";
-	case BARDGM:
-		return "Bard Guildmaster";
-	case ROGUEGM:
-		return "Rogue Guildmaster";
-	case SHAMANGM:
-		return "Shaman Guildmaster";
-	case NECROMANCERGM:
-		return "Necromancer Guildmaster";
-	case WIZARDGM:
-		return "Wizard Guildmaster";
-	case MAGICIANGM:
-		return "Magician Guildmaster";
-	case ENCHANTERGM:
-		return "Enchanter Guildmaster";
-	case BEASTLORDGM:
-		return "Beastlord Guildmaster";
-	case BERSERKERGM:
-		return "Berserker Guildmaster";
-	case MERCHANT:
-		return "Merchant";
-	case ADVENTURERECRUITER:
-		return "Adventure Recruiter";
-	case ADVENTUREMERCHANT:
-		return "Adventure Merchant";
-	case CORPSE_CLASS:
-		return "Corpse Class";
-	case TRIBUTE_MASTER:
-		return "Tribute Master";
-	case GUILD_TRIBUTE_MASTER:
-		return "Guild Tribute Master";
-	default:
-		return "Unknown";
+const char* GetEQClassName(uint8 class_, uint8 level) {
+	switch(class_) {
+		case WARRIOR:
+			if (level >= 70)
+				return "Vanquisher";
+			else if (level >= 65)
+				return "Overlord"; //Baron-Sprite: LEAVE MY CLASSES ALONE.
+			else if (level >= 60)
+				return "Warlord";
+			else if (level >= 55)
+				return "Myrmidon";
+			else if (level >= 51)
+				return "Champion";
+			else
+				return "Warrior";
+		case CLERIC:
+			if (level >= 70)
+				return "Prelate";
+			else if (level >= 65)
+				return "Archon";
+			else if (level >= 60)
+				return "High Priest";
+			else if (level >= 55)
+				return "Templar";
+			else if (level >= 51)
+				return "Vicar";
+			else
+				return "Cleric";
+		case PALADIN:
+			if (level >= 70)
+				return "Lord";
+			else if (level >= 65)
+				return "Lord Protector";
+			else if (level >= 60)
+				return "Crusader";
+			else if (level >= 55)
+				return "Knight";
+			else if (level >= 51)
+				return "Cavalier";
+			else
+				return "Paladin";
+		case RANGER:
+			if (level >= 70)
+				return "Plainswalker";
+			else if (level >= 65)
+				return "Forest Stalker";
+			else if (level >= 60)
+				return "Warder";
+			else if (level >= 55)
+				return "Outrider";
+			else if (level >= 51)
+				return "Pathfinder";
+			else
+				return "Ranger";
+		case SHADOWKNIGHT:
+			if (level >= 70)
+				return "Scourge Knight";
+			else if (level >= 65)
+				return "Dread Lord";
+			else if (level >= 60)
+				return "Grave Lord";
+			else if (level >= 55)
+				return "Revenant";
+			else if (level >= 51)
+				return "Reaver";
+			else
+				return "Shadowknight";
+		case DRUID:
+			if (level >= 70)
+				return "Natureguard";
+			else if (level >= 65)
+				return "Storm Warden";
+			else if (level >= 60)
+				return "Hierophant";
+			else if (level >= 55)
+				return "Preserver";
+			else if (level >= 51)
+				return "Wanderer";
+			else
+				return "Druid";
+		case MONK:
+			if (level >= 70)
+				return "Stone Fist";
+			else if (level >= 65)
+				return "Transcendent";
+			else if (level >= 60)
+				return "Grandmaster";
+			else if (level >= 55)
+				return "Master";
+			else if (level >= 51)
+				return "Disciple";
+			else
+				return "Monk";
+		case BARD:
+			if (level >= 70)
+				return "Performer";
+			else if (level >= 65)
+				return "Maestro";
+			else if (level >= 60)
+				return "Virtuoso";
+			else if (level >= 55)
+				return "Troubadour";
+			else if (level >= 51)
+				return "Minstrel";
+			else
+				return "Bard";
+		case ROGUE:
+			if (level >= 70)
+				return "Nemesis";
+			else if (level >= 65)
+				return "Deceiver";
+			else if (level >= 60)
+				return "Assassin";
+			else if (level >= 55)
+				return "Blackguard";
+			else if (level >= 51)
+				return "Rake";
+			else
+				return "Rogue";
+		case SHAMAN:
+			if (level >= 70)
+				return "Soothsayer";
+			else if (level >= 65)
+				return "Prophet";
+			else if (level >= 60)
+				return "Oracle";
+			else if (level >= 55)
+				return "Luminary";
+			else if (level >= 51)
+				return "Mystic";
+			else
+				return "Shaman";
+		case NECROMANCER:
+			if (level >= 70)
+				return "Wraith";
+			else if (level >= 65)
+				return "Arch Lich";
+			else if (level >= 60)
+				return "Warlock";
+			else if (level >= 55)
+				return "Defiler";
+			else if (level >= 51)
+				return "Heretic";
+			else
+				return "Necromancer";
+		case WIZARD:
+			if (level >= 70)
+				return "Grand Arcanist";
+			else if (level >= 65)
+				return "Arcanist";
+			else if (level >= 60)
+				return "Sorcerer";
+			else if (level >= 55)
+				return "Evoker";
+			else if (level >= 51)
+				return "Channeler";
+			else
+				return "Wizard";
+		case MAGICIAN:
+			if (level >= 70)
+				return "Arch Magus";
+			else if (level >= 65)
+				return "Arch Convoker";
+			else if (level >= 60)
+				return "Arch Mage";
+			else if (level >= 55)
+				return "Conjurer";
+			if (level >= 51)
+				return "Elementalist";
+			else
+				return "Magician";
+		case ENCHANTER:
+			if (level >= 70)
+				return "Bedazzler";
+			else if (level >= 65)
+				return "Coercer";
+			else if (level >= 60)
+				return "Phantasmist";
+			else if (level >= 55)
+				return "Beguiler";
+			else if (level >= 51)
+				return "Illusionist";
+			else
+				return "Enchanter";
+		case BEASTLORD:
+			if (level >= 70)
+				return "Wildblood";
+			else if (level >= 65)
+				return "Feral Lord";
+			else if (level >= 60)
+				return "Savage Lord";
+			else if (level >= 55)
+				return "Animist";
+			else if (level >= 51)
+				return "Primalist";
+			else
+				return "Beastlord";
+		case BERSERKER:
+			if (level >= 70)
+				return "Ravager";
+			else if (level >= 65)
+				return "Fury";
+			else if (level >= 60)
+				return "Rager";
+			else if (level >= 55)
+				return "Vehement";
+			else if (level >= 51)
+				return "Brawler";
+			else
+				return "Berserker";
+		case BANKER:
+			if (level >= 70)
+				return "Master Banker";
+			else if (level >= 65)
+				return "Elder Banker";
+			else if (level >= 60)
+				return "Oldest Banker";
+			else if (level >= 55)
+				return "Older Banker";
+			else if (level >= 51)
+				return "Old Banker";
+			else
+				return "Banker";
+		case WARRIORGM:
+			return "Warrior Guildmaster";
+		case CLERICGM:
+			return "Cleric Guildmaster";
+		case PALADINGM:
+			return "Paladin Guildmaster";
+		case RANGERGM:
+			return "Ranger Guildmaster";
+		case SHADOWKNIGHTGM:
+			return "Shadowknight Guildmaster";
+		case DRUIDGM:
+			return "Druid Guildmaster";
+		case MONKGM:
+			return "Monk Guildmaster";
+		case BARDGM:
+			return "Bard Guildmaster";
+		case ROGUEGM:
+			return "Rogue Guildmaster";
+		case SHAMANGM:
+			return "Shaman Guildmaster";
+		case NECROMANCERGM:
+			return "Necromancer Guildmaster";
+		case WIZARDGM:
+			return "Wizard Guildmaster";
+		case MAGICIANGM:
+			return "Magician Guildmaster";
+		case ENCHANTERGM:
+			return "Enchanter Guildmaster";
+		case BEASTLORDGM:
+			return "Beastlord Guildmaster";
+		case BERSERKERGM:
+			return "Berserker Guildmaster";
+		case MERCHANT:
+			return "Merchant";
+		case ADVENTURERECRUITER:
+			return "Adventure Recruiter";
+		case ADVENTUREMERCHANT:
+			return "Adventure Merchant";
+		case CORPSE_CLASS:
+			return "Corpse Class";
+		case TRIBUTE_MASTER:
+			return "Tribute Master";
+		case GUILD_TRIBUTE_MASTER:
+			return "Guild Tribute Master";
+		default:
+			return "Unknown";
 	}
 }
 
-const char* GetPlayerClassName(uint32 player_class_value, uint8 level)
-{
-	return GetClassIDName(GetClassIDFromPlayerClassValue(player_class_value), level);
-}
-
-uint32 GetPlayerClassValue(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case DRUID:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-	case BEASTLORD:
-	case BERSERKER:
-		return class_id;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-uint32 GetPlayerClassBit(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-		return PLAYER_CLASS_WARRIOR_BIT;
-	case CLERIC:
-		return PLAYER_CLASS_CLERIC_BIT;
-	case PALADIN:
-		return PLAYER_CLASS_PALADIN_BIT;
-	case RANGER:
-		return PLAYER_CLASS_RANGER_BIT;
-	case SHADOWKNIGHT:
-		return PLAYER_CLASS_SHADOWKNIGHT_BIT;
-	case DRUID:
-		return PLAYER_CLASS_DRUID_BIT;
-	case MONK:
-		return PLAYER_CLASS_MONK_BIT;
-	case BARD:
-		return PLAYER_CLASS_BARD_BIT;
-	case ROGUE:
-		return PLAYER_CLASS_ROGUE_BIT;
-	case SHAMAN:
-		return PLAYER_CLASS_SHAMAN_BIT;
-	case NECROMANCER:
-		return PLAYER_CLASS_NECROMANCER_BIT;
-	case WIZARD:
-		return PLAYER_CLASS_WIZARD_BIT;
-	case MAGICIAN:
-		return PLAYER_CLASS_MAGICIAN_BIT;
-	case ENCHANTER:
-		return PLAYER_CLASS_ENCHANTER_BIT;
-	case BEASTLORD:
-		return PLAYER_CLASS_BEASTLORD_BIT;
-	case BERSERKER:
-		return PLAYER_CLASS_BERSERKER_BIT;
-	default:
-		return PLAYER_CLASS_UNKNOWN_BIT;
-	}
-}
-
-uint8 GetClassIDFromPlayerClassValue(uint32 player_class_value)
-{
-	switch (player_class_value) {
-	case PLAYER_CLASS_WARRIOR:
-	case PLAYER_CLASS_CLERIC:
-	case PLAYER_CLASS_PALADIN:
-	case PLAYER_CLASS_RANGER:
-	case PLAYER_CLASS_SHADOWKNIGHT:
-	case PLAYER_CLASS_DRUID:
-	case PLAYER_CLASS_MONK:
-	case PLAYER_CLASS_BARD:
-	case PLAYER_CLASS_ROGUE:
-	case PLAYER_CLASS_SHAMAN:
-	case PLAYER_CLASS_NECROMANCER:
-	case PLAYER_CLASS_WIZARD:
-	case PLAYER_CLASS_MAGICIAN:
-	case PLAYER_CLASS_ENCHANTER:
-	case PLAYER_CLASS_BEASTLORD:
-	case PLAYER_CLASS_BERSERKER:
-		return player_class_value;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-uint8 GetClassIDFromPlayerClassBit(uint32 player_class_bit)
-{
-	switch (player_class_bit) {
-	case PLAYER_CLASS_WARRIOR_BIT:
-		return WARRIOR;
-	case PLAYER_CLASS_CLERIC_BIT:
-		return CLERIC;
-	case PLAYER_CLASS_PALADIN_BIT:
-		return PALADIN;
-	case PLAYER_CLASS_RANGER_BIT:
-		return RANGER;
-	case PLAYER_CLASS_SHADOWKNIGHT_BIT:
-		return SHADOWKNIGHT;
-	case PLAYER_CLASS_DRUID_BIT:
-		return DRUID;
-	case PLAYER_CLASS_MONK_BIT:
-		return MONK;
-	case PLAYER_CLASS_BARD_BIT:
-		return BARD;
-	case PLAYER_CLASS_ROGUE_BIT:
-		return ROGUE;
-	case PLAYER_CLASS_SHAMAN_BIT:
-		return SHAMAN;
-	case PLAYER_CLASS_NECROMANCER_BIT:
-		return NECROMANCER;
-	case PLAYER_CLASS_WIZARD_BIT:
-		return WIZARD;
-	case PLAYER_CLASS_MAGICIAN_BIT:
-		return MAGICIAN;
-	case PLAYER_CLASS_ENCHANTER_BIT:
-		return ENCHANTER;
-	case PLAYER_CLASS_BEASTLORD_BIT:
-		return BEASTLORD;
-	case PLAYER_CLASS_BERSERKER_BIT:
-		return BERSERKER;
-	default:
-		return PLAYER_CLASS_UNKNOWN; // watch
-	}
-}
-
-bool IsFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case BEASTLORD:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsSpellFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case PALADIN:
-	case RANGER:
-	case SHADOWKNIGHT:
-	case BEASTLORD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsNonSpellFighterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case MONK:
-	case BARD:
-	case ROGUE:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsINTCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsWISCasterClass(uint8 class_id)
-{
-	switch (class_id) {
-	case CLERIC:
-	case DRUID:
-	case SHAMAN:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsPlateClass(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case SHADOWKNIGHT:
-	case BARD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsChainClass(uint8 class_id)
-{
-	switch (class_id) {
-	case RANGER:
-	case ROGUE:
-	case SHAMAN:
-	case BERSERKER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsLeatherClass(uint8 class_id)
-{
-	switch (class_id) {
-	case DRUID:
-	case MONK:
-	case BEASTLORD:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool IsClothClass(uint8 class_id)
-{
-	switch (class_id) {
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return true;
-	default:
-		return false;
-	}
-}
-
-uint8 ClassArmorType(uint8 class_id)
-{
-	switch (class_id) {
-	case WARRIOR:
-	case CLERIC:
-	case PALADIN:
-	case SHADOWKNIGHT:
-	case BARD:
-		return ARMOR_TYPE_PLATE;
-	case RANGER:
-	case ROGUE:
-	case SHAMAN:
-	case BERSERKER:
-		return ARMOR_TYPE_CHAIN;
-	case DRUID:
-	case MONK:
-	case BEASTLORD:
-		return ARMOR_TYPE_LEATHER;
-	case NECROMANCER:
-	case WIZARD:
-	case MAGICIAN:
-	case ENCHANTER:
-		return ARMOR_TYPE_CLOTH;
-	default:
-		return ARMOR_TYPE_UNKNOWN;
-	}
-}

common/classes.h

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

common/clientversions.h

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

common/data_verification.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -14,42 +13,36 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
 #ifndef COMMON_DATA_VERIFICATION_H
 #define COMMON_DATA_VERIFICATION_H
 
 #include <algorithm>
 
-
 namespace EQEmu
 {
-	template <typename T>
-	T Clamp(const T& value, const T& lower, const T& upper) {
-		return std::max(lower, std::min(value, upper));
-	}
 
-	template <typename T>
-	T ClampLower(const T& value, const T& lower) {
-		return std::max(lower, value);
-	}
+template <typename T>
+T Clamp(const T& value, const T& lower, const T& upper) {
+	return std::max(lower, std::min(value, upper));
+}
 
-	template <typename T>
-	T ClampUpper(const T& value, const T& upper) {
-		return std::min(value, upper);
-	}
+template <typename T>
+T ClampLower(const T& value, const T& lower) {
+	return std::max(lower, value);
+}
 
-	template <typename T>
-	bool ValueWithin(const T& value, const T& lower, const T& upper) {
-		return value >= lower && value <= upper;
-	}
+template <typename T>
+T ClampUpper(const T& value, const T& upper) {
+	return std::min(value, upper);
+}
 
-	template <typename T1, typename T2, typename T3>
-	bool ValueWithin(const T1& value, const T2& lower, const T3& upper) {
-		return value >= (T1)lower && value <= (T1)upper;
-	}
+template <typename T>
+bool ValueWithin(const T& value, const T& lower, const T& upper) {
+	return value >= lower && value <= upper;
+}
 
-} /*EQEmu*/
+}
 
-#endif /*COMMON_DATA_VERIFICATION_H*/
+#endif

common/database.cpp

@@ -23,7 +23,6 @@
 #include <iomanip>
 #include <iostream>
 #include <map>
-#include <algorithm>
 #include <mysqld_error.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -49,6 +48,7 @@
 extern Client client;
 
 Database::Database () {
+	DBInitVars();
 }
 
 /*
@@ -57,10 +57,13 @@ 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)) {
@@ -73,12 +76,27 @@ 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);
+	}
 }
 
 /*
@@ -87,7 +105,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);
 
@@ -123,6 +141,7 @@ uint32 Database::CheckLogin(const char* name, const char* password, int16* oStat
 //Get Banned IP Address List - Only return false if the incoming connection's IP address is not present in the banned_ips table.
 bool Database::CheckBannedIPs(const char* loginIP)
 {
+	_eqp
 	std::string query = StringFormat("SELECT ip_address FROM Banned_IPs WHERE ip_address='%s'", loginIP);
 
 	auto results = QueryDatabase(query);
@@ -139,6 +158,7 @@ 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()) {
@@ -148,6 +168,7 @@ 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);
 
@@ -161,17 +182,20 @@ 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);
 
@@ -201,6 +225,7 @@ 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)
@@ -224,6 +249,7 @@ 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);
 
@@ -236,6 +262,7 @@ 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);
@@ -248,6 +275,7 @@ 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;
@@ -268,6 +296,7 @@ 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) {
@@ -288,6 +317,7 @@ 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)");
@@ -299,10 +329,7 @@ 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){ 
-		Log.Out(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
-		return false; 
-	}
+	if (charid <= 0){ std::cerr << "Database::DeleteCharacter :: Character not found, stopping delete...\n"; 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);
@@ -337,17 +364,18 @@ 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); // note: only use of GetMobTypeById()
-#else
+#ifdef BOTS																														 
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid);
+#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,"
@@ -625,25 +653,12 @@ 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, slot)"
+	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, is_home)"
 		" 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[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);
-
-        /* HoTT Ability */
-        if(RuleB(Character, GrantHoTTOnCreate))
-        {
-                query = StringFormat("INSERT INTO `character_leadership_abilities` (id, slot, rank) VALUES (%u, %i, %i)", character_id, 14, 1);
-                results = QueryDatabase(query);
-        }
+		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); 
 
 	/* Save Skills */
 	int firstquery = 0;
@@ -679,7 +694,8 @@ 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, EQEmu::InventoryProfile* inv) {
+bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv) {
+	_eqp
 	uint32 charid = 0; 
 	char zone[50]; 
 	float x, y, z; 
@@ -707,8 +723,8 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
-		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
+	for (int16 i=EmuConstants::EQUIPMENT_BEGIN; i<=EmuConstants::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)",
 				charid, i, newinv->GetItem()->ID, newinv->GetCharges(), newinv->GetColor()); 
@@ -716,16 +732,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == EQEmu::inventory::slotCursor) {
-			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
+		if (i == MainCursor) { 
+			i = EmuConstants::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
-			i = EQEmu::legacy::BANK_BEGIN; 
+		else if (i == EmuConstants::CURSOR_BAG_END) { 
+			i = EmuConstants::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EQEmu::legacy::BANK_END) { 
-			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
+		else if (i == EmuConstants::BANK_END) { 
+			i = EmuConstants::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -734,6 +750,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 }
 
 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();
@@ -750,6 +767,7 @@ 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);
@@ -774,6 +792,7 @@ 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()) {
@@ -788,6 +807,7 @@ uint32 Database::GetAccountIDByChar(uint32 char_id) {
 }
 
 uint32 Database::GetAccountIDByName(const char* accname, int16* status, uint32* lsid) {
+	_eqp
 	if (!isAlphaNumeric(accname))
 		return 0;
 
@@ -819,6 +839,7 @@ 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);
 
@@ -838,7 +859,8 @@ void Database::GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID
 
 }
 
-void Database::GetCharName(uint32 char_id, char* name) {
+void Database::GetCharName(uint32 char_id, char* name) { 
+	_eqp
 	std::string query = StringFormat("SELECT `name` FROM `character_data` WHERE id='%i'", char_id);
 	auto results = QueryDatabase(query);
 
@@ -853,75 +875,156 @@ void Database::GetCharName(uint32 char_id, char* name) {
 }
 
 bool Database::LoadVariables() {
-	auto results = QueryDatabase(StringFormat("SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache.last_update));
+	_eqp
+	char *query = nullptr;
+
+	auto results = QueryDatabase(query, LoadVariables_MQ(&query));
 
 	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;
 
-	LockMutex lock(&Mvarcache);
-
-	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);
+	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;
+	}
+
+	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;
+			}
+		}
+	}
+
+	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(std::string varname, std::string &varvalue)
-{
-	varvalue.clear();
+bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
+	_eqp
+	varvalue[0] = '\0';
 
 	LockMutex lock(&Mvarcache);
-
-	if (varname.empty())
+	if (strlen(varname) <= 1)
 		return false;
+	for (uint32 i=0; i<varcache_max; i++) {
 
-	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;
+		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;
 	}
 	return false;
 }
 
-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());
+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);
 	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')", escaped_name.c_str(), escaped_value.c_str());
+	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", varname, varvalue);
 	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);
 
@@ -934,7 +1037,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);
@@ -964,7 +1067,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);
 
@@ -1002,7 +1105,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);
 
@@ -1017,7 +1120,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);
 
@@ -1045,6 +1148,7 @@ 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);
@@ -1065,7 +1169,7 @@ bool Database::LoadZoneNames() {
 }
 
 uint32 Database::GetZoneID(const char* zonename) {
-
+	_eqp
 	if (zonename == nullptr)
 		return 0;
 
@@ -1077,6 +1181,7 @@ 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())
@@ -1089,7 +1194,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);
 
@@ -1107,18 +1212,24 @@ uint8 Database::GetPEQZone(uint32 zoneID, uint32 version){
 
 bool Database::CheckNameFilter(const char* name, bool surname)
 {
+	_eqp
 	std::string str_name = name;
 
-	// the minimum 4 is enforced by the client too
-	if (!name || strlen(name) < 4)
+	if(surname)
 	{
-		return false;
+		// the minimum 4 is enforced by the client too
+		if(!name || strlen(name) < 3)
+		{
+			return false;
+		}
 	}
-
-	// Given name length is enforced by the client too
-	if (!surname && strlen(name) > 15)
+	else
 	{
-		return false;
+		// the minimum 4 is enforced by the client too
+		if(!name || strlen(name) < 4 || strlen(name) > 15)
+		{
+			return false;
+		}
 	}
 
 	for (size_t i = 0; i < str_name.size(); i++)
@@ -1178,7 +1289,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);
 
@@ -1194,6 +1305,7 @@ 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);
@@ -1218,7 +1330,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);
 
@@ -1238,10 +1350,12 @@ 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);
@@ -1257,6 +1371,7 @@ bool Database::UpdateName(const char* oldname, const char* newname) {
 
 // If the name is used or an error occurs, it returns false, otherwise it returns true
 bool Database::CheckUsedName(const char* name) {
+	_eqp
 	std::string query = StringFormat("SELECT `id` FROM `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -1270,6 +1385,7 @@ 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()) {
@@ -1284,6 +1400,7 @@ uint8 Database::GetServerType() {
 }
 
 bool Database::MoveCharacterToZone(const char* charname, const char* zonename, uint32 zoneid) {
+	_eqp
 	if(zonename == nullptr || strlen(zonename) == 0)
 		return false;
 
@@ -1301,11 +1418,13 @@ 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) { 
-	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", GetZoneID(iZonename), iCharID);
+	_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);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()) {
@@ -1316,6 +1435,7 @@ 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);
 
@@ -1327,6 +1447,7 @@ 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);
@@ -1341,6 +1462,7 @@ 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!
@@ -1359,6 +1481,7 @@ 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;
 	
@@ -1408,6 +1531,7 @@ 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);
 
@@ -1431,7 +1555,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);
 
@@ -1443,7 +1567,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);
 
@@ -1462,36 +1586,41 @@ 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)
-{
-	auto escape_str = new char[lines.size() * 2 + 1];
+void Database::AddReport(std::string who, std::string against, std::string lines) { 
+	_eqp
+	char *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')", EscapeString(who).c_str(), EscapeString(against).c_str(), escape_str);
+	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", who.c_str(), 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
@@ -1511,12 +1640,14 @@ 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)
@@ -1532,6 +1663,7 @@ 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);
 
@@ -1542,7 +1674,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;
 	}
 
@@ -1553,6 +1685,7 @@ 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;
 
@@ -1577,6 +1710,7 @@ 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);
 
@@ -1595,6 +1729,7 @@ 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);
 
@@ -1654,6 +1789,7 @@ 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);
 
@@ -1664,7 +1800,7 @@ void Database::ClearAllGroupLeaders(void) {
 }
 
 void Database::ClearGroupLeader(uint32 gid) {
-	
+	_eqp
 	if(gid == 0)
 	{
 		ClearAllGroupLeaders();
@@ -1679,7 +1815,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);
 
@@ -1695,11 +1831,13 @@ 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
@@ -1716,7 +1854,7 @@ void Database::ClearRaid(uint32 rid) {
 }
 
 void Database::ClearAllRaids(void) {
-
+	_eqp
 	std::string query("delete from raid_members");
 	auto results = QueryDatabase(query);
 
@@ -1726,7 +1864,7 @@ void Database::ClearAllRaids(void) {
 
 void Database::ClearAllRaidDetails(void)
 {
-
+	_eqp
 	std::string query("delete from raid_details");
 	auto results = QueryDatabase(query);
 
@@ -1735,7 +1873,7 @@ void Database::ClearAllRaidDetails(void)
 }
 
 void Database::ClearRaidDetails(uint32 rid) {
-	
+	_eqp
 	if(rid == 0)
 	{
 		//clear all raids
@@ -1754,7 +1892,8 @@ 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);
 
@@ -1775,6 +1914,7 @@ 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
@@ -1806,6 +1946,7 @@ 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);
@@ -1863,6 +2004,7 @@ 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);
@@ -1906,6 +2048,7 @@ 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);
@@ -1923,6 +2066,7 @@ 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;
@@ -1930,6 +2074,7 @@ void Database::ClearAllRaidLeaders(void)
 
 void Database::ClearRaidLeader(uint32 gid, uint32 rid)
 {
+	_eqp
 	if (rid == 0) {
 		ClearAllRaidLeaders();
 		return;
@@ -1941,7 +2086,7 @@ void Database::ClearRaidLeader(uint32 gid, uint32 rid)
 
 void Database::UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win)
 {
-
+	_eqp
 	std::string field;
 
 	switch(theme)
@@ -1994,6 +2139,7 @@ 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`, "
@@ -2040,6 +2186,7 @@ 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);
 
@@ -2055,6 +2202,7 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)
 
 void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 {
+	_eqp
 	std::string query = 
 		"SELECT "
 		"log_category_id, "
@@ -2095,75 +2243,3 @@ 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();
-
-}
-
-int Database::GetIPExemption(std::string account_ip) {
-	std::string query = StringFormat("SELECT `exemption_amount` FROM `ip_exemptions` WHERE `exemption_ip` = '%s'", account_ip.c_str());
-	auto results = QueryDatabase(query);
-	
-	if (results.Success() && results.RowCount() > 0) {
-		auto row = results.begin();
-		return atoi(row[0]);
-	}
-	
-	return RuleI(World, MaxClientsPerIP);
-}
-
-int Database::GetInstanceID(uint32 char_id, uint32 zone_id) {
-	std::string query = StringFormat("SELECT instance_list.id FROM instance_list INNER JOIN instance_list_player ON instance_list.id = instance_list_player.id WHERE instance_list.zone = '%i' AND instance_list_player.charid = '%i'", zone_id, char_id);
-	auto results = QueryDatabase(query);
-
-	if (results.Success() && results.RowCount() > 0) {
-		auto row = results.begin();
-		return atoi(row[0]);;
-	}
-
-	return 0;
-}

common/database.h

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

common/database_conversions.cpp

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

common/dbcore.cpp

@@ -98,14 +98,14 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			pStatus = Error;
 
-			auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 
 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
 
-		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 		/* Implement Logging at the Root */
@@ -128,12 +128,7 @@ 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)
-	{
-		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");
-	}
+		Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
 
 	return requestResult;
 }

common/dbcore.h

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

common/deity.cpp

@@ -1,149 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "deity.h"
-
-
-EQEmu::deity::DeityTypeBit EQEmu::deity::ConvertDeityTypeToDeityTypeBit(DeityType deity_type)
-{
-	switch (deity_type) {
-	case DeityBertoxxulous:
-		return bit_DeityBertoxxulous;
-	case DeityBrellSirilis:
-		return bit_DeityBrellSirilis;
-	case DeityCazicThule:
-		return bit_DeityCazicThule;
-	case DeityErollisiMarr:
-		return bit_DeityErollisiMarr;
-	case DeityBristlebane:
-		return bit_DeityBristlebane;
-	case DeityInnoruuk:
-		return bit_DeityInnoruuk;
-	case DeityKarana:
-		return bit_DeityKarana;
-	case DeityMithanielMarr:
-		return bit_DeityMithanielMarr;
-	case DeityPrexus:
-		return bit_DeityPrexus;
-	case DeityQuellious:
-		return bit_DeityQuellious;
-	case DeityRallosZek:
-		return bit_DeityRallosZek;
-	case DeityRodcetNife:
-		return bit_DeityRodcetNife;
-	case DeitySolusekRo:
-		return bit_DeitySolusekRo;
-	case DeityTheTribunal:
-		return bit_DeityTheTribunal;
-	case DeityTunare:
-		return bit_DeityTunare;
-	case DeityVeeshan:
-		return bit_DeityVeeshan;
-	case DeityAgnostic_LB:
-	case DeityAgnostic:
-		return bit_DeityAgnostic;
-	default:
-		return bit_DeityAll;
-	};
-}
-
-EQEmu::deity::DeityType EQEmu::deity::ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit)
-{
-	switch (deity_type_bit) {
-	case bit_DeityAgnostic:
-		return DeityAgnostic;
-	case bit_DeityBertoxxulous:
-		return DeityBertoxxulous;
-	case bit_DeityBrellSirilis:
-		return DeityBrellSirilis;
-	case bit_DeityCazicThule:
-		return DeityCazicThule;
-	case bit_DeityErollisiMarr:
-		return DeityErollisiMarr;
-	case bit_DeityBristlebane:
-		return DeityBristlebane;
-	case bit_DeityInnoruuk:
-		return DeityInnoruuk;
-	case bit_DeityKarana:
-		return DeityKarana;
-	case bit_DeityMithanielMarr:
-		return DeityMithanielMarr;
-	case bit_DeityPrexus:
-		return DeityPrexus;
-	case bit_DeityQuellious:
-		return DeityQuellious;
-	case bit_DeityRallosZek:
-		return DeityRallosZek;
-	case bit_DeityRodcetNife:
-		return DeityRodcetNife;
-	case bit_DeitySolusekRo:
-		return DeitySolusekRo;
-	case bit_DeityTheTribunal:
-		return DeityTheTribunal;
-	case bit_DeityTunare:
-		return DeityTunare;
-	case bit_DeityVeeshan:
-		return DeityVeeshan;
-	default:
-		return DeityUnknown;
-	};
-}
-
-const char* EQEmu::deity::DeityName(DeityType deity_type)
-{
-	switch (deity_type) {
-	case DeityBertoxxulous:
-		return "Bertoxxulous";
-	case DeityBrellSirilis:
-		return "Brell Serilis";
-	case DeityCazicThule:
-		return "Cazic-Thule";
-	case DeityErollisiMarr:
-		return "Erollisi Marr";
-	case DeityBristlebane:
-		return "Bristlebane";
-	case DeityInnoruuk:
-		return "Innoruuk";
-	case DeityKarana:
-		return "Karana";
-	case DeityMithanielMarr:
-		return "Mithaniel Marr";
-	case DeityPrexus:
-		return "Prexus";
-	case DeityQuellious:
-		return "Quellious";
-	case DeityRallosZek:
-		return "Rallos Zek";
-	case DeityRodcetNife:
-		return "Rodcet Nife";
-	case DeitySolusekRo:
-		return "Solusek Ro";
-	case DeityTheTribunal:
-		return "The Tribunal";
-	case DeityTunare:
-		return "Tunare";
-	case DeityVeeshan:
-		return "Veeshan";
-	case DeityAgnostic_LB:
-	case DeityAgnostic:
-		return "Agnostic";
-	default:
-		return "Unknown";
-	};
-}

common/deity.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemu.org)
+	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -14,67 +13,154 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#ifndef COMMON_DEITY_H
-#define COMMON_DEITY_H
+#ifndef DEITY_H
+#define DEITY_H
 
 #include "types.h"
+#include <string>
 
+// NOTE: This code is not fully implemented since there are no references in the existing code
 
-namespace EQEmu
+/*
+**	Diety types
+**
+**	(ref: eqstr_us.txt)
+**
+**	(Another orphaned enumeration...)
+*/
+enum DeityTypes
 {
-	namespace deity {
-		enum DeityType {
-			DeityUnknown = 0,
-			DeityAgnostic_LB = 140,
-			DeityBertoxxulous = 201,
-			DeityBrellSirilis,
-			DeityCazicThule,
-			DeityErollisiMarr,
-			DeityBristlebane,
-			DeityInnoruuk,
-			DeityKarana,
-			DeityMithanielMarr,
-			DeityPrexus,
-			DeityQuellious,
-			DeityRallosZek,
-			DeityRodcetNife,
-			DeitySolusekRo,
-			DeityTheTribunal,
-			DeityTunare,
-			DeityVeeshan,
-			DeityAgnostic = 396
-		};
+/*----*/	DeityUnknown = 0,
+/*----*/	DeityAgnostic_LB = 140,
+/*3251*/	DeityBertoxxulous = 201,
+/*3262*/	DeityBrellSirilis,
+/*3253*/	DeityCazicThule,
+/*3256*/	DeityErollisiMarr,
+/*3252*/	DeityBristlebane,
+/*3254*/	DeityInnoruuk,
+/*3255*/	DeityKarana,
+/*3257*/	DeityMithanielMarr,
+/*3259*/	DeityPrexus,
+/*3260*/	DeityQuellious,
+/*3266*/	DeityRallosZek,
+/*3258*/	DeityRodcetNife,
+/*3261*/	DeitySolusekRo,
+/*3263*/	DeityTheTribunal,
+/*3264*/	DeityTunare,
+/*3265*/	DeityVeeshan,
+/*3250*/	DeityAgnostic = 396
+};
 
-		enum DeityTypeBit : uint32 {
-			bit_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
-		};
+/*
+**	Deity type bits
+**
+**	(New orphan, but make use of it!)
+*/
+enum DeityTypeBits : uint32
+{
+	BIT_DeityAll			= 0x00000000,
+	BIT_DeityAgnostic		= 0x00000001,
+	BIT_DeityBertoxxulous	= 0x00000002,
+	BIT_DeityBrellSirilis	= 0x00000004,
+	BIT_DeityCazicThule		= 0x00000008,
+	BIT_DeityErollisiMarr	= 0x00000010,
+	BIT_DeityBristlebane	= 0x00000020,
+	BIT_DeityInnoruuk		= 0x00000040,
+	BIT_DeityKarana			= 0x00000080,
+	BIT_DeityMithanielMarr	= 0x00000100,
+	BIT_DeityPrexus			= 0x00000200,
+	BIT_DeityQuellious		= 0x00000400,
+	BIT_DeityRallosZek		= 0x00000800,
+	BIT_DeityRodcetNife		= 0x00001000,
+	BIT_DeitySolusekRo		= 0x00002000,
+	BIT_DeityTheTribunal	= 0x00004000,
+	BIT_DeityTunare			= 0x00008000,
+	BIT_DeityVeeshan		= 0x00010000
+};
 
-		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);
-		extern DeityType ConvertDeityTypeBitToDeityType(DeityTypeBit deity_type_bit);
-		extern const char* DeityName(DeityType deity_type);
+static DeityTypeBits ConvertDeityToBitDeity(DeityTypes deity)
+{
+	switch(deity)
+	{
+		case DeityBertoxxulous:		{ return BIT_DeityBertoxxulous; }
+		case DeityBrellSirilis:		{ return BIT_DeityBrellSirilis; }
+		case DeityCazicThule:		{ return BIT_DeityCazicThule; }
+		case DeityErollisiMarr:		{ return BIT_DeityErollisiMarr; }
+		case DeityBristlebane:		{ return BIT_DeityBristlebane; }
+		case DeityInnoruuk:			{ return BIT_DeityInnoruuk; }
+		case DeityKarana:			{ return BIT_DeityKarana; }
+		case DeityMithanielMarr:	{ return BIT_DeityMithanielMarr; }
+		case DeityPrexus:			{ return BIT_DeityPrexus; }
+		case DeityQuellious:		{ return BIT_DeityQuellious; }
+		case DeityRallosZek:		{ return BIT_DeityRallosZek; }
+		case DeityRodcetNife:		{ return BIT_DeityRodcetNife; }
+		case DeitySolusekRo:		{ return BIT_DeitySolusekRo; }
+		case DeityTheTribunal:		{ return BIT_DeityTheTribunal; }
+		case DeityTunare:			{ return BIT_DeityTunare; }
+		case DeityVeeshan:			{ return BIT_DeityVeeshan; }
+		case DeityAgnostic_LB:
+		case DeityAgnostic:			{ return BIT_DeityAgnostic; }
+		default: { break; }
+	};
 
-	} /*deity*/
+	return BIT_DeityAll;
+};
 
-} /*EQEmu*/
+static DeityTypes ConvertBitDeityToDeity(DeityTypeBits deity_bit)
+{
+	switch(deity_bit)
+	{
+		case BIT_DeityAgnostic:			{ return DeityAgnostic; }
+		case BIT_DeityBertoxxulous:		{ return DeityBertoxxulous; }
+		case BIT_DeityBrellSirilis:		{ return DeityBrellSirilis; }
+		case BIT_DeityCazicThule:		{ return DeityCazicThule; }
+		case BIT_DeityErollisiMarr:		{ return DeityErollisiMarr; }
+		case BIT_DeityBristlebane:		{ return DeityBristlebane; }
+		case BIT_DeityInnoruuk:			{ return DeityInnoruuk; }
+		case BIT_DeityKarana:			{ return DeityKarana; }
+		case BIT_DeityMithanielMarr:	{ return DeityMithanielMarr; }
+		case BIT_DeityPrexus:			{ return DeityPrexus; }
+		case BIT_DeityQuellious:		{ return DeityQuellious; }
+		case BIT_DeityRallosZek:		{ return DeityRallosZek; }
+		case BIT_DeityRodcetNife:		{ return DeityRodcetNife; }
+		case BIT_DeitySolusekRo:		{ return DeitySolusekRo; }
+		case BIT_DeityTheTribunal:		{ return DeityTheTribunal; }
+		case BIT_DeityTunare:			{ return DeityTunare; }
+		case BIT_DeityVeeshan:			{ return DeityVeeshan; }
+		default: { break; }
+	};
 
-#endif /* COMMON_DEITY_H */
+	return DeityUnknown;
+};
+
+static std::string GetDeityName(DeityTypes deity)
+{
+	switch(deity)
+	{
+		case DeityBertoxxulous:		{ return "Bertoxxulous"; }
+		case DeityBrellSirilis:		{ return "Brell Serilis"; }
+		case DeityCazicThule:		{ return "Cazic-Thule"; }
+		case DeityErollisiMarr:		{ return "Erollisi Marr"; }
+		case DeityBristlebane:		{ return "Bristlebane"; }
+		case DeityInnoruuk:			{ return "Innoruuk"; }
+		case DeityKarana:			{ return "Karana"; }
+		case DeityMithanielMarr:	{ return "Mithaniel Marr"; }
+		case DeityPrexus:			{ return "Prexus"; }
+		case DeityQuellious:		{ return "Quellious"; }
+		case DeityRallosZek:		{ return "Rallos Zek"; }
+		case DeityRodcetNife:		{ return "Rodcet Nife"; }
+		case DeitySolusekRo:		{ return "Solusek Ro"; }
+		case DeityTheTribunal:		{ return "The Tribunal"; }
+		case DeityTunare:			{ return "Tunare"; }
+		case DeityVeeshan:			{ return "Veeshan"; }
+		case DeityAgnostic_LB:
+		case DeityAgnostic:			{ return "Agnostic"; }
+		default: { break; }
+	};
+
+	return "Unknown";
+};
+
+#endif

common/emu_constants.cpp

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

common/emu_constants.h

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

common/emu_legacy.cpp

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

common/emu_legacy.h

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

common/emu_limits.cpp

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

common/emu_limits.h

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

common/emu_oplist.h

@@ -64,7 +64,6 @@ N(OP_BuffRemoveRequest),
 N(OP_Bug),
 N(OP_CameraEffect),
 N(OP_Camp),
-N(OP_CancelSneakHide),
 N(OP_CancelTask),
 N(OP_CancelTrade),
 N(OP_CastSpell),
@@ -165,7 +164,6 @@ N(OP_FinishTrade),
 N(OP_FinishWindow),
 N(OP_FinishWindow2),
 N(OP_Fishing),
-N(OP_Fling),
 N(OP_FloatListThing),
 N(OP_Forage),
 N(OP_ForceFindPerson),
@@ -217,7 +215,6 @@ N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
-N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -289,7 +286,6 @@ N(OP_LFGuild),
 N(OP_LFPCommand),
 N(OP_LFPGetMatchesRequest),
 N(OP_LFPGetMatchesResponse),
-N(OP_LinkedReuse),
 N(OP_LoadSpellSet),
 N(OP_LocInfo),
 N(OP_LockoutTimerInfo),
@@ -352,7 +348,6 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
-N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
 N(OP_PetitionCheckIn),
@@ -369,8 +364,6 @@ N(OP_PetitionUnCheckout),
 N(OP_PetitionUpdate),
 N(OP_PickPocket),
 N(OP_PlayerProfile),
-N(OP_PlayerStateAdd),
-N(OP_PlayerStateRemove),
 N(OP_PlayEverquestRequest),
 N(OP_PlayEverquestResponse),
 N(OP_PlayMP3),
@@ -526,6 +519,8 @@ N(OP_VetRewardsAvaliable),
 N(OP_VoiceMacroIn),
 N(OP_VoiceMacroOut),
 N(OP_WeaponEquip1),
+N(OP_WeaponEquip2),
+N(OP_WeaponUnequip2),
 N(OP_WearChange),
 N(OP_Weather),
 N(OP_Weblink),
@@ -539,8 +534,6 @@ N(OP_WorldLogout),
 N(OP_WorldObjectsSent),
 N(OP_WorldUnknown001),
 N(OP_XTargetAutoAddHaters),
-N(OP_XTargetOpen),
-N(OP_XTargetOpenResponse),
 N(OP_XTargetRequest),
 N(OP_XTargetResponse),
 N(OP_YellForHelp),
@@ -554,5 +547,4 @@ N(OP_ZoneServerInfo),
 N(OP_ZoneServerReady),
 N(OP_ZoneSpawns),
 N(OP_ZoneUnavail),
-N(OP_ResetAA),
 // mail and chat opcodes located in ../mail_oplist.h

common/emu_tcp_connection.cpp

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

common/emu_versions.cpp

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

common/emu_versions.h

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

common/eq_constants.h

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

common/eq_dictionary.cpp

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

common/eq_dictionary.h

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

common/eq_limits.cpp

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

common/eq_limits.h

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

common/eq_packet.cpp

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

common/eq_packet.h

@@ -62,7 +62,7 @@ class EQProtocolPacket : public BasePacket {
 	friend class EQStream;
 	friend class EQStreamPair;
 public:
-	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf, len), opcode(op) { acked = false; sent_time = 0; }
+	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf,len), opcode(op) { acked = false; }
 //	EQProtocolPacket(const unsigned char *buf, uint32 len);
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
@@ -70,7 +70,6 @@ public:
 	EQRawApplicationPacket *MakeAppPacket() const;
 
 	bool acked;
-	uint32 sent_time;
 
 	virtual void build_raw_header_dump(char *buffer, uint16 seq=0xffff) const;
 	virtual void build_header_dump(char *buffer) const;

common/eq_stream.cpp

@@ -50,6 +50,7 @@
 uint16 EQStream::MaxWindowSize=2048;
 
 void EQStream::init(bool resetSession) {
+	_eqp
 	// we only reset these statistics if it is a 'new' connection
 	if ( resetSession )
 	{
@@ -72,10 +73,8 @@ void EQStream::init(bool resetSession) {
 	RateThreshold=RATEBASE/250;
 	DecayRate=DECAYBASE/250;
 	BytesWritten=0;
-	sent_packet_count = 0;
-	received_packet_count = 0;
 	SequencedBase = 0;
-	AverageDelta = 500;
+	NextSequencedSend = 0;
 
 	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 		retransmittimer = Timer::GetCurrentTime();
@@ -86,10 +85,15 @@ 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);
@@ -99,6 +103,7 @@ 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);
@@ -106,6 +111,7 @@ 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.
@@ -117,6 +123,7 @@ EQProtocolPacket *EQStream::MakeProtocolPacket(const unsigned char *buf, uint32
 
 void EQStream::ProcessPacket(EQProtocolPacket *p)
 {
+	_eqp
 	uint32 processed=0, subpacket_length=0;
 	if (p == nullptr)
 		return;
@@ -288,8 +295,10 @@ 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: {
@@ -298,12 +307,14 @@ 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: {
@@ -312,6 +323,7 @@ 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);
 
@@ -324,6 +336,7 @@ 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);
@@ -333,8 +346,10 @@ 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: {
@@ -400,6 +415,7 @@ 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();
 
@@ -407,30 +423,36 @@ 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+SequencedQueue.size());
+					seq, SequencedBase, SequencedBase+NextSequencedSend);
 
-				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);
-						}
+				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;
 					}
 				}
 
 				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);
 			}
@@ -439,49 +461,46 @@ 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(ClientSessionStats))
+			if(p->Size() < sizeof(SessionStats))
 			{
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
-			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
+#ifndef COLLECTOR
+			SessionStats *Stats=(SessionStats *)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(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));
+				(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));
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if (RETRANSMIT_TIMEOUT_MULT && ntohl(ClientStats->average_delta)) {
+				if(RETRANSMIT_TIMEOUT_MULT && ntohl(Stats->average_delta)) {
 					//recalculate retransmittimeout using the larger of the last rtt or average rtt, which is multiplied by the rule value
-					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))
+					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)) 
 							* RETRANSMIT_TIMEOUT_MULT;
 					} else {
-						retransmittimeout = ntohl(ClientStats->average_delta) * 2 * RETRANSMIT_TIMEOUT_MULT;
+						retransmittimeout = ntohl(Stats->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);
 				}
 			}
-
-			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));
+#endif
 		}
 		break;
 		case OP_SessionStatResponse: {
@@ -502,6 +521,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 
 void EQStream::QueuePacket(const EQApplicationPacket *p, bool ack_req)
 {
+	_eqp
 	if(p == nullptr)
 		return;
 
@@ -513,6 +533,7 @@ 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
 
@@ -542,6 +563,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 
 void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 {
+	_eqp
 	uint32 chunksize, used;
 	uint32 length;
 
@@ -559,18 +581,16 @@ 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);
 
-		auto tmpbuff = new unsigned char[p->size + 3];
+		unsigned char *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);
 
-		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
-		*(uint32 *)(out->pBuffer+2)=htonl(length);
+		EQProtocolPacket *out=new EQProtocolPacket(OP_Fragment,nullptr,MaxLen-4);
+		*(uint32 *)(out->pBuffer+2)=htonl(p->Size());
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
 		SequencedPush(out);
 
 
@@ -581,16 +601,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, length);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
 		}
 		delete p;
 		delete[] tmpbuff;
 	} else {
 
-		auto tmpbuff = new unsigned char[p->Size() + 3];
+		unsigned char *tmpbuff=new unsigned char[p->Size()+3];
 		length=p->serialize(opcode, tmpbuff+2) + 2;
 
-		auto out = new EQProtocolPacket(OP_Packet, tmpbuff, length);
+		EQProtocolPacket *out=new EQProtocolPacket(OP_Packet,tmpbuff,length);
 
 		delete[] tmpbuff;
 		SequencedPush(out);
@@ -600,37 +620,50 @@ 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(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());
 	}
 
-	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(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());
 	}
-
 	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)
 {
-uint16 Seq=htons(seq);
+	_eqp
+	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)));
@@ -638,8 +671,9 @@ uint16 Seq=htons(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)));
 }
 
@@ -669,15 +703,21 @@ 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();
-
-	uint16 count = 0;
-	// get to start of packets
-	while (sitr != SequencedQueue.end() && (*sitr)->sent_time > 0) {
-		++sitr;
-		++count;
-	}
+	if (sitr!=SequencedQueue.end())
+	sitr += NextSequencedSend;
 
 	// Loop until both are empty or MaxSends is reached
 	while(!SeqEmpty || !NonSeqEmpty) {
@@ -691,7 +731,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())) {
-				// Trying to combine this packet with the base didn't work (too big maybe)
+				// Tryint 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);
@@ -714,9 +754,16 @@ void EQStream::Write(int eq_fd)
 			NonSeqEmpty=true;
 		}
 
-		if (sitr != SequencedQueue.end()) {
-			uint16 seq_send = SequencedBase + count;	//just for logging...
+		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(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;
@@ -724,61 +771,17 @@ void EQStream::Write(int eq_fd)
 			}
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				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;
-					}
+				if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
 					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;
-					++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 + 1, (*sitr)->size);
-					ReadyToSend.push(p);
-					BytesWritten+=p->size;
-					p=nullptr;
-					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
-						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
-						break;
-					}
-				} 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;
-					++count;
-				}
-			} else {
-				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;
-					++count;
+					NextSequencedSend++;
 				} 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)
@@ -794,16 +797,45 @@ void EQStream::Write(int eq_fd)
 					}
 				} else {
 					// Combine worked
-					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();
+					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;
-					++count;
+					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;
+					NextSequencedSend++;
+				} 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);
+					ReadyToSend.push(p);
+					BytesWritten+=p->size;
+					p=nullptr;
+
+					if (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;
+					}
+				} 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;
+					NextSequencedSend++;
 				}
 			}
 
 			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;
@@ -842,8 +874,9 @@ void EQStream::Write(int eq_fd)
 
 void EQStream::WritePacket(int eq_fd, EQProtocolPacket *p)
 {
-uint32 length;
-sockaddr_in address;
+	_eqp
+	uint32 length;
+	sockaddr_in address;
 	address.sin_family = AF_INET;
 	address.sin_addr.s_addr=remote_ip;
 	address.sin_port=remote_port;
@@ -862,11 +895,9 @@ sockaddr_in address;
 	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);
@@ -882,7 +913,8 @@ sockaddr_in address;
 
 void EQStream::SendSessionResponse()
 {
-	auto out = new EQProtocolPacket(OP_SessionResponse, nullptr, sizeof(SessionResponse));
+	_eqp
+	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(SessionResponse));
 	SessionResponse *Response=(SessionResponse *)out->pBuffer;
 	Response->Session=htonl(Session);
 	Response->MaxLength=htonl(MaxLen);
@@ -904,7 +936,8 @@ void EQStream::SendSessionResponse()
 
 void EQStream::SendSessionRequest()
 {
-	auto out = new EQProtocolPacket(OP_SessionRequest, nullptr, sizeof(SessionRequest));
+	_eqp
+	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(SessionRequest));
 	SessionRequest *Request=(SessionRequest *)out->pBuffer;
 	memset(Request,0,sizeof(SessionRequest));
 	Request->Session=htonl(time(nullptr));
@@ -917,10 +950,11 @@ void EQStream::SendSessionRequest()
 
 void EQStream::_SendDisconnect()
 {
+	_eqp
 	if(GetState() == CLOSED)
 		return;
 
-	auto out = new EQProtocolPacket(OP_SessionDisconnect, nullptr, sizeof(uint32));
+	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionDisconnect,nullptr,sizeof(uint32));
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
@@ -929,6 +963,7 @@ void EQStream::_SendDisconnect()
 
 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
 {
+	_eqp
 	MInboundQueue.lock();
 	InboundQueue.push_back(p);
 	MInboundQueue.unlock();
@@ -936,11 +971,12 @@ void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
 
 EQApplicationPacket *EQStream::PopPacket()
 {
-EQRawApplicationPacket *p=nullptr;
+	_eqp
+	EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -961,11 +997,12 @@ EQRawApplicationPacket *p=nullptr;
 
 EQRawApplicationPacket *EQStream::PopRawPacket()
 {
-EQRawApplicationPacket *p=nullptr;
+	_eqp
+	EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -988,11 +1025,12 @@ EQRawApplicationPacket *p=nullptr;
 
 EQRawApplicationPacket *EQStream::PeekPacket()
 {
-EQRawApplicationPacket *p=nullptr;
+	_eqp
+	EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 	}
 	MInboundQueue.unlock();
@@ -1002,7 +1040,8 @@ EQRawApplicationPacket *p=nullptr;
 
 void EQStream::InboundQueueClear()
 {
-EQApplicationPacket *p=nullptr;
+	_eqp
+	EQApplicationPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
 
@@ -1020,7 +1059,8 @@ EQApplicationPacket *p=nullptr;
 
 bool EQStream::HasOutgoingData()
 {
-bool flag;
+	_eqp
+	bool flag;
 
 	//once closed, we have nothing more to say
 	if(CheckClosed())
@@ -1045,7 +1085,8 @@ bool flag;
 
 void EQStream::OutboundQueueClear()
 {
-EQProtocolPacket *p=nullptr;
+	_eqp
+	EQProtocolPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
 
@@ -1067,7 +1108,8 @@ EQProtocolPacket *p=nullptr;
 
 void EQStream::PacketQueueClear()
 {
-EQProtocolPacket *p=nullptr;
+	_eqp
+	EQProtocolPacket *p=nullptr;
 
 	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
 
@@ -1083,6 +1125,7 @@ EQProtocolPacket *p=nullptr;
 
 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)) {
@@ -1107,6 +1150,7 @@ void EQStream::Process(const unsigned char *buffer, const uint32 length)
 
 long EQStream::GetNextAckToSend()
 {
+	_eqp
 	MAcks.lock();
 	long l=NextAckToSend;
 	MAcks.unlock();
@@ -1116,6 +1160,7 @@ long EQStream::GetNextAckToSend()
 
 long EQStream::GetLastAckSent()
 {
+	_eqp
 	MAcks.lock();
 	long l=LastAckSent;
 	MAcks.unlock();
@@ -1125,9 +1170,17 @@ long EQStream::GetLastAckSent()
 
 void EQStream::AckPackets(uint16 seq)
 {
-std::deque<EQProtocolPacket *>::iterator itr, tmp;
+	_eqp
+	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) {
@@ -1144,20 +1197,27 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 		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, SequencedQueue.size());
+			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);
 				SequencedBase = NextOutSeq;
+				NextSequencedSend = 0;
 				break;
 			}
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
 			//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();
@@ -1165,6 +1225,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 
 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;
@@ -1173,6 +1234,7 @@ 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;
@@ -1181,6 +1243,7 @@ void EQStream::SetLastAckSent(uint32 seq)
 
 void EQStream::ProcessQueue()
 {
+	_eqp
 	if(PacketQueue.empty()) {
 		return;
 	}
@@ -1196,8 +1259,9 @@ void EQStream::ProcessQueue()
 
 EQProtocolPacket *EQStream::RemoveQueue(uint16 seq)
 {
-std::map<unsigned short,EQProtocolPacket *>::iterator itr;
-EQProtocolPacket *qp=nullptr;
+	_eqp
+	std::map<unsigned short,EQProtocolPacket *>::iterator itr;
+	EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
@@ -1208,6 +1272,7 @@ EQProtocolPacket *qp=nullptr;
 
 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) {
@@ -1238,6 +1303,7 @@ void EQStream::SetStreamType(EQStreamType type)
 
 const char *EQStream::StreamTypeString(EQStreamType t)
 {
+	_eqp
 	switch (t) {
 		case LoginStream:
 			return "Login";
@@ -1267,6 +1333,7 @@ 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;
@@ -1280,6 +1347,7 @@ 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;
@@ -1288,7 +1356,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();
@@ -1327,6 +1395,7 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
 
 void EQStream::Decay()
 {
+	_eqp
 	MRate.lock();
 	uint32 rate=DecayRate;
 	MRate.unlock();
@@ -1335,43 +1404,26 @@ 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, 
@@ -1382,6 +1434,7 @@ 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);
@@ -1398,6 +1451,7 @@ 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 ClientSessionStats {
+struct SessionStats {
 /*000*/	uint16 RequestID;
 /*002*/	uint32 last_local_delta;
 /*006*/	uint32 average_delta;
@@ -83,16 +83,6 @@ struct ClientSessionStats {
 /*038*/
 };
 
-struct ServerSessionStats {
-/*000*/	uint16 RequestID;
-/*002*/	uint32 ServerTime;
-/*006*/	uint64 packets_sent_echo;
-/*014*/	uint64 packets_received_echo;
-/*022*/	uint64 packets_sent;
-/*030*/	uint64 packets_received;
-/*038*/
-};
-
 #pragma pack()
 
 class OpcodeManager;
@@ -153,6 +143,7 @@ class EQStream : public EQStreamInterface {
 		std::deque<EQProtocolPacket *> SequencedQueue;
 		uint16 NextOutSeq;
 		uint16 SequencedBase;	//the sequence number of SequencedQueue[0]
+		long NextSequencedSend;	//index into SequencedQueue
 		Mutex MOutboundQueue;
 
 		//a buffer we use for compression/decompression
@@ -167,13 +158,10 @@ class EQStream : public EQStreamInterface {
 
 		int32 BytesWritten;
 
-		uint64 sent_packet_count;
-		uint64 received_packet_count;
-
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
-		uint32 AverageDelta;
+
 
 		OpcodeManager **OpMgr;
 
@@ -277,13 +265,11 @@ class EQStream : public EQStreamInterface {
 		void AddBytesSent(uint32 bytes)
 		{
 			bytes_sent += bytes;
-			++sent_packet_count;
 		}
 
 		void AddBytesRecv(uint32 bytes)
 		{
 			bytes_recv += bytes;
-			++received_packet_count;
 		}
 
 		virtual const uint32 GetBytesSent() const { return bytes_sent; }
@@ -302,9 +288,6 @@ 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 <winsock2.h>
+	#include <winsock.h>
 	#include <process.h>
 	#include <io.h>
 	#include <stdio.h>
@@ -23,7 +23,8 @@
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
 	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
@@ -40,7 +41,8 @@ EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
-	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
+	_eqp
+	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
 	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
@@ -58,6 +60,7 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 	: Timeoutable(5000), stream_timeout(timeout)
 {
+	_eqp
 	StreamType=type;
 	Port=port;
 	sock=-1;
@@ -65,6 +68,7 @@ EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 
 void EQStreamFactory::Close()
 {
+	_eqp
 	Stop();
 
 #ifdef _WINDOWS
@@ -77,7 +81,8 @@ void EQStreamFactory::Close()
 
 bool EQStreamFactory::Open()
 {
-struct sockaddr_in address;
+	_eqp
+	struct sockaddr_in address;
 #ifndef WIN32
 	pthread_t t1,t2;
 #endif
@@ -118,9 +123,10 @@ struct sockaddr_in address;
 
 std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
+	_eqp
 	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
-	if (!NewStreams.empty()) {
+	if (NewStreams.size()) {
 		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
@@ -132,6 +138,7 @@ std::shared_ptr<EQStream> EQStreamFactory::Pop()
 
 void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
+	_eqp
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
@@ -139,6 +146,7 @@ void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 
 void EQStreamFactory::ReaderLoop()
 {
+	_eqp
 	fd_set readset;
 	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 	int num;
@@ -216,6 +224,7 @@ void EQStreamFactory::ReaderLoop()
 
 void EQStreamFactory::CheckTimeout()
 {
+	_eqp
 	//lock streams the entire time were checking timeouts, it should be fast.
 	MStreams.lock();
 
@@ -235,7 +244,7 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				auto temp = stream_itr;
+				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
 				++stream_itr;
 				temp->second = nullptr;
 				Streams.erase(temp);
@@ -250,7 +259,9 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-	bool havework = true;
+	_eqp
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
+	bool havework=true;
 	std::vector<std::shared_ptr<EQStream>> wants_write;
 	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
 	bool decay = false;
@@ -259,7 +270,7 @@ void EQStreamFactory::WriterLoop()
 	WriterRunning = true;
 	DecayTimer.Enable();
 
-	while (sock != -1) {
+	while(sock!=-1) {
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -268,36 +279,34 @@ void EQStreamFactory::WriterLoop()
 		havework = false;
 		wants_write.clear();
 
-		decay = DecayTimer.Check();
+		decay=DecayTimer.Check();
 
-		// copy streams into a seperate list so we dont have to keep
-		// MStreams locked while we are writting
+		//copy streams into a seperate list so we dont have to keep
+		//MStreams locked while we are writting
 		MStreams.lock();
-		for (auto stream_itr = Streams.begin(); stream_itr != Streams.end(); ++stream_itr) {
+		for(stream_itr=Streams.begin();stream_itr!=Streams.end();++stream_itr) {
 			// If it's time to decay the bytes sent, then let's do it before we try to write
 			if (decay)
 				stream_itr->second->Decay();
 
-			// bullshit checking, to see if this is really happening, GDB seems to think so...
-			if (stream_itr->second == nullptr) {
-				fprintf(stderr,
-					"ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i",
-					stream_itr->first.first, stream_itr->first.second);
+			//bullshit checking, to see if this is really happening, GDB seems to think so...
+			if(stream_itr->second == nullptr) {
+				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i", stream_itr->first.first, stream_itr->first.second);
 				continue;
 			}
 
 			if (stream_itr->second->HasOutgoingData()) {
-				havework = true;
+				havework=true;
 				stream_itr->second->PutInUse();
 				wants_write.push_back(stream_itr->second);
 			}
 		}
 		MStreams.unlock();
 
-		// do the actual writes
+		//do the actual writes
 		cur = wants_write.begin();
 		end = wants_write.end();
-		for (; cur != end; ++cur) {
+		for(; cur != end; ++cur) {
 			(*cur)->Write(sock);
 			(*cur)->ReleaseFromUse();
 		}

common/eq_stream_ident.cpp

@@ -1,5 +1,3 @@
-#include <utility>
-
 #include "global_define.h"
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
@@ -27,7 +25,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 }
 
 void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
-	auto p = new Patch;
+	Patch *p = new Patch;
 	p->signature = sig;
 	p->name = name;
 	p->opcodes = opcodes;
@@ -158,7 +156,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 }
 
 EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
-:	stream(std::move(s)),
+:	stream(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 "emu_versions.h"
+#include "clientversions.h"
 
 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 EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
+	virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -21,9 +21,9 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
+const ClientVersion EQStreamProxy::GetClientVersion() const
 {
-	return m_structs->ClientVersion();
+	return m_structs->GetClientVersion();
 }
 
 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 EQEmu::versions::ClientVersion ClientVersion() const;
+	virtual const ClientVersion GetClientVersion() 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);
-	auto res = new char[len * 2 + 1];
+	char *res = new char[len*2+1];
 
 	mysql_real_escape_string(mysql_ref,res,from,len);
 

common/eqemu_config.cpp

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

common/eqemu_config.h

@@ -79,16 +79,12 @@ class EQEmuConfig : public XMLParser
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;
-		std::string PluginPlFile;
+		std::string EQTimeFile;
 
 		// From <directories/>
 		std::string MapDir;
 		std::string QuestDir;
 		std::string PluginDir;
-		std::string LuaModuleDir;
-		std::string PatchDir;
-		std::string SharedMemDir;
-		std::string LogDir;
 
 		// From <launcher/>
 		std::string LogPrefix;
@@ -158,16 +154,11 @@ class EQEmuConfig : public XMLParser
 			// Files
 			SpellsFile = "spells_us.txt";
 			OpCodesFile = "opcodes.conf";
-			PluginPlFile = "plugin.pl";
+			EQTimeFile = "eqtime.cfg";
 			// Dirs
-			MapDir = "Maps/";
-			QuestDir = "quests/";
-			PluginDir = "plugins/";
-			LuaModuleDir = "lua_modules/";
-			PatchDir = "./";
-			SharedMemDir = "shared/";
-			LogDir = "logs/";
-
+			MapDir = "Maps";
+			QuestDir = "quests";
+			PluginDir = "plugins";
 			// 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,12 +273,14 @@ 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,12 +48,14 @@ namespace Logs {
 		Combat,
 		Commands,
 		Crash,
+		Database,
 		Debug,
 		Doors,
 		Error,
 		Guilds,
 		Inventory,
 		Launcher,
+		LoginServer,
 		Netcode,
 		Normal,
 		Object,
@@ -82,8 +84,6 @@ namespace Logs {
 		Client_Server_Packet_Unhandled,
 		Server_Client_Packet_With_Dump,
 		Client_Server_Packet_With_Dump,
-		Login_Server,
-		Client_Login,
 		MaxCategoryID	/* Don't Remove this*/
 	};
 
@@ -98,12 +98,14 @@ namespace Logs {
 		"Combat",
 		"Commands",
 		"Crash",
+		"Database",
 		"Debug",
 		"Doors",
 		"Error",
 		"Guilds",
 		"Inventory",
 		"Launcher",
+		"LoginServer",
 		"Netcode",
 		"Normal",
 		"Object",
@@ -124,16 +126,14 @@ namespace Logs {
 		"WebInterface Server",
 		"World Server",
 		"Zone Server",
-		"MySQL Error",
-		"MySQL Query",
+		"MySQLError",
+		"MySQLQuery",
 		"Mercenaries",
 		"Quest Debug",
 		"Packet :: Server -> Client",
 		"Packet :: Client -> Server Unhandled",
 		"Packet :: Server -> Client (Dump)",
 		"Packet :: Client -> Server (Dump)",
-		"Login Server",
-		"Client Login"
 	};
 }
 

common/eqtime.cpp

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

common/eqtime.h

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

common/extprofile.cpp

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

common/extprofile.h

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

common/faction.cpp

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

common/features.h

@@ -154,12 +154,11 @@ enum {	//reuse times
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
 	AIthink_duration = 150,
-	AIscanarea_delay = 6000,
+	AIscanarea_delay = 500,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
 	AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	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,
@@ -213,8 +212,8 @@ enum {	//some random constants
 #define MAX_NPC_FACTIONS 20
 
 //individual faction pool
-#define MAX_PERSONAL_FACTION 2000
-#define MIN_PERSONAL_FACTION -2000
+#define MAX_PERSONAL_FACTION 1200
+#define MIN_PERSONAL_FACTION -3000
 
 //The Level Cap:
 //#define LEVEL_CAP RuleI(Character, MaxLevel)	//hard cap is 127
@@ -233,8 +232,6 @@ 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,
@@ -273,9 +270,6 @@ enum {
 #define NPC_DEFAULT_LOGGING_ENABLED false
 
 
-// This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
-#define SAYLINK_ITEM_ID 0xFFFFF
-
 
 /*
 

common/global_define.h

@@ -16,7 +16,6 @@
 	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>
@@ -27,9 +26,16 @@
 #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 <winsock2.h>
 	#include <windows.h>
+	#include <winsock2.h>
 #endif
 
 #endif

common/guild_base.cpp

@@ -39,10 +39,8 @@ BaseGuildManager::~BaseGuildManager() {
 	ClearGuilds();
 }
 
-
-
 bool BaseGuildManager::LoadGuilds() {
-
+	_eqp
 	ClearGuilds();
 
 	if(m_db == nullptr) {
@@ -104,6 +102,7 @@ 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);
@@ -169,6 +168,7 @@ 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.
-	auto info = new GuildInfo;
+	GuildInfo *info = new GuildInfo;
 	info->name = guild_name;
 	info->leader_char_id = leader_char_id;
 	info->minstatus = minstatus;
@@ -213,6 +213,7 @@ 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);
@@ -236,9 +237,9 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	results = m_db->QueryDatabase(query);
 
 	//escape our strings.
-	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];
+	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];
 	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());
@@ -264,7 +265,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	for(rank = 0; rank <= GUILD_MAX_RANK; rank++) {
 		const RankInfo &rankInfo = info->ranks[rank];
 
-		auto title_esc = new char[rankInfo.name.length() * 2 + 1];
+		char *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 "
@@ -295,6 +296,7 @@ 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);
@@ -342,6 +344,7 @@ 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);
@@ -353,6 +356,7 @@ uint32 BaseGuildManager::CreateGuild(const char* name, uint32 leader_char_id) {
 }
 
 bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
+	_eqp
 	if(!DBDeleteGuild(guild_id))
 		return(false);
 
@@ -362,6 +366,7 @@ bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
 }
 
 bool BaseGuildManager::RenameGuild(uint32 guild_id, const char* name) {
+	_eqp
 	if(!DBRenameGuild(guild_id, name))
 		return(false);
 
@@ -371,6 +376,7 @@ 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);
@@ -390,6 +396,7 @@ 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);
 
@@ -400,6 +407,7 @@ 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);
 
@@ -410,6 +418,7 @@ bool BaseGuildManager::SetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::SetGuildChannel(uint32 GuildID, const char* Channel)
 {
+	_eqp
 	if(!DBSetGuildChannel(GuildID, Channel))
 		return(false);
 
@@ -419,6 +428,7 @@ 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);
 
@@ -439,6 +449,7 @@ 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);
 
@@ -452,6 +463,7 @@ bool BaseGuildManager::SetGuildRank(uint32 charid, uint8 rank) {
 
 
 bool BaseGuildManager::SetBankerFlag(uint32 charid, bool is_banker) {
+	_eqp
 	if(!DBSetBankerFlag(charid, is_banker))
 		return(false);
 
@@ -461,12 +473,14 @@ 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);
 
@@ -476,6 +490,7 @@ bool BaseGuildManager::SetAltFlag(uint32 charid, bool is_alt)
 }
 
 bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
+	_eqp
 	if(!DBSetTributeFlag(charid, enabled))
 		return(false);
 
@@ -485,6 +500,7 @@ bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
 }
 
 bool BaseGuildManager::SetPublicNote(uint32 charid, const char *note) {
+	_eqp
 	if(!DBSetPublicNote(charid, note))
 		return(false);
 
@@ -494,6 +510,7 @@ 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)
@@ -515,6 +532,7 @@ 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;
@@ -551,6 +569,7 @@ 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;
@@ -564,7 +583,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 	//escape our strings.
 	uint32 len = strlen(name);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, name, len);
 
 	//insert the new `guilds` entry
@@ -587,6 +606,7 @@ 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;
@@ -622,6 +642,7 @@ 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);
@@ -636,8 +657,8 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 	//escape our strings.
 	uint32 len = strlen(motd);
 	uint32 len2 = strlen(setter);
-	auto esc = new char[len * 2 + 1];
-	auto esc_set = new char[len2 * 2 + 1];
+	char *esc = new char[len*2+1];
+	char *esc_set = new char[len2*2+1];
 	m_db->DoEscapeString(esc, motd, len);
 	m_db->DoEscapeString(esc_set, setter, len2);
 
@@ -664,6 +685,7 @@ 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;
 
@@ -675,7 +697,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 	//escape our strings.
 	uint32 len = strlen(URL);
-	auto esc = new char[len * 2 + 1];
+	char *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);
@@ -697,6 +719,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 {
+	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -709,7 +732,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 
 	//escape our strings.
 	uint32 len = strlen(Channel);
-	auto esc = new char[len * 2 + 1];
+	char *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);
@@ -730,6 +753,7 @@ 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);
@@ -758,11 +782,13 @@ 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"));
@@ -770,6 +796,7 @@ bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
 
 bool BaseGuildManager::GetBankerFlag(uint32 CharID)
 {
+	_eqp
 	if(!m_db)
 		return false;
 
@@ -792,6 +819,7 @@ 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);
 
@@ -800,6 +828,7 @@ bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
 
 bool BaseGuildManager::GetAltFlag(uint32 CharID)
 {
+	_eqp
     if(!m_db)
 		return false;
 
@@ -821,18 +850,20 @@ 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);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, note, len);
 
 	//insert the new `guilds` entry
@@ -851,6 +882,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 }
 
 bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
+	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -867,18 +899,19 @@ 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.`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` "
+"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 "
 #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];
@@ -906,6 +939,7 @@ static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
 
 
 bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo *> &members) {
+	_eqp
 	members.clear();
 
 	if(m_db == nullptr)
@@ -918,8 +952,8 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		return false;
 	}
 
-	for (auto row = results.begin(); row != results.end(); ++row) {
-		auto ci = new CharGuildInfo;
+    for (auto row = results.begin(); row != results.end(); ++row) {
+		CharGuildInfo *ci = new CharGuildInfo;
 		ProcessGuildMember(row, *ci);
 		members.push_back(ci);
 	}
@@ -930,6 +964,7 @@ 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);
@@ -937,7 +972,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 
 	//escape our strings.
 	uint32 nl = strlen(char_name);
-	auto esc = new char[nl * 2 + 1];
+	char *esc = new char[nl*2+1];
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
@@ -961,6 +996,7 @@ 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;
@@ -969,7 +1005,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.mob_type = 'C'", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id);
 #else
     query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
 #endif
@@ -991,10 +1027,11 @@ 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);
-	auto buffer = new uint8[length];
+	uint8 *buffer = new uint8[length];
 
 	//a bit little better than memsetting the whole thing...
 	uint32 r,pos;
@@ -1018,6 +1055,7 @@ 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;
@@ -1028,6 +1066,7 @@ 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;
@@ -1038,6 +1077,7 @@ 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())
@@ -1048,6 +1088,7 @@ 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)
@@ -1060,6 +1101,7 @@ 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())
@@ -1071,6 +1113,7 @@ 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())
@@ -1082,6 +1125,7 @@ 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())
@@ -1091,12 +1135,14 @@ 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);
@@ -1112,6 +1158,7 @@ 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();
@@ -1124,6 +1171,7 @@ 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())
@@ -1136,6 +1184,7 @@ 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
@@ -1157,6 +1206,7 @@ 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);
@@ -1182,6 +1232,7 @@ 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())
@@ -1201,18 +1252,21 @@ 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_profile.h

@@ -1,230 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  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 COMMON_INVENTORY_PROFILE_H
-#define COMMON_INVENTORY_PROFILE_H
-
-
-#include "item_instance.h"
-
-#include <list>
-
-
-//FatherNitwit: location bits for searching specific
-//places with HasItem() and HasItemByUse()
-enum {
-	invWhereWorn		= 0x01,
-	invWherePersonal	= 0x02,	//in the character's inventory
-	invWhereBank		= 0x04,
-	invWhereSharedBank	= 0x08,
-	invWhereTrading		= 0x10,
-	invWhereCursor		= 0x20
-};
-
-// ########################################
-// Class: Queue
-//	Queue that allows a read-only iterator
-class ItemInstQueue
-{
-public:
-	~ItemInstQueue();
-	/////////////////////////
-	// Public Methods
-	/////////////////////////
-
-	inline std::list<EQEmu::ItemInstance*>::const_iterator cbegin() { return m_list.cbegin(); }
-	inline std::list<EQEmu::ItemInstance*>::const_iterator cend() { return m_list.cend(); }
-
-	inline int size() { return static_cast<int>(m_list.size()); } // TODO: change to size_t
-	inline bool empty() { return m_list.empty(); }
-
-	void push(EQEmu::ItemInstance* inst);
-	void push_front(EQEmu::ItemInstance* inst);
-	EQEmu::ItemInstance* pop();
-	EQEmu::ItemInstance* pop_back();
-	EQEmu::ItemInstance* peek_front() const;
-
-protected:
-	/////////////////////////
-	// Protected Members
-	/////////////////////////
-
-	std::list<EQEmu::ItemInstance*> m_list;
-};
-
-// ########################################
-// Class: EQEmu::InventoryProfile
-//	Character inventory
-namespace EQEmu
-{
-	class InventoryProfile
-	{
-		friend class ItemInstance;
-	public:
-		///////////////////////////////
-		// Public Methods
-		///////////////////////////////
-
-		InventoryProfile() { m_mob_version = versions::MobVersion::Unknown; m_mob_version_set = false; }
-		~InventoryProfile();
-
-		bool SetInventoryVersion(versions::MobVersion inventory_version) {
-			if (!m_mob_version_set) {
-				m_mob_version = versions::ValidateMobVersion(inventory_version);
-				return (m_mob_version_set = true);
-			}
-			else {
-				return false;
-			}
-		}
-		bool SetInventoryVersion(versions::ClientVersion client_version) { return SetInventoryVersion(versions::ConvertClientVersionToMobVersion(client_version)); }
-
-		versions::MobVersion InventoryVersion() { return m_mob_version; }
-
-		static void CleanDirty();
-		static void MarkDirty(ItemInstance *inst);
-
-		// Retrieve a writeable item at specified slot
-		ItemInstance* GetItem(int16 slot_id) const;
-		ItemInstance* GetItem(int16 slot_id, uint8 bagidx) const;
-
-		inline std::list<ItemInstance*>::const_iterator cursor_cbegin() { return m_cursor.cbegin(); }
-		inline std::list<ItemInstance*>::const_iterator cursor_cend() { return m_cursor.cend(); }
-
-		inline int CursorSize() { return m_cursor.size(); }
-		inline bool CursorEmpty() { return m_cursor.empty(); }
-
-		// Retrieve a read-only item from inventory
-		inline const ItemInstance* operator[](int16 slot_id) const { return GetItem(slot_id); }
-
-		// Add item to inventory
-		int16 PutItem(int16 slot_id, const ItemInstance& inst);
-
-		// Add item to cursor queue
-		int16 PushCursor(const ItemInstance& inst);
-
-		// Get cursor item in front of queue
-		ItemInstance* GetCursorItem();
-
-		// Swap items in inventory
-		bool SwapItem(int16 slot_a, int16 slot_b);
-
-		// Remove item from inventory
-		bool DeleteItem(int16 slot_id, uint8 quantity = 0);
-
-		// Checks All items in a bag for No Drop
-		bool CheckNoDrop(int16 slot_id, bool recurse = true);
-
-		// Remove item from inventory (and take control of memory)
-		ItemInstance* PopItem(int16 slot_id);
-
-		// Check whether there is space for the specified number of the specified item.
-		bool HasSpaceForItem(const ItemData *ItemToTry, int16 Quantity);
-
-		// Check whether item exists in inventory
-		// where argument specifies OR'd list of invWhere constants to look
-		int16 HasItem(uint32 item_id, uint8 quantity = 0, uint8 where = 0xFF);
-
-		// Check whether item exists in inventory
-		// where argument specifies OR'd list of invWhere constants to look
-		int16 HasItemByUse(uint8 use, uint8 quantity = 0, uint8 where = 0xFF);
-
-		// Check whether item exists in inventory
-		// where argument specifies OR'd list of invWhere constants to look
-		int16 HasItemByLoreGroup(uint32 loregroup, uint8 where = 0xFF);
-
-		// Locate an available inventory slot
-		int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
-		int16 FindFreeSlotForTradeItem(const ItemInstance* inst);
-
-		// Calculate slot_id for an item within a bag
-		static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id
-		static int16 CalcSlotId(int16 bagslot_id, uint8 bagidx); // Calc slot_id for item inside bag
-		static uint8 CalcBagIdx(int16 slot_id); // Calc bagidx for slot_id
-		static int16 CalcSlotFromMaterial(uint8 material);
-		static uint8 CalcMaterialFromSlot(int16 equipslot);
-
-		static bool CanItemFitInContainer(const ItemData *ItemToTry, const ItemData *Container);
-
-		//  Test for valid inventory casting slot
-		bool SupportsClickCasting(int16 slot_id);
-		bool SupportsPotionBeltCasting(int16 slot_id);
-
-		// Test whether a given slot can support a container item
-		static bool SupportsContainers(int16 slot_id);
-
-		int GetSlotByItemInst(ItemInstance *inst);
-
-		uint8 FindBrightestLightType();
-
-		void dumpEntireInventory();
-		void dumpWornItems();
-		void dumpInventory();
-		void dumpBankItems();
-		void dumpSharedBankItems();
-
-		void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, std::string value);
-		void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, int value);
-		void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, float value);
-		void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, bool value);
-		std::string GetCustomItemData(int16 slot_id, std::string identifier);
-	protected:
-		///////////////////////////////
-		// Protected Methods
-		///////////////////////////////
-
-		int GetSlotByItemInstCollection(const std::map<int16, ItemInstance*> &collection, ItemInstance *inst);
-		void dumpItemCollection(const std::map<int16, ItemInstance*> &collection);
-		void dumpBagContents(ItemInstance *inst, std::map<int16, ItemInstance*>::const_iterator *it);
-
-		// Retrieves item within an inventory bucket
-		ItemInstance* _GetItem(const std::map<int16, ItemInstance*>& bucket, int16 slot_id) const;
-
-		// Private "put" item into bucket, without regard for what is currently in bucket
-		int16 _PutItem(int16 slot_id, ItemInstance* inst);
-
-		// Checks an inventory bucket for a particular item
-		int16 _HasItem(std::map<int16, ItemInstance*>& bucket, uint32 item_id, uint8 quantity);
-		int16 _HasItem(ItemInstQueue& iqueue, uint32 item_id, uint8 quantity);
-		int16 _HasItemByUse(std::map<int16, ItemInstance*>& bucket, uint8 use, uint8 quantity);
-		int16 _HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint8 quantity);
-		int16 _HasItemByLoreGroup(std::map<int16, ItemInstance*>& bucket, uint32 loregroup);
-		int16 _HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup);
-
-
-		// Player inventory
-		std::map<int16, ItemInstance*>	m_worn;		// Items worn by character
-		std::map<int16, ItemInstance*>	m_inv;		// Items in character personal inventory
-		std::map<int16, ItemInstance*>	m_bank;		// Items in character bank
-		std::map<int16, ItemInstance*>	m_shbank;	// Items in character shared bank
-		std::map<int16, ItemInstance*>	m_trade;	// Items in a trade session
-		::ItemInstQueue					m_cursor;	// Items on cursor: FIFO
-
-	private:
-		// Active mob version
-		versions::MobVersion m_mob_version;
-		bool m_mob_version_set;
-	};
-}
-
-#endif /*COMMON_INVENTORY_PROFILE_H*/

common/inventory_slot.cpp

@@ -1,397 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "inventory_slot.h"
-#include "textures.h"
-#include "string_util.h"
-
-
-int8 EQEmu::inventory::ConvertEquipmentIndexToTextureIndex(int16 slot_index)
-{
-	switch (slot_index) {
-	case slotHead:
-		return textures::armorHead;
-	case slotChest:
-		return textures::armorChest;
-	case slotArms:
-		return textures::armorArms;
-	case slotWrist1:
-		return textures::armorWrist;
-	case slotHands:
-		return textures::armorHands;
-	case slotLegs:
-		return textures::armorLegs;
-	case slotFeet:
-		return textures::armorFeet;
-	case slotPrimary:
-		return textures::weaponPrimary;
-	case slotSecondary:
-		return textures::weaponSecondary;
-	default:
-		return textures::textureInvalid;
-	}
-}
-
-int8 EQEmu::inventory::ConvertEquipmentSlotToTextureIndex(const InventorySlot& inventory_slot)
-{
-	if ((!inventory_slot.Typeless() && !inventory_slot.IsTypeIndex(typePossessions)) || !inventory_slot.IsContainerIndex(containerInvalid) || !inventory_slot.IsSocketIndex(socketInvalid))
-		return textures::textureInvalid;
-
-	return ConvertEquipmentIndexToTextureIndex(inventory_slot.SlotIndex());
-}
-
-int16 EQEmu::inventory::ConvertTextureIndexToEquipmentIndex(int8 texture_index)
-{
-	switch (texture_index) {
-	case textures::armorHead:
-		return slotHead;
-	case textures::armorChest:
-		return slotChest;
-	case textures::armorArms:
-		return slotArms;
-	case textures::armorWrist:
-		return slotWrist1;
-	case textures::armorHands:
-		return slotHands;
-	case textures::armorLegs:
-		return slotLegs;
-	case textures::armorFeet:
-		return slotFeet;
-	case textures::weaponPrimary:
-		return slotPrimary;
-	case textures::weaponSecondary:
-		return slotSecondary;
-	default:
-		return slotInvalid;
-	}
-}
-
-bool EQEmu::InventorySlot::IsValidSlot() const
-{
-	if (_typeless)
-		return false;
-	
-	int16 slot_count = inventory::SlotCount(_type_index);
-	if (!slot_count || _slot_index < inventory::slotBegin || _slot_index >= slot_count)
-		return false;
-
-	if (_container_index < inventory::containerInvalid || _container_index >= inventory::ContainerCount)
-		return false;
-
-	if (_socket_index < inventory::socketInvalid || _socket_index >= inventory::SocketCount)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsDeleteSlot() const
-{
-	if (_typeless)
-		return (_slot_index == inventory::slotInvalid && _container_index == inventory::containerInvalid && _socket_index == inventory::socketInvalid);
-	else
-		return (_type_index == inventory::typeInvalid && _slot_index == inventory::slotInvalid && _container_index == inventory::containerInvalid && _socket_index == inventory::socketInvalid);
-}
-
-bool EQEmu::InventorySlot::IsEquipmentIndex(int16 slot_index)
-{
-	/*if (slot_index < inventory::EquipmentBegin || slot_index > inventory::EquipmentEnd)
-		return false;*/
-	if ((slot_index < legacy::EQUIPMENT_BEGIN || slot_index > legacy::EQUIPMENT_END) && slot_index != legacy::SLOT_POWER_SOURCE)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsGeneralIndex(int16 slot_index)
-{
-	/*if (slot_index < inventory::GeneralBegin || slot_index > inventory::GeneralEnd)
-		return false;*/
-	if (slot_index < legacy::GENERAL_BEGIN || slot_index > legacy::GENERAL_END)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsCursorIndex(int16 slot_index)
-{
-	/*if (slot_index != inventory::slotCursor)
-		return false;*/
-	if (slot_index != legacy::SLOT_CURSOR)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsWeaponIndex(int16 slot_index)
-{
-	/*if ((slot_index != inventory::slotRange) && (slot_index != inventory::slotPrimary) && (slot_index != inventory::slotSecondary))
-		return false;*/
-	if ((slot_index != legacy::SLOT_RANGE) && (slot_index != legacy::SLOT_PRIMARY) && (slot_index != legacy::SLOT_SECONDARY))
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsTextureIndex(int16 slot_index)
-{
-	switch (slot_index) {
-	case inventory::slotHead:
-	case inventory::slotChest:
-	case inventory::slotArms:
-	case inventory::slotWrist1:
-	case inventory::slotHands:
-	case inventory::slotLegs:
-	case inventory::slotFeet:
-	case inventory::slotPrimary:
-	case inventory::slotSecondary:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool EQEmu::InventorySlot::IsTintableIndex(int16 slot_index)
-{
-	switch (slot_index) {
-	case inventory::slotHead:
-	case inventory::slotChest:
-	case inventory::slotArms:
-	case inventory::slotWrist1:
-	case inventory::slotHands:
-	case inventory::slotLegs:
-	case inventory::slotFeet:
-		return true;
-	default:
-		return false;
-	}
-}
-
-bool EQEmu::InventorySlot::IsEquipmentSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsEquipmentIndex(_slot_index);
-}
-
-bool EQEmu::InventorySlot::IsGeneralSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsGeneralIndex(_socket_index);
-}
-
-bool EQEmu::InventorySlot::IsCursorSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsCursorIndex(_slot_index);
-}
-
-bool EQEmu::InventorySlot::IsWeaponSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsWeaponIndex(_slot_index);
-}
-
-bool EQEmu::InventorySlot::IsTextureSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsTextureIndex(_slot_index);
-}
-
-bool EQEmu::InventorySlot::IsTintableSlot() const
-{
-	if (!_typeless && (_type_index != inventory::typePossessions))
-		return false;
-
-	if ((_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-		return false;
-
-	return IsTintableIndex(_slot_index);
-}
-
-bool EQEmu::InventorySlot::IsSlot() const
-{
-	if (!_typeless && (_type_index == inventory::typeInvalid))
-		return false;
-	if (_slot_index == inventory::slotInvalid)
-		return false;
-	if (_container_index != inventory::containerInvalid)
-		return false;
-	if (_socket_index != inventory::socketInvalid)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsSlotSocket() const
-{
-	if (!_typeless && (_type_index == inventory::typeInvalid))
-		return false;
-	if (_slot_index == inventory::slotInvalid)
-		return false;
-	if (_container_index != inventory::containerInvalid)
-		return false;
-	if (_socket_index == inventory::socketInvalid)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsContainer() const
-{
-	if (!_typeless && (_type_index == inventory::typeInvalid))
-		return false;
-	if (_slot_index == inventory::slotInvalid)
-		return false;
-	if (_container_index == inventory::containerInvalid)
-		return false;
-	if (_socket_index != inventory::socketInvalid)
-		return false;
-
-	return true;
-}
-
-bool EQEmu::InventorySlot::IsContainerSocket() const
-{
-	if (!_typeless && (_type_index == inventory::typeInvalid))
-		return false;
-	if (_slot_index == inventory::slotInvalid)
-		return false;
-	if (_container_index == inventory::containerInvalid)
-		return false;
-	if (_socket_index == inventory::socketInvalid)
-		return false;
-
-	return true;
-}
-
-EQEmu::InventorySlot EQEmu::InventorySlot::ToTopOwner() const
-{
-	return InventorySlot(_type_index, _slot_index);
-}
-
-EQEmu::InventorySlot EQEmu::InventorySlot::ToOwner() const
-{
-	if (IsSlot() || IsSlotSocket() || IsContainer())
-		return InventorySlot(_type_index, _slot_index);
-
-	if (IsContainerSocket())
-		return InventorySlot(_type_index, _slot_index, _container_index);
-
-	return InventorySlot();
-}
-
-const std::string EQEmu::InventorySlot::ToString() const
-{
-	return StringFormat("(%i%s, %i, %i, %i)", _type_index, (_typeless ? " [typeless]" : ""), _slot_index, _container_index, _socket_index);
-}
-
-const std::string EQEmu::InventorySlot::ToName() const
-{
-	return StringFormat("InventorySlot - _type_index: %i%s, _slot_index: %i, _container_index: %i, _socket_index: %i", _type_index, (_typeless ? " [typeless]" : ""), _slot_index, _container_index, _socket_index);
-}
-
-void EQEmu::InventorySlot::SetInvalidSlot()
-{
-	_type_index = inventory::typeInvalid;
-	_slot_index = inventory::slotInvalid;
-	_container_index = inventory::containerInvalid;
-	_socket_index = inventory::socketInvalid;
-}
-
-//bool EQEmu::InventorySlot::IsBonusIndex(int16 slot_index)
-//{
-//	if ((slot_index >= inventory::EquipmentBegin) && (slot_index <= inventory::EquipmentEnd) && (slot_index != inventory::slotAmmo))
-//		return true;
-//
-//	return false;
-//}
-
-//bool EQEmu::InventorySlot::IsBonusSlot() const
-//{
-//	if ((_type_index != inventory::typePossessions) || (_container_index != inventory::containerInvalid) || (_socket_index != inventory::socketInvalid))
-//		return false;
-//
-//	return IsBonusIndex(_slot_index);
-//}
-
-bool inventory_slot_typeless_lessthan(const EQEmu::InventorySlot& lhs, const EQEmu::InventorySlot& rhs)
-{
-	if (lhs.SlotIndex() < rhs.SlotIndex())
-		return true;
-
-	if ((lhs.SlotIndex() == rhs.SlotIndex()) && (lhs.ContainerIndex() < rhs.ContainerIndex()))
-		return true;
-
-	if ((lhs.SlotIndex() == rhs.SlotIndex()) && (lhs.ContainerIndex() == rhs.ContainerIndex()) && (lhs.SocketIndex() < rhs.SocketIndex()))
-		return true;
-
-	return false;
-}
-
-bool EQEmu::InventorySlot::operator<(const InventorySlot& rhs) const
-{
-	if (Typeless() || rhs.Typeless())
-		return inventory_slot_typeless_lessthan(*this, rhs);
-	
-	if (TypeIndex() < rhs.TypeIndex())
-		return true;
-
-	if ((TypeIndex() == rhs.TypeIndex()) && (SlotIndex() < rhs.SlotIndex()))
-		return true;
-
-	if ((TypeIndex() == rhs.TypeIndex()) && (SlotIndex() == rhs.SlotIndex()) && (ContainerIndex() < rhs.ContainerIndex()))
-		return true;
-
-	if ((TypeIndex() == rhs.TypeIndex()) && (SlotIndex() == rhs.SlotIndex()) && (ContainerIndex() == rhs.ContainerIndex()) && (SocketIndex() < rhs.SocketIndex()))
-		return true;
-
-	return false;
-}
-
-bool EQEmu::operator==(const InventorySlot& lhs, const InventorySlot& rhs)
-{
-	if (lhs.Typeless() || rhs.Typeless())
-		return ((lhs.SlotIndex() == rhs.SlotIndex()) && (lhs.ContainerIndex() == rhs.ContainerIndex()) && (lhs.SocketIndex() == rhs.SocketIndex()));
-	
-	return ((lhs.TypeIndex() == rhs.TypeIndex()) && (lhs.SlotIndex() == rhs.SlotIndex()) && (lhs.ContainerIndex() == rhs.ContainerIndex()) && (lhs.SocketIndex() == rhs.SocketIndex()));
-}

common/inventory_slot.h

@@ -1,133 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_INVENTORY_SLOT
-#define COMMON_INVENTORY_SLOT
-
-#include "emu_constants.h"
-
-
-namespace EQEmu
-{
-	class InventorySlot;
-
-	namespace inventory {
-		int8 ConvertEquipmentIndexToTextureIndex(int16 slot_index);
-		int8 ConvertEquipmentSlotToTextureIndex(const InventorySlot& inventory_slot);
-		int16 ConvertTextureIndexToEquipmentIndex(int8 texture_index);
-	}
-	
-	class InventorySlot {
-	public:
-		InventorySlot() : _type_index(inventory::typeInvalid), _slot_index(inventory::slotInvalid), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index) : _type_index(type_index), _slot_index(inventory::slotInvalid), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index, int16 parent_index) : _type_index(type_index), _slot_index(parent_index), _container_index(inventory::containerInvalid), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index, int16 parent_index, int16 bag_index) : _type_index(type_index), _slot_index(parent_index), _container_index(bag_index), _socket_index(inventory::socketInvalid), _typeless(false) { }
-		InventorySlot(int16 type_index, int16 parent_index, int16 bag_index, int16 aug_index) : _type_index(type_index), _slot_index(parent_index), _container_index(bag_index), _socket_index(aug_index), _typeless(false) { }
-		InventorySlot(const InventorySlot& r) : _type_index(r._type_index), _slot_index(r._slot_index), _container_index(r._container_index), _socket_index(r._socket_index), _typeless(r._typeless) { }
-		InventorySlot(int16 type_index, const InventorySlot& r) : _type_index(type_index), _slot_index(r._slot_index), _container_index(r._container_index), _socket_index(r._socket_index), _typeless(false) { }
-
-		inline int16 TypeIndex() const { return _type_index; }
-		inline int16 SlotIndex() const { return _slot_index; }
-		inline int16 ContainerIndex() const { return _container_index; }
-		inline int16 SocketIndex() const { return _socket_index; }
-
-		bool Typeless() const { return _typeless; }
-
-		bool IsValidSlot() const;
-		bool IsDeleteSlot() const;
-
-		static bool IsEquipmentIndex(int16 slot_index);
-		static bool IsGeneralIndex(int16 slot_index);
-		static bool IsCursorIndex(int16 slot_index);
-		static bool IsWeaponIndex(int16 slot_index);
-		static bool IsTextureIndex(int16 slot_index);
-		static bool IsTintableIndex(int16 slot_index);
-
-		bool IsEquipmentSlot() const;
-		bool IsGeneralSlot() const;
-		bool IsCursorSlot() const;
-		bool IsWeaponSlot() const;
-		bool IsTextureSlot() const;
-		bool IsTintableSlot() const;
-
-		bool IsSlot() const;
-		bool IsSlotSocket() const;
-		bool IsContainer() const;
-		bool IsContainerSocket() const;
-
-		InventorySlot ToTopOwner() const;
-		InventorySlot ToOwner() const;
-
-		const std::string ToString() const;
-		const std::string ToName() const;
-
-		bool IsTypeIndex(int16 type_index) const { return (_type_index == type_index); }
-		bool IsSlotIndex(int16 slot_index) const { return (_slot_index == slot_index); }
-		bool IsContainerIndex(int16 container_index) const { return (_container_index == container_index); }
-		bool IsSocketIndex(int16 socket_index) const { return (_socket_index == socket_index); }
-
-		void SetType(int16 type_index) { _type_index = type_index; }
-		void SetSlot(int16 slot_index) { _slot_index = slot_index; }
-		void SetContainer(int16 container_index) { _container_index = container_index; }
-		void SetSocket(int16 socket_index) { _socket_index = socket_index; }
-
-		void SetInvalidSlot();
-
-		void SetTypeInvalid() { _type_index = inventory::typeInvalid; }
-		void SetSlotInvalid() { _slot_index = inventory::slotInvalid; }
-		void SetContainerInvalid() { _container_index = inventory::containerInvalid; }
-		void SetSocketInvalid() { _socket_index = inventory::socketInvalid; }
-
-		void SetTypeBegin() { _type_index = inventory::typeBegin; }
-		void SetSlotBegin() { _slot_index = inventory::slotBegin; }
-		void SetContainerBegin() { _container_index = inventory::containerBegin; }
-		void SetSocketBegin() { _socket_index = inventory::socketBegin; }
-
-		void IncrementType() { ++_type_index; }
-		void IncrementSlot() { ++_slot_index; }
-		void IncrementContainer() { ++_container_index; }
-		void IncrementSocket() { ++_socket_index; }
-
-		void SetTypeless() { _typeless = true; }
-		void ClearTypeless() { _typeless = false; }
-
-		// these two methods should really check for all bonus-valid slots..currently checks for equipment only (rework needed)
-		//static bool IsBonusIndex(int16 slot_index);
-		//bool IsBonusSlot() const;
-
-		bool operator<(const InventorySlot& rhs) const;
-
-	private:
-		int16 _type_index;
-		//int16 _unknown2; // not implemented
-		int16 _slot_index;
-		int16 _container_index;
-		int16 _socket_index;
-		//int16 _unknown1; // not implemented
-
-		bool _typeless;
-	};
-
-	bool operator==(const InventorySlot& lhs, const InventorySlot& rhs);
-	bool operator!=(const InventorySlot& lhs, const InventorySlot& rhs) { return (!(lhs == rhs)); }
-
-} /*EQEmu*/
-
-#endif /*COMMON_INVENTORY_SLOT*/

common/ipc_mutex.cpp

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

common/item.h

@@ -0,0 +1,475 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is 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
+*/
+
+// @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
+
+class ItemParse;			// Parses item packets
+class EvolveInfo;			// Stores information about an evolving item family
+
+#include "../common/eq_constants.h"
+#include "../common/item_struct.h"
+#include "../common/timer.h"
+
+#include <list>
+#include <map>
+
+
+namespace ItemField
+{
+	enum
+	{
+		source = 0,
+#define F(x) x,
+#include "item_fieldlist.h"
+#undef F
+		updated
+	};
+};
+
+// Specifies usage type for item inside ItemInst
+enum ItemInstTypes
+{
+	ItemInstNormal = 0,
+	ItemInstWorldContainer
+};
+
+typedef enum {
+	byFlagIgnore,	//do not consider this flag
+	byFlagSet,		//apply action if the flag is set
+	byFlagNotSet	//apply action if the flag is NOT set
+} byFlagSetting;
+
+
+//FatherNitwit: location bits for searching specific
+//places with HasItem() and HasItemByUse()
+enum {
+	invWhereWorn		= 0x01,
+	invWherePersonal	= 0x02,	//in the character's inventory
+	invWhereBank		= 0x04,
+	invWhereSharedBank	= 0x08,
+	invWhereTrading		= 0x10,
+	invWhereCursor		= 0x20
+};
+
+
+// ########################################
+// Class: Queue
+//	Queue that allows a read-only iterator
+class ItemInstQueue
+{
+public:
+	~ItemInstQueue();
+	/////////////////////////
+	// Public Methods
+	/////////////////////////
+
+	inline std::list<ItemInst*>::const_iterator cbegin() { return m_list.cbegin(); }
+	inline std::list<ItemInst*>::const_iterator cend() { return m_list.cend(); }
+
+	inline int size() { return static_cast<int>(m_list.size()); } // TODO: change to size_t
+	inline bool empty() { return m_list.empty(); }
+
+	void push(ItemInst* inst);
+	void push_front(ItemInst* inst);
+	ItemInst* pop();
+	ItemInst* pop_back();
+	ItemInst* peek_front() const;
+
+protected:
+	/////////////////////////
+	// Protected Members
+	/////////////////////////
+
+	std::list<ItemInst*> m_list;
+};
+
+// ########################################
+// Class: Inventory
+//	Character inventory
+class Inventory
+{
+	friend class ItemInst;
+public:
+	///////////////////////////////
+	// Public Methods
+	///////////////////////////////
+
+	Inventory() { m_version = ClientVersion::Unknown; m_versionset = false; }
+	~Inventory();
+
+	// Inventory v2 creep
+	bool SetInventoryVersion(ClientVersion version) {
+		if (!m_versionset) {
+			m_version = version;
+			return (m_versionset = true);
+		}
+		else {
+			return false;
+		}
+	}
+
+	ClientVersion GetInventoryVersion() { return m_version; }
+
+	static void CleanDirty();
+	static void MarkDirty(ItemInst *inst);
+
+	// Retrieve a writeable item at specified slot
+	ItemInst* GetItem(int16 slot_id) const;
+	ItemInst* GetItem(int16 slot_id, uint8 bagidx) const;
+
+	inline std::list<ItemInst*>::const_iterator cursor_cbegin() { return m_cursor.cbegin(); }
+	inline std::list<ItemInst*>::const_iterator cursor_cend() { return m_cursor.cend(); }
+
+	inline int CursorSize() { return m_cursor.size(); }
+	inline bool CursorEmpty() { return m_cursor.empty(); }
+
+	// Retrieve a read-only item from inventory
+	inline const ItemInst* operator[](int16 slot_id) const { return GetItem(slot_id); }
+
+	// Add item to inventory
+	int16 PutItem(int16 slot_id, const ItemInst& inst);
+
+	// Add item to cursor queue
+	int16 PushCursor(const ItemInst& inst);
+
+	// Get cursor item in front of queue
+	ItemInst* GetCursorItem();
+
+	// Swap items in inventory
+	bool SwapItem(int16 slot_a, int16 slot_b);
+
+	// Remove item from inventory
+	bool DeleteItem(int16 slot_id, uint8 quantity=0);
+
+	// Checks All items in a bag for No Drop
+	bool CheckNoDrop(int16 slot_id);
+
+	// Remove item from inventory (and take control of memory)
+	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);
+
+	// Check whether item exists in inventory
+	// where argument specifies OR'd list of invWhere constants to look
+	int16 HasItem(uint32 item_id, uint8 quantity = 0, uint8 where = 0xFF);
+
+	// Check whether item exists in inventory
+	// where argument specifies OR'd list of invWhere constants to look
+	int16 HasItemByUse(uint8 use, uint8 quantity=0, uint8 where=0xFF);
+
+	// Check whether item exists in inventory
+	// where argument specifies OR'd list of invWhere constants to look
+	int16 HasItemByLoreGroup(uint32 loregroup, uint8 where=0xFF);
+
+	// Locate an available inventory slot
+	int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
+	int16 FindFreeSlotForTradeItem(const ItemInst* inst);
+
+	// Calculate slot_id for an item within a bag
+	static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id
+	static int16 CalcSlotId(int16 bagslot_id, uint8 bagidx); // Calc slot_id for item inside bag
+	static uint8 CalcBagIdx(int16 slot_id); // Calc bagidx for slot_id
+	static int16 CalcSlotFromMaterial(uint8 material);
+	static uint8 CalcMaterialFromSlot(int16 equipslot);
+
+	static bool CanItemFitInContainer(const Item_Struct *ItemToTry, const Item_Struct *Container);
+
+	//  Test for valid inventory casting slot
+	bool SupportsClickCasting(int16 slot_id);
+	bool SupportsPotionBeltCasting(int16 slot_id);
+
+	// Test whether a given slot can support a container item
+	static bool SupportsContainers(int16 slot_id);
+
+	int GetSlotByItemInst(ItemInst *inst);
+
+	uint8 FindHighestLightValue();
+
+	void dumpEntireInventory();
+	void dumpWornItems();
+	void dumpInventory();
+	void dumpBankItems();
+	void dumpSharedBankItems();
+
+	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, std::string value);
+	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, int value);
+	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, float value);
+	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, bool value);
+	std::string GetCustomItemData(int16 slot_id, std::string identifier);
+protected:
+	///////////////////////////////
+	// Protected Methods
+	///////////////////////////////
+
+	int GetSlotByItemInstCollection(const std::map<int16, ItemInst*> &collection, ItemInst *inst);
+	void dumpItemCollection(const std::map<int16, ItemInst*> &collection);
+	void dumpBagContents(ItemInst *inst, std::map<int16, ItemInst*>::const_iterator *it);
+
+	// Retrieves item within an inventory bucket
+	ItemInst* _GetItem(const std::map<int16, ItemInst*>& bucket, int16 slot_id) const;
+
+	// Private "put" item into bucket, without regard for what is currently in bucket
+	int16 _PutItem(int16 slot_id, ItemInst* inst);
+
+	// Checks an inventory bucket for a particular item
+	int16 _HasItem(std::map<int16, ItemInst*>& bucket, uint32 item_id, uint8 quantity);
+	int16 _HasItem(ItemInstQueue& iqueue, uint32 item_id, uint8 quantity);
+	int16 _HasItemByUse(std::map<int16, ItemInst*>& bucket, uint8 use, uint8 quantity);
+	int16 _HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint8 quantity);
+	int16 _HasItemByLoreGroup(std::map<int16, ItemInst*>& bucket, uint32 loregroup);
+	int16 _HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup);
+
+
+	// Player inventory
+	std::map<int16, ItemInst*>	m_worn;		// Items worn by character
+	std::map<int16, ItemInst*>	m_inv;		// Items in character personal inventory
+	std::map<int16, ItemInst*>	m_bank;		// Items in character bank
+	std::map<int16, ItemInst*>	m_shbank;	// Items in character shared bank
+	std::map<int16, ItemInst*>	m_trade;	// Items in a trade session
+	ItemInstQueue				m_cursor;	// Items on cursor: FIFO
+
+private:
+	// Active inventory version
+	ClientVersion m_version;
+	bool m_versionset;
+};
+
+class SharedDatabase;
+
+// ########################################
+// Class: ItemInst
+//	Base class for an instance of an item
+//	An item instance encapsulates item data + data specific
+//	to an item instance (includes dye, augments, charges, etc)
+class ItemInst
+{
+public:
+	/////////////////////////
+	// Methods
+	/////////////////////////
+
+	// Constructors/Destructor
+	ItemInst(const Item_Struct* item = nullptr, int16 charges = 0);
+
+	ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0);
+
+	ItemInst(ItemInstTypes use_type);
+
+	ItemInst(const ItemInst& copy);
+
+	~ItemInst();
+
+	// Query item type
+	bool IsType(ItemClassTypes item_class) const;
+
+	// Can item be stacked?
+	bool IsStackable() const;
+	bool IsCharged() const;
+
+	// Can item be equipped by/at?
+	bool IsEquipable(uint16 race, uint16 class_) const;
+	bool IsEquipable(int16 slot_id) const;
+
+	//
+	// Augments
+	//
+	bool IsAugmentable() const;
+	bool AvailableWearSlot(uint32 aug_wear_slots) const;
+	int8 AvailableAugmentSlot(int32 augtype) const;
+	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); }
+
+	//
+	// Contents
+	//
+	ItemInst* GetItem(uint8 slot) const;
+	uint32 GetItemID(uint8 slot) const;
+	inline const ItemInst* operator[](uint8 slot) const { return GetItem(slot); }
+	void PutItem(uint8 slot, const ItemInst& inst);
+	void PutItem(SharedDatabase *db, uint8 slot, uint32 item_id) { return; } // not defined anywhere...
+	void DeleteItem(uint8 slot);
+	ItemInst* PopItem(uint8 index);
+	void Clear();
+	void ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent);
+	uint8 FirstOpenSlot() const;
+	uint8 GetTotalItemCount() const;
+	bool IsNoneEmptyContainer();
+	std::map<uint8, ItemInst*>* GetContents() { return &m_contents; }
+
+	//
+	// Augments
+	//
+	ItemInst* GetAugment(uint8 slot) const;
+	uint32 GetAugmentItemID(uint8 slot) const;
+	void PutAugment(uint8 slot, const ItemInst& inst);
+	void PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id);
+	void DeleteAugment(uint8 slot);
+	ItemInst* RemoveAugment(uint8 index);
+	bool IsAugmented();
+	ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const;
+	bool UpdateOrnamentationInfo();
+	static bool CanTransform(const Item_Struct *ItemToTry, const Item_Struct *Container, bool AllowAll = false);
+	
+	// Has attack/delay?
+	bool IsWeapon() const;
+	bool IsAmmo() const;
+
+	// 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;
+
+	int16 GetCharges() const				{ return m_charges; }
+	void SetCharges(int16 charges)			{ m_charges = charges; }
+
+	uint32 GetPrice() const					{ return m_price; }
+	void SetPrice(uint32 price)				{ m_price = price; }
+
+	void SetColor(uint32 color)				{ m_color = color; }
+	uint32 GetColor() const					{ return m_color; }
+
+	uint32 GetMerchantSlot() const			{ return m_merchantslot; }
+	void SetMerchantSlot(uint32 slot)		{ m_merchantslot = slot; }
+
+	int32 GetMerchantCount() const			{ return m_merchantcount; }
+	void SetMerchantCount(int32 count)		{ m_merchantcount = count; }
+
+	int16 GetCurrentSlot() const			{ return m_currentslot; }
+	void SetCurrentSlot(int16 curr_slot)	{ m_currentslot = curr_slot; }
+
+	// Is this item already attuned?
+	bool IsAttuned() const					{ return m_attuned; }
+	void SetAttuned(bool flag)				{ m_attuned=flag; }
+
+	std::string GetCustomDataString() const;
+	std::string GetCustomData(std::string identifier);
+	void SetCustomData(std::string identifier, std::string value);
+	void SetCustomData(std::string identifier, int value);
+	void SetCustomData(std::string identifier, float value);
+	void SetCustomData(std::string identifier, bool value);
+	void DeleteCustomData(std::string identifier);
+
+	// Allows treatment of this object as though it were a pointer to m_item
+	operator bool() const { return (m_item != nullptr); }
+
+	// Compare inner Item_Struct of two ItemInst objects
+	bool operator==(const ItemInst& right) const { return (this->m_item == right.m_item); }
+	bool operator!=(const ItemInst& right) const { return (this->m_item != right.m_item); }
+
+	// Clone current item
+	ItemInst* Clone() const;
+
+	bool IsSlotAllowed(int16 slot_id) const;
+
+	bool IsScaling() const				{ return m_scaling; }
+	bool IsEvolving() const				{ return (m_evolveLvl >= 1); }
+	uint32 GetExp() const				{ return m_exp; }
+	void SetExp(uint32 exp)				{ m_exp = exp; }
+	void AddExp(uint32 exp)				{ m_exp += exp; }
+	bool IsActivated()					{ return m_activated; }
+	void SetActivated(bool activated)	{ m_activated = activated; }
+	int8 GetEvolveLvl() const			{ return m_evolveLvl; }
+	void SetScaling(bool v)				{ m_scaling = v; }
+	uint32 GetOrnamentationIcon() const							{ return m_ornamenticon; }
+	void SetOrnamentIcon(uint32 ornament_icon)					{ m_ornamenticon = ornament_icon; }
+	uint32 GetOrnamentationIDFile() const						{ return m_ornamentidfile; }
+	void SetOrnamentationIDFile(uint32 ornament_idfile)			{ m_ornamentidfile = ornament_idfile; }
+	uint32 GetOrnamentHeroModel(int32 material_slot = -1) const;
+	void SetOrnamentHeroModel(uint32 ornament_hero_model)		{ m_ornament_hero_model = ornament_hero_model; }
+	uint32 GetRecastTimestamp() const							{ return m_recast_timestamp; }
+	void SetRecastTimestamp(uint32 in)							{ m_recast_timestamp = in; }
+
+	void Initialize(SharedDatabase *db = nullptr);
+	void ScaleItem();
+	bool EvolveOnAllKills() const;
+	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; }
+	inline int32 GetSerialNumber() const { return m_SerialNumber; }
+	inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
+
+	std::map<std::string, Timer>& GetTimers() { return m_timers; }
+	void SetTimer(std::string name, uint32 time);
+	void StopTimer(std::string name);
+	void ClearTimers();
+
+protected:
+	//////////////////////////
+	// Protected Members
+	//////////////////////////
+	std::map<uint8, ItemInst*>::const_iterator _cbegin() { return m_contents.cbegin(); }
+	std::map<uint8, ItemInst*>::const_iterator _cend() { return m_contents.cend(); }
+
+	friend class Inventory;
+
+
+	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
+	int16				m_charges;	// # of charges for chargeable items
+	uint32				m_price;	// Bazaar /trader price
+	uint32				m_color;
+	uint32				m_merchantslot;
+	int16				m_currentslot;
+	bool				m_attuned;
+	int32				m_merchantcount;		//number avaliable on the merchant, -1=unlimited
+	int32				m_SerialNumber;	// Unique identifier for this instance of an item. Needed for Bazaar.
+	uint32				m_exp;
+	int8				m_evolveLvl;
+	bool				m_activated;
+	Item_Struct*		m_scaledItem;
+	EvolveInfo*			m_evolveInfo;
+	bool				m_scaling;
+	uint32				m_ornamenticon;
+	uint32				m_ornamentidfile;
+	uint32				m_ornament_hero_model;
+	uint32				m_recast_timestamp;
+
+	//
+	// Items inside of this item (augs or contents);
+	std::map<uint8, ItemInst*>			m_contents; // Zero-based index: min=0, max=9
+	std::map<std::string, std::string>	m_custom_data;
+	std::map<std::string, Timer>		m_timers;
+};
+
+class EvolveInfo {
+public:
+	friend class ItemInst;
+	//temporary
+	uint16				LvlKills[9];
+	uint32				FirstItem;
+	uint8				MaxLvl;
+	bool				AllKills;
+
+	EvolveInfo();
+	EvolveInfo(uint32 first, uint8 max, bool allkills, uint32 L2, uint32 L3, uint32 L4, uint32 L5, uint32 L6, uint32 L7, uint32 L8, uint32 L9, uint32 L10);
+	~EvolveInfo();
+};
+
+#endif // #define __ITEM_H

common/item_data.cpp

@@ -1,209 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "item_data.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::ItemData::IsEquipable(uint16 race_id, uint16 class_id) const
-{
-	if (!(Races & GetPlayerRaceBit(race_id)))
-		return false;
-
-	if (!(Classes & GetPlayerClassBit(GetPlayerClassValue(class_id))))
-		return false;
-
-	return true;
-}
-
-bool EQEmu::ItemData::IsClassCommon() const
-{
-	return (ItemClass == item::ItemClassCommon);
-}
-
-bool EQEmu::ItemData::IsClassBag() const
-{
-	return (ItemClass == item::ItemClassBag);
-}
-
-bool EQEmu::ItemData::IsClassBook() const
-{
-	return (ItemClass == item::ItemClassBook);
-}
-
-bool EQEmu::ItemData::IsType1HWeapon() const
-{
-	return ((ItemType == item::ItemType1HBlunt) || (ItemType == item::ItemType1HSlash) || (ItemType == item::ItemType1HPiercing));
-}
-
-bool EQEmu::ItemData::IsType2HWeapon() const
-{
-	return ((ItemType == item::ItemType2HBlunt) || (ItemType == item::ItemType2HSlash) || (ItemType == item::ItemType2HPiercing));
-}
-
-bool EQEmu::ItemData::IsTypeShield() const
-{
-	return (ItemType == item::ItemTypeShield);
-}

common/item_data.h

@@ -1,545 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
-*/
-
-#ifndef COMMON_ITEM_DATA_H
-#define COMMON_ITEM_DATA_H
-
-
-/*
- * Note: (Doodman)
- *	This structure has field names that match the DB name exactly.
- *	Please take care as to not mess this up as it should make
- *	everyones life (i.e. mine) much easier. And the DB names
- *	match the field name from the 13th floor (SEQ) item collectors,
- *	so please maintain that as well.
- *
- * Note #2: (Doodman)
- *	UnkXXX fields are left in here for completeness but commented
- *	out since they are really unknown and since the items are now
- *	preserialized they should not be needed. Conversly if they
- *	-are- needed, then they shouldn't be unkown.
- *
- * Note #3: (Doodman)
- *	Please take care when adding new found data fields to add them
- *	to the appropriate structure. Item_Struct has elements that are
- *	global to all types of items only.
- *
- * Note #4: (Doodman)
- *	Made ya look! Ha!
- */
-
-#include "emu_constants.h"
-
-
-namespace EQEmu
-{
-	namespace item {
-		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
-
-/*
-			Unknowns:
-
-			Mounts?
-			Ornamentations?
-			GuildBanners?
-			Collectible? 
-			Placeable?
-			(others?)
-*/
-		};
-
-		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
-		};
-
-		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
-		};
-
-		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
-
-		// 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
-
-/*4687*/	//AugTypeAllItems, // ?? unknown atm
-/*4688*/	//AugTypePrestige, // ?? unknown atm
-/*4689*/	//AugTypeNonPrestige, // ?? unknown atm
-		};
-
-		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
-		};
-
-		enum ItemEffect {
-			ItemEffectCombatProc = 0,
-			ItemEffectClick,
-			ItemEffectWorn,
-			ItemEffectExpendable,
-			ItemEffectEquipClick,
-			ItemEffectClick2, //5		//name unknown
-			ItemEffectFocus,
-			ItemEffectScroll,
-			ItemEffectCount
-		};
-
-		enum ItemSize : uint8 {
-			ItemSizeTiny = 0,
-			ItemSizeSmall,
-			ItemSizeMedium,
-			ItemSizeLarge,
-			ItemSizeGiant,
-			ItemSizeCount
-		};
-
-		enum ItemDataType : uint8 {
-			ItemDataBase = 0,
-			ItemDataScaling,
-			ItemDataEvolving,
-			ItemDataCount
-		};
-
-		struct ItemEffect_Struct {
-			int16	Effect;
-			uint8	Type;
-			uint8	Level;
-			uint8	Level2;
-			//MaxCharges
-			//CastTime
-			//RecastDelay
-			//RecastType
-			//ProcRate
-		};
-
-		uint32 ConvertAugTypeToAugTypeBit(uint8 aug_type);
-		uint8 ConvertAugTypeBitToAugType(uint32 aug_type_bit);
-
-	} /*item*/
-
-	struct InternalSerializedItem_Struct {
-		int16 slot_id;
-		const void * inst;
-	};
-
-	struct ItemData {
-		// Non packet based fields
-		uint8	MinStatus;
-
-		// 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;
-
-		//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[inventory::SocketCount];	// RoF: Augment Slot 1-6 Type
-		uint8	AugSlotVisible[inventory::SocketCount];	// RoF: Augment Slot 1-6 Visible
-		uint8	AugSlotUnk2[inventory::SocketCount];	// 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) const;
-		bool IsClassCommon() const;
-		bool IsClassBag() const;
-		bool IsClassBook() const;
-		bool IsType1HWeapon() const;
-		bool IsType2HWeapon() const;
-		bool IsTypeShield() const;
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_ITEM_DATA_H*/

common/item_fieldlist.h

@@ -41,7 +41,6 @@ F(ac)
 F(deity)
 F(skillmodvalue)
 F(UNK033)
-F(skillmodmax)
 F(skillmodtype)
 F(banedmgrace)
 F(banedmgamt)
@@ -173,10 +172,7 @@ 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_instance.h

@@ -1,334 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  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 COMMON_ITEM_INSTANCE_H
-#define COMMON_ITEM_INSTANCE_H
-
-
-class ItemParse;			// Parses item packets
-class EvolveInfo;			// Stores information about an evolving item family
-
-#include "../common/eq_constants.h"
-#include "../common/item_data.h"
-#include "../common/timer.h"
-#include "../common/bodytypes.h"
-#include "../common/deity.h"
-#include "../common/memory_buffer.h"
-
-#include <map>
-
-
-// Specifies usage type for item inside EQEmu::ItemInstance
-enum ItemInstTypes
-{
-	ItemInstNormal = 0,
-	ItemInstWorldContainer
-};
-
-typedef enum {
-	byFlagIgnore,	//do not consider this flag
-	byFlagSet,		//apply action if the flag is set
-	byFlagNotSet	//apply action if the flag is NOT set
-} byFlagSetting;
-
-class SharedDatabase;
-
-// ########################################
-// Class: EQEmu::ItemInstance
-//	Base class for an instance of an item
-//	An item instance encapsulates item data + data specific
-//	to an item instance (includes dye, augments, charges, etc)
-namespace EQEmu
-{
-	class InventoryProfile;
-	
-	class ItemInstance {
-	public:
-		/////////////////////////
-		// Methods
-		/////////////////////////
-
-		// Constructors/Destructor
-		ItemInstance(const ItemData* item = nullptr, int16 charges = 0);
-
-		ItemInstance(SharedDatabase *db, uint32 item_id, int16 charges = 0);
-
-		ItemInstance(ItemInstTypes use_type);
-
-		ItemInstance(const ItemInstance& copy);
-
-		~ItemInstance();
-
-		// Query item type
-		bool IsType(item::ItemClass item_class) const;
-
-		bool IsClassCommon() const;
-		bool IsClassBag() const;
-		bool IsClassBook() const;
-
-		// Can item be stacked?
-		bool IsStackable() const;
-		bool IsCharged() const;
-
-		// Can item be equipped by/at?
-		bool IsEquipable(uint16 race, uint16 class_) const;
-		bool IsEquipable(int16 slot_id) const;
-
-		//
-		// Augments
-		//
-		bool IsAugmentable() const;
-		bool AvailableWearSlot(uint32 aug_wear_slots) const;
-		int8 AvailableAugmentSlot(int32 augtype) const;
-		bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
-		inline int32 GetAugmentType() const { return ((m_item) ? m_item->AugType : 0); }
-
-		inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == item::ItemEffectExpendable) || (m_item->ItemType == item::ItemTypePotion)) : false); }
-
-		//
-		// Contents
-		//
-		ItemInstance* GetItem(uint8 slot) const;
-		uint32 GetItemID(uint8 slot) const;
-		inline const ItemInstance* operator[](uint8 slot) const { return GetItem(slot); }
-		void PutItem(uint8 slot, const ItemInstance& inst);
-		void PutItem(SharedDatabase *db, uint8 slot, uint32 item_id) { return; } // not defined anywhere...
-		void DeleteItem(uint8 slot);
-		ItemInstance* PopItem(uint8 index);
-		void Clear();
-		void ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent);
-		uint8 FirstOpenSlot() const;
-		uint8 GetTotalItemCount() const;
-		bool IsNoneEmptyContainer();
-		std::map<uint8, ItemInstance*>* GetContents() { return &m_contents; }
-
-		//
-		// Augments
-		//
-		ItemInstance* GetAugment(uint8 slot) const;
-		uint32 GetAugmentItemID(uint8 slot) const;
-		void PutAugment(uint8 slot, const ItemInstance& inst);
-		void PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id);
-		void DeleteAugment(uint8 slot);
-		ItemInstance* RemoveAugment(uint8 index);
-		bool IsAugmented();
-		ItemInstance* GetOrnamentationAug(int32 ornamentationAugtype) const;
-		bool UpdateOrnamentationInfo();
-		static bool CanTransform(const ItemData *ItemToTry, const ItemData *Container, bool AllowAll = false);
-
-		// Has attack/delay?
-		bool IsWeapon() const;
-		bool IsAmmo() const;
-
-		// Accessors
-		const uint32 GetID() const { return ((m_item) ? m_item->ID : 0); }
-		const uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : 0); }
-		const ItemData* GetItem() const;
-		const ItemData* GetUnscaledItem() const;
-
-		int16 GetCharges() const				{ return m_charges; }
-		void SetCharges(int16 charges)			{ m_charges = charges; }
-
-		uint32 GetPrice() const					{ return m_price; }
-		void SetPrice(uint32 price)				{ m_price = price; }
-
-		void SetColor(uint32 color)				{ m_color = color; }
-		uint32 GetColor() const					{ return m_color; }
-
-		uint32 GetMerchantSlot() const			{ return m_merchantslot; }
-		void SetMerchantSlot(uint32 slot)		{ m_merchantslot = slot; }
-
-		int32 GetMerchantCount() const			{ return m_merchantcount; }
-		void SetMerchantCount(int32 count)		{ m_merchantcount = count; }
-
-		int16 GetCurrentSlot() const			{ return m_currentslot; }
-		void SetCurrentSlot(int16 curr_slot)	{ m_currentslot = curr_slot; }
-
-		// Is this item already attuned?
-		bool IsAttuned() const					{ return m_attuned; }
-		void SetAttuned(bool flag)				{ m_attuned = flag; }
-
-		std::string GetCustomDataString() const;
-		std::string GetCustomData(std::string identifier);
-		void SetCustomData(std::string identifier, std::string value);
-		void SetCustomData(std::string identifier, int value);
-		void SetCustomData(std::string identifier, float value);
-		void SetCustomData(std::string identifier, bool value);
-		void DeleteCustomData(std::string identifier);
-
-		// Allows treatment of this object as though it were a pointer to m_item
-		operator bool() const { return (m_item != nullptr); }
-
-		// Compare inner Item_Struct of two ItemInstance objects
-		bool operator==(const ItemInstance& right) const { return (this->m_item == right.m_item); }
-		bool operator!=(const ItemInstance& right) const { return (this->m_item != right.m_item); }
-
-		// Clone current item
-		ItemInstance* Clone() const;
-
-		bool IsSlotAllowed(int16 slot_id) const;
-
-		bool IsDroppable(bool recurse = true) const;
-
-		bool IsScaling() const				{ return m_scaling; }
-		bool IsEvolving() const				{ return (m_evolveLvl >= 1); }
-		uint32 GetExp() const				{ return m_exp; }
-		void SetExp(uint32 exp)				{ m_exp = exp; }
-		void AddExp(uint32 exp)				{ m_exp += exp; }
-		bool IsActivated()					{ return m_activated; }
-		void SetActivated(bool activated)	{ m_activated = activated; }
-		int8 GetEvolveLvl() const			{ return m_evolveLvl; }
-		void SetScaling(bool v)				{ m_scaling = v; }
-		uint32 GetOrnamentationIcon() const							{ return m_ornamenticon; }
-		void SetOrnamentIcon(uint32 ornament_icon)					{ m_ornamenticon = ornament_icon; }
-		uint32 GetOrnamentationIDFile() const						{ return m_ornamentidfile; }
-		void SetOrnamentationIDFile(uint32 ornament_idfile)			{ m_ornamentidfile = ornament_idfile; }
-		uint32 GetOrnamentHeroModel(int32 material_slot = -1) const;
-		void SetOrnamentHeroModel(uint32 ornament_hero_model)		{ m_ornament_hero_model = ornament_hero_model; }
-		uint32 GetRecastTimestamp() const							{ return m_recast_timestamp; }
-		void SetRecastTimestamp(uint32 in)							{ m_recast_timestamp = in; }
-
-		void Initialize(SharedDatabase *db = nullptr);
-		void ScaleItem();
-		bool EvolveOnAllKills() const;
-		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; }
-		void Serialize(OutBuffer& ob, int16 slot_id) const { 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; }
-
-		std::map<std::string, Timer>& GetTimers() { return m_timers; }
-		void SetTimer(std::string name, uint32 time);
-		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
-		//////////////////////////
-		friend class InventoryProfile;
-
-		std::map<uint8, ItemInstance*>::const_iterator _cbegin() { return m_contents.cbegin(); }
-		std::map<uint8, ItemInstance*>::const_iterator _cend() { return m_contents.cend(); }
-
-		void _PutItem(uint8 index, ItemInstance* inst) { m_contents[index] = inst; }
-
-		ItemInstTypes		m_use_type;	// Usage type for item
-		const ItemData*		m_item;		// Ptr to item data
-		int16				m_charges;	// # of charges for chargeable items
-		uint32				m_price;	// Bazaar /trader price
-		uint32				m_color;
-		uint32				m_merchantslot;
-		int16				m_currentslot;
-		bool				m_attuned;
-		int32				m_merchantcount;		//number avaliable on the merchant, -1=unlimited
-		int32				m_SerialNumber;	// Unique identifier for this instance of an item. Needed for Bazaar.
-		uint32				m_exp;
-		int8				m_evolveLvl;
-		bool				m_activated;
-		ItemData*			m_scaledItem;
-		::EvolveInfo*		m_evolveInfo;
-		bool				m_scaling;
-		uint32				m_ornamenticon;
-		uint32				m_ornamentidfile;
-		uint32				m_ornament_hero_model;
-		uint32				m_recast_timestamp;
-
-		//
-		// Items inside of this item (augs or contents);
-		std::map<uint8, ItemInstance*>		m_contents; // Zero-based index: min=0, max=9
-		std::map<std::string, std::string>	m_custom_data;
-		std::map<std::string, Timer>		m_timers;
-	};
-}
-
-class EvolveInfo {
-public:
-	friend class EQEmu::ItemInstance;
-	//temporary
-	uint16				LvlKills[9];
-	uint32				FirstItem;
-	uint8				MaxLvl;
-	bool				AllKills;
-
-	EvolveInfo();
-	EvolveInfo(uint32 first, uint8 max, bool allkills, uint32 L2, uint32 L3, uint32 L4, uint32 L5, uint32 L6, uint32 L7, uint32 L8, uint32 L9, uint32 L10);
-	~EvolveInfo();
-};
-
-#endif /*COMMON_ITEM_INSTANCE_H*/

common/item_struct.h

@@ -0,0 +1,251 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
+*/
+
+#ifndef ITEM_STRUCT_H
+#define ITEM_STRUCT_H
+
+/*
+ * Note: (Doodman)
+ *	This structure has field names that match the DB name exactly.
+ *	Please take care as to not mess this up as it should make
+ *	everyones life (i.e. mine) much easier. And the DB names
+ *	match the field name from the 13th floor (SEQ) item collectors,
+ *	so please maintain that as well.
+ *
+ * Note #2: (Doodman)
+ *	UnkXXX fields are left in here for completeness but commented
+ *	out since they are really unknown and since the items are now
+ *	preserialized they should not be needed. Conversly if they
+ *	-are- needed, then they shouldn't be unkown.
+ *
+ * Note #3: (Doodman)
+ *	Please take care when adding new found data fields to add them
+ *	to the appropriate structure. Item_Struct has elements that are
+ *	global to all types of items only.
+ *
+ * Note #4: (Doodman)
+ *	Made ya look! Ha!
+ */
+
+//#include "eq_constants.h"
+#include "eq_dictionary.h"
+
+/*
+** Child struct of Item_Struct:
+**	Effect data: Click, Proc, Focus, Worn, Scroll
+**
+*/
+struct ItemEffect_Struct {
+	int16	Effect;
+	uint8	Type;
+	uint8	Level;
+	uint8	Level2;
+	//MaxCharges
+	//CastTime
+	//RecastDelay
+	//RecastType
+	//ProcRate
+};
+
+class ItemInst;
+
+struct InternalSerializedItem_Struct {
+	int16 slot_id;
+	const void * inst;
+};
+
+// use EmuConstants::ITEM_COMMON_SIZE
+//#define MAX_AUGMENT_SLOTS 5
+
+struct Item_Struct {
+	bool IsEquipable(uint16 Race, uint16 Class) const;
+	// Non packet based fields
+	uint8	MinStatus;
+
+	// 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;
+
+	//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
+	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
+	};
+	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];
+
+};
+
+#endif

common/light_source.cpp

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

common/light_source.h

@@ -1,115 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-	
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_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
-		};
-
-		extern uint8 TypeToLevel(uint8 light_type);
-		extern bool IsLevelGreater(uint8 left_type, uint8 right_type);
-	
-	}; /*lightsource*/
-
-	struct LightSource_Struct {
-		uint8 Slot[lightsource::LightCount];
-
-		LightSource_Struct();
-
-		void Clear();
-
-		inline uint8& operator[](lightsource::LightSlot index) { return Slot[index]; }
-	};
-
-	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_Struct Type; // Light types (classifications)
-		LightSource_Struct Level; // Light levels (intensities) - used to determine which light source should be active
-
-		LightSourceProfile() { }
-
-		void Clear();
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_LIGHT_SOURCE_H*/

common/memory_buffer.cpp

@@ -1,277 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-*/
-
-#include "memory_buffer.h"
-
-
-EQEmu::MemoryBuffer::MemoryBuffer()
-{
-	buffer_ = nullptr;
-	size_ = 0;
-	capacity_ = 0;
-	read_pos_ = 0;
-	write_pos_ = 0;
-}
-
-EQEmu::MemoryBuffer::MemoryBuffer(size_t sz)
-{
-	buffer_ = nullptr;
-	size_ = 0;
-	capacity_ = 0;
-	read_pos_ = 0;
-	write_pos_ = 0;
-	Resize(sz);
-}
-
-EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
-{
-	if(other.capacity_) {
-		buffer_ = new uchar[other.capacity_];
-		memcpy(buffer_, other.buffer_, other.capacity_);
-	} else {
-		buffer_ = nullptr;
-	}
-
-	size_ = other.size_;
-	capacity_ = other.capacity_;
-	write_pos_ = other.write_pos_;
-	read_pos_ = other.read_pos_;
-}
-
-EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
-{
-	uchar *tbuf = other.buffer_;
-	size_t tsz = other.size_;
-	size_t tcapacity = other.capacity_;
-	size_t twrite_pos = other.write_pos_;
-	size_t tread_pos = other.read_pos_;
-
-	other.buffer_ = nullptr;
-	other.size_ = 0;
-	other.capacity_ = 0;
-	other.read_pos_ = 0;
-	other.write_pos_ = 0;
-
-	buffer_ = tbuf;
-	size_ = tsz;
-	capacity_ = tcapacity;
-	write_pos_ = twrite_pos;
-	read_pos_ = tread_pos;
-}
-
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other)
-{
-	if(this == &other) {
-		return *this;
-	}
-
-	if(buffer_) {
-		delete[] buffer_;
-	}
-
-	if(other.capacity_) {
-		buffer_ = new uchar[other.capacity_];
-		memcpy(buffer_, other.buffer_, other.capacity_);
-	}
-	else {
-		buffer_ = nullptr;
-	}
-
-	size_ = other.size_;
-	capacity_ = other.capacity_;
-	write_pos_ = other.write_pos_;
-	read_pos_ = other.read_pos_;
-	return *this;
-}
-
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other)
-{
-	uchar *tbuf = other.buffer_;
-	size_t tsz = other.size_;
-	size_t tcapacity = other.capacity_;
-	size_t twrite_pos = other.write_pos_;
-	size_t tread_pos = other.read_pos_;
-
-	other.buffer_ = nullptr;
-	other.size_ = 0;
-	other.capacity_ = 0;
-	other.read_pos_ = 0;
-	other.write_pos_ = 0;
-
-	buffer_ = tbuf;
-	size_ = tsz;
-	capacity_ = tcapacity;
-	write_pos_ = twrite_pos;
-	read_pos_ = tread_pos;
-	return *this;
-}
-
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
-{
-	if(!rhs.buffer_) {
-		return *this;
-	}
-
-	if(buffer_) {
-		size_t old_size = size_;
-		Resize(size_ + rhs.size_);
-		memcpy(&buffer_[old_size], rhs.buffer_, rhs.size_);
-	} else {
-		buffer_ = new uchar[rhs.capacity_];
-		memcpy(buffer_, rhs.buffer_, rhs.capacity_);
-		size_ = rhs.size_;
-		capacity_ = rhs.capacity_;
-	}
-
-	return *this;
-}
-
-EQEmu::MemoryBuffer::~MemoryBuffer()
-{
-	Clear();
-}
-
-uchar& EQEmu::MemoryBuffer::operator[](size_t pos)
-{
-	return buffer_[pos];
-}
-
-const uchar& EQEmu::MemoryBuffer::operator[](size_t pos) const
-{
-	return buffer_[pos];
-}
-
-bool EQEmu::MemoryBuffer::Empty()
-{
-	return size_ == 0;
-}
-
-bool EQEmu::MemoryBuffer::Empty() const
-{
-	return size_ == 0;
-}
-
-size_t EQEmu::MemoryBuffer::Size()
-{
-	return size_;
-}
-
-size_t EQEmu::MemoryBuffer::Size() const
-{
-	return size_;
-}
-
-size_t EQEmu::MemoryBuffer::Capacity()
-{
-	return capacity_;
-}
-
-size_t EQEmu::MemoryBuffer::Capacity() const
-{
-	return capacity_;
-}
-
-void EQEmu::MemoryBuffer::Resize(size_t sz)
-{
-	if(!buffer_) {
-		size_t new_size = sz + 64;
-		buffer_ = new uchar[new_size];
-		capacity_ = new_size;
-		size_ = sz;
-		memset(buffer_, 0, capacity_);
-		return;
-	}
-
-	if(sz > capacity_) {
-		size_t new_size = sz + 32;
-		uchar *temp = new uchar[new_size];
-		memcpy(temp, buffer_, capacity_);
-		delete[] buffer_;
-		buffer_ = temp;
-		
-		capacity_ = new_size;
-		size_ = sz;
-	}
-	else {
-		size_ = sz;
-	}
-}
-
-void EQEmu::MemoryBuffer::Clear()
-{
-	if(buffer_) {
-		delete[] buffer_;
-		buffer_ = nullptr;
-	}
-	
-	size_ = 0;
-	capacity_ = 0;
-	write_pos_ = 0;
-	read_pos_ = 0;
-}
-
-void EQEmu::MemoryBuffer::Zero()
-{
-	if(buffer_) {
-		memset(buffer_, 0, capacity_);
-	}
-}
-
-void EQEmu::MemoryBuffer::Write(const char *val, size_t len)
-{
-	size_t size_needed = write_pos_ + len;
-	Resize(size_needed);
-
-	memcpy(&buffer_[write_pos_], val, len);
-	write_pos_ += len;
-}
-
-void EQEmu::MemoryBuffer::Read(uchar *buf, size_t len)
-{
-	memcpy(buf, &buffer_[read_pos_], len);
-	read_pos_ += len;
-}
-
-void EQEmu::MemoryBuffer::Read(char *str)
-{
-	size_t len = strlen((const char*)&buffer_[read_pos_]);
-	memcpy(str, &buffer_[read_pos_], len);
-	read_pos_ += len;
-}
-
-void EQEmu::OutBuffer::overwrite(OutBuffer::pos_type position, const char *_Str, std::streamsize _Count)
-{
-	auto last_pos = tellp();
-	seekp(position);
-	write(_Str, _Count);
-	seekp(last_pos);
-}
-
-uchar* EQEmu::OutBuffer::detach()
-{
-	size_t buffer_size = tellp();
-	if (buffer_size == 0)
-		return nullptr;
-
-	auto out_buffer = new uchar[buffer_size];
-	memcpy(out_buffer, str().c_str(), buffer_size);
-	flush();
-
-	return out_buffer;
-}

common/memory_buffer.h

@@ -1,134 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_MEMORY_BUFFER
-#define COMMON_MEMORY_BUFFER
-
-#include "types.h"
-
-#include <type_traits>
-#include <string.h>
-#include <string>
-#include <sstream>
-
-
-namespace EQEmu
-{
-	class MemoryBuffer {
-	public:
-		MemoryBuffer();
-		MemoryBuffer(size_t sz);
-		MemoryBuffer(const MemoryBuffer &other);
-		MemoryBuffer(MemoryBuffer &&other);
-		MemoryBuffer& operator=(const MemoryBuffer &other);
-		MemoryBuffer& operator=(MemoryBuffer &&other);
-		MemoryBuffer& operator+=(const MemoryBuffer &rhs);
-		friend MemoryBuffer operator+(MemoryBuffer lhs, const MemoryBuffer& rhs) { return lhs += rhs; }
-		~MemoryBuffer();
-		
-		uchar& operator[](size_t pos);
-		const uchar& operator[](size_t pos) const;
-
-		template<typename T>
-		operator T*() {
-			return reinterpret_cast<T*>(buffer_);
-		}
-
-		template<typename T>
-		operator T*() const {
-			return reinterpret_cast<T*>(buffer_);
-		}
-
-		operator bool() { return buffer_ != nullptr; }
-		operator bool() const { return buffer_ != nullptr; }
-
-		bool Empty();
-		bool Empty() const;
-		size_t Size();
-		size_t Size() const;
-		size_t Capacity();
-		size_t Capacity() const;
-		
-		void Resize(size_t sz);
-		void Clear();
-		void Zero();
-
-		template<typename T>
-		void Write(T val) {
-			static_assert(std::is_pod<T>::value, "MemoryBuffer::Write<T>(T val) only works on pod and string types.");
-			Write((const char*)&val, sizeof(T));
-		}
-
-		template<typename T>
-		T Read() {
-			static_assert(std::is_pod<T>::value, "MemoryBuffer::Read<T>() only works on pod and string types.");
-			T temp;
-			Read((uchar*)&temp, sizeof(T));
-			return temp;
-		}
-
-		void Write(const std::string &val) {
-			Write(val.c_str(), val.length());
-			Write((uint8)0);
-		}
-
-		void Write(const char *val) {
-			size_t len = strlen(val);
-			Write(val, len);
-			Write((uint8)0);
-		}
-
-		std::string ReadString() {
-			std::string ret;
-			size_t len = strlen((const char*)&buffer_[read_pos_]);
-			ret.resize(len);
-			memcpy(&ret[0], &buffer_[read_pos_], len);
-			read_pos_ += len + 1;
-			return ret;
-		}
-	
-		void Write(const char *val, size_t len);
-		void Read(uchar *buf, size_t len);
-		void Read(char *str);
-
-		inline size_t GetWritePosition() { return write_pos_; }
-		inline void SetWritePosition(size_t wp) { write_pos_ = wp; }
-		inline void WriteSkipBytes(size_t skip) { write_pos_ += skip; }
-		inline size_t GetReadPosition() { return read_pos_; }
-		inline void SetReadPosition(size_t rp) { read_pos_ = rp; }
-		inline void ReadSkipBytes(size_t skip) { read_pos_ += skip; }
-		
-	private:
-		uchar *buffer_;
-		size_t size_;
-		size_t capacity_;
-		size_t write_pos_;
-		size_t read_pos_;
-	};
-
-	class OutBuffer : public std::stringstream {
-	public:
-		inline size_t size() { return tellp(); }
-		void overwrite(OutBuffer::pos_type position, const char *_Str, std::streamsize _Count);
-		uchar* detach();
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_MEMORY_BUFFER*/

common/misc.cpp

@@ -24,36 +24,6 @@
 
 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()) {
@@ -78,12 +48,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);
@@ -186,10 +156,10 @@ static char *temp=nullptr;
 
 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()) {
@@ -335,14 +305,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;
@@ -355,8 +325,8 @@ unsigned long used=0,len=0;
 
 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));
@@ -366,8 +336,8 @@ char buf[4];
 
 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;
@@ -393,8 +363,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);
@@ -419,8 +389,8 @@ unsigned long rows,offset=0;
 
 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);
@@ -430,8 +400,8 @@ union { unsigned long ip; struct { unsigned char a,b,c,d; } octet;} ipoctet;
 
 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);
@@ -450,9 +420,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++) {
@@ -481,8 +451,8 @@ bool in_quote=false;
 
 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;
@@ -524,11 +494,11 @@ char *bptr;
 
 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);
@@ -550,9 +520,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,10 +24,6 @@ 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 <winsock2.h>
+	#include <winsock.h>
 	#include <windows.h>
 #else
 	#include <pthread.h>

common/mysql_request_result.cpp

@@ -32,7 +32,6 @@ 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 <winsock2.h>
+	#include <winsock.h>
 	#include <windows.h>
 #endif
 
@@ -10,12 +10,6 @@
 #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 <winsock2.h>
+	#include <winsock.h>
 	#include <windows.h>
 #endif
 

common/opcode_dispatch.h

@@ -146,7 +146,6 @@ 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);
@@ -173,7 +172,7 @@ IN(OP_TradeAcceptClick, TradeAccept_Struct);
 IN(OP_BoardBoat, EntityId_Struct);		//not really the struct, just 4 bytes
 INz(OP_LeaveBoat);		//?
 IN(OP_RandomReq, RandomReq_Struct);
-IN(OP_Buff, SpellBuffPacket_Struct);
+IN(OP_Buff, SpellBuffFade_Struct);
 IN(OP_GMHideMe, SpawnAppearance_Struct);
 IN(OP_GMNameChange, GMName_Struct);
 IN(OP_GMKill, GMKill_Struct);
@@ -181,7 +180,7 @@ IN(OP_GMLastName, GMLastName_Struct);
 IN(OP_GMToggle, GMToggle_Struct);
 IN(OP_LFGCommand, LFG_Struct);
 IN(OP_GMGoto, GMSummon_Struct);
-INv(OP_TraderShop, TraderClick_Struct);
+IN(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
@@ -400,7 +399,7 @@ OUT(OP_Weather, Weather_Struct);
 OUT(OP_ZoneChange, ZoneChange_Struct);
 OUT(OP_ZoneInUnknown, ZoneInUnknown_Struct);
 
-//this is the set of opcodes which are already listed
+//this is the set of opcodes which are allready listed
 //in the IN section above, but are also sent OUT
 #ifdef DISJOINT_DIRECTIONS
 OUTz(OP_ClientReady);		//follows OP_SetServerFilter
@@ -415,7 +414,7 @@ OUTv(OP_SendAATable, SendAA_Struct);
 OUT(OP_AAAction, UseAA_Struct);
 OUT(OP_Bazaar, BazaarReturnDone_Struct);
 //alt:OUT(OP_Bazaar, BazaarWelcome_Struct);
-OUT(OP_Buff, SpellBuffPacket_Struct);
+OUT(OP_Buff, SpellBuffFade_Struct);
 OUT(OP_ClickObject, ClickObject_Struct);
 OUT(OP_ClientUpdate, PlayerPositionUpdateServer_Struct);
 OUT(OP_SpawnPositionUpdate, SpawnPositionUpdate_Struct);
@@ -450,7 +449,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);
-OUTv(OP_TraderShop, TraderClick_Struct);
+OUT(OP_TraderShop, TraderClick_Struct);
 OUT(OP_WearChange, WearChange_Struct);
 OUT(OP_ZoneEntry, ServerZoneEntry_Struct);
 #endif

common/opcode_map.cpp

@@ -1,307 +0,0 @@
-#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;
-	auto ascii = new char[cols + 1];
+	char* 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;
-	auto ascii = new char[cols + 1];
+	char* ascii = new char[cols + 1];
 	memset(ascii, 0, cols + 1);
 	uint32 i;
 	for (i = skip; i < size; i++)

common/packet_dump_file.cpp

@@ -94,9 +94,7 @@ 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;
-	auto ascii = new char[cols + 1];
-	memset(ascii, 0, cols + 1);
+	int j = 0; char* ascii = new char[cols+1]; memset(ascii, 0, cols+1);
 	uint32 i;
 	for(i=skip; i<size; i++)
 	{

common/packetfile.cpp

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

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

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

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

common/patches/patches.cpp

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

common/patches/patches.h

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

common/patches/rof.h

@@ -1,31 +1,11 @@
-/*	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
+#ifndef ROF_H_
+#define 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);
@@ -43,31 +23,13 @@ namespace RoF
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
+		virtual const ClientVersion GetClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof_ops.h"
 	};
 
-	enum class CastingSlot : uint32 {
-		Gem1       = 0,
-		Gem2       = 1,
-		Gem3       = 2,
-		Gem4       = 3,
-		Gem5       = 4,
-		Gem6       = 5,
-		Gem7       = 6,
-		Gem8       = 7,
-		Gem9       = 8,
-		Gem10      = 9,
-		Gem11      = 10,
-		Gem12      = 11,
-		Item       = 12,
-		Discipline = 13,
-		AltAbility = 0xFF
-	};
+};
 
-}; /*RoF*/
-
-#endif /*COMMON_ROF_H*/
+#endif /*ROF_H_*/

common/patches/rof2.h

@@ -1,31 +1,11 @@
-/*	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
+#ifndef ROF2_H_
+#define 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);
@@ -43,31 +23,13 @@ namespace RoF2
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
+		virtual const ClientVersion GetClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof2_ops.h"
 	};
 
-	enum class CastingSlot : uint32 {
-		Gem1       = 0,
-		Gem2       = 1,
-		Gem3       = 2,
-		Gem4       = 3,
-		Gem5       = 4,
-		Gem6       = 5,
-		Gem7       = 6,
-		Gem8       = 7,
-		Gem9       = 8,
-		Gem10      = 9,
-		Gem11      = 10,
-		Gem12      = 11,
-		Item       = 12,
-		Discipline = 13,
-		AltAbility = 0xFF
-	};
+};
 
-}; /*RoF2*/
-
-#endif /*COMMON_ROF2_H*/
+#endif /*ROF2_H_*/

common/patches/rof2_constants.h

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