Additional fixups.

GetBaseDamage is now used for Bash/Slam additionally.

.travis.yml

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

CMakeLists.txt

@@ -30,6 +30,7 @@
 #EQEMU_BUILD_LUA
 #EQEMU_SANITIZE_LUA_LIBS
 #EQEMU_BUILD_CLIENT_FILES
+#EQEMU_USE_MAP_MMFS
 #EQEMU_MAP_DIR
 
 #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
@@ -275,6 +276,11 @@ 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})

README.md

@@ -1,53 +1,59 @@
-EQEmu
-===
+# 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)   |
 
-[![Build Status](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)
+***
 
-Overview
----
+**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
 
-EQEmu is a custom server implementation for EverQuest
+## 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)
 
-Dependencies
----
+### > Debian/Ubuntu
 
-For Windows: http://eqemu.github.io
+> 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
 
-Login Server dependencies for Windows/Linux/OSX: http://eqemu.github.io
+### > CentOS/Fedora
 
-For Debian based distros (adjust to your local flavor):
+> curl -O https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh install.sh && chmod 755 install.sh && ./install.sh
 
-- libmysqlclient-dev
-- libperl-dev
-- liblua5.1-0-dev (5.2 should work as well)
-- libboost-dev
+## Supported Clients
 
-Further instructions on building the source can be found on the
-[wiki](http://wiki.eqemulator.org/i?M=Wiki).
+|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">|
 
-Bug reports
----
-
-Please use the [issue tracker](https://github.com/EQEmu/Server/issues) provided by GitHub to send us bug
+## 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
 reports or feature requests.
+* The [EQEmu Forums](http://www.eqemulator.org/forums/) are also a place to submit and get help with bugs.
 
-The [EQEmu Forums](http://www.eqemulator.org/forums/) also have forums to submit
-bugs/get help with bugs.
+## Contributions <img src="http://image.flaticon.com/icons/png/512/25/25231.png" width="20">
 
-Contributions
----
-
-The preferred way to contribute is to fork the repo and submit a pull request on
+* The preferred way to contribute is to fork the repo and submit a pull request on
 GitHub. If you need help with your changes, you can always post on the forums or
-try IRC. You can also post unified diffs (`git diff` should do the trick) on the
+try Discord. You can also post unified diffs (`git diff` should do the trick) on the
 [Server Code Submissions](http://www.eqemulator.org/forums/forumdisplay.php?f=669)
 forum, although pull requests will be much quicker and easier on all parties.
 
-Contact
----
- - **User IRC Channel**: `#eqemu` on `irc.eqemulator.net`
- - **Developer IRC Channel**: `#eqemucoders` on `irc.eqemulator.net`
+## 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
+---
 - [EQEmulator Forums](http://www.eqemulator.org/forums)
 - [EQEmulator Wiki](http://wiki.eqemulator.org/i?M=Wiki)
-

client_files/export/main.cpp

@@ -32,6 +32,7 @@ EQEmuLogSys Log;
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
+void ExportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
@@ -44,12 +45,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	const EQEmuConfig *config = EQEmuConfig::get();
+	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
-		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
+		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
 		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
@@ -62,6 +63,7 @@ int main(int argc, char **argv) {
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
+	ExportDBStrings(&database);
 
 	Log.CloseFileLogs();
 
@@ -194,7 +196,38 @@ void ExportBaseData(SharedDatabase *db) {
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	} else {
+	}
+
+	fclose(f);
+}
+
+void ExportDBStrings(SharedDatabase *db) {
+	Log.Out(Logs::General, Logs::Status, "Exporting DB Strings...");
+
+	FILE *f = fopen("export/dbstr_us.txt", "w");
+	if(!f) {
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
+		return;
+	}
+
+	fprintf(f, "Major^Minor^String(New)\n");
+	const std::string query = "SELECT * FROM db_str ORDER BY id, type";
+	auto results = db->QueryDatabase(query);
+	if(results.Success()) {
+		for(auto row = results.begin(); row != results.end(); ++row) {
+			std::string line;
+			unsigned int fields = results.ColumnCount();
+			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
+				if(rowIndex != 0)
+					line.push_back('^');
+
+				if(row[rowIndex] != nullptr) {
+					line += row[rowIndex];
+				}
+			}
+
+			fprintf(f, "%s\n", line.c_str());
+		}
 	}
 
 	fclose(f);

client_files/import/main.cpp

@@ -30,6 +30,7 @@ EQEmuLogSys Log;
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
+void ImportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
@@ -42,12 +43,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	const EQEmuConfig *config = EQEmuConfig::get();
+	auto Config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
-		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
+	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
+		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
 		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
@@ -59,6 +60,7 @@ int main(int argc, char **argv) {
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
+	ImportDBStrings(&database);
 
 	Log.CloseFileLogs();
 	
@@ -76,6 +78,24 @@ int GetSpellColumns(SharedDatabase *db) {
 	return results.RowCount();
 }
 
+bool IsStringField(int i) {
+	switch(i)
+	{
+	case 1:
+	case 2:
+	case 3:
+	case 4:
+	case 5:
+	case 6:
+	case 7:
+	case 8:
+		return true;
+		break;
+	default:
+		return false;
+	}
+}
+
 void ImportSpells(SharedDatabase *db) {
 	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
@@ -113,7 +133,12 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				sql += split[i];
+				if(split[i].compare("") == 0 && !IsStringField(i)) {
+					sql += "0";
+				}
+				else {
+					sql += split[i];
+				}
 				sql += "'";
 			}
 
@@ -128,7 +153,12 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				sql += split[i];
+				if(split[i].compare("") == 0 && !IsStringField(i)) {
+					sql += "0";
+				} else {
+					sql += split[i];
+				}
+
 				sql += "'";
 			}
 
@@ -174,7 +204,6 @@ void ImportSkillCaps(SharedDatabase *db) {
 			continue;
 		}
 
-
 		int class_id, skill_id, level, cap;
 		class_id = atoi(split[0].c_str());
 		skill_id = atoi(split[1].c_str());
@@ -234,3 +263,56 @@ void ImportBaseData(SharedDatabase *db) {
 
 	fclose(f);
 }
+
+void ImportDBStrings(SharedDatabase *db) {
+	Log.Out(Logs::General, Logs::Status, "Importing DB Strings...");
+
+	FILE *f = fopen("import/dbstr_us.txt", "r");
+	if(!f) {
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
+		return;
+	}
+
+	std::string delete_sql = "DELETE FROM db_str";
+	db->QueryDatabase(delete_sql);
+
+	char buffer[2048];
+	bool first = true;
+	while(fgets(buffer, 2048, f)) {
+		if(first) {
+			first = false;
+			continue;
+		}
+
+		for(int i = 0; i < 2048; ++i) {
+			if(buffer[i] == '\n') {
+				buffer[i] = 0;
+				break;
+			}
+		}
+
+		auto split = SplitString(buffer, '^');
+
+		if(split.size() < 2) {
+			continue;
+		}
+
+		std::string sql;
+		int id, type;
+		std::string value;
+		
+		id = atoi(split[0].c_str());
+		type = atoi(split[1].c_str());
+		
+		if(split.size() >= 3) {
+			value = ::EscapeString(split[2]);
+		}
+
+		sql = StringFormat("INSERT INTO db_str(id, type, value) VALUES(%u, %u, '%s')",
+						   id, type, value.c_str());
+
+		db->QueryDatabase(sql);
+	}
+
+	fclose(f);
+}

cmake/FindMySQL.cmake

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

common/CMakeLists.txt

@@ -11,15 +11,20 @@ SET(common_sources
 	database_conversions.cpp
 	database_instances.cpp
 	dbcore.cpp
+	deity.cpp
+	emu_constants.cpp
+	emu_legacy.cpp
+	emu_limits.cpp
 	emu_opcodes.cpp
 	emu_tcp_connection.cpp
 	emu_tcp_server.cpp
-	eq_dictionary.cpp
+	emu_versions.cpp
 	eqdb.cpp
 	eqdb_res.cpp
 	eqemu_exception.cpp
 	eqemu_config.cpp
 	eqemu_logsys.cpp
+	eq_limits.cpp
 	eq_packet.cpp
 	eq_stream.cpp
 	eq_stream_factory.cpp
@@ -30,9 +35,14 @@ SET(common_sources
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
+	inventory_profile.cpp
+	inventory_slot.cpp
 	ipc_mutex.cpp
-	item.cpp
+	item_data.cpp
+	item_instance.cpp
+	light_source.cpp
 	md5.cpp
+	memory_buffer.cpp
 	memory_mapped_file.cpp
 	misc.cpp
 	misc_functions.cpp
@@ -51,6 +61,7 @@ SET(common_sources
 	races.cpp
 	rdtsc.cpp
 	rulesys.cpp
+	say_link.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -59,6 +70,7 @@ SET(common_sources
 	struct_strategy.cpp
 	tcp_connection.cpp
 	tcp_server.cpp
+	textures.cpp
 	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
@@ -67,11 +79,17 @@ SET(common_sources
 	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
@@ -104,12 +122,15 @@ 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
@@ -117,6 +138,7 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
+	eq_limits.h
 	eq_packet.h
 	eq_stream.h
 	eq_stream_factory.h
@@ -135,15 +157,19 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
+	inventory_profile.h
+	inventory_slot.h
 	ipc_mutex.h
-	item.h
+	item_data.h
 	item_fieldlist.h
-	item_struct.h
+	item_instance.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
@@ -166,6 +192,7 @@ SET(common_headers
 	rdtsc.h
 	rulesys.h
 	ruletypes.h
+	say_link.h
 	seperator.h
 	serverinfo.h
 	servertalk.h
@@ -177,6 +204,7 @@ SET(common_headers
 	tcp_basic_server.h
 	tcp_connection.h
 	tcp_server.h
+	textures.h
 	timeoutmgr.h
 	timer.h
 	types.h
@@ -188,37 +216,30 @@ SET(common_headers
 	zone_numbers.h
 	patches/patches.h
 	patches/sod.h
-	patches/sod_constants.h
-	patches/sod_itemfields.h
+	patches/sod_limits.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_constants.h
-	patches/sof_itemfields.h
-	patches/sof_opcode_list.h
+	patches/sof_limits.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_constants.h
-	patches/rof_itemfields.h
+	patches/rof_limits.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_constants.h
-	patches/rof2_itemfields.h
+	patches/rof2_limits.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_constants.h
-	patches/titanium_itemfields.h
+	patches/titanium_limits.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_constants.h
-	patches/uf_itemfields.h
+	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
 	SocketLib/Base64.h
@@ -241,46 +262,45 @@ SET(common_headers
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-	patches/sod_itemfields.h
+	patches/sod_limits.h
 	patches/sod_ops.h
-	patches/sod_constants.h
 	patches/sod_structs.h
 	patches/sof.h
-	patches/sof_itemfields.h
-	patches/sof_opcode_list.h
+	patches/sof_limits.h
 	patches/sof_ops.h
-	patches/sof_constants.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-	patches/rof_itemfields.h
+	patches/rof_limits.h
 	patches/rof_ops.h
-	patches/rof_constants.h
 	patches/rof_structs.h
 	patches/rof2.h
-	patches/rof2_itemfields.h
+	patches/rof2_limits.h
 	patches/rof2_ops.h
-	patches/rof2_constants.h
 	patches/rof2_structs.h
 	patches/titanium.h
-	patches/titanium_itemfields.h
+	patches/titanium_limits.h
 	patches/titanium_ops.h
-	patches/titanium_constants.h
 	patches/titanium_structs.h
 	patches/uf.h
-	patches/uf_itemfields.h
+	patches/uf_limits.h
 	patches/uf_ops.h
-	patches/uf_constants.h
 	patches/uf_structs.h
 	patches/patches.cpp
 	patches/sod.cpp
+	patches/sod_limits.cpp
 	patches/sof.cpp
+	patches/sof_limits.cpp
 	patches/rof.cpp
+	patches/rof_limits.cpp
 	patches/rof2.cpp
+	patches/rof2_limits.cpp
 	patches/titanium.cpp
+	patches/titanium_limits.cpp
 	patches/uf.cpp
+	patches/uf_limits.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES

common/base_packet.h

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

common/classes.cpp

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

common/classes.h

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

common/clientversions.h

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

common/data_verification.h

@@ -1,5 +1,6 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
+
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -13,36 +14,42 @@
 
 	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 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 ClampLower(const T& value, const T& lower) {
-	return std::max(lower, value);
-}
+	template <typename T>
+	T ClampUpper(const T& value, const T& upper) {
+		return std::min(value, upper);
+	}
 
-template <typename T>
-T ClampUpper(const T& value, const T& upper) {
-	return std::min(value, upper);
-}
+	template <typename T>
+	bool ValueWithin(const T& value, const T& lower, const T& upper) {
+		return value >= lower && value <= upper;
+	}
 
-template <typename T>
-bool ValueWithin(const T& value, const T& lower, const T& upper) {
-	return value >= lower && value <= upper;
-}
+	template <typename T1, typename T2, typename T3>
+	bool ValueWithin(const T1& value, const T2& lower, const T3& upper) {
+		return value >= (T1)lower && value <= (T1)upper;
+	}
 
-}
+} /*EQEmu*/
 
-#endif
+#endif /*COMMON_DATA_VERIFICATION_H*/

common/database.cpp

@@ -23,6 +23,7 @@
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <algorithm>
 #include <mysqld_error.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -48,7 +49,6 @@
 extern Client client;
 
 Database::Database () {
-	DBInitVars();
 }
 
 /*
@@ -57,7 +57,6 @@ 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)
 {
-	DBInitVars();
 	Connect(host, user, passwd, database, port);
 }
 
@@ -74,25 +73,12 @@ bool Database::Connect(const char* host, const char* user, const char* passwd, c
 	}
 }
 
-void Database::DBInitVars() { 
-	varcache_array = 0;
-	varcache_max = 0;
-	varcache_lastupdate = 0;
-}
-
 /*
 	Close the connection to the database
 */
 
 Database::~Database()
 {
-	unsigned int x;
-	if (varcache_array) {
-		for (x=0; x<varcache_max; x++) {
-			safe_delete_array(varcache_array[x]);
-		}
-		safe_delete_array(varcache_array);
-	}
 }
 
 /*
@@ -313,11 +299,15 @@ bool Database::DeleteCharacter(char *name) {
 	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-	if (charid <= 0){ std::cerr << "Database::DeleteCharacter :: Character not found, stopping delete...\n"; return false; }
+	if (charid <= 0){ 
+		Log.Out(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
+		return false; 
+	}
 
 	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_enabledtasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `completed_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `friends` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `mail` WHERE `charid` = '%d'", charid); QueryDatabase(query);
@@ -348,11 +338,11 @@ bool Database::DeleteCharacter(char *name) {
 	query = StringFormat("DELETE FROM `character_inspect_messages` WHERE `id` = %u", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_leadership_abilities` WHERE `id` = %u", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_alt_currency` WHERE `char_id` = '%d'", charid); QueryDatabase(query);
-#ifdef BOTS																														 
-	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid);
-#else																															 
+#ifdef BOTS
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid); // note: only use of GetMobTypeById()
+#else
 	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
-#endif																															 
+#endif
 	QueryDatabase(query);
 	
 	return true;
@@ -636,12 +626,25 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 	);
 	auto results = QueryDatabase(query);
 	/* Save Bind Points */
-	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, is_home)"
+	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
 		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
+		"(%u, %u, %u, %f, %f, %f, %f, %i), "
+		"(%u, %u, %u, %f, %f, %f, %f, %i), "
+		"(%u, %u, %u, %f, %f, %f, %f, %i), "
 		"(%u, %u, %u, %f, %f, %f, %f, %i)",
 		character_id, pp->binds[0].zoneId, 0, pp->binds[0].x, pp->binds[0].y, pp->binds[0].z, pp->binds[0].heading, 0,
-		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 1
-	); results = QueryDatabase(query); 
+		character_id, pp->binds[1].zoneId, 0, pp->binds[1].x, pp->binds[1].y, pp->binds[1].z, pp->binds[1].heading, 1,
+		character_id, pp->binds[2].zoneId, 0, pp->binds[2].x, pp->binds[2].y, pp->binds[2].z, pp->binds[2].heading, 2,
+		character_id, pp->binds[3].zoneId, 0, pp->binds[3].x, pp->binds[3].y, pp->binds[3].z, pp->binds[3].heading, 3,
+		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 4
+	); results = QueryDatabase(query);
+
+        /* 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);
+        }
 
 	/* Save Skills */
 	int firstquery = 0;
@@ -677,7 +680,7 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 }
 
 /* This only for new Character creation storing */
-bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv) {
+bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv) {
 	uint32 charid = 0; 
 	char zone[50]; 
 	float x, y, z; 
@@ -705,8 +708,8 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i=EmuConstants::EQUIPMENT_BEGIN; i<=EmuConstants::BANK_BAGS_END;) {
-		const ItemInst* newinv = inv->GetItem(i);
+	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
+		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
 				charid, i, newinv->GetItem()->ID, newinv->GetCharges(), newinv->GetColor()); 
@@ -714,16 +717,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == MainCursor) { 
-			i = EmuConstants::GENERAL_BAGS_BEGIN; 
+		if (i == EQEmu::inventory::slotCursor) {
+			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EmuConstants::CURSOR_BAG_END) { 
-			i = EmuConstants::BANK_BEGIN; 
+		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
+			i = EQEmu::legacy::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EmuConstants::BANK_END) { 
-			i = EmuConstants::BANK_BAGS_BEGIN; 
+		else if (i == EQEmu::legacy::BANK_END) { 
+			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -836,7 +839,7 @@ 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) {
 	std::string query = StringFormat("SELECT `name` FROM `character_data` WHERE id='%i'", char_id);
 	auto results = QueryDatabase(query);
 
@@ -851,145 +854,69 @@ void Database::GetCharName(uint32 char_id, char* name) {
 }
 
 bool Database::LoadVariables() {
-	char *query = nullptr;
-
-	auto results = QueryDatabase(query, LoadVariables_MQ(&query));
+	auto results = QueryDatabase(StringFormat("SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache.last_update));
 
 	if (!results.Success())
-	{
-		safe_delete_array(query);
 		return false;
-	}
-
-	safe_delete_array(query);
-	return LoadVariables_result(std::move(results));
-}
-
-uint32 Database::LoadVariables_MQ(char** query)
-{
-	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)
-{
-	uint32 i = 0;
-	LockMutex lock(&Mvarcache);
 
 	if (results.RowCount() == 0)
 		return true;
 
-	if (!varcache_array) {
-		varcache_max = results.RowCount();
-		varcache_array = new VarCache_Struct*[varcache_max];
-		for (i=0; i<varcache_max; i++)
-			varcache_array[i] = 0;
-	}
-	else {
-		uint32 tmpnewmax = varcache_max + results.RowCount();
-		VarCache_Struct** tmp = new VarCache_Struct*[tmpnewmax];
-		for (i=0; i<tmpnewmax; i++)
-			tmp[i] = 0;
-		for (i=0; i<varcache_max; i++)
-			tmp[i] = varcache_array[i];
-		VarCache_Struct** tmpdel = varcache_array;
-		varcache_array = tmp;
-		varcache_max = tmpnewmax;
-		delete [] tmpdel;
-	}
+	LockMutex lock(&Mvarcache);
 
-	for (auto row = results.begin(); row != results.end(); ++row)
-	{
-		varcache_lastupdate = atoi(row[2]);
-		for (i=0; i<varcache_max; i++) {
-			if (varcache_array[i]) {
-				if (strcasecmp(varcache_array[i]->varname, row[0]) == 0) {
-					delete varcache_array[i];
-					varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
-					strn0cpy(varcache_array[i]->varname, row[0], sizeof(varcache_array[i]->varname));
-					strcpy(varcache_array[i]->value, row[1]);
-					break;
-				}
-			}
-			else {
-				varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
-				strcpy(varcache_array[i]->varname, row[0]);
-				strcpy(varcache_array[i]->value, row[1]);
-				break;
-			}
-		}
+	std::string key, value;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		varcache.last_update = atoi(row[2]); // ahh should we be comparing if this is newer?
+		key = row[0];
+		value = row[1];
+		std::transform(std::begin(key), std::end(key), std::begin(key), ::tolower); // keys are lower case, DB doesn't have to be
+		varcache.Add(key, value);
 	}
 
-	uint32 max_used = 0;
-	for (i=0; i<varcache_max; i++) {
-		if (varcache_array[i]) {
-			if (i > max_used)
-				max_used = i;
-		}
-	}
-
-	varcache_max = max_used + 1;
-
 	return true;
 }
 
 // Gets variable from 'variables' table
-bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
-	varvalue[0] = '\0';
+bool Database::GetVariable(std::string varname, std::string &varvalue)
+{
+	varvalue.clear();
 
 	LockMutex lock(&Mvarcache);
-	if (strlen(varname) <= 1)
-		return false;
-	for (uint32 i=0; i<varcache_max; i++) {
 
-		if (varcache_array[i]) {
-			if (strcasecmp(varcache_array[i]->varname, varname) == 0) {
-				snprintf(varvalue, varvalue_len, "%s", varcache_array[i]->value);
-				varvalue[varvalue_len-1] = 0;
-				return true;
-			}
-		}
-		else
-			return false;
+	if (varname.empty())
+		return false;
+
+	std::transform(std::begin(varname), std::end(varname), std::begin(varname), ::tolower); // all keys are lower case
+	auto tmp = varcache.Get(varname);
+	if (tmp) {
+		varvalue = *tmp;
+		return true;
 	}
 	return false;
 }
 
-bool Database::SetVariable(const char* varname_in, const char* varvalue_in) {
-	
-	char *varname,*varvalue;
-
-	varname=(char *)malloc(strlen(varname_in)*2+1);
-	varvalue=(char *)malloc(strlen(varvalue_in)*2+1);
-	DoEscapeString(varname, varname_in, strlen(varname_in));
-	DoEscapeString(varvalue, varvalue_in, strlen(varvalue_in));
-
-	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", varvalue, varname);
+bool Database::SetVariable(const std::string varname, const std::string &varvalue)
+{
+	std::string escaped_name = EscapeString(varname);
+	std::string escaped_value = EscapeString(varvalue);
+	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", escaped_value.c_str(), escaped_name.c_str());
 	auto results = QueryDatabase(query);
 
 	if (!results.Success())
-	{
-		free(varname);
-		free(varvalue);
 		return false;
-	}
 
 	if (results.RowsAffected() == 1)
 	{
 		LoadVariables(); // refresh cache
-		free(varname);
-		free(varvalue);
 		return true;
 	}
 
-	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", varname, varvalue);
+	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", escaped_name.c_str(), escaped_value.c_str());
 	results = QueryDatabase(query);
-	free(varname);
-	free(varvalue);
 
 	if (results.RowsAffected() != 1)
 		return false;
-	
+
 	LoadVariables(); // refresh cache
 	return true;
 }
@@ -1183,21 +1110,16 @@ bool Database::CheckNameFilter(const char* name, bool surname)
 {
 	std::string str_name = name;
 
-	if(surname)
+	// the minimum 4 is enforced by the client too
+	if (!name || strlen(name) < 4)
 	{
-		// the minimum 4 is enforced by the client too
-		if(!name || strlen(name) < 3)
-		{
-			return false;
-		}
+		return false;
 	}
-	else
+
+	// Given name length is enforced by the client too
+	if (!surname && strlen(name) > 15)
 	{
-		// the minimum 4 is enforced by the client too
-		if(!name || strlen(name) < 4 || strlen(name) > 15)
-		{
-			return false;
-		}
+		return false;
 	}
 
 	for (size_t i = 0; i < str_name.size(); i++)
@@ -1384,7 +1306,7 @@ bool Database::MoveCharacterToZone(const char* charname, const char* 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", iZonename, GetZoneID(iZonename), iCharID);
+	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", GetZoneID(iZonename), iCharID);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()) {
@@ -1560,11 +1482,12 @@ void Database::SetFirstLogon(uint32 CharID, uint8 firstlogon) {
 	QueryDatabase(query); 
 }
 
-void Database::AddReport(std::string who, std::string against, std::string lines) { 
-	char *escape_str = new char[lines.size()*2+1];
+void Database::AddReport(std::string who, std::string against, std::string lines)
+{
+	auto escape_str = new char[lines.size() * 2 + 1];
 	DoEscapeString(escape_str, lines.c_str(), lines.size());
 
-	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", who.c_str(), against.c_str(), escape_str);
+	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", EscapeString(who).c_str(), EscapeString(against).c_str(), escape_str);
 	QueryDatabase(query);
 	safe_delete_array(escape_str);
 }
@@ -1984,7 +1907,7 @@ void Database::GetRaidLeadershipInfo(uint32 rid, char *maintank,
 
 void Database::SetRaidGroupLeaderInfo(uint32 gid, uint32 rid)
 {
-	std::string query = StringFormat("UPDATE raid_leaders SET leadershipaa = '', WHERE gid = %lu AND rid = %lu",
+	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);
 
@@ -2154,6 +2077,16 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 		log_settings[log_category].log_to_file = atoi(row[3]);
 		log_settings[log_category].log_to_gmsay = atoi(row[4]);
 
+		/* Determine if any output method is enabled for the category 
+			and set it to 1 so it can used to check if category is enabled */
+		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 is_category_enabled = log_to_console || log_to_file || log_to_gmsay;
+
+		if (is_category_enabled)
+			log_settings[log_category].is_category_enabled = 1;
+
 		/* 
 			This determines whether or not the process needs to actually file log anything.
 			If we go through this whole loop and nothing is set to any debug level, there is no point to create a file or keep anything open
@@ -2162,4 +2095,76 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 			Log.file_logs_enabled = true;
 		}
 	}
-}
+}
+
+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-2003 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 
 #include "global_define.h"
 #include "eqemu_logsys.h"
+
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
@@ -36,10 +37,14 @@
 //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];
@@ -66,8 +71,14 @@ struct npcDecayTimes_Struct {
 
 
 struct VarCache_Struct {
-	char varname[26];	
-	char value[0];
+	std::map<std::string, std::string> m_cache;
+	uint32 last_update;
+	VarCache_Struct() : last_update(0) { }
+	void Add(const std::string &key, const std::string &value) { m_cache[key] = value; }
+	const std::string *Get(const std::string &key) {
+		auto it = m_cache.find(key);
+		return (it != m_cache.end() ? &it->second : nullptr);
+	}
 };
 
 class PTimerList;
@@ -87,7 +98,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 */
@@ -102,7 +113,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, Inventory* inv);
+	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv);
 	bool	UpdateName(const char* oldname, const char* newname);
 
 	/* General Information Queries */
@@ -179,6 +190,10 @@ 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 */
@@ -209,17 +224,14 @@ public:
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
-	bool	CheckDatabaseConvertBotsPostPPDeblob();
 	bool	CheckDatabaseConvertCorpseDeblob();
 	bool	CheckDatabaseConvertPPDeblob();
 
 	/* Database Variables */
 
-	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
-	bool	SetVariable(const char* varname, const char* varvalue);
+	bool	GetVariable(std::string varname, std::string &varvalue);
+	bool	SetVariable(const std::string varname, const std::string &varvalue);
 	bool	LoadVariables();
-	uint32	LoadVariables_MQ(char** query);
-	bool	LoadVariables_result(MySQLRequestResult results);
 
 	/* General Queries */
 
@@ -241,6 +253,8 @@ public:
 	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
 
 	void	AddReport(std::string who, std::string against, std::string lines);
+	struct TimeOfDay_Struct		LoadTime(time_t &realtime);
+	bool	SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
 	void	ClearMerchantTemp();
 	void	ClearPTimers(uint32 charid);
 	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
@@ -248,18 +262,16 @@ public:
 	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
+	void	ClearInvSnapshots(bool use_rule = true);
+
 	/* EQEmuLogSys */
 	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
-	void DBInitVars();
-
 	std::map<uint32,std::string>	zonename_array;
 
-	Mutex				Mvarcache;
-	uint32				varcache_max;
-	VarCache_Struct**	varcache_array;
-	uint32				varcache_lastupdate;
+	Mutex Mvarcache;
+	VarCache_Struct varcache;
 
 	/* Groups, utility methods. */
 	void    ClearAllGroupLeaders();

common/database_conversions.cpp

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

common/dbcore.cpp

@@ -98,19 +98,20 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			pStatus = Error;
 
-			char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+			auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 
 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
 
-		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
+		auto errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
 		/* Implement Logging at the Root */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
+			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
+				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}
 
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
@@ -125,8 +126,14 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
         rowCount = (uint32)mysql_num_rows(res);
 
 	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
-
-	Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
+	
+	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");
+	}
 
 	return requestResult;
 }

common/dbcore.h

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

common/deity.cpp

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

common/deity.h

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

common/emu_constants.cpp

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

common/emu_constants.h

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

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

common/emu_legacy.h

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

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

common/emu_limits.h

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

@@ -25,6 +25,9 @@ N(OP_AdventureRequest),
 N(OP_AdventureStatsReply),
 N(OP_AdventureStatsRequest),
 N(OP_AdventureUpdate),
+N(OP_AggroMeterLockTarget),
+N(OP_AggroMeterTargetInfo),
+N(OP_AggroMeterUpdate),
 N(OP_AltCurrency),
 N(OP_AltCurrencyMerchantReply),
 N(OP_AltCurrencyMerchantRequest),
@@ -64,6 +67,7 @@ N(OP_BuffRemoveRequest),
 N(OP_Bug),
 N(OP_CameraEffect),
 N(OP_Camp),
+N(OP_CancelSneakHide),
 N(OP_CancelTask),
 N(OP_CancelTrade),
 N(OP_CastSpell),
@@ -164,6 +168,7 @@ N(OP_FinishTrade),
 N(OP_FinishWindow),
 N(OP_FinishWindow2),
 N(OP_Fishing),
+N(OP_Fling),
 N(OP_FloatListThing),
 N(OP_Forage),
 N(OP_ForceFindPerson),
@@ -215,6 +220,7 @@ N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
+N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -286,6 +292,7 @@ N(OP_LFGuild),
 N(OP_LFPCommand),
 N(OP_LFPGetMatchesRequest),
 N(OP_LFPGetMatchesResponse),
+N(OP_LinkedReuse),
 N(OP_LoadSpellSet),
 N(OP_LocInfo),
 N(OP_LockoutTimerInfo),
@@ -348,6 +355,7 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
+N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
 N(OP_PetitionCheckIn),
@@ -364,6 +372,8 @@ N(OP_PetitionUnCheckout),
 N(OP_PetitionUpdate),
 N(OP_PickPocket),
 N(OP_PlayerProfile),
+N(OP_PlayerStateAdd),
+N(OP_PlayerStateRemove),
 N(OP_PlayEverquestRequest),
 N(OP_PlayEverquestResponse),
 N(OP_PlayMP3),
@@ -519,8 +529,6 @@ N(OP_VetRewardsAvaliable),
 N(OP_VoiceMacroIn),
 N(OP_VoiceMacroOut),
 N(OP_WeaponEquip1),
-N(OP_WeaponEquip2),
-N(OP_WeaponUnequip2),
 N(OP_WearChange),
 N(OP_Weather),
 N(OP_Weblink),
@@ -534,6 +542,8 @@ N(OP_WorldLogout),
 N(OP_WorldObjectsSent),
 N(OP_WorldUnknown001),
 N(OP_XTargetAutoAddHaters),
+N(OP_XTargetOpen),
+N(OP_XTargetOpenResponse),
 N(OP_XTargetRequest),
 N(OP_XTargetResponse),
 N(OP_YellForHelp),
@@ -547,4 +557,5 @@ N(OP_ZoneServerInfo),
 N(OP_ZoneServerReady),
 N(OP_ZoneSpawns),
 N(OP_ZoneUnavail),
+N(OP_ResetAA),
 // mail and chat opcodes located in ../mail_oplist.h

common/emu_tcp_connection.cpp

@@ -456,21 +456,21 @@ void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
 			std::cout << reason;
 		std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
 	#endif
-	ServerPacket* pack = new ServerPacket(0);
-	pack->size = 1;
-	if (reason)
-		pack->size += strlen(reason) + 1;
-	pack->pBuffer = new uchar[pack->size];
-	memset(pack->pBuffer, 0, pack->size);
-	pack->pBuffer[0] = 255;
-	strcpy((char*) &pack->pBuffer[1], reason);
-	SendPacket(pack);
-	safe_delete(pack);
+		auto pack = new ServerPacket(0);
+		pack->size = 1;
+		if (reason)
+			pack->size += strlen(reason) + 1;
+		pack->pBuffer = new uchar[pack->size];
+		memset(pack->pBuffer, 0, pack->size);
+		pack->pBuffer[0] = 255;
+		strcpy((char *)&pack->pBuffer[1], reason);
+		SendPacket(pack);
+		safe_delete(pack);
 }
 
 void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect) {
 	if (iSendRelayDisconnect) {
-		ServerPacket* pack = new ServerPacket(0, 5);
+		auto pack = new ServerPacket(0, 5);
 		pack->pBuffer[0] = 3;
 		*((uint32*) &pack->pBuffer[1]) = relay->GetRemoteID();
 		SendPacket(pack);
@@ -609,7 +609,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
 		if (base >= recvbuf_used) {
 			safe_delete_array(recvbuf);
 		} else {
-			uchar* tmpbuf = new uchar[recvbuf_size - base];
+			auto tmpbuf = new uchar[recvbuf_size - base];
 			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
 			safe_delete_array(recvbuf);
 			recvbuf = tmpbuf;
@@ -683,7 +683,7 @@ bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
 			safe_delete_array(recvbuf);
 		}
 		else {
-			uchar* tmpbuf = new uchar[recvbuf_size - base];
+			auto tmpbuf = new uchar[recvbuf_size - base];
 			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
 			safe_delete_array(recvbuf);
 			recvbuf = tmpbuf;
@@ -739,7 +739,8 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
 				break;
 			}
-			EmuTCPConnection* con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32*) data), *((uint32*) &data[4]), *((uint16*) &data[8]));
+			auto con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32 *)data),
+							*((uint32 *)&data[4]), *((uint16 *)&data[8]));
 			Server->AddConnection(con);
 			RelayCount++;
 			break;
@@ -787,7 +788,7 @@ bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
 	if(sent_something)
 		keepalive_timer.Start();
 	else if (TCPMode == modePacket && keepalive_timer.Check()) {
-		ServerPacket* pack = new ServerPacket(0, 0);
+		auto pack = new ServerPacket(0, 0);
 		SendPacket(pack);
 		safe_delete(pack);
 		#if TCPN_DEBUG >= 5

common/emu_tcp_server.cpp

@@ -24,7 +24,7 @@ void EmuTCPServer::Process() {
 
 void EmuTCPServer::CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
 {
-	EmuTCPConnection *conn = new EmuTCPConnection(ID, this, in_socket, irIP, irPort, pOldFormat);
+	auto conn = new EmuTCPConnection(ID, this, in_socket, irIP, irPort, pOldFormat);
 	AddConnection(conn);
 }
 

common/emu_versions.cpp

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

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

common/eq_dictionary.cpp

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

common/eq_dictionary.h

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

common/eq_limits.cpp

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

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

@@ -24,6 +24,7 @@
 #include "platform.h"
 #include <iomanip>
 #include <iostream>
+#include <sstream>
 #include <stdio.h>
 
 #ifndef STATIC_OPCODE
@@ -259,7 +260,7 @@ bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 {
 bool result=false;
 	if (opcode==OP_Combined && size+rhs->size+5<256) {
-		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+3];
+		auto tmpbuffer = new unsigned char[size + rhs->size + 3];
 		memcpy(tmpbuffer,pBuffer,size);
 		uint32 offset=size;
 		tmpbuffer[offset++]=rhs->Size();
@@ -269,7 +270,7 @@ bool result=false;
 		pBuffer=tmpbuffer;
 		result=true;
 	} else if (size+rhs->size+7<256) {
-		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+6];
+		auto tmpbuffer = new unsigned char[size + rhs->size + 6];
 		uint32 offset=0;
 		tmpbuffer[offset++]=Size();
 		offset+=serialize(tmpbuffer+offset);
@@ -456,7 +457,7 @@ EQApplicationPacket *EQApplicationPacket::Copy() const {
 }
 
 EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	EQRawApplicationPacket *res = new EQRawApplicationPacket(opcode, pBuffer, size);
+	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
 	res->copyInfo(this);
 	return(res);
 }
@@ -510,3 +511,8 @@ void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
 //	DumpPacketAscii(app->pBuffer, app->size);
 }
 
+std::string DumpPacketToString(const EQApplicationPacket* app){
+	std::ostringstream out;
+	out << DumpPacketHexToString(app->pBuffer, app->size);
+	return out.str();
+}

common/eq_packet.h

@@ -20,6 +20,7 @@
 
 #include "base_packet.h"
 #include "platform.h"
+#include <iostream>
 
 #ifdef STATIC_OPCODE
 	typedef unsigned short EmuOpcode;
@@ -61,7 +62,7 @@ class EQProtocolPacket : public BasePacket {
 	friend class EQStream;
 	friend class EQStreamPair;
 public:
-	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf,len), opcode(op) { acked = false; }
+	EQProtocolPacket(uint16 op, const unsigned char *buf, uint32 len) : BasePacket(buf, len), opcode(op) { acked = false; sent_time = 0; }
 //	EQProtocolPacket(const unsigned char *buf, uint32 len);
 	bool combine(const EQProtocolPacket *rhs);
 	uint32 serialize (unsigned char *dest) const;
@@ -69,6 +70,7 @@ public:
 	EQRawApplicationPacket *MakeAppPacket() const;
 
 	bool acked;
+	uint32 sent_time;
 
 	virtual void build_raw_header_dump(char *buffer, uint16 seq=0xffff) const;
 	virtual void build_header_dump(char *buffer) const;
@@ -146,6 +148,6 @@ protected:
 };
 
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
-
+extern std::string DumpPacketToString(const EQApplicationPacket* app);
 
 #endif

common/eq_stream.cpp

@@ -23,6 +23,7 @@
 #include "op_codes.h"
 #include "crc16.h"
 #include "platform.h"
+#include "string_util.h"
 
 #include <string>
 #include <iomanip>
@@ -71,8 +72,10 @@ void EQStream::init(bool resetSession) {
 	RateThreshold=RATEBASE/250;
 	DecayRate=DECAYBASE/250;
 	BytesWritten=0;
+	sent_packet_count = 0;
+	received_packet_count = 0;
 	SequencedBase = 0;
-	NextSequencedSend = 0;
+	AverageDelta = 500;
 
 	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 		retransmittimer = Timer::GetCurrentTime();
@@ -83,10 +86,6 @@ 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)
@@ -289,10 +288,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_KeepAlive: {
-#ifndef COLLECTOR
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
-#endif
 		}
 		break;
 		case OP_Ack: {
@@ -301,14 +298,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			AckPackets(seq);
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 				retransmittimer = Timer::GetCurrentTime();
 			}
-#endif
 		}
 		break;
 		case OP_SessionRequest: {
@@ -317,7 +312,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			if (GetState()==ESTABLISHED) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
 
@@ -330,7 +324,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					break;
 				}
 			}
-#endif
 			sessionAttempts++;
 			// we set established below, so statistics will not be reset for session attempts/stream active.
 			init(GetState()!=ESTABLISHED);
@@ -340,10 +333,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SetMaxLen(ntohl(Request->MaxLength));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
-#ifndef COLLECTOR
 			Key=0x11223344;
 			SendSessionResponse();
-#endif
 		}
 		break;
 		case OP_SessionResponse: {
@@ -409,7 +400,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();
 
@@ -417,36 +407,30 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
 			if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
-					seq, SequencedBase, SequencedBase+NextSequencedSend);
+					seq, SequencedBase, SequencedBase+SequencedQueue.size());
 
-				bool retransmit_acked_packets = false;
-				if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-					retransmit_acked_packets = RETRANSMIT_ACKED_PACKETS;
-				}
-
-				if(!retransmit_acked_packets) {
-					uint16 sqsize = SequencedQueue.size();
-					uint16 index = seq - SequencedBase;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
-					if (index < sqsize) {
-						std::deque<EQProtocolPacket *>::iterator sitr;
-						sitr = SequencedQueue.begin();
-						sitr += index;
-						(*sitr)->acked = true;
+				uint16 sqsize = SequencedQueue.size();
+				uint16 index = seq - SequencedBase;
+				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+				if (index < sqsize) {
+					SequencedQueue[index]->acked = true;
+					// flag packets for a resend
+					uint16 count = 0;
+					uint32 timeout = AverageDelta * 2 + 100;
+					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
+						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
+							(*sitr)->sent_time = 0;
+							Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
+						}
 					}
 				}
 
 				if(RETRANSMIT_TIMEOUT_MULT) {
 					retransmittimer = Timer::GetCurrentTime();
 				}
-
-				NextSequencedSend = 0;
 			} else {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
 			}
@@ -455,46 +439,49 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 			MOutboundQueue.unlock();
-#endif
 		}
 		break;
 		case OP_SessionStatRequest: {
-			if(p->Size() < sizeof(SessionStats))
+			if(p->Size() < sizeof(ClientSessionStats))
 			{
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
-#ifndef COLLECTOR
-			SessionStats *Stats=(SessionStats *)p->pBuffer;
+			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
-				(unsigned long)ntohl(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta),
-				(unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta),
-				(unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta));
-			uint64 x=Stats->packets_received;
-			Stats->packets_received=Stats->packets_sent;
-			Stats->packets_sent=x;
-			NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse,p->pBuffer,p->size));
-			AdjustRates(ntohl(Stats->average_delta));
+				(unsigned long)ntohl(ClientStats->packets_received), (unsigned long)ntohl(ClientStats->packets_sent), (unsigned long)ntohl(ClientStats->last_local_delta),
+				(unsigned long)ntohl(ClientStats->low_delta), (unsigned long)ntohl(ClientStats->average_delta),
+				(unsigned long)ntohl(ClientStats->high_delta), (unsigned long)ntohl(ClientStats->last_remote_delta));
+			
+			AdjustRates(ntohl(ClientStats->average_delta));
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if(RETRANSMIT_TIMEOUT_MULT && ntohl(Stats->average_delta)) {
+				if (RETRANSMIT_TIMEOUT_MULT && ntohl(ClientStats->average_delta)) {
 					//recalculate retransmittimeout using the larger of the last rtt or average rtt, which is multiplied by the rule value
-					if((ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) > (ntohl(Stats->average_delta) * 2)) {
-						retransmittimeout = (ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) 
+					if ((ntohl(ClientStats->last_local_delta) + ntohl(ClientStats->last_remote_delta)) > (ntohl(ClientStats->average_delta) * 2)) {
+						retransmittimeout = (ntohl(ClientStats->last_local_delta) + ntohl(ClientStats->last_remote_delta))
 							* RETRANSMIT_TIMEOUT_MULT;
 					} else {
-						retransmittimeout = ntohl(Stats->average_delta) * 2 * RETRANSMIT_TIMEOUT_MULT;
+						retransmittimeout = ntohl(ClientStats->average_delta) * 2 * RETRANSMIT_TIMEOUT_MULT;
 					}
+					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
 				}
 			}
-#endif
+
+			ServerSessionStats *ServerStats = (ServerSessionStats *)p->pBuffer;
+
+			//ServerStats->RequestID = ClientStats->RequestID; // no change
+			ServerStats->ServerTime = htonl(Timer::GetCurrentTime());
+			ServerStats->packets_sent_echo = ClientStats->packets_sent; // still in htonll format
+			ServerStats->packets_received_echo = ClientStats->packets_received; // still in htonll format
+			ServerStats->packets_sent = htonll(GetPacketsSent());
+			ServerStats->packets_received = htonll(GetPacketsReceived());
+
+			NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse, p->pBuffer, p->size));
 		}
 		break;
 		case OP_SessionStatResponse: {
@@ -555,21 +542,35 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 
 void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 {
-	uint32 chunksize,used;
+	uint32 chunksize, used;
 	uint32 length;
 
+	if (Log.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
+		if (p->GetOpcode() != OP_SpecialMesg){
+			Log.Out(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+		}
+	}
+
+	if (Log.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
+		if (p->GetOpcode() != OP_SpecialMesg){
+			Log.Out(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
+		}
+	}
+
 	// Convert the EQApplicationPacket to 1 or more EQProtocolPackets
 	if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->size);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
 
-		unsigned char *tmpbuff=new unsigned char[p->size+3];
+		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
+		if (length != p->Size())
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
 
-		EQProtocolPacket *out=new EQProtocolPacket(OP_Fragment,nullptr,MaxLen-4);
-		*(uint32 *)(out->pBuffer+2)=htonl(p->Size());
+		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
+		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
 		SequencedPush(out);
 
 
@@ -580,16 +581,16 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
 	} else {
 
-		unsigned char *tmpbuff=new unsigned char[p->Size()+3];
+		auto tmpbuff = new unsigned char[p->Size() + 3];
 		length=p->serialize(opcode, tmpbuff+2) + 2;
 
-		EQProtocolPacket *out=new EQProtocolPacket(OP_Packet,tmpbuff,length);
+		auto out = new EQProtocolPacket(OP_Packet, tmpbuff, length);
 
 		delete[] tmpbuff;
 		SequencedPush(out);
@@ -599,42 +600,32 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 
 void EQStream::SequencedPush(EQProtocolPacket *p)
 {
-#ifdef COLLECTOR
-	delete p;
-#else
 	MOutboundQueue.lock();
-if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-}
-if(NextSequencedSend > SequencedQueue.size()) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-}
+	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+			SequencedBase, SequencedQueue.size(), NextOutSeq);
+	}
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase);
-	*(uint16 *)(p->pBuffer)=htons(NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
+		NextOutSeq, p->size, SequencedBase);
+	*(uint16 *)(p->pBuffer) = htons(NextOutSeq);
 	SequencedQueue.push_back(p);
 	NextOutSeq++;
 
-if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
-}
-if(NextSequencedSend > SequencedQueue.size()) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-}
+	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+			SequencedBase, SequencedQueue.size(), NextOutSeq);
+	}
+
 	MOutboundQueue.unlock();
-#endif
 }
 
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
-#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)
@@ -678,21 +669,15 @@ void EQStream::Write(int eq_fd)
 	// Place to hold the base packet t combine into
 	EQProtocolPacket *p=nullptr;
 
-	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-		// if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue
-		if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend &&
-			(GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
-				"buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend);
-			NextSequencedSend = 0;
-			retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet
-		}
-	}
-
 	// Find the next sequenced packet to send from the "queue"
 	sitr = SequencedQueue.begin();
-	if (sitr!=SequencedQueue.end())
-	sitr += NextSequencedSend;
+
+	uint16 count = 0;
+	// get to start of packets
+	while (sitr != SequencedQueue.end() && (*sitr)->sent_time > 0) {
+		++sitr;
+		++count;
+	}
 
 	// Loop until both are empty or MaxSends is reached
 	while(!SeqEmpty || !NonSeqEmpty) {
@@ -706,7 +691,7 @@ void EQStream::Write(int eq_fd)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
-				// Tryint to combine this packet with the base didn't work (too big maybe)
+				// Trying to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
@@ -729,16 +714,9 @@ void EQStream::Write(int eq_fd)
 			NonSeqEmpty=true;
 		}
 
-		if (sitr!=SequencedQueue.end()) {
-			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
-			}
+		if (sitr != SequencedQueue.end()) {
+			uint16 seq_send = SequencedBase + count;	//just for logging...
 
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
-			uint16 seq_send = SequencedBase + NextSequencedSend;	//just for logging...
-			
 			if(SequencedQueue.empty()) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
@@ -746,26 +724,32 @@ void EQStream::Write(int eq_fd)
 			}
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
+				if ((*sitr)->acked || (*sitr)->sent_time != 0) {
+					++sitr;
+					++count;
+					if (p) {
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						ReadyToSend.push(p);
+						BytesWritten += p->size;
+						p = nullptr;
+					}
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
-					sitr++;
-					NextSequencedSend++;
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
-
-					if (BytesWritten > threshold) {
+					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
 						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
@@ -773,17 +757,28 @@ void EQStream::Write(int eq_fd)
 				} else {
 					// Combine worked
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				}
 			} else {
-				if (!p) {
+				if ((*sitr)->sent_time != 0) {
+					++sitr;
+					++count;
+					if (p) {
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						ReadyToSend.push(p);
+						BytesWritten += p->size;
+						p = nullptr;
+					}
+				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
@@ -799,18 +794,16 @@ void EQStream::Write(int eq_fd)
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					NextSequencedSend++;
+					++count;
 				}
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
-			if(NextSequencedSend > SequencedQueue.size()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-			}
 		} else {
 			// No more sequenced packets
 			SeqEmpty=true;
@@ -869,9 +862,11 @@ 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);
@@ -887,7 +882,7 @@ sockaddr_in address;
 
 void EQStream::SendSessionResponse()
 {
-EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(SessionResponse));
+	auto out = new EQProtocolPacket(OP_SessionResponse, nullptr, sizeof(SessionResponse));
 	SessionResponse *Response=(SessionResponse *)out->pBuffer;
 	Response->Session=htonl(Session);
 	Response->MaxLength=htonl(MaxLen);
@@ -909,7 +904,7 @@ EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(Ses
 
 void EQStream::SendSessionRequest()
 {
-EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(SessionRequest));
+	auto out = new EQProtocolPacket(OP_SessionRequest, nullptr, sizeof(SessionRequest));
 	SessionRequest *Request=(SessionRequest *)out->pBuffer;
 	memset(Request,0,sizeof(SessionRequest));
 	Request->Session=htonl(time(nullptr));
@@ -925,7 +920,7 @@ void EQStream::_SendDisconnect()
 	if(GetState() == CLOSED)
 		return;
 
-	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionDisconnect,nullptr,sizeof(uint32));
+	auto out = new EQProtocolPacket(OP_SessionDisconnect, nullptr, sizeof(uint32));
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
@@ -944,21 +939,19 @@ EQApplicationPacket *EQStream::PopPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
 	MInboundQueue.unlock();
 
-	//resolve the opcode if we can.
-	if(p) {
-		if(OpMgr != nullptr && *OpMgr != nullptr) {
+	if (p) {
+		if (OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if (emu_op == OP_Unknown) {
-				Log.Out(Logs::General, Logs::Netcode, "[ERROR] Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
-			}
-
+				// Log.Out(Logs::General, Logs::Client_Server_Packet_Unhandled, "Unknown :: [%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->opcode, p->Size(), DumpPacketToString(p).c_str());
+			} 
 			p->SetOpcode(emu_op);
 		}
 	}
@@ -971,8 +964,8 @@ EQRawApplicationPacket *EQStream::PopRawPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -998,8 +991,8 @@ EQRawApplicationPacket *EQStream::PeekPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (InboundQueue.size()) {
-		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
+	if (!InboundQueue.empty()) {
+		auto itr = InboundQueue.begin();
 		p=*itr;
 	}
 	MInboundQueue.unlock();
@@ -1090,8 +1083,8 @@ EQProtocolPacket *p=nullptr;
 
 void EQStream::Process(const unsigned char *buffer, const uint32 length)
 {
-static unsigned char newbuffer[2048];
-uint32 newlength=0;
+	static unsigned char newbuffer[2048];
+	uint32 newlength=0;
 	if (EQProtocolPacket::ValidateCRC(buffer,length,Key)) {
 		if (compressed) {
 			newlength=EQProtocolPacket::Decompress(buffer,length,newbuffer,2048);
@@ -1135,13 +1128,6 @@ void EQStream::AckPackets(uint16 seq)
 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) {
@@ -1157,28 +1143,21 @@ if(NextSequencedSend > SequencedQueue.size()) {
 		//this is a good ack, we get to ack some blocks.
 		seq++;	//we stop at the block right after their ack, counting on the wrap of both numbers.
 		while(SequencedBase != seq) {
-if(SequencedQueue.empty()) {
-Log.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. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
+			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());
+				SequencedBase = NextOutSeq;
+				break;
+			}
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
-			//adjust our "next" pointer
-			if(NextSequencedSend > 0)
-				NextSequencedSend--;
 			//advance the base sequence number to the seq of the block after the one we just got rid of.
 			SequencedBase++;
 		}
-if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
-}
-if(NextSequencedSend > SequencedQueue.size()) {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
-}
+		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);
+		}
 	}
 
 	MOutboundQueue.unlock();
@@ -1356,6 +1335,18 @@ 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)
@@ -1363,18 +1354,24 @@ void EQStream::AdjustRates(uint32 average_delta)
 	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, 

common/eq_stream.h

@@ -71,7 +71,7 @@ struct SessionResponse {
 };
 
 //Deltas are in ms, representing round trip times
-struct SessionStats {
+struct ClientSessionStats {
 /*000*/	uint16 RequestID;
 /*002*/	uint32 last_local_delta;
 /*006*/	uint32 average_delta;
@@ -83,6 +83,16 @@ struct SessionStats {
 /*038*/
 };
 
+struct ServerSessionStats {
+/*000*/	uint16 RequestID;
+/*002*/	uint32 ServerTime;
+/*006*/	uint64 packets_sent_echo;
+/*014*/	uint64 packets_received_echo;
+/*022*/	uint64 packets_sent;
+/*030*/	uint64 packets_received;
+/*038*/
+};
+
 #pragma pack()
 
 class OpcodeManager;
@@ -143,7 +153,6 @@ class EQStream : public EQStreamInterface {
 		std::deque<EQProtocolPacket *> SequencedQueue;
 		uint16 NextOutSeq;
 		uint16 SequencedBase;	//the sequence number of SequencedQueue[0]
-		long NextSequencedSend;	//index into SequencedQueue
 		Mutex MOutboundQueue;
 
 		//a buffer we use for compression/decompression
@@ -158,10 +167,13 @@ class EQStream : public EQStreamInterface {
 
 		int32 BytesWritten;
 
+		uint64 sent_packet_count;
+		uint64 received_packet_count;
+
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
-
+		uint32 AverageDelta;
 
 		OpcodeManager **OpMgr;
 
@@ -265,11 +277,13 @@ class EQStream : public EQStreamInterface {
 		void AddBytesSent(uint32 bytes)
 		{
 			bytes_sent += bytes;
+			++sent_packet_count;
 		}
 
 		void AddBytesRecv(uint32 bytes)
 		{
 			bytes_recv += bytes;
+			++received_packet_count;
 		}
 
 		virtual const uint32 GetBytesSent() const { return bytes_sent; }
@@ -288,6 +302,9 @@ class EQStream : public EQStreamInterface {
 			return bytes_recv / (Timer::GetTimeSeconds() - create_time);
 		}
 
+		const uint64 GetPacketsSent() { return sent_packet_count; }
+		const uint64 GetPacketsReceived() { return received_packet_count; }
+
 		//used for dynamic stream identification
 		class Signature {
 		public:

common/eq_stream_factory.cpp

@@ -3,7 +3,7 @@
 #include "eq_stream_factory.h"
 
 #ifdef _WINDOWS
-	#include <winsock.h>
+	#include <winsock2.h>
 	#include <process.h>
 	#include <io.h>
 	#include <stdio.h>
@@ -120,7 +120,7 @@ std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
 	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
-	if (NewStreams.size()) {
+	if (!NewStreams.empty()) {
 		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
@@ -235,7 +235,7 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
+				auto temp = stream_itr;
 				++stream_itr;
 				temp->second = nullptr;
 				Streams.erase(temp);
@@ -250,8 +250,7 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-	bool havework=true;
+	bool havework = true;
 	std::vector<std::shared_ptr<EQStream>> wants_write;
 	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
 	bool decay = false;
@@ -260,7 +259,7 @@ void EQStreamFactory::WriterLoop()
 	WriterRunning = true;
 	DecayTimer.Enable();
 
-	while(sock!=-1) {
+	while (sock != -1) {
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -269,34 +268,36 @@ void EQStreamFactory::WriterLoop()
 		havework = false;
 		wants_write.clear();
 
-		decay=DecayTimer.Check();
+		decay = DecayTimer.Check();
 
-		//copy streams into a seperate list so we dont have to keep
-		//MStreams locked while we are writting
+		// copy streams into a seperate list so we dont have to keep
+		// MStreams locked while we are writting
 		MStreams.lock();
-		for(stream_itr=Streams.begin();stream_itr!=Streams.end();++stream_itr) {
+		for (auto stream_itr = Streams.begin(); stream_itr != Streams.end(); ++stream_itr) {
 			// If it's time to decay the bytes sent, then let's do it before we try to write
 			if (decay)
 				stream_itr->second->Decay();
 
-			//bullshit checking, to see if this is really happening, GDB seems to think so...
-			if(stream_itr->second == nullptr) {
-				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i", stream_itr->first.first, stream_itr->first.second);
+			// bullshit checking, to see if this is really happening, GDB seems to think so...
+			if (stream_itr->second == nullptr) {
+				fprintf(stderr,
+					"ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i",
+					stream_itr->first.first, stream_itr->first.second);
 				continue;
 			}
 
 			if (stream_itr->second->HasOutgoingData()) {
-				havework=true;
+				havework = true;
 				stream_itr->second->PutInUse();
 				wants_write.push_back(stream_itr->second);
 			}
 		}
 		MStreams.unlock();
 
-		//do the actual writes
+		// do the actual writes
 		cur = wants_write.begin();
 		end = wants_write.end();
-		for(; cur != end; ++cur) {
+		for (; cur != end; ++cur) {
 			(*cur)->Write(sock);
 			(*cur)->ReleaseFromUse();
 		}

common/eq_stream_ident.cpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #include "global_define.h"
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
@@ -25,7 +27,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 }
 
 void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
-	Patch *p = new Patch;
+	auto p = new Patch;
 	p->signature = sig;
 	p->name = name;
 	p->opcodes = opcodes;
@@ -156,7 +158,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 }
 
 EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
-:	stream(s),
+:	stream(std::move(s)),
 	expire(STREAM_IDENT_WAIT_MS)
 {
 }

common/eq_stream_intf.h

@@ -4,7 +4,7 @@
 //this is the only part of an EQStream that is seen by the application.
 
 #include <string>
-#include "clientversions.h"
+#include "emu_versions.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 ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
+	virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

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

common/eq_stream_proxy.h

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

common/eqdb.cpp

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

common/eqemu_config.cpp

@@ -80,7 +80,7 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 			sprintf(str, "loginserver%i", ++LoginCount);
 			sub_ele = ele->FirstChildElement(str);
 			if (sub_ele) {
-				LoginConfig* loginconfig = new LoginConfig;
+				auto loginconfig = new LoginConfig;
 				text = ParseTextBlock(sub_ele, "host", true);
 				if (text) {
 					loginconfig->LoginHost = text;
@@ -254,9 +254,9 @@ void EQEmuConfig::do_files(TiXmlElement *ele)
 	if (text) {
 		OpCodesFile = text;
 	}
-	text = ParseTextBlock(ele, "eqtime", true);
+	text = ParseTextBlock(ele, "plugin.pl", true);
 	if (text) {
-		EQTimeFile = text;
+		PluginPlFile = text;
 	}
 }
 
@@ -266,14 +266,45 @@ void EQEmuConfig::do_directories(TiXmlElement *ele)
 	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 += '/';
 	}
 }
 
@@ -408,8 +439,8 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "OpCodesFile") {
 		return (OpCodesFile);
 	}
-	if (var_name == "EQTimeFile") {
-		return (EQTimeFile);
+	if (var_name == "PluginPlFile") {
+		return (PluginPlFile);
 	}
 	if (var_name == "MapDir") {
 		return (MapDir);
@@ -420,6 +451,18 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "PluginDir") {
 		return (PluginDir);
 	}
+	if (var_name == "LuaModuleDir") {
+		return (LuaModuleDir);
+	}
+	if (var_name == "PatchDir") {
+		return (PatchDir);
+	}
+	if (var_name == "SharedMemDir") {
+		return (SharedMemDir);
+	}
+	if (var_name == "LogDir") {
+		return (LogDir);
+	}
 	if (var_name == "LogPrefix") {
 		return (LogPrefix);
 	}
@@ -475,10 +518,14 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
-	std::cout << "EQTimeFile = " << EQTimeFile << std::endl;
+	std::cout << "PluginPlFile = " << PluginPlFile << std::endl;
 	std::cout << "MapDir = " << MapDir << std::endl;
 	std::cout << "QuestDir = " << QuestDir << std::endl;
 	std::cout << "PluginDir = " << PluginDir << std::endl;
+	std::cout << "LuaModuleDir = " << LuaModuleDir << std::endl;
+	std::cout << "PatchDir = " << PatchDir << std::endl;
+	std::cout << "SharedMemDir = " << SharedMemDir << std::endl;
+	std::cout << "LogDir = " << LogDir << std::endl;
 	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
 	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
 	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;

common/eqemu_config.h

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

common/eqemu_logsys.cpp

@@ -102,6 +102,7 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	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
@@ -116,32 +117,27 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		platform_file_name = "ucs";
 	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
 		platform_file_name = "login";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
 		platform_file_name = "launcher";
 }
 
 std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
 {
-	std::string category_string;
-	if (log_category > 0 && Logs::LogCategoryName[log_category])
-		category_string = StringFormat("[%s] ", Logs::LogCategoryName[log_category]);
-	return StringFormat("%s%s", category_string.c_str(), in_message.c_str());
+	std::string ret;
+	ret.push_back('[');
+	ret.append(Logs::LogCategoryName[log_category]);
+	ret.push_back(']');
+	ret.push_back(' ');
+	ret.append(in_message);
+	return ret;
 }
 
 void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_gmsay == 0)
-		return;
-
 	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
 	if (log_category == Logs::LogCategory::Netcode)
 		return;
 
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_gmsay < debug_level)
-		return;
-
 	/* Check to see if the process that actually ran this is zone */
 	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
 		on_log_gmsay_hook(log_category, message);
@@ -159,14 +155,6 @@ void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const
 		crash_log.close();
 	}
 
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_file == 0)
-		return;
-
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_file < debug_level)
-		return;
-
 	char time_stamp[80];
 	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 
@@ -245,13 +233,6 @@ uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {
 
 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_console == 0)
-		return;
-
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_console < debug_level)
-		return;
 
 	#ifdef _WINDOWS
 		HANDLE  console_handle;
@@ -272,12 +253,25 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 
 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
-	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;
+	bool log_to_console = true;
+	if (log_settings[log_category].log_to_console < debug_level) {
+		log_to_console = false;
+	}
+
+	bool log_to_file = true;
+	if (log_settings[log_category].log_to_file < debug_level) {
+		log_to_file = false;
+	}
+
+	bool log_to_gmsay = true;
+	if (log_settings[log_category].log_to_gmsay < debug_level) {
+		log_to_gmsay = false;
+	}
+
+	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
+	if (nothing_to_log)
+		return;
 
 	va_list args;
 	va_start(args, message);
@@ -288,7 +282,7 @@ void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::st
 
 	if (log_to_console) EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
 	if (log_to_gmsay) EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
-	if (log_to_file) EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_message);
+	if (log_to_file) EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
 }
 
 void EQEmuLogSys::SetCurrentTimeStamp(char* time_stamp)

common/eqemu_logsys.h

@@ -78,6 +78,12 @@ namespace Logs {
 		MySQLQuery,
 		Mercenaries,
 		QuestDebug,
+		Server_Client_Packet,
+		Client_Server_Packet_Unhandled,
+		Server_Client_Packet_With_Dump,
+		Client_Server_Packet_With_Dump,
+		Login_Server,
+		Client_Login,
 		MaxCategoryID	/* Don't Remove this*/
 	};
 
@@ -88,7 +94,7 @@ namespace Logs {
 		"AI",
 		"Aggro",
 		"Attack",
-		"Client Server Packet",
+		"Packet :: Client -> Server",
 		"Combat",
 		"Commands",
 		"Crash",
@@ -121,7 +127,13 @@ namespace Logs {
 		"MySQL Error",
 		"MySQL Query",
 		"Mercenaries",
-		"Quest Debug"
+		"Quest Debug",
+		"Packet :: Server -> Client",
+		"Packet :: Client -> Server Unhandled",
+		"Packet :: Server -> Client (Dump)",
+		"Packet :: Client -> Server (Dump)",
+		"Login Server",
+		"Client Login"
 	};
 }
 
@@ -160,6 +172,7 @@ public:
 		uint8 log_to_file;
 		uint8 log_to_console;
 		uint8 log_to_gmsay;
+		uint8 is_category_enabled; /* When any log output in a category > 0, set this to 1 as (Enabled) */
 	};
 
 	/* Internally used memory reference for all log settings per category.

common/eqtime.cpp

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

common/eqtime.h

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

common/extprofile.h

@@ -19,7 +19,7 @@
 #define EXTENDED_PROFILE_H
 
 #include "eq_packet_structs.h"
-#include "item.h"
+#include "inventory_profile.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 */
-	uint32				pet_items[_MaterialCount]; /* Not Used */
+	EQEmu::TextureMaterialProfile	pet_items; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */
@@ -54,6 +54,8 @@ struct ExtendedProfile_Struct {
 	uint32				mercTimerRemaining; /* Not Used */
 	uint8				mercGender; /* Not Used */
 	int32				mercState; /* Not Used */
+	uint32				last_invsnapshot_time; /* Used */
+	uint32				next_invsnapshot_time; /* Used */
 };
 
 #pragma pack()

common/features.h

@@ -154,11 +154,12 @@ enum {	//reuse times
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
 	AIthink_duration = 150,
-	AIscanarea_delay = 500,
+	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
 	AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
+	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed
 	ClientProximity_interval = 150,
 	CombatEventTimer_expire = 12000,
 	Tribute_duration = 600000,
@@ -212,8 +213,8 @@ enum {	//some random constants
 #define MAX_NPC_FACTIONS 20
 
 //individual faction pool
-#define MAX_PERSONAL_FACTION 1200
-#define MIN_PERSONAL_FACTION -3000
+#define MAX_PERSONAL_FACTION 2000
+#define MIN_PERSONAL_FACTION -2000
 
 //The Level Cap:
 //#define LEVEL_CAP RuleI(Character, MaxLevel)	//hard cap is 127
@@ -232,6 +233,11 @@ enum {	//some random constants
 #define GROUP_EXP_PER_POINT 1000
 #define RAID_EXP_PER_POINT 2000
 
+#define ZONE_CONTROLLER_NPC_ID 10
+
+// Timer to update aggrometer
+#define AGGRO_METER_UPDATE_MS 1000
+
 //Some hard coded statuses from commands and other places:
 enum {
 	minStatusToBeGM = 40,
@@ -270,6 +276,9 @@ enum {
 #define NPC_DEFAULT_LOGGING_ENABLED false
 
 
+// This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
+#define SAYLINK_ITEM_ID 0xFFFFF
+
 
 /*
 

common/global_define.h

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

common/guild_base.cpp

@@ -179,7 +179,7 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 	}
 
 	//make the new entry and store it into the map.
-	GuildInfo *info = new GuildInfo;
+	auto info = new GuildInfo;
 	info->name = guild_name;
 	info->leader_char_id = leader_char_id;
 	info->minstatus = minstatus;
@@ -236,9 +236,9 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	results = m_db->QueryDatabase(query);
 
 	//escape our strings.
-	char *name_esc = new char[info->name.length()*2+1];
-	char *motd_esc = new char[info->motd.length()*2+1];
-	char *motd_set_esc = new char[info->motd_setter.length()*2+1];
+	auto name_esc = new char[info->name.length() * 2 + 1];
+	auto motd_esc = new char[info->motd.length() * 2 + 1];
+	auto motd_set_esc = new char[info->motd_setter.length() * 2 + 1];
 	m_db->DoEscapeString(name_esc, info->name.c_str(), info->name.length());
 	m_db->DoEscapeString(motd_esc, info->motd.c_str(), info->motd.length());
 	m_db->DoEscapeString(motd_set_esc, info->motd_setter.c_str(), info->motd_setter.length());
@@ -264,7 +264,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	for(rank = 0; rank <= GUILD_MAX_RANK; rank++) {
 		const RankInfo &rankInfo = info->ranks[rank];
 
-		char *title_esc = new char[rankInfo.name.length()*2+1];
+		auto title_esc = new char[rankInfo.name.length() * 2 + 1];
 		m_db->DoEscapeString(title_esc, rankInfo.name.c_str(), rankInfo.name.length());
 
         query = StringFormat("INSERT INTO guild_ranks "
@@ -564,7 +564,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 	//escape our strings.
 	uint32 len = strlen(name);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, name, len);
 
 	//insert the new `guilds` entry
@@ -636,8 +636,8 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 	//escape our strings.
 	uint32 len = strlen(motd);
 	uint32 len2 = strlen(setter);
-	char *esc = new char[len*2+1];
-	char *esc_set = new char[len2*2+1];
+	auto esc = new char[len * 2 + 1];
+	auto esc_set = new char[len2 * 2 + 1];
 	m_db->DoEscapeString(esc, motd, len);
 	m_db->DoEscapeString(esc_set, setter, len2);
 
@@ -675,7 +675,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 	//escape our strings.
 	uint32 len = strlen(URL);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, URL, len);
 
     std::string query = StringFormat("UPDATE guilds SET url='%s' WHERE id=%d", esc, GuildID);
@@ -709,7 +709,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 
 	//escape our strings.
 	uint32 len = strlen(Channel);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, Channel, len);
 
     std::string query = StringFormat("UPDATE guilds SET channel='%s' WHERE id=%d", esc, GuildID);
@@ -832,7 +832,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 
 	//escape our strings.
 	uint32 len = strlen(note);
-	char *esc = new char[len*2+1];
+	auto esc = new char[len * 2 + 1];
 	m_db->DoEscapeString(esc, note, len);
 
 	//insert the new `guilds` entry
@@ -867,16 +867,16 @@ bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
 //factored out so I dont have to copy this crap.
 #ifdef BOTS
 #define GuildMemberBaseQuery \
-"SELECT c.id,c.name,c.class,c.level,c.timelaston,c.zoneid," \
-" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
-" g.banker,g.public_note,g.alt" \
-" FROM vwBotCharacterMobs AS c LEFT JOIN vwGuildMembers AS g ON c.id=g.char_id AND c.mobtype = g.mobtype "
+"SELECT c.`id`, c.`name`, c.`class`, c.`level`, c.`last_login`, c.`zone_id`," \
+" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
+" g.`banker`, g.`public_note`, g.`alt`" \
+" FROM `vw_bot_character_mobs` AS c LEFT JOIN `vw_guild_members` AS g ON c.`id` = g.`char_id` AND c.`mob_type` = g.`mob_type` "
 #else
 #define GuildMemberBaseQuery \
-"SELECT c.id,c.name,c.class,c.level,c.last_login,c.zone_id," \
-" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
-" g.banker,g.public_note,g.alt " \
-" FROM `character_data` AS c LEFT JOIN guild_members AS g ON c.id=g.char_id "
+"SELECT c.`id`, c.`name`, c.`class`, c.`level`, c.`last_login`, c.`zone_id`," \
+" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
+" g.`banker`, g.`public_note`, g.`alt` " \
+" FROM `character_data` AS c LEFT JOIN `guild_members` AS g ON c.`id` = g.`char_id` "
 #endif
 static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
 	//fields from `characer_`
@@ -918,8 +918,8 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 		return false;
 	}
 
-    for (auto row = results.begin(); row != results.end(); ++row) {
-		CharGuildInfo *ci = new CharGuildInfo;
+	for (auto row = results.begin(); row != results.end(); ++row) {
+		auto ci = new CharGuildInfo;
 		ProcessGuildMember(row, *ci);
 		members.push_back(ci);
 	}
@@ -937,7 +937,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 
 	//escape our strings.
 	uint32 nl = strlen(char_name);
-	char *esc = new char[nl*2+1];
+	auto esc = new char[nl * 2 + 1];
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
@@ -969,7 +969,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 	//load up the rank info for each guild.
 	std::string query;
 #ifdef BOTS
-    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mob_type = 'C'", char_id);
 #else
     query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
 #endif
@@ -994,7 +994,7 @@ uint8 *BaseGuildManager::MakeGuildList(const char *head_name, uint32 &length) co
 	//dynamic structs will make this a lot less painful.
 
 	length = sizeof(GuildsList_Struct);
-	uint8 *buffer = new uint8[length];
+	auto buffer = new uint8[length];
 
 	//a bit little better than memsetting the whole thing...
 	uint32 r,pos;

common/inventory_profile.h

@@ -0,0 +1,230 @@
+/*	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, int16 general_start = legacy::GENERAL_BEGIN, uint8 bag_start = inventory::containerBegin);
+
+		// 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

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

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

common/item.h

@@ -1,478 +0,0 @@
-/*	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>
-
-// Helper typedefs
-typedef std::map<int16, ItemInst*>::const_iterator			iter_inst;
-typedef std::map<uint8, ItemInst*>::const_iterator			iter_contents;
-
-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 begin() { return m_list.begin(); }
-	inline std::list<ItemInst*>::const_iterator end() { return m_list.end(); }
-
-	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_begin() { return m_cursor.begin(); }
-	inline std::list<ItemInst*>::const_iterator cursor_end() { return m_cursor.end(); }
-
-	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, iter_inst *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
-	//////////////////////////
-	iter_contents _begin()		{ return m_contents.begin(); }
-	iter_contents _end()		{ return m_contents.end(); }
-
-	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

@@ -0,0 +1,227 @@
+/*	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) || (ItemType == item::ItemTypeMartial));
+}
+
+bool EQEmu::ItemData::IsType2HWeapon() const
+{
+	return ((ItemType == item::ItemType2HBlunt) || (ItemType == item::ItemType2HSlash) || (ItemType == item::ItemType2HPiercing));
+}
+
+bool EQEmu::ItemData::IsTypeShield() const
+{
+	return (ItemType == item::ItemTypeShield);
+}
+
+bool EQEmu::ItemData::CheckLoreConflict(const ItemData* l_item, const ItemData* r_item)
+{
+	if (!l_item || !r_item)
+		return false;
+
+	if (!l_item->LoreGroup || !r_item->LoreGroup)
+		return false;
+
+	if (l_item->LoreGroup == r_item->LoreGroup) {
+		if ((l_item->LoreGroup == -1) && (l_item->ID != r_item->ID))
+			return false;
+
+		return true;
+	}
+
+	return false;
+}

common/item_data.h

@@ -0,0 +1,548 @@
+/*	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;
+
+		static bool CheckLoreConflict(const ItemData* l_item, const ItemData* r_item);
+		bool CheckLoreConflict(const ItemData* item) const { return CheckLoreConflict(this, item); }
+	};
+
+} /*EQEmu*/
+
+#endif /*COMMON_ITEM_DATA_H*/

common/item_fieldlist.h

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

common/item_instance.h

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

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

@@ -0,0 +1,99 @@
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+	
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "light_source.h"
+
+#include <string.h>
+
+
+uint8 EQEmu::lightsource::TypeToLevel(uint8 light_type)
+{
+	switch (light_type) {
+	case LightTypeGlobeOfStars:
+		return LightLevelBrilliant;		// 10
+	case LightTypeFlamelessLantern:
+	case LightTypeGreaterLightstone:
+		return LightLevelLargeMagic;	// 9
+	case LightTypeLargeLantern:
+		return LightLevelLargeLantern;	// 8
+	case LightTypeSteinOfMoggok:
+	case LightTypeLightstone:
+		return LightLevelMagicLantern;	// 7
+	case LightTypeSmallLantern:
+		return LightLevelSmallLantern;	// 6
+	case LightTypeColdlight:
+	case LightTypeUnknown2:
+		return LightLevelBlueLight;		// 5
+	case LightTypeFireBeetleEye:
+	case LightTypeUnknown1:
+		return LightLevelRedLight;		// 4
+	case LightTypeTinyGlowingSkull:
+	case LightTypeLightGlobe:
+		return LightLevelSmallMagic;	// 3
+	case LightTypeTorch:
+		return LightLevelTorch;			// 2
+	case LightTypeCandle:
+		return LightLevelCandle;		// 1
+	default:
+		return LightLevelUnlit;			// 0
+	}
+}
+
+bool EQEmu::lightsource::IsLevelGreater(uint8 left_type, uint8 right_type)
+{
+	static const uint8 light_levels[LightTypeCount] = {
+		LightLevelUnlit,			/* LightTypeNone */
+		LightLevelCandle,			/* LightTypeCandle */
+		LightLevelTorch,			/* LightTypeTorch */
+		LightLevelSmallMagic,		/* LightTypeTinyGlowingSkull */
+		LightLevelSmallLantern,		/* LightTypeSmallLantern */
+		LightLevelMagicLantern,		/* LightTypeSteinOfMoggok */
+		LightLevelLargeLantern,		/* LightTypeLargeLantern */
+		LightLevelLargeMagic,		/* LightTypeFlamelessLantern */
+		LightLevelBrilliant,		/* LightTypeGlobeOfStars */
+		LightLevelSmallMagic,		/* LightTypeLightGlobe */
+		LightLevelMagicLantern,		/* LightTypeLightstone */
+		LightLevelLargeMagic,		/* LightTypeGreaterLightstone */
+		LightLevelRedLight,			/* LightTypeFireBeetleEye */
+		LightLevelBlueLight,		/* LightTypeColdlight */
+		LightLevelRedLight,			/* LightTypeUnknown1 */
+		LightLevelBlueLight			/* LightTypeUnknown2 */
+	};
+
+	if (left_type >= LightTypeCount) { left_type = LightTypeNone; }
+	if (right_type >= LightTypeCount) { right_type = LightTypeNone; }
+
+	return (light_levels[left_type] > light_levels[right_type]);
+}
+
+EQEmu::LightSource_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

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

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

@@ -0,0 +1,134 @@
+/*	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/mutex.h

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

common/mysql_request_result.h

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

common/mysql_request_row.h

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

common/opcode_dispatch.h

@@ -146,6 +146,7 @@ INr(OP_GuildDelete);	//?
 IN(OP_GuildPublicNote, GuildUpdate_PublicNote);
 INz(OP_GetGuildsList);	//?
 IN(OP_SetGuildMOTD, GuildMOTD_Struct);
+IN(OP_SetRunMode, SetRunMode_Struct);
 INz(OP_GuildPeace);		//?
 INz(OP_GuildWar);		//?
 IN(OP_GuildLeader, GuildMakeLeader);
@@ -172,7 +173,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, SpellBuffFade_Struct);
+IN(OP_Buff, SpellBuffPacket_Struct);
 IN(OP_GMHideMe, SpawnAppearance_Struct);
 IN(OP_GMNameChange, GMName_Struct);
 IN(OP_GMKill, GMKill_Struct);
@@ -180,7 +181,7 @@ IN(OP_GMLastName, GMLastName_Struct);
 IN(OP_GMToggle, GMToggle_Struct);
 IN(OP_LFGCommand, LFG_Struct);
 IN(OP_GMGoto, GMSummon_Struct);
-IN(OP_TraderShop, TraderClick_Struct);
+INv(OP_TraderShop, TraderClick_Struct);
 IN(OP_ShopRequest, Merchant_Click_Struct);
 IN(OP_Bazaar, BazaarSearch_Struct);
 //alt:IN(OP_Bazaar, BazaarWelcome_Struct);		//alternate structure for OP_Bazaar
@@ -399,7 +400,7 @@ OUT(OP_Weather, Weather_Struct);
 OUT(OP_ZoneChange, ZoneChange_Struct);
 OUT(OP_ZoneInUnknown, ZoneInUnknown_Struct);
 
-//this is the set of opcodes which are allready listed
+//this is the set of opcodes which are already listed
 //in the IN section above, but are also sent OUT
 #ifdef DISJOINT_DIRECTIONS
 OUTz(OP_ClientReady);		//follows OP_SetServerFilter
@@ -414,7 +415,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, SpellBuffFade_Struct);
+OUT(OP_Buff, SpellBuffPacket_Struct);
 OUT(OP_ClickObject, ClickObject_Struct);
 OUT(OP_ClientUpdate, PlayerPositionUpdateServer_Struct);
 OUT(OP_SpawnPositionUpdate, SpawnPositionUpdate_Struct);
@@ -449,7 +450,7 @@ OUT(OP_Trader, TraderBuy_Struct);	//3 possible lengths
 //alt:OUT(OP_Trader, Trader_ShowItems_Struct);
 //alt:OUT(OP_Trader, Trader_Struct);
 OUT(OP_TraderBuy, TraderBuy_Struct);
-OUT(OP_TraderShop, TraderClick_Struct);
+OUTv(OP_TraderShop, TraderClick_Struct);
 OUT(OP_WearChange, WearChange_Struct);
 OUT(OP_ZoneEntry, ServerZoneEntry_Struct);
 #endif

common/packet_dump.cpp

@@ -17,6 +17,7 @@
 */
 
 #include <iostream>
+#include <sstream>
 #include <iomanip>
 #include <stdio.h>
 
@@ -53,7 +54,7 @@ void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
 	// Output as HEX
 	char output[4];
 	int j = 0;
-	char* ascii = new char[cols+1];
+	auto ascii = new char[cols + 1];
 	memset(ascii, 0, cols+1);
 	uint32 i;
 	for(i=skip; i<size; i++)
@@ -89,6 +90,54 @@ void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
 	safe_delete_array(ascii);
 }
 
+std::string DumpPacketHexToString(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
+	std::ostringstream out;
+	if (size == 0 || size > 39565)
+		return "";
+
+	out << "\n";
+	
+	// Output as HEX
+	char output[4];
+	int j = 0;
+	auto ascii = new char[cols + 1];
+	memset(ascii, 0, cols + 1);
+	uint32 i;
+	for (i = skip; i < size; i++)
+	{
+		if ((i - skip) % cols == 0) {
+			if (i != skip)
+				out << " | " << ascii << std::endl;
+				out << std::setw(4) << std::setfill(' ') << i - skip << ": ";
+			memset(ascii, 0, cols + 1);
+			j = 0;
+		}
+		else if ((i - skip) % (cols / 2) == 0) {
+			out << "- ";
+		}
+		sprintf(output, "%02X ", (unsigned char)buf[i]);
+		out << output;
+
+		if (buf[i] >= 32 && buf[i] < 127) {
+			ascii[j++] = buf[i];
+		}
+		else {
+			ascii[j++] = '.';
+		}
+		//		std::cout << std::setfill(0) << std::setw(2) << std::hex << (int)buf[i] << " "; // unknown intent [CODEBUG]
+	}
+	uint32 k = ((i - skip) - 1) % cols;
+	if (k < 8)
+		out << "  ";
+	for (uint32 h = k + 1; h < cols; h++) {
+		out << "   ";
+	}
+	out << " | " << ascii << std::endl;
+	safe_delete_array(ascii);
+
+	return out.str();
+}
+
 void DumpPacket(const uchar* buf, uint32 size)
 {
 	DumpPacketHex(buf, size);

common/packet_dump.h

@@ -24,6 +24,7 @@ class ServerPacket;
 
 void DumpPacketAscii(const uchar* buf, uint32 size, uint32 cols=16, uint32 skip=0);
 void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols=16, uint32 skip=0);
+std::string DumpPacketHexToString(const uchar* buf, uint32 size, uint32 cols = 16, uint32 skip = 0);
 void DumpPacketBin(const void* data, uint32 len);
 void DumpPacket(const uchar* buf, uint32 size);
 void DumpPacket(const ServerPacket* pack, bool iShowInfo = false);

common/packet_dump_file.cpp

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

common/patches/deprecated_titanium_itemfields_a.h

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

common/patches/deprecated_titanium_itemfields_b.h

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

common/patches/makepatch

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

common/patches/patches.cpp

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

common/patches/patches.h

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

common/patches/rof.h

@@ -1,11 +1,31 @@
-#ifndef ROF_H_
-#define ROF_H_
+/*	EQEMu: Everquest Server Emulator
+
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+	
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef COMMON_ROF_H
+#define COMMON_ROF_H
 
 #include "../struct_strategy.h"
 
 class EQStreamIdentifier;
 
-namespace RoF {
+namespace RoF
+{
 
 	//these are the only public member of this namespace.
 	extern void Register(EQStreamIdentifier &into);
@@ -23,13 +43,31 @@ namespace RoF {
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const ClientVersion GetClientVersion() const;
+		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof_ops.h"
 	};
 
-};
+	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
+	};
 
-#endif /*ROF_H_*/
+}; /*RoF*/
+
+#endif /*COMMON_ROF_H*/

common/patches/rof2.h

@@ -1,11 +1,31 @@
-#ifndef ROF2_H_
-#define ROF2_H_
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef COMMON_ROF2_H
+#define COMMON_ROF2_H
 
 #include "../struct_strategy.h"
 
 class EQStreamIdentifier;
 
-namespace RoF2 {
+namespace RoF2
+{
 
 	//these are the only public member of this namespace.
 	extern void Register(EQStreamIdentifier &into);
@@ -23,13 +43,31 @@ namespace RoF2 {
 	protected:
 
 		virtual std::string Describe() const;
-		virtual const ClientVersion GetClientVersion() const;
+		virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 
 		//magic macro to declare our opcode processors
 		#include "ss_declare.h"
 		#include "rof2_ops.h"
 	};
 
-};
+	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
+	};
 
-#endif /*ROF2_H_*/
+}; /*RoF2*/
+
+#endif /*COMMON_ROF2_H*/

common/patches/rof2_constants.h

@@ -1,219 +0,0 @@
-/*
-EQEMu:  Everquest Server Emulator
-
-Copyright (C) 2001-2014 EQEMu Development Team (http://eqemulator.net)
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; version 2 of the License.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY except by those people which sell it, which
-are required to give you total support for your newly bought product;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-*/
-
-#ifndef ROF2_CONSTANTS_H_
-#define ROF2_CONSTANTS_H_
-
-#include "../types.h"
-
-namespace RoF2 {
-	namespace maps {
-		typedef enum : int16 {
-			MapPossessions = 0,
-			MapBank,
-			MapSharedBank,
-			MapTrade,
-			MapWorld,
-			MapLimbo,
-			MapTribute,
-			MapTrophyTribute,
-			MapGuildTribute,
-			MapMerchant,
-			MapDeleted,
-			MapCorpse,
-			MapBazaar,
-			MapInspect,
-			MapRealEstate,
-			MapViewMODPC,
-			MapViewMODBank,
-			MapViewMODSharedBank,
-			MapViewMODLimbo,
-			MapAltStorage,
-			MapArchived,
-			MapMail,
-			MapGuildTrophyTribute,
-			MapKrono,
-			MapOther,
-			_MapCount
-		} InventoryMaps;
-	}
-
-	namespace slots {
-		typedef enum : int16 {
-			MainCharm = 0,
-			MainEar1,
-			MainHead,
-			MainFace,
-			MainEar2,
-			MainNeck,
-			MainShoulders,
-			MainArms,
-			MainBack,
-			MainWrist1,
-			MainWrist2,
-			MainRange,
-			MainHands,
-			MainPrimary,
-			MainSecondary,
-			MainFinger1,
-			MainFinger2,
-			MainChest,
-			MainLegs,
-			MainFeet,
-			MainWaist,
-			MainPowerSource,
-			MainAmmo,
-			MainGeneral1,
-			MainGeneral2,
-			MainGeneral3,
-			MainGeneral4,
-			MainGeneral5,
-			MainGeneral6,
-			MainGeneral7,
-			MainGeneral8,
-			MainGeneral9,
-			MainGeneral10,
-			MainCursor,
-			_MainCount,
-			_MainEquipmentBegin = MainCharm,
-			_MainEquipmentEnd = MainAmmo,
-			_MainEquipmentCount = (_MainEquipmentEnd - _MainEquipmentBegin + 1),
-			_MainGeneralBegin = MainGeneral1,
-			_MainGeneralEnd = MainGeneral10,
-			_MainGeneralCount = (_MainGeneralEnd - _MainGeneralBegin + 1)
-		} EquipmentSlots;
-	}
-
-	namespace consts {
-		static const uint16	MAP_POSSESSIONS_SIZE = slots::_MainCount;
-		static const uint16 MAP_BANK_SIZE = 24;
-		static const uint16 MAP_SHARED_BANK_SIZE = 2;
-		static const uint16 MAP_TRADE_SIZE = 8;
-		static const uint16 MAP_WORLD_SIZE = 10;
-		static const uint16 MAP_LIMBO_SIZE = 36;
-		static const uint16 MAP_TRIBUTE_SIZE = 0; //?
-		static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
-		static const uint16 MAP_MERCHANT_SIZE = 0;
-		static const uint16 MAP_DELETED_SIZE = 0;
-		static const uint16 MAP_CORPSE_SIZE = slots::_MainCount;
-		static const uint16 MAP_BAZAAR_SIZE = 200;
-		static const uint16 MAP_INSPECT_SIZE = slots::_MainEquipmentCount;
-		static const uint16 MAP_REAL_ESTATE_SIZE = 0;
-		static const uint16 MAP_VIEW_MOD_PC_SIZE = MAP_POSSESSIONS_SIZE;
-		static const uint16 MAP_VIEW_MOD_BANK_SIZE = MAP_BANK_SIZE;
-		static const uint16 MAP_VIEW_MOD_SHARED_BANK_SIZE = MAP_SHARED_BANK_SIZE;
-		static const uint16 MAP_VIEW_MOD_LIMBO_SIZE = MAP_LIMBO_SIZE;
-		static const uint16 MAP_ALT_STORAGE_SIZE = 0;
-		static const uint16 MAP_ARCHIVED_SIZE = 0;
-		static const uint16 MAP_MAIL_SIZE = 0;
-		static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 MAP_KRONO_SIZE = NOT_USED;
-		static const uint16 MAP_OTHER_SIZE = 0;
-
-		// most of these definitions will go away with the structure-based system..this maintains compatibility for now
-		// (bag slots and main slots beyond Possessions are assigned for compatibility with current server coding)
-		static const int16 EQUIPMENT_BEGIN = slots::MainCharm;
-		static const int16 EQUIPMENT_END = slots::MainAmmo;
-		static const uint16 EQUIPMENT_SIZE = slots::_MainEquipmentCount;
-
-		static const int16 GENERAL_BEGIN = slots::MainGeneral1;
-		static const int16 GENERAL_END = slots::MainGeneral10;
-		static const uint16 GENERAL_SIZE = slots::_MainGeneralCount;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 99;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR = slots::MainCursor;
-		static const int16 CURSOR_BAG_BEGIN = 351;
-		static const int16 CURSOR_BAG_END_OFFSET = 9;
-		static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
-
-		static const int16 BANK_BEGIN = 2000;
-		static const int16 BANK_END = 2023;
-		static const int16 BANK_BAGS_BEGIN = 2031;
-		static const int16 BANK_BAGS_END_OFFSET = 239;
-		static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
-
-		static const int16 SHARED_BANK_BEGIN = 2500;
-		static const int16 SHARED_BANK_END = 2501;
-		static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-		static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-		static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
-
-		static const int16 TRADE_BEGIN = 3000;
-		static const int16 TRADE_END = 3007;
-		static const int16 TRADE_NPC_END = 3003;
-		static const int16 TRADE_BAGS_BEGIN = 3031;
-		static const int16 TRADE_BAGS_END_OFFSET = 79;
-		static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
-
-		static const int16 WORLD_BEGIN = 4000;
-		static const int16 WORLD_END = 4009;
-
-		static const int16 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-
-		static const int16 CORPSE_BEGIN = slots::MainGeneral1;
-		static const int16 CORPSE_END = slots::MainGeneral1 + slots::MainCursor;
-
-		static const uint16 ITEM_COMMON_SIZE = 6;
-		static const uint16 ITEM_CONTAINER_SIZE = 255; // 255; (server max will be 255..unsure what actual client is - test)
-
-		static const uint32 BANDOLIERS_COUNT = 20;	// count = number of bandolier instances
-		static const uint32 BANDOLIER_SIZE = 4;		// size = number of equipment slots in bandolier instance
-		static const uint32 POTION_BELT_SIZE = 5;
-
-		static const size_t TEXT_LINK_BODY_LENGTH = 56;
-	}
-
-	namespace limits {
-		static const bool ALLOWS_EMPTY_BAG_IN_BAG = true;
-		static const bool ALLOWS_CLICK_CAST_FROM_BAG = true;
-		static const bool COIN_HAS_WEIGHT = false;
-	}
-
-};	//end namespace RoF2
-
-#endif /*ROF2_CONSTANTS_H_*/
-
-/*
-RoF2 Notes:
-	** Structure-based inventory **
-ok	Possessions: ( 0, { 0 .. 33 }, -1, -1 ) (Corpse: { 23 .. 56 } [Offset 23])
-ok		[Equipment: ( 0, { 0 .. 22 }, -1, -1 )]
-ok		[General: ( 0, { 23 .. 32 }, -1, -1 )]
-ok		[Cursor: ( 0, 33, -1, -1 )]
-	General Bags: ( 0, { 23 .. 32 }, { 0 .. (maxsize - 1) }, -1 )
-	Cursor Bags: ( 0, 33, { 0 .. (maxsize - 1) }, -1 )
-
-	Bank: ( 1, { 0 .. 23 }, -1, -1 )
-	Bank Bags: ( 1, { 0 .. 23 }, { 0 .. (maxsize - 1)}, -1 )
-
-	Shared Bank: ( 2, { 0 .. 1 }, -1, -1 )
-	Shared Bank Bags: ( 2, { 0 .. 1 }, { 0 .. (maxsize - 1) }, -1 )
-
-	Trade: ( 3, { 0 .. 8 }, -1, -1 )
-	(Trade Bags: 3031 - 3110 -- server values)
-
-	World: ( 4, { 0 .. 10 }, -1, -1 )
-
-*/

common/patches/rof2_limits.cpp

@@ -0,0 +1,284 @@
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rof2_limits.h"
+
+#include "../string_util.h"
+
+
+size_t RoF2::invtype::GetInvTypeSize(int inv_type)
+{
+	switch (inv_type) {
+	case invtype::InvTypePossessions:
+		return invtype::InvTypePossessionsSize;
+	case invtype::InvTypeBank:
+		return invtype::InvTypeBankSize;
+	case invtype::InvTypeSharedBank:
+		return invtype::InvTypeSharedBankSize;
+	case invtype::InvTypeTrade:
+		return invtype::InvTypeTradeSize;
+	case invtype::InvTypeWorld:
+		return invtype::InvTypeWorldSize;
+	case invtype::InvTypeLimbo:
+		return invtype::InvTypeLimboSize;
+	case invtype::InvTypeTribute:
+		return invtype::InvTypeTributeSize;
+	case invtype::InvTypeTrophyTribute:
+		return invtype::InvTypeTrophyTributeSize;
+	case invtype::InvTypeGuildTribute:
+		return invtype::InvTypeGuildTributeSize;
+	case invtype::InvTypeMerchant:
+		return invtype::InvTypeMerchantSize;
+	case invtype::InvTypeDeleted:
+		return invtype::InvTypeDeletedSize;
+	case invtype::InvTypeCorpse:
+		return invtype::InvTypeCorpseSize;
+	case invtype::InvTypeBazaar:
+		return invtype::InvTypeBazaarSize;
+	case invtype::InvTypeInspect:
+		return invtype::InvTypeInspectSize;
+	case invtype::InvTypeRealEstate:
+		return invtype::InvTypeRealEstateSize;
+	case invtype::InvTypeViewMODPC:
+		return invtype::InvTypeViewMODPCSize;
+	case invtype::InvTypeViewMODBank:
+		return invtype::InvTypeViewMODBankSize;
+	case invtype::InvTypeViewMODSharedBank:
+		return invtype::InvTypeViewMODSharedBankSize;
+	case invtype::InvTypeViewMODLimbo:
+		return invtype::InvTypeViewMODLimboSize;
+	case invtype::InvTypeAltStorage:
+		return invtype::InvTypeAltStorageSize;
+	case invtype::InvTypeArchived:
+		return invtype::InvTypeArchivedSize;
+	case invtype::InvTypeMail:
+		return invtype::InvTypeMailSize;
+	case invtype::InvTypeGuildTrophyTribute:
+		return invtype::InvTypeGuildTrophyTributeSize;
+	case invtype::InvTypeKrono:
+		return invtype::InvTypeKronoSize;
+	case invtype::InvTypeOther:
+		return invtype::InvTypeOtherSize;
+	default:
+		return 0;
+	}
+}
+
+const char* RoF2::invtype::GetInvTypeName(int inv_type)
+{
+	switch (inv_type) {
+	case invtype::InvTypeInvalid:
+		return "Invalid Type";
+	case invtype::InvTypePossessions:
+		return "Possessions";
+	case invtype::InvTypeBank:
+		return "Bank";
+	case invtype::InvTypeSharedBank:
+		return "Shared Bank";
+	case invtype::InvTypeTrade:
+		return "Trade";
+	case invtype::InvTypeWorld:
+		return "World";
+	case invtype::InvTypeLimbo:
+		return "Limbo";
+	case invtype::InvTypeTribute:
+		return "Tribute";
+	case invtype::InvTypeTrophyTribute:
+		return "Trophy Tribute";
+	case invtype::InvTypeGuildTribute:
+		return "Guild Tribute";
+	case invtype::InvTypeMerchant:
+		return "Merchant";
+	case invtype::InvTypeDeleted:
+		return "Deleted";
+	case invtype::InvTypeCorpse:
+		return "Corpse";
+	case invtype::InvTypeBazaar:
+		return "Bazaar";
+	case invtype::InvTypeInspect:
+		return "Inspect";
+	case invtype::InvTypeRealEstate:
+		return "Real Estate";
+	case invtype::InvTypeViewMODPC:
+		return "View MOD PC";
+	case invtype::InvTypeViewMODBank:
+		return "View MOD Bank";
+	case invtype::InvTypeViewMODSharedBank:
+		return "View MOD Shared Bank";
+	case invtype::InvTypeViewMODLimbo:
+		return "View MOD Limbo";
+	case invtype::InvTypeAltStorage:
+		return "Alt Storage";
+	case invtype::InvTypeArchived:
+		return "Archived";
+	case invtype::InvTypeMail:
+		return "Mail";
+	case invtype::InvTypeGuildTrophyTribute:
+		return "Guild Trophy Tribute";
+	case invtype::InvTypeKrono:
+		return "Krono";
+	case invtype::InvTypeOther:
+		return "Other";
+	default:
+		return "Unknown Type";
+	}
+}
+
+bool RoF2::invtype::IsInvTypePersistent(int inv_type)
+{
+	switch (inv_type) {
+	case invtype::InvTypePossessions:
+	case invtype::InvTypeBank:
+	case invtype::InvTypeSharedBank:
+	case invtype::InvTypeTrade:
+	case invtype::InvTypeWorld:
+	case invtype::InvTypeLimbo:
+	case invtype::InvTypeTribute:
+	case invtype::InvTypeTrophyTribute:
+	case invtype::InvTypeGuildTribute:
+		return true;
+	default:
+		return false;
+	}
+}
+
+const char* RoF2::invslot::GetInvPossessionsSlotName(int inv_slot)
+{
+	switch (inv_slot) {
+	case invslot::InvSlotInvalid:
+		return "Invalid Slot";
+	case invslot::PossessionsCharm:
+		return "Charm";
+	case invslot::PossessionsEar1:
+		return "Ear 1";
+	case invslot::PossessionsHead:
+		return "Head";
+	case invslot::PossessionsFace:
+		return "Face";
+	case invslot::PossessionsEar2:
+		return "Ear 2";
+	case invslot::PossessionsNeck:
+		return "Neck";
+	case invslot::PossessionsShoulders:
+		return "Shoulders";
+	case invslot::PossessionsArms:
+		return "Arms";
+	case invslot::PossessionsBack:
+		return "Back";
+	case invslot::PossessionsWrist1:
+		return "Wrist 1";
+	case invslot::PossessionsWrist2:
+		return "Wrist 2";
+	case invslot::PossessionsRange:
+		return "Range";
+	case invslot::PossessionsHands:
+		return "Hands";
+	case invslot::PossessionsPrimary:
+		return "Primary";
+	case invslot::PossessionsSecondary:
+		return "Secondary";
+	case invslot::PossessionsFinger1:
+		return "Finger 1";
+	case invslot::PossessionsFinger2:
+		return "Finger 2";
+	case invslot::PossessionsChest:
+		return "Chest";
+	case invslot::PossessionsLegs:
+		return "Legs";
+	case invslot::PossessionsFeet:
+		return "Feet";
+	case invslot::PossessionsWaist:
+		return "Waist";
+	case invslot::PossessionsPowerSource:
+		return "Power Source";
+	case invslot::PossessionsAmmo:
+		return "Ammo";
+	case invslot::PossessionsGeneral1:
+		return "General 1";
+	case invslot::PossessionsGeneral2:
+		return "General 2";
+	case invslot::PossessionsGeneral3:
+		return "General 3";
+	case invslot::PossessionsGeneral4:
+		return "General 4";
+	case invslot::PossessionsGeneral5:
+		return "General 5";
+	case invslot::PossessionsGeneral6:
+		return "General 6";
+	case invslot::PossessionsGeneral7:
+		return "General 7";
+	case invslot::PossessionsGeneral8:
+		return "General 8";
+	case invslot::PossessionsGeneral9:
+		return "General 9";
+	case invslot::PossessionsGeneral10:
+		return "General 10";
+	case invslot::PossessionsCursor:
+		return "Cursor";
+	default:
+		return "Unknown Slot";
+	}
+}
+
+const char* RoF2::invslot::GetInvSlotName(int inv_type, int inv_slot)
+{
+	if (inv_type == invtype::InvTypePossessions)
+		return invslot::GetInvPossessionsSlotName(inv_slot);
+
+	size_t type_size = invtype::GetInvTypeSize(inv_type);
+
+	if (!type_size || inv_slot == invslot::InvSlotInvalid)
+		return "Invalid Slot";
+
+	if ((size_t)(inv_slot + 1) >= type_size)
+		return "Unknown Slot";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Slot %i", (inv_slot + 1));
+
+	return ret_str.c_str();
+}
+
+const char* RoF2::invbag::GetInvBagIndexName(int bag_index)
+{
+	if (bag_index == invbag::InvBagInvalid)
+		return "Invalid Bag";
+
+	if ((size_t)bag_index >= invbag::ItemBagSize)
+		return "Unknown Bag";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Bag %i", (bag_index + 1));
+
+	return ret_str.c_str();
+}
+
+const char* RoF2::invaug::GetInvAugIndexName(int aug_index)
+{
+	if (aug_index == invaug::InvAugInvalid)
+		return "Invalid Augment";
+
+	if ((size_t)aug_index >= invaug::ItemAugSize)
+		return "Unknown Augment";
+
+	static std::string ret_str;
+	ret_str = StringFormat("Augment %i", (aug_index + 1));
+
+	return ret_str.c_str();
+}

common/patches/rof2_limits.h

@@ -0,0 +1,302 @@
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef COMMON_ROF2_LIMITS_H
+#define COMMON_ROF2_LIMITS_H
+
+#include "../types.h"
+#include "../emu_versions.h"
+#include "../skills.h"
+
+
+namespace RoF2
+{
+	enum : int { Invalid = -1, Null, Safety };
+
+	enum : bool { False = false, True = true };
+
+	// pre-declarations
+	namespace inventory {
+		inline EQEmu::versions::ClientVersion GetInventoryRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*inventory*/
+
+	namespace invtype {
+		inline EQEmu::versions::ClientVersion GetInvTypeRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvTypeInvalid = -1, InvTypeBegin };
+
+		enum InventoryType : int {
+			InvTypePossessions = InvTypeBegin,
+			InvTypeBank,
+			InvTypeSharedBank,
+			InvTypeTrade,
+			InvTypeWorld,
+			InvTypeLimbo,
+			InvTypeTribute,
+			InvTypeTrophyTribute,
+			InvTypeGuildTribute,
+			InvTypeMerchant,
+			InvTypeDeleted,
+			InvTypeCorpse,
+			InvTypeBazaar,
+			InvTypeInspect,
+			InvTypeRealEstate,
+			InvTypeViewMODPC,
+			InvTypeViewMODBank,
+			InvTypeViewMODSharedBank,
+			InvTypeViewMODLimbo,
+			InvTypeAltStorage,
+			InvTypeArchived,
+			InvTypeMail,
+			InvTypeGuildTrophyTribute,
+			InvTypeKrono,
+			InvTypeOther,
+			InvTypeCount
+		};
+
+	} /*invtype*/
+
+	namespace invslot {
+		inline EQEmu::versions::ClientVersion GetInvSlotRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvSlotInvalid = -1, InvSlotBegin };
+
+		enum PossessionsSlot : int {
+			PossessionsCharm = InvSlotBegin,
+			PossessionsEar1,
+			PossessionsHead,
+			PossessionsFace,
+			PossessionsEar2,
+			PossessionsNeck,
+			PossessionsShoulders,
+			PossessionsArms,
+			PossessionsBack,
+			PossessionsWrist1,
+			PossessionsWrist2,
+			PossessionsRange,
+			PossessionsHands,
+			PossessionsPrimary,
+			PossessionsSecondary,
+			PossessionsFinger1,
+			PossessionsFinger2,
+			PossessionsChest,
+			PossessionsLegs,
+			PossessionsFeet,
+			PossessionsWaist,
+			PossessionsPowerSource,
+			PossessionsAmmo,
+			PossessionsGeneral1,
+			PossessionsGeneral2,
+			PossessionsGeneral3,
+			PossessionsGeneral4,
+			PossessionsGeneral5,
+			PossessionsGeneral6,
+			PossessionsGeneral7,
+			PossessionsGeneral8,
+			PossessionsGeneral9,
+			PossessionsGeneral10,
+			PossessionsCursor,
+			PossessionsCount
+		};
+
+		const int EquipmentBegin = PossessionsCharm;
+		const int EquipmentEnd = PossessionsAmmo;
+		const int EquipmentCount = (EquipmentEnd - EquipmentBegin + 1);
+
+		const int GeneralBegin = PossessionsGeneral1;
+		const int GeneralEnd = PossessionsGeneral10;
+		const int GeneralCount = (GeneralEnd - GeneralBegin + 1);
+
+	} /*invslot*/
+
+	namespace invbag {
+		inline EQEmu::versions::ClientVersion GetInvBagRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvBagInvalid = -1, InvBagBegin };
+
+	} /*invbag*/
+
+	namespace invaug {
+		inline EQEmu::versions::ClientVersion GetInvAugRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		enum : int { InvAugInvalid = -1, InvAugBegin };
+
+	} /*invaug*/
+
+	namespace item {
+		inline EQEmu::versions::ClientVersion GetItemRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+		//enum Unknown : int { // looks like item class..but, RoF has it too - nothing in UF-
+		//	Unknown1 = 0,
+		//	Unknown2 = 1,
+		//	Unknown3 = 2,
+		//	Unknown4 = 5 // krono?
+		//};
+
+		enum ItemPacketType : int {
+			ItemPacketMerchant = 100,
+			ItemPacketTradeView = 101,
+			ItemPacketLoot = 102,
+			ItemPacketTrade = 103,
+			ItemPacketCharInventory = 105,
+			ItemPacketLimbo = 106,
+			ItemPacketWorldContainer = 107,
+			ItemPacketTributeItem = 108,
+			ItemPacketGuildTribute = 109,
+			ItemPacket10 = 110,
+			ItemPacket11 = 111,
+			ItemPacket12 = 112,
+			ItemPacketRecovery = 113,
+			ItemPacket14 = 115
+		};
+
+	} /*item*/
+
+	namespace profile {
+		inline EQEmu::versions::ClientVersion GetProfileRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*profile*/
+
+	namespace constants {
+		inline EQEmu::versions::ClientVersion GetConstantsRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*constants*/
+
+	namespace behavior {
+		inline EQEmu::versions::ClientVersion GetBehaviorRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*behavior*/
+
+	namespace skills {
+		inline EQEmu::versions::ClientVersion GetSkillsRef() { return EQEmu::versions::ClientVersion::RoF2; }
+
+	} /*skills*/
+
+
+	// declarations
+	namespace inventory {
+		const bool ConcatenateInvTypeLimbo = false;
+
+		const bool AllowOverLevelEquipment = true;
+
+		const bool AllowEmptyBagInBag = true;
+		const bool AllowClickCastFromBag = true;
+
+	} /*inventory*/
+
+	namespace invtype {
+		const size_t InvTypePossessionsSize = invslot::PossessionsCount;
+		const size_t InvTypeBankSize = 24;
+		const size_t InvTypeSharedBankSize = 2;
+		const size_t InvTypeTradeSize = 8;
+		const size_t InvTypeWorldSize = 10;
+		const size_t InvTypeLimboSize = 36;
+		const size_t InvTypeTributeSize = 5;
+		const size_t InvTypeTrophyTributeSize = 0;//unknown
+		const size_t InvTypeGuildTributeSize = 2;//unverified
+		const size_t InvTypeMerchantSize = 200;
+		const size_t InvTypeDeletedSize = 0;//unknown - "Recovery Tab"
+		const size_t InvTypeCorpseSize = InvTypePossessionsSize;
+		const size_t InvTypeBazaarSize = 200;
+		const size_t InvTypeInspectSize = invslot::EquipmentCount;
+		const size_t InvTypeRealEstateSize = 0;//unknown
+		const size_t InvTypeViewMODPCSize = InvTypePossessionsSize;
+		const size_t InvTypeViewMODBankSize = InvTypeBankSize;
+		const size_t InvTypeViewMODSharedBankSize = InvTypeSharedBankSize;
+		const size_t InvTypeViewMODLimboSize = InvTypeLimboSize;
+		const size_t InvTypeAltStorageSize = 0;//unknown - "Shroud Bank"
+		const size_t InvTypeArchivedSize = 0;//unknown
+		const size_t InvTypeMailSize = 0;//unknown
+		const size_t InvTypeGuildTrophyTributeSize = 0;//unknown
+		const size_t InvTypeKronoSize = 0;//unknown
+		const size_t InvTypeOtherSize = 0;//unknown
+
+		extern size_t GetInvTypeSize(int inv_type);
+		extern const char* GetInvTypeName(int inv_type);
+
+		extern bool IsInvTypePersistent(int inv_type);
+
+	} /*invtype*/
+
+	namespace invslot {
+		extern const char* GetInvPossessionsSlotName(int inv_slot);
+		extern const char* GetInvSlotName(int inv_type, int inv_slot);
+
+	} /*invslot*/
+
+	namespace invbag {
+		const size_t ItemBagSize = 255; // server Size will be 255..unsure what actual client is (test)
+
+		extern const char* GetInvBagIndexName(int bag_index);
+
+	} /*invbag*/
+
+	namespace invaug {
+		const size_t ItemAugSize = 6;
+
+		extern const char* GetInvAugIndexName(int aug_index);
+
+	} /*invaug*/
+
+	namespace item {
+
+	} /*item*/
+
+	namespace profile {
+		const size_t TributeSize = invtype::InvTypeTributeSize;
+		const size_t GuildTributeSize = invtype::InvTypeGuildTributeSize;
+
+		const size_t BandoliersSize = 20;		// number of bandolier instances
+		const size_t BandolierItemCount = 4;	// number of equipment slots in bandolier instance
+
+		const size_t PotionBeltSize = 5;
+
+		const size_t SkillArraySize = 100;
+
+	} /*profile*/
+
+	namespace constants {
+		const size_t CharacterCreationLimit = 12;
+
+		const size_t SayLinkBodySize = 56;
+
+		const int LongBuffs = 42;
+		const int ShortBuffs = 20;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 97;
+		const int PetBuffs = NPCBuffs;
+		const int MercBuffs = LongBuffs;
+
+	} /*constants*/
+
+	namespace behavior {
+		const bool CoinHasWeight = false;
+
+	} /*behavior*/
+
+	namespace skills {
+		const size_t LastUsableSkill = EQEmu::skills::Skill2HPiercing;
+
+	} /*skills*/
+
+}; /*RoF2*/
+
+#endif /*COMMON_ROF2_LIMITS_H*/

common/patches/rof2_ops.h

@@ -1,11 +1,35 @@
+/*	EQEMu: Everquest Server Emulator
+	
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
 // out-going packets that require an ENCODE translation:
 // Begin RoF2 Encodes
 
 E(OP_SendMembershipDetails)
+E(OP_TraderShop)
+E(OP_TraderDelItem)
 
 // incoming packets that require a DECODE translation:
 // Begin RoF2 Decodes
 
+D(OP_TraderShop)
+
 // End RoF2 Encodes/Decodes
 
 // These require Encodes/Decodes for RoF, so they do for RoF2 as well
@@ -53,6 +77,7 @@ E(OP_GroupFollow)
 E(OP_GroupFollow2)
 E(OP_GroupInvite)
 E(OP_GroupUpdate)
+E(OP_GuildBank)
 E(OP_GuildMemberList)
 E(OP_GuildMemberUpdate)
 E(OP_GuildsList)
@@ -60,7 +85,6 @@ E(OP_HPUpdate)
 E(OP_Illusion)
 E(OP_InspectBuffs)
 E(OP_InspectRequest)
-E(OP_InterruptCast)
 E(OP_ItemLinkResponse)
 E(OP_ItemPacket)
 E(OP_ItemVerifyReply)
@@ -107,6 +131,7 @@ E(OP_Trader)
 E(OP_TraderBuy)
 E(OP_TributeInfo)
 E(OP_TributeItem)
+E(OP_VetClaimReply)
 E(OP_VetRewardsAvaliable)
 E(OP_WearChange)
 E(OP_WhoAllResponse)
@@ -115,10 +140,12 @@ E(OP_ZoneEntry)
 E(OP_ZonePlayerToBind)
 E(OP_ZoneServerInfo)
 E(OP_ZoneSpawns)
+E(OP_CrystalCountUpdate)
 // Begin RoF Decodes
 D(OP_AdventureMerchantSell)
 D(OP_AltCurrencySell)
 D(OP_AltCurrencySellSelection)
+D(OP_Animation)
 D(OP_ApplyPoison)
 D(OP_AugmentInfo)
 D(OP_AugmentItem)
@@ -146,6 +173,7 @@ D(OP_GroupFollow)
 D(OP_GroupFollow2)
 D(OP_GroupInvite)
 D(OP_GroupInvite2)
+D(OP_GuildBank)
 D(OP_GuildDemote)
 D(OP_GuildRemove)
 D(OP_GuildStatus)
@@ -170,6 +198,7 @@ D(OP_Trader)
 D(OP_TraderBuy)
 D(OP_TradeSkillCombine)
 D(OP_TributeItem)
+D(OP_VetClaimRequest)
 D(OP_WhoAllRequest)
 D(OP_ZoneChange)
 D(OP_ZoneEntry)