Merchant buying in flux but it works better now

.travis.yml

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

CMakeLists.txt

@@ -30,7 +30,6 @@
 #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
@@ -276,11 +275,6 @@ IF(EQEMU_BUILD_LUA)
 	ADD_DEFINITIONS(-DLUA_EQEMU)
 ENDIF(EQEMU_BUILD_LUA)
 
-OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-IF(EQEMU_USE_MAP_MMFS)
-	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-ENDIF(EQEMU_USE_MAP_MMFS)
-
 SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
 
 ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})

README.md

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

client_files/export/main.cpp

@@ -45,12 +45,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
 		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;

client_files/import/main.cpp

@@ -43,12 +43,12 @@ int main(int argc, char **argv) {
 		return 1;
 	}
 
-	auto Config = EQEmuConfig::get();
+	const EQEmuConfig *config = EQEmuConfig::get();
 
 	SharedDatabase database;
 	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
-	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
-		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
+	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
+		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
 		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;

cmake/FindMySQL.cmake

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

common/CMakeLists.txt

@@ -11,20 +11,15 @@ SET(common_sources
 	database_conversions.cpp
 	database_instances.cpp
 	dbcore.cpp
-	deity.cpp
-	emu_constants.cpp
-	emu_legacy.cpp
-	emu_limits.cpp
 	emu_opcodes.cpp
 	emu_tcp_connection.cpp
 	emu_tcp_server.cpp
-	emu_versions.cpp
+	eq_dictionary.cpp
 	eqdb.cpp
 	eqdb_res.cpp
 	eqemu_exception.cpp
 	eqemu_config.cpp
 	eqemu_logsys.cpp
-	eq_limits.cpp
 	eq_packet.cpp
 	eq_stream.cpp
 	eq_stream_factory.cpp
@@ -35,10 +30,14 @@ SET(common_sources
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
+	inventory.cpp
+	inventory_db_data_model.cpp
 	ipc_mutex.cpp
 	item.cpp
-	item_base.cpp
-	light_source.cpp
+	item_container.cpp
+	item_container_default_serialization.cpp
+	item_container_personal_serialization.cpp
+	item_instance.cpp
 	md5.cpp
 	memory_buffer.cpp
 	memory_mapped_file.cpp
@@ -59,7 +58,6 @@ SET(common_sources
 	races.cpp
 	rdtsc.cpp
 	rulesys.cpp
-	say_link.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -68,7 +66,6 @@ SET(common_sources
 	struct_strategy.cpp
 	tcp_connection.cpp
 	tcp_server.cpp
-	textures.cpp
 	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
@@ -77,17 +74,11 @@ 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
@@ -120,15 +111,12 @@ SET(common_headers
 	database.h
 	dbcore.h
 	deity.h
-	emu_constants.h
-	emu_legacy.h
-	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
 	emu_tcp_connection.h
 	emu_tcp_server.h
-	emu_versions.h
 	eq_constants.h
+	eq_dictionary.h
 	eq_packet_structs.h
 	eqdb.h
 	eqdb_res.h
@@ -136,7 +124,6 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
-	eq_limits.h
 	eq_packet.h
 	eq_stream.h
 	eq_stream_factory.h
@@ -155,12 +142,20 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
+	inventory.h
+	inventory_data_model.h
+	inventory_db_data_model.h
+	inventory_null_data_model.h
 	ipc_mutex.h
 	item.h
-	item_base.h
+	item_container.h
+	item_container_default_serialization.h
+	item_container_personal_serialization.h
+	item_container_serialization_strategy.h
+	item_data.h
 	item_fieldlist.h
+	item_instance.h
 	languages.h
-	light_source.h
 	linked_list.h
 	loottable.h
 	mail_oplist.h
@@ -188,7 +183,6 @@ SET(common_headers
 	rdtsc.h
 	rulesys.h
 	ruletypes.h
-	say_link.h
 	seperator.h
 	serverinfo.h
 	servertalk.h
@@ -200,7 +194,6 @@ SET(common_headers
 	tcp_basic_server.h
 	tcp_connection.h
 	tcp_server.h
-	textures.h
 	timeoutmgr.h
 	timer.h
 	types.h
@@ -212,38 +205,37 @@ SET(common_headers
 	zone_numbers.h
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
-	patches/sod_limits.h
+	patches/sod_constants.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
 	patches/sod_structs.h
 	patches/sof.h
-#	patches/sof_itemfields.h
-	patches/sof_limits.h
-#	patches/sof_opcode_list.h
+	patches/sof_constants.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
 	patches/sof_ops.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-#	patches/rof_itemfields.h
-	patches/rof_limits.h
+	patches/rof_constants.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
-	patches/rof2_limits.h
+	patches/rof2_constants.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
 	patches/rof2_structs.h
 	patches/titanium.h
-#	patches/titanium_itemfields_a.h
-#	patches/titanium_itemfields_b.h
-	patches/titanium_limits.h
+	patches/titanium_constants.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
-	patches/uf_limits.h
+	patches/uf_constants.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
 	patches/uf_structs.h
 	SocketLib/Base64.h
@@ -266,53 +258,46 @@ SET(common_headers
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
-	patches/sod_limits.h
+	patches/sod_itemfields.h
 	patches/sod_ops.h
+	patches/sod_constants.h
 	patches/sod_structs.h
 	patches/sof.h
-#	patches/sof_itemfields.h
-	patches/sof_limits.h
-#	patches/sof_opcode_list.h
+	patches/sof_itemfields.h
+	patches/sof_opcode_list.h
 	patches/sof_ops.h
+	patches/sof_constants.h
 	patches/sof_structs.h
 	patches/ss_declare.h
 	patches/ss_define.h
 	patches/ss_register.h
 	patches/rof.h
-#	patches/rof_itemfields.h
-	patches/rof_limits.h
+	patches/rof_itemfields.h
 	patches/rof_ops.h
+	patches/rof_constants.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
-	patches/rof2_limits.h
+	patches/rof2_itemfields.h
 	patches/rof2_ops.h
+	patches/rof2_constants.h
 	patches/rof2_structs.h
 	patches/titanium.h
-#	patches/titanium_itemfields_a.h
-#	patches/titanium_itemfields_b.h
-	patches/titanium_limits.h
+	patches/titanium_itemfields.h
 	patches/titanium_ops.h
+	patches/titanium_constants.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
-	patches/uf_limits.h
+	patches/uf_itemfields.h
 	patches/uf_ops.h
+	patches/uf_constants.h
 	patches/uf_structs.h
 	patches/patches.cpp
 	patches/sod.cpp
-	patches/sod_limits.cpp
 	patches/sof.cpp
-	patches/sof_limits.cpp
 	patches/rof.cpp
-	patches/rof_limits.cpp
 	patches/rof2.cpp
-	patches/rof2_limits.cpp
 	patches/titanium.cpp
-	patches/titanium_limits.cpp
 	patches/uf.cpp
-	patches/uf_limits.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES

common/base_packet.h

@@ -22,10 +22,10 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifdef _WINDOWS
+#ifdef WIN32
 	#include <time.h>
-	#include <winsock2.h>
 	#include <windows.h>
+	#include <winsock2.h>
 #else
 	#include <sys/time.h>
 	#include <netinet/in.h>
@@ -67,8 +67,6 @@ public:
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
 	uint8 ReadUInt8(uint32 Offset) const { uint8 value = *(uint8 *)(pBuffer + Offset); return value; }
-	uint16 ReadUInt16() { uint16 value = *(uint16 *)(pBuffer + _rpos); _rpos += sizeof(uint16); return value; }
-	uint16 ReadUInt16(uint32 Offset) const { uint16 value = *(uint16 *)(pBuffer + Offset); return value; }
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }

common/classes.cpp

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

common/classes.h

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

common/clientversions.h

@@ -0,0 +1,153 @@
+/*
+EQEMu:  Everquest Server Emulator
+
+Copyright (C) 2001-2015 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 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 "Unknown";
+	case ClientVersion::Client62:
+		return "Client62";
+	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";
+	case ClientVersion::MobNPC:
+		return "MobNPC";
+	case ClientVersion::MobMerc:
+		return "MobMerc";
+	case ClientVersion::MobBot:
+		return "MobBot";
+	case ClientVersion::MobPet:
+		return "MobPet";
+	default:
+		return "<ERROR> Invalid ClientVersion";
+	};
+}
+
+static uint32 ClientBitFromVersion(ClientVersion clientVersion)
+{
+	switch (clientVersion)
+	{
+	case ClientVersion::Unknown:
+	case ClientVersion::Client62:
+		return 0;
+	case ClientVersion::Titanium:
+	case ClientVersion::SoF:
+	case ClientVersion::SoD:
+	case ClientVersion::UF:
+	case ClientVersion::RoF:
+	case ClientVersion::RoF2:
+	case ClientVersion::MobNPC:
+	case ClientVersion::MobMerc:
+	case ClientVersion::MobBot:
+	case ClientVersion::MobPet:
+		return ((uint32)1 << (static_cast<unsigned int>(clientVersion) - 1));
+	default:
+		return 0;
+	}
+}
+
+static ClientVersion ClientVersionFromBit(uint32 clientVersionBit)
+{
+	switch (clientVersionBit)
+	{
+	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;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobNPC) - 1)):
+		return ClientVersion::MobNPC;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobMerc) - 1)):
+		return ClientVersion::MobMerc;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobBot) - 1)):
+		return ClientVersion::MobBot;
+	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobPet) - 1)):
+		return ClientVersion::MobPet;
+	default:
+		return ClientVersion::Unknown;
+	}
+}
+
+#endif /* CLIENTVERSIONS_H */

common/data_verification.h

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

common/database.cpp

@@ -23,7 +23,6 @@
 #include <iomanip>
 #include <iostream>
 #include <map>
-#include <algorithm>
 #include <mysqld_error.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -49,6 +48,7 @@
 extern Client client;
 
 Database::Database () {
+	DBInitVars();
 }
 
 /*
@@ -57,6 +57,7 @@ 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);
 }
 
@@ -73,12 +74,25 @@ 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);
+	}
 }
 
 /*
@@ -299,10 +313,7 @@ bool Database::DeleteCharacter(char *name) {
 	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
-	if (charid <= 0){ 
-		Log.Out(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
-		return false; 
-	}
+	if (charid <= 0){ std::cerr << "Database::DeleteCharacter :: Character not found, stopping delete...\n"; return false; }
 
 	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
@@ -337,11 +348,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); // note: only use of GetMobTypeById()
-#else
+#ifdef BOTS																														 
+	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d' AND GetMobTypeById(%i) = 'C'", charid);
+#else																															 
 	query = StringFormat("DELETE FROM `guild_members` WHERE `char_id` = '%d'", charid);
-#endif
+#endif																															 
 	QueryDatabase(query);
 	
 	return true;
@@ -625,18 +636,12 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 	);
 	auto results = QueryDatabase(query);
 	/* Save Bind Points */
-	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, slot)"
+	query = StringFormat("REPLACE INTO `character_bind` (id, zone_id, instance_id, x, y, z, heading, is_home)"
 		" VALUES (%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
-		"(%u, %u, %u, %f, %f, %f, %f, %i), "
 		"(%u, %u, %u, %f, %f, %f, %f, %i)",
 		character_id, pp->binds[0].zoneId, 0, pp->binds[0].x, pp->binds[0].y, pp->binds[0].z, pp->binds[0].heading, 0,
-		character_id, pp->binds[1].zoneId, 0, pp->binds[1].x, pp->binds[1].y, pp->binds[1].z, pp->binds[1].heading, 1,
-		character_id, pp->binds[2].zoneId, 0, pp->binds[2].x, pp->binds[2].y, pp->binds[2].z, pp->binds[2].heading, 2,
-		character_id, pp->binds[3].zoneId, 0, pp->binds[3].x, pp->binds[3].y, pp->binds[3].z, pp->binds[3].heading, 3,
-		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 4
-	); results = QueryDatabase(query);
+		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 1
+	); results = QueryDatabase(query); 
 
 	/* Save Skills */
 	int firstquery = 0;
@@ -672,7 +677,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, InventoryOld* inv) {
 	uint32 charid = 0; 
 	char zone[50]; 
 	float x, y, z; 
@@ -700,7 +705,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
+	for (int16 i=EmuConstants::EQUIPMENT_BEGIN; i<=EmuConstants::BANK_BAGS_END;) {
 		const ItemInst* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
@@ -709,16 +714,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == EQEmu::legacy::SlotCursor) {
-			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
+		if (i == MainCursor) { 
+			i = EmuConstants::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
-			i = EQEmu::legacy::BANK_BEGIN; 
+		else if (i == EmuConstants::CURSOR_BAG_END) { 
+			i = EmuConstants::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EQEmu::legacy::BANK_END) { 
-			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
+		else if (i == EmuConstants::BANK_END) { 
+			i = EmuConstants::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -831,7 +836,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);
 
@@ -846,69 +851,145 @@ void Database::GetCharName(uint32 char_id, char* name) {
 }
 
 bool Database::LoadVariables() {
-	auto results = QueryDatabase(StringFormat("SELECT varname, value, unix_timestamp() FROM variables where unix_timestamp(ts) >= %d", varcache.last_update));
+	char *query = nullptr;
+
+	auto results = QueryDatabase(query, LoadVariables_MQ(&query));
 
 	if (!results.Success())
+	{
+		safe_delete_array(query);
 		return false;
+	}
+
+	safe_delete_array(query);
+	return LoadVariables_result(std::move(results));
+}
+
+uint32 Database::LoadVariables_MQ(char** query)
+{
+	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;
 
-	LockMutex lock(&Mvarcache);
-
-	std::string key, value;
-	for (auto row = results.begin(); row != results.end(); ++row) {
-		varcache.last_update = atoi(row[2]); // ahh should we be comparing if this is newer?
-		key = row[0];
-		value = row[1];
-		std::transform(std::begin(key), std::end(key), std::begin(key), ::tolower); // keys are lower case, DB doesn't have to be
-		varcache.Add(key, value);
+	if (!varcache_array) {
+		varcache_max = results.RowCount();
+		varcache_array = new VarCache_Struct*[varcache_max];
+		for (i=0; i<varcache_max; i++)
+			varcache_array[i] = 0;
 	}
+	else {
+		uint32 tmpnewmax = varcache_max + results.RowCount();
+		VarCache_Struct** tmp = new VarCache_Struct*[tmpnewmax];
+		for (i=0; i<tmpnewmax; i++)
+			tmp[i] = 0;
+		for (i=0; i<varcache_max; i++)
+			tmp[i] = varcache_array[i];
+		VarCache_Struct** tmpdel = varcache_array;
+		varcache_array = tmp;
+		varcache_max = tmpnewmax;
+		delete [] tmpdel;
+	}
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		varcache_lastupdate = atoi(row[2]);
+		for (i=0; i<varcache_max; i++) {
+			if (varcache_array[i]) {
+				if (strcasecmp(varcache_array[i]->varname, row[0]) == 0) {
+					delete varcache_array[i];
+					varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
+					strn0cpy(varcache_array[i]->varname, row[0], sizeof(varcache_array[i]->varname));
+					strcpy(varcache_array[i]->value, row[1]);
+					break;
+				}
+			}
+			else {
+				varcache_array[i] = (VarCache_Struct*) new uint8[sizeof(VarCache_Struct) + strlen(row[1]) + 1];
+				strcpy(varcache_array[i]->varname, row[0]);
+				strcpy(varcache_array[i]->value, row[1]);
+				break;
+			}
+		}
+	}
+
+	uint32 max_used = 0;
+	for (i=0; i<varcache_max; i++) {
+		if (varcache_array[i]) {
+			if (i > max_used)
+				max_used = i;
+		}
+	}
+
+	varcache_max = max_used + 1;
 
 	return true;
 }
 
 // Gets variable from 'variables' table
-bool Database::GetVariable(std::string varname, std::string &varvalue)
-{
-	varvalue.clear();
+bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
+	varvalue[0] = '\0';
 
 	LockMutex lock(&Mvarcache);
-
-	if (varname.empty())
+	if (strlen(varname) <= 1)
 		return false;
+	for (uint32 i=0; i<varcache_max; i++) {
 
-	std::transform(std::begin(varname), std::end(varname), std::begin(varname), ::tolower); // all keys are lower case
-	auto tmp = varcache.Get(varname);
-	if (tmp) {
-		varvalue = *tmp;
-		return true;
+		if (varcache_array[i]) {
+			if (strcasecmp(varcache_array[i]->varname, varname) == 0) {
+				snprintf(varvalue, varvalue_len, "%s", varcache_array[i]->value);
+				varvalue[varvalue_len-1] = 0;
+				return true;
+			}
+		}
+		else
+			return false;
 	}
 	return false;
 }
 
-bool Database::SetVariable(const std::string varname, const std::string &varvalue)
-{
-	std::string escaped_name = EscapeString(varname);
-	std::string escaped_value = EscapeString(varvalue);
-	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", escaped_value.c_str(), escaped_name.c_str());
+bool Database::SetVariable(const char* varname_in, const char* varvalue_in) {
+	
+	char *varname,*varvalue;
+
+	varname=(char *)malloc(strlen(varname_in)*2+1);
+	varvalue=(char *)malloc(strlen(varvalue_in)*2+1);
+	DoEscapeString(varname, varname_in, strlen(varname_in));
+	DoEscapeString(varvalue, varvalue_in, strlen(varvalue_in));
+
+	std::string query = StringFormat("Update variables set value='%s' WHERE varname like '%s'", varvalue, varname);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success())
+	{
+		free(varname);
+		free(varvalue);
 		return false;
+	}
 
 	if (results.RowsAffected() == 1)
 	{
 		LoadVariables(); // refresh cache
+		free(varname);
+		free(varvalue);
 		return true;
 	}
 
-	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", escaped_name.c_str(), escaped_value.c_str());
+	query = StringFormat("Insert Into variables (varname, value) values ('%s', '%s')", varname, varvalue);
 	results = QueryDatabase(query);
+	free(varname);
+	free(varvalue);
 
 	if (results.RowsAffected() != 1)
 		return false;
-
+	
 	LoadVariables(); // refresh cache
 	return true;
 }
@@ -1102,16 +1183,21 @@ bool Database::CheckNameFilter(const char* name, bool surname)
 {
 	std::string str_name = name;
 
-	// the minimum 4 is enforced by the client too
-	if (!name || strlen(name) < 4)
+	if(surname)
 	{
-		return false;
+		// the minimum 4 is enforced by the client too
+		if(!name || strlen(name) < 3)
+		{
+			return false;
+		}
 	}
-
-	// Given name length is enforced by the client too
-	if (!surname && strlen(name) > 15)
+	else
 	{
-		return false;
+		// the minimum 4 is enforced by the client too
+		if(!name || strlen(name) < 4 || strlen(name) > 15)
+		{
+			return false;
+		}
 	}
 
 	for (size_t i = 0; i < str_name.size(); i++)
@@ -1298,7 +1384,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", GetZoneID(iZonename), iCharID);
+	std::string query = StringFormat("UPDATE `character_data` SET `zone_id` = %i, `x` = -1, `y` = -1, `z` = -1 WHERE `id` = %i", iZonename, GetZoneID(iZonename), iCharID);
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()) {
@@ -1474,12 +1560,11 @@ void Database::SetFirstLogon(uint32 CharID, uint8 firstlogon) {
 	QueryDatabase(query); 
 }
 
-void Database::AddReport(std::string who, std::string against, std::string lines)
-{
-	auto escape_str = new char[lines.size() * 2 + 1];
+void Database::AddReport(std::string who, std::string against, std::string lines) { 
+	char *escape_str = new char[lines.size()*2+1];
 	DoEscapeString(escape_str, lines.c_str(), lines.size());
 
-	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", EscapeString(who).c_str(), EscapeString(against).c_str(), escape_str);
+	std::string query = StringFormat("INSERT INTO reports (name, reported, reported_text) VALUES('%s', '%s', '%s')", who.c_str(), against.c_str(), escape_str);
 	QueryDatabase(query);
 	safe_delete_array(escape_str);
 }
@@ -2088,75 +2173,3 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 		}
 	}
 }
-
-void Database::ClearInvSnapshots(bool use_rule)
-{
-	uint32 del_time = time(nullptr);
-	if (use_rule) { del_time -= RuleI(Character, InvSnapshotHistoryD) * 86400; }
-
-	std::string query = StringFormat("DELETE FROM inventory_snapshots WHERE time_index <= %lu", (unsigned long)del_time);
-	QueryDatabase(query);
-}
-
-struct TimeOfDay_Struct Database::LoadTime(time_t &realtime)
-{
-
-	TimeOfDay_Struct eqTime;
-	std::string query = StringFormat("SELECT minute,hour,day,month,year,realtime FROM eqtime limit 1");
-	auto results = QueryDatabase(query);
-
-	if (!results.Success() || results.RowCount() == 0){
-		Log.Out(Logs::Detail, Logs::World_Server, "Loading EQ time of day failed. Using defaults.");
-		eqTime.minute = 0;
-		eqTime.hour = 9;
-		eqTime.day = 1;
-		eqTime.month = 1;
-		eqTime.year = 3100;
-		realtime = time(0);
-	}
-	else{
-		auto row = results.begin();
-
-		eqTime.minute = atoi(row[0]);
-		eqTime.hour = atoi(row[1]);
-		eqTime.day = atoi(row[2]);
-		eqTime.month = atoi(row[3]);
-		eqTime.year = atoi(row[4]);
-		realtime = atoi(row[5]);
-	}
-
-	return eqTime;
-}
-
-bool Database::SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year)
-{
-	std::string query = StringFormat("UPDATE eqtime set minute = %d, hour = %d, day = %d, month = %d, year = %d, realtime = %d limit 1", minute, hour, day, month, year, time(0));
-	auto results = QueryDatabase(query);
-
-	return results.Success();
-
-}
-
-int Database::GetIPExemption(std::string account_ip) {
-	std::string query = StringFormat("SELECT `exemption_amount` FROM `ip_exemptions` WHERE `exemption_ip` = '%s'", account_ip.c_str());
-	auto results = QueryDatabase(query);
-	
-	if (results.Success() && results.RowCount() > 0) {
-		auto row = results.begin();
-		return atoi(row[0]);
-	}
-	
-	return RuleI(World, MaxClientsPerIP);
-}
-
-int Database::GetInstanceID(uint32 char_id, uint32 zone_id) {
-	std::string query = StringFormat("SELECT instance_list.id FROM instance_list INNER JOIN instance_list_player ON instance_list.id = instance_list_player.id WHERE instance_list.zone = '%i' AND instance_list_player.charid = '%i'", zone_id, char_id);
-	auto results = QueryDatabase(query);
-
-	if (results.Success() && results.RowCount() > 0) {
-		auto row = results.begin();
-		return atoi(row[0]);;
-	}
-
-	return 0;
-}

common/database.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -23,11 +23,11 @@
 
 #include "global_define.h"
 #include "eqemu_logsys.h"
-
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
 #include "eq_packet_structs.h"
+#include "inventory.h"
 
 #include <cmath>
 #include <string>
@@ -37,7 +37,7 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
-class Inventory;
+class InventoryOld;
 class MySQLRequestResult;
 class Client;
 
@@ -67,14 +67,8 @@ struct npcDecayTimes_Struct {
 
 
 struct VarCache_Struct {
-	std::map<std::string, std::string> m_cache;
-	uint32 last_update;
-	VarCache_Struct() : last_update(0) { }
-	void Add(const std::string &key, const std::string &value) { m_cache[key] = value; }
-	const std::string *Get(const std::string &key) {
-		auto it = m_cache.find(key);
-		return (it != m_cache.end() ? &it->second : nullptr);
-	}
+	char varname[26];	
+	char value[0];
 };
 
 class PTimerList;
@@ -94,7 +88,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 */
@@ -109,7 +103,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, InventoryOld* inv);
 	bool	UpdateName(const char* oldname, const char* newname);
 
 	/* General Information Queries */
@@ -186,10 +180,6 @@ public:
 
 	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
-	
-	int		GetIPExemption(std::string account_ip);
-
-	int		GetInstanceID(uint32 char_id, uint32 zone_id);
 
 
 	/* Groups */
@@ -220,14 +210,17 @@ public:
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
+	bool	CheckDatabaseConvertBotsPostPPDeblob();
 	bool	CheckDatabaseConvertCorpseDeblob();
 	bool	CheckDatabaseConvertPPDeblob();
 
 	/* Database Variables */
 
-	bool	GetVariable(std::string varname, std::string &varvalue);
-	bool	SetVariable(const std::string varname, const std::string &varvalue);
+	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
+	bool	SetVariable(const char* varname, const char* varvalue);
 	bool	LoadVariables();
+	uint32	LoadVariables_MQ(char** query);
+	bool	LoadVariables_result(MySQLRequestResult results);
 
 	/* General Queries */
 
@@ -249,8 +242,6 @@ public:
 	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
 
 	void	AddReport(std::string who, std::string against, std::string lines);
-	struct TimeOfDay_Struct		LoadTime(time_t &realtime);
-	bool	SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
 	void	ClearMerchantTemp();
 	void	ClearPTimers(uint32 charid);
 	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
@@ -258,16 +249,18 @@ public:
 	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
-	void	ClearInvSnapshots(bool use_rule = true);
-
 	/* EQEmuLogSys */
 	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
+	void DBInitVars();
+
 	std::map<uint32,std::string>	zonename_array;
 
-	Mutex Mvarcache;
-	VarCache_Struct varcache;
+	Mutex				Mvarcache;
+	uint32				varcache_max;
+	VarCache_Struct**	varcache_array;
+	uint32				varcache_lastupdate;
 
 	/* Groups, utility methods. */
 	void    ClearAllGroupLeaders();

common/database_conversions.cpp

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

common/dbcore.cpp

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

common/dbcore.h

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

common/deity.cpp

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

common/deity.h

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

common/emu_constants.cpp

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

common/emu_constants.h

@@ -1,70 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_EMU_CONSTANTS_H
-#define COMMON_EMU_CONSTANTS_H
-
-#include "eq_limits.h"
-#include "emu_legacy.h"
-#include "emu_versions.h"
-
-#include <string>
-
-
-namespace EQEmu
-{
-	namespace inventory {
-		//using namespace RoF2::invtype;
-		//using namespace RoF2::invslot;
-		//using namespace RoF2::invbag;
-		//using namespace RoF2::invaug;
-
-	} /*inventory*/
-
-	namespace constants {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
-
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
-
-	} /*constants*/
-	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*/

common/emu_legacy.cpp

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

common/emu_legacy.h

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

common/emu_limits.cpp

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

common/emu_limits.h

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

common/emu_oplist.h

@@ -64,7 +64,6 @@ N(OP_BuffRemoveRequest),
 N(OP_Bug),
 N(OP_CameraEffect),
 N(OP_Camp),
-N(OP_CancelSneakHide),
 N(OP_CancelTask),
 N(OP_CancelTrade),
 N(OP_CastSpell),
@@ -165,7 +164,6 @@ N(OP_FinishTrade),
 N(OP_FinishWindow),
 N(OP_FinishWindow2),
 N(OP_Fishing),
-N(OP_Fling),
 N(OP_FloatListThing),
 N(OP_Forage),
 N(OP_ForceFindPerson),
@@ -217,7 +215,6 @@ N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
-N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -289,7 +286,6 @@ N(OP_LFGuild),
 N(OP_LFPCommand),
 N(OP_LFPGetMatchesRequest),
 N(OP_LFPGetMatchesResponse),
-N(OP_LinkedReuse),
 N(OP_LoadSpellSet),
 N(OP_LocInfo),
 N(OP_LockoutTimerInfo),
@@ -539,8 +535,6 @@ N(OP_WorldLogout),
 N(OP_WorldObjectsSent),
 N(OP_WorldUnknown001),
 N(OP_XTargetAutoAddHaters),
-N(OP_XTargetOpen),
-N(OP_XTargetOpenResponse),
 N(OP_XTargetRequest),
 N(OP_XTargetResponse),
 N(OP_YellForHelp),
@@ -554,5 +548,4 @@ N(OP_ZoneServerInfo),
 N(OP_ZoneServerReady),
 N(OP_ZoneSpawns),
 N(OP_ZoneUnavail),
-N(OP_ResetAA),
 // mail and chat opcodes located in ../mail_oplist.h

common/emu_tcp_connection.cpp

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

common/emu_tcp_server.cpp

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

common/emu_versions.cpp

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

common/emu_versions.h

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

common/eq_constants.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -14,57 +13,407 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#ifndef COMMON_EQ_CONSTANTS_H
-#define COMMON_EQ_CONSTANTS_H
+#ifndef EQ_CONSTANTS_H
+#define EQ_CONSTANTS_H
 
 #include "skills.h"
 #include "types.h"
 
+/*
+** Light Types
+**
+*/
+enum LightTypes
+{
+	lightTypeNone = 0,
+	lightTypeCandle,
+	lightTypeTorch,
+	lightTypeTinyGlowingSkull,
+	lightTypeSmallLantern,
+	lightTypeSteinOfMoggok,
+	lightTypeLargeLantern,
+	lightTypeFlamelessLantern,
+	lightTypeGlobeOfStars,
+	lightTypeLightGlobe,
+	lightTypeLightstone,
+	lightTypeGreaterLightstone,
+	lightTypeFireBeetleEye,
+	lightTypeColdlight,
+	lightTypeUnknown1,
+	lightTypeUnknown2
+};
 
-//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)
+#define LIGHT_TYPES_COUNT 16
 
-//#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
+/*
+** Light Levels
+**
+*/
+enum LightLevels
+{
+	lightLevelUnlit = 0,
+	lightLevelCandle,
+	lightLevelTorch,
+	lightLevelSmallMagic,
+	lightLevelRedLight,
+	lightLevelBlueLight,
+	lightLevelSmallLantern,
+	lightLevelMagicLantern,
+	lightLevelLargeLantern,
+	lightLevelLargeMagic,
+	lightLevelBrilliant
+};
+
+#define LIGHT_LEVELS_COUNT 11
+
+/*
+**	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
+};
+
+/*
+**	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])
+*/
+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 ItemData.BagType
+**
+**	(ref: database, web forums and eqstr_us.txt)
+*/
+enum ContainerUseTypes : uint8
+{
+/*3400*/	BagTypeSmallBag = 0,
+/*3401*/	BagTypeLargeBag,
+/*3402*/	BagTypeQuiver,
+/*3403*/	BagTypeBeltPouch,
+/*3404*/	BagTypeWristPouch,
+/*3405*/	BagTypeBackPack,
+/*3406*/	BagTypeSmallChest,
+/*3407*/	BagTypeLargeChest,
+/*----*/	BagTypeBandolier,				// <*Database Reference Only>
+/*3408*/	BagTypeMedicineBag,
+/*3409*/	BagTypeToolBox,
+/*3410*/	BagTypeLexicon,
+/*3411*/	BagTypeMortar,
+/*3412*/	BagTypeSelfDusting,				// Quest container (Auto-clear contents?)
+/*3413*/	BagTypeMixingBowl,
+/*3414*/	BagTypeOven,
+/*3415*/	BagTypeSewingKit,
+/*3416*/	BagTypeForge,
+/*3417*/	BagTypeFletchingKit,
+/*3418*/	BagTypeBrewBarrel,
+/*3419*/	BagTypeJewelersKit,
+/*3420*/	BagTypePotteryWheel,
+/*3421*/	BagTypeKiln,
+/*3422*/	BagTypeKeymaker,				// (no database entries as of peq rev 69)
+/*3423*/	BagTypeWizardsLexicon,
+/*3424*/	BagTypeMagesLexicon,
+/*3425*/	BagTypeNecromancersLexicon,
+/*3426*/	BagTypeEnchantersLexicon,
+/*----*/	BagTypeUnknown1,				// (a coin pouch/purse?) (no database entries as of peq rev 69)
+/*----*/	BagTypeConcordanceofResearch,	// <*Database Reference Only>
+/*3427*/	BagTypeAlwaysWorks,				// Quest container (Never-fail combines?)
+/*3428*/	BagTypeKoadaDalForge,			// High Elf
+/*3429*/	BagTypeTeirDalForge,			// Dark Elf
+/*3430*/	BagTypeOggokForge,				// Ogre
+/*3431*/	BagTypeStormguardForge,			// Dwarf
+/*3432*/	BagTypeAkanonForge,				// Gnome
+/*3433*/	BagTypeNorthmanForge,			// Barbarian
+/*----*/	BagTypeUnknown2,				// (no database entries as of peq rev 69)
+/*3434*/	BagTypeCabilisForge,			// Iksar
+/*3435*/	BagTypeFreeportForge,			// Human 1
+/*3436*/	BagTypeRoyalQeynosForge,		// Human 2
+/*3439*/	BagTypeHalflingTailoringKit,
+/*3438*/	BagTypeErudTailoringKit,
+/*3440*/	BagTypeFierDalTailoringKit,		// Wood Elf
+/*3441*/	BagTypeFierDalFletchingKit,		// Wood Elf
+/*3437*/	BagTypeIksarPotteryWheel,
+/*3442*/	BagTypeTackleBox,
+/*3443*/	BagTypeTrollForge,
+/*3445*/	BagTypeFierDalForge,			// Wood Elf
+/*3444*/	BagTypeValeForge,				// Halfling
+/*3446*/	BagTypeErudForge,
+/*----*/	BagTypeTradersSatchel,			// <*Database Reference Only> (db: Yellow Trader's Satchel Token?)
+/*5785*/	BagTypeGuktaForge,				// Froglok (no database entries as of peq rev 69)
+/*3359*/	BagTypeAugmentationSealer,
+/*----*/	BagTypeIceCreamChurn,			// <*Database Reference Only>
+/*6325*/	BagTypeTransformationmold,		// Ornamentation
+/*6340*/	BagTypeDetransformationmold,	// Ornamentation Stripper
+/*5400*/	BagTypeUnattuner,
+/*7684*/	BagTypeTradeskillBag,
+/*7692*/	BagTypeCollectibleBag,
+/*----*/	_BagTypeCount
+};
+
+/*
+** Item Effect Types
+**
+*/
+enum {
+	ET_CombatProc = 0,
+	ET_ClickEffect = 1,
+	ET_WornEffect = 2,
+	ET_Expendable = 3,
+	ET_EquipClick = 4,
+	ET_ClickEffect2 = 5,	//name unknown
+	ET_Focus = 6,
+	ET_Scroll = 7
+};
+
+//SpawnAppearance types:
+#define AT_Die			0	// this causes the client to keel over and zone to bind point
+#define AT_WhoLevel		1	// the level that shows up on /who
+#define AT_Invis		3	// 0 = visible, 1 = invisible
+#define AT_PVP			4	// 0 = blue, 1 = pvp (red)
+#define AT_Light		5	// light type emitted by player (lightstone, shiny shield)
+#define AT_Anim			14	// 100=standing, 110=sitting, 111=ducking, 115=feigned, 105=looting
+#define AT_Sneak		15	// 0 = normal, 1 = sneaking
+#define AT_SpawnID		16	// server to client, sets player spawn id
+#define AT_HP			17	// Client->Server, my HP has changed (like regen tic)
+#define AT_Linkdead		18	// 0 = normal, 1 = linkdead
+#define AT_Levitate		19	// 0=off, 1=flymode, 2=levitate
+#define AT_GM			20	// 0 = normal, 1 = GM - all odd numbers seem to make it GM
+#define AT_Anon			21	// 0 = normal, 1 = anon, 2 = roleplay
+#define AT_GuildID		22
+#define AT_GuildRank	23	// 0=member, 1=officer, 2=leader
+#define AT_AFK			24	// 0 = normal, 1 = afk
+#define AT_Pet			25	// Param is EntityID of owner, or 0 for when charm breaks
+#define AT_Split		28	// 0 = normal, 1 = autosplit on
+#define AT_Size			29	// spawn's size
+#define AT_NPCName		31	// change PC's name's color to NPC color 0 = normal, 1 = npc name
+#define AT_ShowHelm		43	// 0 = do not show helmet graphic, 1 = show graphic
+#define AT_DamageState	44	// The damage state of a destructible object (0 through 4)
+//#define AT_Trader		300	// Bazzar Trader Mode
 
 // animations for AT_Anim
 #define ANIM_FREEZE	102
@@ -170,40 +519,15 @@ typedef enum {
 #define MT_StrikeThrough		339
 #define MT_Stun					340
 
-// TODO: Really should combine above and below into one
-
 //from showeq
 enum ChatColor
 {
-	/*
 	CC_Default					= 0,
 	CC_DarkGrey					= 1,
 	CC_DarkGreen				= 2,
 	CC_DarkBlue					= 3,
 	CC_Purple					= 5,
 	CC_LightGrey				= 6,
-	*/
-
-	CC_WhiteSmoke				= 0,	// FF|F0F0F0
-	CC_Green					= 2,	// FF|008000
-	CC_BrightBlue				= 3,	// FF|0040FF
-	CC_Magenta					= 5,	// FF|F000F0
-	CC_Gray						= 6,	// FF|808080
-	CC_LightGray				= 7,	// FF|E0E0E0
-	//CC_WhiteSmoke2				= 10,	// FF|F0F0F0
-	CC_DarkGray					= 12,	// FF|A0A0A0
-	CC_Red						= 13,	// FF|F00000
-	CC_Lime						= 14,	// FF|00F000
-	CC_Yellow					= 15,	// FF|F0F000
-	CC_Blue						= 16,	// FF|0000F0
-	CC_LightNavy				= 17,	// FF|0000AF
-	CC_Cyan						= 18,	// FF|00F0F0
-	CC_Black					= 20,	// FF|000000
-	
-	// any index <= 255 that is not defined above
-	CC_DimGray					= 1,	// FF|606060
-	CC_Default					= 1,
-
 	CC_User_Say					= 256,
 	CC_User_Tell				= 257,
 	CC_User_Group				= 258,
@@ -399,7 +723,7 @@ static const uint8 DamageTypeUnknown	= 0xFF;
 **
 **	(indexed by 'Skill' of SkillUseTypes)
 */
-static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
+static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated
 {
 /*1HBlunt*/					0,
 /*1HSlashing*/				1,
@@ -475,10 +799,29 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 /*Intimidation*/			DamageTypeUnknown,
 /*Berserking*/				DamageTypeUnknown,
 /*Taunt*/					DamageTypeUnknown,
-/*Frenzy*/					74,
-/*RemoveTrap*/				DamageTypeUnknown,	// Needs research (set for SenseTrap value)
-/*TripleAttack*/			DamageTypeUnknown,	// Needs research (set for DoubleAttack value)
-/*2HPiercing*/				36					// Needs research (set for 1HPiercing value - similar to slash/blunt)
+/*Frenzy*/					74 //,
+// /*RemoveTrap*/				DamageTypeUnknown,	// Needs research (set for SenseTrap value)
+// /*TripleAttack*/			DamageTypeUnknown,	// Needs research (set for DoubleAttack value)
+// /*2HPiercing*/				36					// Needs research (set for 1HPiercing value - similar to slash/blunt)
+};
+
+/*
+**	Material use slots
+**
+*/
+enum MaterialUseSlots : uint8
+{
+	MaterialHead = 0,
+	MaterialChest,
+	MaterialArms,
+	MaterialWrist,
+	MaterialHands,
+	MaterialLegs,
+	MaterialFeet,
+	MaterialPrimary,
+	MaterialSecondary,
+	_MaterialCount,
+	_MaterialInvalid = 255
 };
 
 /*
@@ -515,16 +858,164 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 **
 */
 
+enum InventoryMapTypes : int16 {
+	MapPossessions = 0,
+	MapBank,
+	MapSharedBank,
+	MapTrade,
+	MapWorld,
+	MapLimbo,
+	MapTribute,
+	MapTrophyTribute,
+	MapGuildTribute,
+	MapMerchant,
+	MapDeleted,
+	MapCorpse,
+	MapBazaar,
+	MapInspect,
+	MapRealEstate,
+	MapViewMODPC,
+	MapViewMODBank,
+	MapViewMODSharedBank,
+	MapViewMODLimbo,
+	MapAltStorage,
+	MapArchived,
+	MapMail,
+	MapGuildTrophyTribute,
+	MapKrono,
+	MapOther,
+	_MapCount
+};
+
+enum InventoryMainTypes : int16 {
+	MainCharm = 0,
+	MainEar1,
+	MainHead,
+	MainFace,
+	MainEar2,
+	MainNeck,
+	MainShoulders,
+	MainArms,
+	MainBack,
+	MainWrist1,
+	MainWrist2,
+	MainRange,
+	MainHands,
+	MainPrimary,
+	MainSecondary,
+	MainFinger1,
+	MainFinger2,
+	MainChest,
+	MainLegs,
+	MainFeet,
+	MainWaist,
+	MainPowerSource = 9999, // temp
+	MainAmmo = 21, // temp
+	MainGeneral1,
+	MainGeneral2,
+	MainGeneral3,
+	MainGeneral4,
+	MainGeneral5,
+	MainGeneral6,
+	MainGeneral7,
+	MainGeneral8,
+	//MainGeneral9,
+	//MainGeneral10,
+	MainCursor,
+	_MainCount
+};
+
 #define INVALID_INDEX	-1
+#define NOT_USED		0
 #define NO_ITEM			0
 
 // yes..these are redundant... but, they help to identify and define what is actually being performed
 // plus, since they're pre-op's, they don't affect the actual binary size
-#define TYPE_BEGIN	0
-#define SLOT_BEGIN	0
-#define SUB_INDEX_BEGIN	0
-#define AUG_INDEX_BEGIN	0
+#define MAP_BEGIN	0
+#define MAIN_BEGIN	0
+#define SUB_BEGIN	0
+#define AUG_BEGIN	0
+
+namespace legacy {
+	// this is for perl and other legacy systems
+
+	typedef enum {
+		SLOT_CHARM			= 0,
+		SLOT_EAR01			= 1,
+		SLOT_HEAD			= 2,
+		SLOT_FACE			= 3,
+		SLOT_EAR02			= 4,
+		SLOT_NECK			= 5,
+		SLOT_SHOULDER		= 6,
+		SLOT_ARMS			= 7,
+		SLOT_BACK			= 8,
+		SLOT_BRACER01		= 9,
+		SLOT_BRACER02		= 10,
+		SLOT_RANGE			= 11,
+		SLOT_HANDS			= 12,
+		SLOT_PRIMARY		= 13,
+		SLOT_SECONDARY		= 14,
+		SLOT_RING01			= 15,
+		SLOT_RING02			= 16,
+		SLOT_CHEST			= 17,
+		SLOT_LEGS			= 18,
+		SLOT_FEET			= 19,
+		SLOT_WAIST			= 20,
+		SLOT_POWER_SOURCE	= 9999,
+		SLOT_AMMO			= 21,
+		SLOT_GENERAL_1		= 22,
+		SLOT_GENERAL_2		= 23,
+		SLOT_GENERAL_3		= 24,
+		SLOT_GENERAL_4		= 25,
+		SLOT_GENERAL_5		= 26,
+		SLOT_GENERAL_6		= 27,
+		SLOT_GENERAL_7		= 28,
+		SLOT_GENERAL_8		= 29,
+		//SLOT_GENERAL_9	= not supported
+		//SLOT_GENERAL_10	= not supported
+		SLOT_CURSOR			= 30,
+		SLOT_CURSOR_END		= (int16)0xFFFE, // I hope no one is using this...
+		SLOT_TRADESKILL		= 1000,
+		SLOT_AUGMENT		= 1001,
+		SLOT_INVALID		= (int16)0xFFFF,
+
+		SLOT_POSSESSIONS_BEGIN	= 0,
+		SLOT_POSSESSIONS_END	= 30,
+
+		SLOT_EQUIPMENT_BEGIN	= 0,
+		SLOT_EQUIPMENT_END		= 21,
+
+		SLOT_PERSONAL_BEGIN		= 22,
+		SLOT_PERSONAL_END		= 29,
+		SLOT_PERSONAL_BAGS_BEGIN	= 251,
+		SLOT_PERSONAL_BAGS_END		= 330,
+
+		SLOT_CURSOR_BAG_BEGIN		= 331,
+		SLOT_CURSOR_BAG_END			= 340,
+
+		SLOT_TRIBUTE_BEGIN	= 400,
+		SLOT_TRIBUTE_END	= 404,
+
+		SLOT_BANK_BEGIN			= 2000,
+		SLOT_BANK_END			= 2023,
+		SLOT_BANK_BAGS_BEGIN	= 2031,
+		SLOT_BANK_BAGS_END		= 2270,
+
+		SLOT_SHARED_BANK_BEGIN		= 2500,
+		SLOT_SHARED_BANK_END		= 2501,
+		SLOT_SHARED_BANK_BAGS_BEGIN	= 2531,
+		SLOT_SHARED_BANK_BAGS_END	= 2550,
+
+		SLOT_TRADE_BEGIN		= 3000,
+		SLOT_TRADE_END			= 3007,
+		SLOT_TRADE_BAGS_BEGIN	= 3031,
+		SLOT_TRADE_BAGS_END		= 3110,
+
+		SLOT_WORLD_BEGIN	= 4000,
+		SLOT_WORLD_END		= 4009
+	} InventorySlot;
+}
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
-#endif /*COMMON_EQ_CONSTANTS_H*/
+#endif

common/eq_dictionary.cpp

@@ -0,0 +1,943 @@
+/*
+EQEMu:  Everquest Server Emulator
+
+Copyright (C) 2001-2015 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 "SharedBank";
+	case MapTrade:
+		return "Trade";
+	case MapWorld:
+		return "World";
+	case MapLimbo:
+		return "Limbo";
+	case MapTribute:
+		return "Tribute";
+	case MapTrophyTribute:
+		return "TrophyTribute";
+	case MapGuildTribute:
+		return "GuildTribute";
+	case MapMerchant:
+		return "Merchant";
+	case MapDeleted:
+		return "Deleted";
+	case MapCorpse:
+		return "Corpse";
+	case MapBazaar:
+		return "Bazaar";
+	case MapInspect:
+		return "Inspect";
+	case MapRealEstate:
+		return "RealEstate";
+	case MapViewMODPC:
+		return "ViewMODPC";
+	case MapViewMODBank:
+		return "ViewMODBank";
+	case MapViewMODSharedBank:
+		return "ViewMODSharedBank";
+	case MapViewMODLimbo:
+		return "ViewMODLimbo";
+	case MapAltStorage:
+		return "AltStorage";
+	case MapArchived:
+		return "Archived";
+	case MapMail:
+		return "Mail";
+	case MapGuildTrophyTribute:
+		return "GuildTrophyTribute";
+	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 "Ear1";
+	case MainHead:
+		return "Head";
+	case MainFace:
+		return "Face";
+	case MainEar2:
+		return "Ear2";
+	case MainNeck:
+		return "Neck";
+	case MainShoulders:
+		return "Shoulders";
+	case MainArms:
+		return "Arms";
+	case MainBack:
+		return "Back";
+	case MainWrist1:
+		return "Wrist1";
+	case MainWrist2:
+		return "Wrist2";
+	case MainRange:
+		return "Range";
+	case MainHands:
+		return "Hands";
+	case MainPrimary:
+		return "Primary";
+	case MainSecondary:
+		return "Secondary";
+	case MainFinger1:
+		return "Finger1";
+	case MainFinger2:
+		return "Finger2";
+	case MainChest:
+		return "Chest";
+	case MainLegs:
+		return "Legs";
+	case MainFeet:
+		return "Feet";
+	case MainWaist:
+		return "Waist";
+	case MainPowerSource:
+		return "PowerSource";
+	case MainAmmo:
+		return "Ammo";
+	case MainGeneral1:
+		return "General1";
+	case MainGeneral2:
+		return "General2";
+	case MainGeneral3:
+		return "General3";
+	case MainGeneral4:
+		return "General4";
+	case MainGeneral5:
+		return "General5";
+	case MainGeneral6:
+		return "General6";
+	case MainGeneral7:
+		return "General7";
+	case MainGeneral8:
+		return "General8";
+	/*
+	case MainGeneral9:
+		return "General9";
+	case MainGeneral10:
+		return "General10";
+	*/
+	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;
+}
+
+// database
+size_t EQLimits::CharacterCreationLimit(ClientVersion clientVersion)
+{
+	static const size_t local[CLIENT_VERSION_COUNT] = {
+/*Unknown*/		NOT_USED,
+/*Client62*/	NOT_USED,
+/*Titanium*/	Titanium::consts::CHARACTER_CREATION_LIMIT,
+/*SoF*/			SoF::consts::CHARACTER_CREATION_LIMIT,
+/*SoD*/			SoD::consts::CHARACTER_CREATION_LIMIT,
+/*UF*/			UF::consts::CHARACTER_CREATION_LIMIT,
+/*RoF*/			RoF::consts::CHARACTER_CREATION_LIMIT,
+/*RoF2*/		RoF2::consts::CHARACTER_CREATION_LIMIT,
+
+/*MobNPC*/		NOT_USED,
+/*MobMerc*/		NOT_USED,
+/*MobBot*/		NOT_USED,
+/*MobPet*/		NOT_USED
+	};
+
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
+}
+
+// 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))];
+}

common/eq_dictionary.h

@@ -0,0 +1,205 @@
+/*
+EQEMu:  Everquest Server Emulator
+
+Copyright (C) 2001-2015 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
+
+	static const size_t CHARACTER_CREATION_LIMIT = RoF2::consts::CHARACTER_CREATION_LIMIT;
+
+	// 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;
+
+	// 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 = RoF2::consts::BANDOLIERS_SIZE;			// number of bandolier instances
+	static const size_t BANDOLIER_ITEM_COUNT = RoF2::consts::BANDOLIER_ITEM_COUNT;	// number of equipment slots in bandolier instance
+
+	// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
+	static const size_t POTION_BELT_ITEM_COUNT = RoF2::consts::POTION_BELT_ITEM_COUNT;
+
+	static const size_t TEXT_LINK_BODY_LENGTH = RoF2::consts::TEXT_LINK_BODY_LENGTH;
+};
+
+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);
+
+	// database
+	static size_t CharacterCreationLimit(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);
+};
+
+#endif /* EQ_DICTIONARY_H */
+
+/*
+Working Notes:
+--------------
+
+- full review of client_packet.cpp and client translators needed
+
+
+*/

common/eq_limits.cpp

@@ -1,381 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "emu_constants.h"
-#include "emu_limits.h"
-
-
-static const EQEmu::constants::LookupEntry constants_lookup_entries[EQEmu::versions::ClientVersionCount] =
-{
-	{ // Unknown
-		ClientUnknown::Null
-	},
-	{ // Client62
-		Client62::Null
-	},
-	{ // Titanium
-		Titanium::constants::CharacterCreationLimit
-	},
-	{ // SoF
-		SoF::constants::CharacterCreationLimit
-	},
-	{ // SoD
-		SoD::constants::CharacterCreationLimit
-	},
-	{ // UF
-		UF::constants::CharacterCreationLimit
-	},
-	{ // RoF
-		RoF::constants::CharacterCreationLimit
-	},
-	{ // RoF2
-		RoF2::constants::CharacterCreationLimit
-	}
-};
-
-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::InventoryVersionCount] =
-{
-	{ // Unknown
-		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
-		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
-	},
-	{ // Titanium
-		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::legacy::ITEM_CONTAINER_SIZE, /*Titanium::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*Titanium::invaug::ItemAugSize,*/
-
-		Titanium::inventory::AllowEmptyBagInBag, Titanium::inventory::AllowClickCastFromBag, Titanium::inventory::ConcatenateInvTypeLimbo, Titanium::inventory::AllowOverLevelEquipment
-	},
-	{ // SoF
-		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::legacy::ITEM_CONTAINER_SIZE, /*SoF::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*SoF::invaug::ItemAugSize,*/
-
-		SoF::inventory::AllowEmptyBagInBag, SoF::inventory::AllowClickCastFromBag, SoF::inventory::ConcatenateInvTypeLimbo, SoF::inventory::AllowOverLevelEquipment
-	},
-	{ // SoD
-		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::legacy::ITEM_CONTAINER_SIZE, /*SoD::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*SoD::invaug::ItemAugSize,*/
-
-		SoD::inventory::AllowEmptyBagInBag, SoD::inventory::AllowClickCastFromBag, SoD::inventory::ConcatenateInvTypeLimbo, SoD::inventory::AllowOverLevelEquipment
-	},
-	{ // UF
-		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::legacy::ITEM_CONTAINER_SIZE, /*UF::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*UF::invaug::ItemAugSize,*/
-
-		UF::inventory::AllowEmptyBagInBag, UF::inventory::AllowClickCastFromBag, UF::inventory::ConcatenateInvTypeLimbo, UF::inventory::AllowOverLevelEquipment
-	},
-	{ // RoF
-		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::legacy::ITEM_CONTAINER_SIZE, /*RoF::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*RoF::invaug::ItemAugSize,*/
-
-		RoF::False, /*RoF::inventory::AllowEmptyBagInBag,*/ RoF::inventory::AllowClickCastFromBag, RoF::inventory::ConcatenateInvTypeLimbo, RoF::inventory::AllowOverLevelEquipment
-	},
-	{ // RoF2
-		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::legacy::ITEM_CONTAINER_SIZE, /*RoF2::invbag::ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*RoF2::invaug::ItemAugSize,*/
-
-		RoF2::False, /*RoF2::inventory::AllowEmptyBagInBag,*/ RoF2::inventory::AllowClickCastFromBag, RoF2::inventory::ConcatenateInvTypeLimbo, RoF2::inventory::AllowOverLevelEquipment
-	},
-	{ // NPC
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::NPC::False, EntityLimits::NPC::False, EntityLimits::NPC::False, EntityLimits::NPC::False
-	},
-	{ // NPCMerchant
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::NPCMerchant::False, EntityLimits::NPCMerchant::False, EntityLimits::NPCMerchant::False, EntityLimits::NPCMerchant::False
-	},
-	{ // Merc
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::Merc::False, EntityLimits::Merc::False, EntityLimits::Merc::False, EntityLimits::Merc::False
-	},
-	{ // Bot
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::Bot::False, EntityLimits::Bot::False, EntityLimits::Bot::False, EntityLimits::Bot::False
-	},
-	{ // ClientPet
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::ClientPet::False, EntityLimits::ClientPet::False, EntityLimits::ClientPet::False, EntityLimits::ClientPet::False
-	},
-	{ // NPCPet
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::NPCPet::False, EntityLimits::NPCPet::False, EntityLimits::NPCPet::False, EntityLimits::NPCPet::False
-	},
-	{ // MercPet
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*ItemAugSize,*/
-
-		EntityLimits::MercPet::False, EntityLimits::MercPet::False, EntityLimits::MercPet::False, EntityLimits::MercPet::False
-	},
-	{ // BotPet
-		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::legacy::ITEM_CONTAINER_SIZE, /*ItemBagSize,*/ EQEmu::legacy::ITEM_COMMON_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*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::legacy::ITEM_CONTAINER_SIZE, /*RoF2::Null,*/ RoF2::Null,
-
-		RoF2::False, RoF2::False, RoF2::False, RoF2::False
-	}
-};
-
-const EQEmu::inventory::LookupEntry* EQEmu::inventory::Lookup(versions::InventoryVersion inventory_version)
-{
-	return &inventory_lookup_entries[static_cast<int>(versions::ValidateInventoryVersion(inventory_version))];
-}
-
-static const EQEmu::behavior::LookupEntry behavior_lookup_entries[EQEmu::versions::InventoryVersionCount] =
-{
-	{ // 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::InventoryVersion inventory_version)
-{
-	return &behavior_lookup_entries[static_cast<int>(versions::ValidateInventoryVersion(inventory_version))];
-}

common/eq_limits.h

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

@@ -260,7 +260,7 @@ bool EQProtocolPacket::combine(const EQProtocolPacket *rhs)
 {
 bool result=false;
 	if (opcode==OP_Combined && size+rhs->size+5<256) {
-		auto tmpbuffer = new unsigned char[size + rhs->size + 3];
+		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+3];
 		memcpy(tmpbuffer,pBuffer,size);
 		uint32 offset=size;
 		tmpbuffer[offset++]=rhs->Size();
@@ -270,7 +270,7 @@ bool result=false;
 		pBuffer=tmpbuffer;
 		result=true;
 	} else if (size+rhs->size+7<256) {
-		auto tmpbuffer = new unsigned char[size + rhs->size + 6];
+		unsigned char *tmpbuffer=new unsigned char [size+rhs->size+6];
 		uint32 offset=0;
 		tmpbuffer[offset++]=Size();
 		offset+=serialize(tmpbuffer+offset);
@@ -457,7 +457,7 @@ EQApplicationPacket *EQApplicationPacket::Copy() const {
 }
 
 EQRawApplicationPacket *EQProtocolPacket::MakeAppPacket() const {
-	auto res = new EQRawApplicationPacket(opcode, pBuffer, size);
+	EQRawApplicationPacket *res = new EQRawApplicationPacket(opcode, pBuffer, size);
 	res->copyInfo(this);
 	return(res);
 }

common/eq_packet.h

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

common/eq_packet_structs.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -25,17 +25,16 @@
 #include <list>
 #include <time.h>
 #include "../common/version.h"
-#include "emu_constants.h"
-#include "textures.h"
-
+//#include "../common/item_data.h"
 
 static const uint32 BUFF_COUNT = 25;
-static const uint32 PET_BUFF_COUNT = 30;
 static const uint32 MAX_MERC = 100;
 static const uint32 MAX_MERC_GRADES = 10;
 static const uint32 MAX_MERC_STANCES = 10;
 static const uint32 BLOCKED_BUFF_COUNT = 20;
 
+//#include "eq_constants.h"
+#include "eq_dictionary.h"
 
 /*
 ** Compiler override to ensure
@@ -127,7 +126,45 @@ struct LDoNTrapTemplate
 
 // All clients translate the character select information to some degree
 
-struct CharSelectEquip : EQEmu::Texture_Struct, EQEmu::Tint_Struct {};
+struct Inventory_Slot_Struct
+{
+	int16 type;
+	int16 slot;
+	int16 bag;
+	int16 aug;
+};
+
+struct Color_Struct
+{
+	union {
+		struct {
+			uint8 Blue;
+			uint8 Green;
+			uint8 Red;
+			uint8 UseTint;	// if there's a tint this is FF
+		} RGB;
+		uint32 Color;
+	};
+};
+
+struct EquipStruct
+{
+	uint32 Material;
+	uint32 Unknown1;
+	uint32 EliteMaterial;
+	uint32 HeroForgeModel;
+	uint32 Material2;	// Same as material?
+};
+
+struct CharSelectEquip
+{
+	uint32 Material;
+	uint32 Unknown1;
+	uint32 EliteMaterial;
+	uint32 HeroForgeModel;
+	uint32 Material2;
+	Color_Struct Color;
+};
 
 // RoF2-based hybrid struct
 struct CharacterSelectEntry_Struct
@@ -142,7 +179,7 @@ struct CharacterSelectEntry_Struct
 	uint16 Instance;
 	uint8 Gender;
 	uint8 Face;
-	CharSelectEquip	Equip[EQEmu::textures::TextureCount];
+	CharSelectEquip	Equip[9];
 	uint8 Unknown15;			// Seen FF
 	uint8 Unknown19;			// Seen FF
 	uint32 DrakkinTattoo;
@@ -251,7 +288,22 @@ struct Spawn_Struct {
 /*0189*/ uint32	petOwnerId;			// If this is a pet, the spawn id of owner
 /*0193*/ uint8	guildrank;			// 0=normal, 1=officer, 2=leader
 /*0194*/ uint8	unknown0194[3];
-/*0197*/ EQEmu::TextureProfile equipment;
+/*0197*/ union
+{
+	struct
+	{
+		/*0000*/ EquipStruct equip_helmet;     // Equipment: Helmet visual
+		/*0000*/ EquipStruct equip_chest;      // Equipment: Chest visual
+		/*0000*/ EquipStruct equip_arms;       // Equipment: Arms visual
+		/*0000*/ EquipStruct equip_bracers;    // Equipment: Wrist visual
+		/*0000*/ EquipStruct equip_hands;      // Equipment: Hands visual
+		/*0000*/ EquipStruct equip_legs;       // Equipment: Legs visual
+		/*0000*/ EquipStruct equip_feet;       // Equipment: Boots visual
+		/*0000*/ EquipStruct equip_primary;    // Equipment: Main visual
+		/*0000*/ EquipStruct equip_secondary;  // Equipment: Off visual
+	} equip;
+	/*0000*/ EquipStruct equipment[_MaterialCount];
+};
 /*0233*/ float	runspeed;		// Speed when running
 /*0036*/ uint8	afk;			// 0=no, 1=afk
 /*0238*/ uint32	guildID;		// Current guild
@@ -282,7 +334,22 @@ union
 /*0340*/ uint32 spawnId;		// Spawn Id
 /*0344*/ uint8 unknown0344[3];
 /*0347*/ uint8 IsMercenary;
-/*0348*/ EQEmu::TintProfile equipment_tint;
+/*0348*/ union
+		 {
+			struct
+			{
+				/*0348*/ Color_Struct color_helmet;		// Color of helmet item
+				/*0352*/ Color_Struct color_chest;		// Color of chest item
+				/*0356*/ Color_Struct color_arms;		// Color of arms item
+				/*0360*/ Color_Struct color_bracers;	// Color of bracers item
+				/*0364*/ Color_Struct color_hands;		// Color of hands item
+				/*0368*/ Color_Struct color_legs;		// Color of legs item
+				/*0372*/ Color_Struct color_feet;		// Color of feet item
+				/*0376*/ Color_Struct color_primary;	// Color of primary item
+				/*0380*/ Color_Struct color_secondary;	// Color of secondary item
+			} equipment_colors;
+			/*0348*/ Color_Struct colors[_MaterialCount]; // Array elements correspond to struct equipment_colors above
+		 };
 /*0384*/ uint8	lfg;			// 0=off, 1=lfg on
 /*0385*/
 
@@ -387,19 +454,7 @@ struct MemorizeSpell_Struct {
 uint32 slot;		// Spot in the spell book/memorized slot
 uint32 spell_id;	// Spell id (200 or c8 is minor healing, etc)
 uint32 scribing;	// 1 if memorizing a spell, set to 0 if scribing to book, 2 if un-memming
-uint32 reduction;	// lower reuse
-};
-
-/*
-** Linked Spell Reuse Timer
-** Length: 12
-** Comes before the OP_Memorize
-** Live (maybe TDS steam) has an extra DWORD after timer_id
-*/
-struct LinkedSpellReuseTimer_Struct {
-	uint32 timer_id; // Timer ID of the spell
-	uint32 end_time; // timestamp of when it will be ready
-	uint32 start_time; // timestamp of when it started
+uint32 unknown12;
 };
 
 /*
@@ -432,11 +487,10 @@ struct DeleteSpell_Struct
 
 struct ManaChange_Struct
 {
-/*00*/	uint32	new_mana;		// New Mana AMount
-/*04*/	uint32	stamina;
-/*08*/	uint32	spell_id;
-/*12*/	uint8	keepcasting;	// won't stop the cast. Change mana while casting?
-/*13*/	uint8	padding[3];		// client doesn't read it, garbage data seems like
+	uint32	new_mana; // New Mana AMount
+	uint32	stamina;
+	uint32	spell_id;
+	uint32	unknown12;
 };
 
 struct SwapSpell_Struct
@@ -502,28 +556,30 @@ struct SpawnAppearance_Struct
 // this is used inside profile
 struct SpellBuff_Struct
 {
-/*000*/	uint8	effect_type;	// 0 = no buff, 2 = buff, 4 = inverse affects of buff
-/*001*/	uint8	level;
+/*000*/	uint8	slotid;		//badly named... seems to be 2 for a real buff, 0 otherwise
+/*001*/ uint8	level;
 /*002*/	uint8	bard_modifier;
-/*003*/	uint8	unknown003;		// MQ2 used to call this "damage shield" -- don't see client referencing it, so maybe server side DS type tracking? -- OSX client calls this "activated"
+/*003*/	uint8	effect;			//not real
 /*004*/	uint32	spellid;
-/*008*/	int32	duration;
-/*012*/	uint32	counters;	// single book keeping value (counters, rune/vie)
-/*016*/	uint32	player_id;	// caster ID, pretty sure just zone ID
-// extra stuff for newer packets
-/*020*/	uint32	num_hits;
-/*024*/	float	y;				// referenced by SPA 441
-/*028*/	float	x;				// unsure if all buffs get them
-/*032*/	float	z;				// as valid data
-/*036*/
+/*008*/ int32	duration;
+/*012*/	uint32	counters;
+/*016*/	uint32	player_id;	//'global' ID of the caster, for wearoff messages
+/*020*/
 };
 
-struct SpellBuffPacket_Struct {
+struct SpellBuffFade_Struct {
 /*000*/	uint32 entityid;
-/*004*/	SpellBuff_Struct buff;
-/*040*/	uint32 slotid;
-/*044*/	uint32 bufffade;
-/*048*/
+/*004*/	uint8 slot;
+/*005*/	uint8 level;
+/*006*/	uint8 effect;
+/*007*/	uint8 unknown7;
+/*008*/	uint32 spellid;
+/*012*/	int32 duration;
+/*016*/	uint32 num_hits;
+/*020*/	uint32 unknown020;	//prolly global player ID
+/*024*/	uint32 slotid;
+/*028*/	uint32 bufffade;
+/*032*/
 };
 
 // Underfoot & later struct.
@@ -536,8 +592,8 @@ struct BuffRemoveRequest_Struct
 
 struct PetBuff_Struct {
 /*000*/ uint32 petid;
-/*004*/ uint32 spellid[PET_BUFF_COUNT];
-/*124*/ int32 ticsremaining[PET_BUFF_COUNT];
+/*004*/ uint32 spellid[BUFF_COUNT+5];
+/*124*/ int32 ticsremaining[BUFF_COUNT+5];
 /*244*/ uint32 buffcount;
 };
 
@@ -729,7 +785,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[EQEmu::legacy::BANDOLIER_ITEM_COUNT];
+	BandolierItem_Struct Items[EmuConstants::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -743,7 +799,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[EQEmu::legacy::POTION_BELT_ITEM_COUNT];
+	PotionBeltItem_Struct Items[EmuConstants::POTION_BELT_ITEM_COUNT];
 };
 
 struct MovePotionToBelt_Struct
@@ -834,7 +890,7 @@ struct SuspendedMinion_Struct
 	/*002*/	uint32 HP;
 	/*006*/	uint32 Mana;
 	/*010*/	SpellBuff_Struct Buffs[BUFF_COUNT];
-	/*510*/	EQEmu::TextureShortProfile Items;
+	/*510*/	uint32 Items[_MaterialCount];
 	/*546*/	char Name[64];
 	/*610*/
 };
@@ -848,7 +904,7 @@ struct SuspendedMinion_Struct
  */
 static const uint32 MAX_PP_LANGUAGE = 28;
 static const uint32 MAX_PP_SPELLBOOK = 480;	// Set for all functions
-static const uint32 MAX_PP_MEMSPELL = static_cast<uint32>(EQEmu::CastingSlot::MaxGems); // Set to latest client so functions can work right -- 12
+static const uint32 MAX_PP_MEMSPELL = 9; // Set to latest client so functions can work right
 static const uint32 MAX_PP_REF_SPELLBOOK = 480;	// Set for Player Profile size retain
 static const uint32 MAX_PP_REF_MEMSPELL = 9; // Set for Player Profile size retain
 
@@ -929,7 +985,7 @@ struct PlayerProfile_Struct
 /*0245*/	uint8				guildbanker;
 /*0246*/	uint8				unknown0246[6];		//
 /*0252*/	uint32				intoxication;
-/*0256*/	uint32				spellSlotRefresh[MAX_PP_MEMSPELL];	//in ms
+/*0256*/	uint32				spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
 /*0292*/	uint32				abilitySlotRefresh;
 /*0296*/	uint8				haircolor;			// Player hair color
 /*0297*/	uint8				beardcolor;			// Player beard color
@@ -942,9 +998,9 @@ struct PlayerProfile_Struct
 /*0304*/	uint8				ability_time_minutes;
 /*0305*/	uint8				ability_time_hours;	//place holder
 /*0306*/	uint8				unknown0306[6];		// @bp Spacer/Flag?
-/*0312*/	EQEmu::TextureShortProfile	item_material;	// Item texture/material of worn/held items
+/*0312*/	uint32				item_material[_MaterialCount];	// Item texture/material of worn/held items
 /*0348*/	uint8				unknown0348[44];
-/*0392*/	EQEmu::TintProfile	item_tint;
+/*0392*/	Color_Struct		item_tint[_MaterialCount];
 /*0428*/	AA_Array			aa_array[MAX_PP_AA_ARRAY];
 /*2348*/	float				unknown2384;		//seen ~128, ~47
 /*2352*/	char				servername[32];		// length probably not right
@@ -970,7 +1026,7 @@ struct PlayerProfile_Struct
 /*2580*/	uint8				unknown2616[4];
 /*2584*/	uint32				spell_book[MAX_PP_REF_SPELLBOOK];
 /*4504*/	uint8				unknown4540[128];	// Was [428] all 0xff
-/*4632*/	uint32				mem_spells[MAX_PP_MEMSPELL];
+/*4632*/	uint32				mem_spells[MAX_PP_REF_MEMSPELL];
 /*4668*/	uint8				unknown4704[32];	//
 /*4700*/	float				y;					// Player y position
 /*4704*/	float				x;					// Player x position
@@ -1045,7 +1101,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[EQEmu::legacy::TRIBUTE_SIZE];
+/*7224*/	Tribute_Struct		tributes[EmuConstants::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1072,7 +1128,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[EQEmu::legacy::BANDOLIERS_SIZE];
+/*12844*/	Bandolier_Struct	bandoliers[EmuConstants::BANDOLIERS_SIZE];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -1179,7 +1235,7 @@ struct WearChange_Struct{
 /*010*/ uint32 elite_material;	// 1 for Drakkin Elite Material
 /*014*/ uint32 hero_forge_model; // New to VoA
 /*018*/ uint32 unknown18; // New to RoF
-/*022*/ EQEmu::Tint_Struct color;
+/*022*/ Color_Struct color;
 /*026*/ uint8 wear_slot_id;
 /*027*/
 };
@@ -1274,7 +1330,7 @@ struct CombatDamage_Struct
 /* 11 */	float force;
 /* 15 */	float meleepush_xy;	// see above notes in Action_Struct
 /* 19 */	float meleepush_z;
-/* 23 */	uint32 special; // 2 = Rampage, 1 = Wild Rampage
+/* 23 */
 };
 
 /*
@@ -1470,38 +1526,17 @@ struct ExpUpdate_Struct
 enum ItemPacketType
 {
 	ItemPacketViewLink			= 0x00,
-	ItemPacketMerchant			= 0x64,
 	ItemPacketTradeView			= 0x65,
 	ItemPacketLoot				= 0x66,
 	ItemPacketTrade				= 0x67,
 	ItemPacketCharInventory		= 0x69,
-	ItemPacketLimbo				= 0x6A,
-	ItemPacketWorldContainer	= 0x6B,
+	ItemPacketSummonItem		= 0x6A,
 	ItemPacketTributeItem		= 0x6C,
-	ItemPacketGuildTribute		= 0x6D,
-	ItemPacketCharmUpdate		= 0x6E, // noted as incorrect
+	ItemPacketMerchant			= 0x64,
+	ItemPacketWorldContainer	= 0x6B,
+	ItemPacketCharmUpdate		= 0x6E,
 	ItemPacketInvalid			= 0xFF
 };
-
-//enum ItemPacketType
-//{
-//	ItemPacketMerchant			= /*100*/ 0x64, // Titanium+
-//	ItemPacketTradeView			= /*101*/ 0x65,
-//	ItemPacketLoot				= /*102*/ 0x66,
-//	ItemPacketTrade				= /*103*/ 0x67,
-//	ItemPacketCharInventory		= /*105*/ 0x69, // 105 looks like raw item packet (no appearance update) thru shared bank..110, possibly possessions with appearance update
-//	ItemPacketLimbo				= /*106*/ 0x6A,
-//	ItemPacketWorldContainer	= /*107*/ 0x6B,
-//	ItemPacketTributeItem		= /*108*/ 0x6C,
-//	ItemPacketGuildTribute		= /*109*/ 0x6D, // missing from EQEmu
-//	ItemPacket10				= /*110*/ 0x6E,
-//	ItemPacket11				= /*111*/ 0x6F, // UF+ (equipment slots only) (RoF+ checks '(WORD*)slot + 4 != -1' [(WORD*)]slot + 2 would be bag index - if used) (guess) (appearance (over-level) items?)
-//	ItemPacket12				= /*112*/ 0x70, // RoF+ (causes stat update) (could be TrophyTribute and GuildTrophyTribute together - two case methodology - is it checking for GuildID?)
-//	ItemPacketMerchantRecovery	= /*113*/ 0x71,
-//	ItemPacket14				= /*115*/ 0x73, (real estate/moving crate?)
-//	ItemPacket__				= /*xxx*/ 0xXX // switch 'default' - all clients
-//};
-
 struct ItemPacket_Struct
 {
 /*00*/	ItemPacketType	PacketType;
@@ -1531,7 +1566,7 @@ struct DeleteItem_Struct {
 /*0012*/
 };
 
-struct MoveItem_Struct
+struct MoveItemOld_Struct
 {
 /*0000*/ uint32 from_slot;
 /*0004*/ uint32 to_slot;
@@ -1539,6 +1574,19 @@ struct MoveItem_Struct
 /*0012*/
 };
 
+struct MoveItem_Struct
+{
+	int16 from_type;
+	int16 from_slot;
+	int16 from_bag_slot;
+	int16 from_aug_slot;
+	int16 to_type;
+	int16 to_slot;
+	int16 to_bag_slot;
+	int16 to_aug_slot;
+	uint32 number_in_stack;
+};
+
 // both MoveItem_Struct/DeleteItem_Struct server structures will be changing to a structure-based slot format..this will
 // be used for handling SoF/SoD/etc... time stamps sent using the MoveItem_Struct format. (nothing will be done with this
 // info at the moment..but, it is forwarded on to the server for handling/future use)
@@ -1930,12 +1978,11 @@ Unknowns:
 
 
 struct Merchant_Sell_Struct {
-/*000*/	uint32	npcid;			// Merchant NPC's entity id
-/*004*/	uint32	playerid;		// Player's entity id
-/*008*/	uint32	itemslot;
-		uint32	unknown12;
-/*016*/	uint32	quantity;
-/*020*/ uint32	price;
+	uint32 npcid;
+	uint32 playerid;
+	uint32 itemslot;
+	int32 quantity;
+	uint32 price;
 };
 struct Merchant_Purchase_Struct {
 /*000*/	uint32	npcid;			// Merchant NPC's entity id
@@ -2071,7 +2118,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	EQEmu::ItemBase item;
+	ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 
@@ -2097,7 +2144,7 @@ struct Illusion_Struct { //size: 256 - SoF
 /*092*/	uint32	drakkin_heritage;	//
 /*096*/	uint32	drakkin_tattoo;		//
 /*100*/	uint32	drakkin_details;	//
-/*104*/	EQEmu::TintProfile	armor_tint;	//
+/*104*/	uint32	armor_tint[_MaterialCount];	//
 /*140*/	uint8	eyecolor1;		// Field Not Identified in any Illusion Struct
 /*141*/	uint8	eyecolor2;		// Field Not Identified in any Illusion Struct
 /*142*/	uint8	unknown138[114];	//
@@ -2508,25 +2555,23 @@ struct BookRequest_Struct {
 */
 struct Object_Struct {
 /*00*/	uint32	linked_list_addr[2];// They are, get this, prev and next, ala linked list
-/*08*/	float	size;				//
+/*08*/	uint16	size;				//
 /*10*/	uint16	solidtype;			//
 /*12*/	uint32	drop_id;			// Unique object id for zone
 /*16*/	uint16	zone_id;			// Redudant, but: Zone the object appears in
 /*18*/	uint16	zone_instance;		//
 /*20*/	uint32	unknown020;			//
 /*24*/	uint32	unknown024;			//
-/*28*/	float	tilt_x;
-/*32*/	float	tilt_y;
-/*36*/	float	heading;			// heading
-/*40*/	float	z;					// z coord
-/*44*/	float	x;					// x coord
-/*76*/	float	y;					// y coord
-/*80*/	char	object_name[32];	// Name of object, usually something like IT63_ACTORDEF
-/*84*/	uint32	unknown076;			//
-/*88*/	uint32	object_type;		// Type of object, not directly translated to OP_OpenObject
-/*92*/	uint32	unknown084;			//set to 0xFF
-		uint32	spawn_id;			// Spawn Id of client interacting with object
-
+/*28*/	float	heading;			// heading
+/*32*/	float	z;					// z coord
+/*36*/	float	x;					// x coord
+/*40*/	float	y;					// y coord
+/*44*/	char	object_name[32];	// Name of object, usually something like IT63_ACTORDEF
+/*76*/	uint32	unknown076;			//
+/*80*/	uint32	object_type;		// Type of object, not directly translated to OP_OpenObject
+/*84*/	uint32	unknown084;			//set to 0xFF
+/*88*/	uint32	spawn_id;			// Spawn Id of client interacting with object
+/*92*/
 };
 // 01 = generic drop, 02 = armor, 19 = weapon
 //[13:40] and 0xff seems to be indicative of the tradeskill/openable items that end up returning the old style item type in the OP_OpenObject
@@ -3369,6 +3414,27 @@ struct PetitionBug_Struct{
 	char	text[1028];
 };
 
+struct DyeStruct
+{
+	union
+	{
+		struct
+		{
+			struct Color_Struct head;
+			struct Color_Struct chest;
+			struct Color_Struct arms;
+			struct Color_Struct wrists;
+			struct Color_Struct hands;
+			struct Color_Struct legs;
+			struct Color_Struct feet;
+			struct Color_Struct primary;	// you can't actually dye this
+			struct Color_Struct secondary;	// or this
+		}
+		dyes;
+		struct Color_Struct dye[_MaterialCount];
+	};
+};
+
 struct ApproveZone_Struct {
 	char	name[64];
 	uint32	zoneid;
@@ -3426,8 +3492,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EQEmu::legacy::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQEmu::legacy::TRIBUTE_SIZE];		//all 00's
+	uint32	tributes[EmuConstants::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EmuConstants::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -4172,52 +4238,6 @@ struct UseAA_Struct {
 	uint32 end;
 };
 
-//new AA stuff
-//reference only
-struct AARankInfo_Struct
-{
-	uint32 id;
-	int32 upper_hotkey_sid;
-	int32 lower_hotkey_sid;
-	int32 title_sid;
-	int32 desc_sid;
-	int32 level_req;
-	int32 cost;
-	uint32 seq;
-	uint32 current_level;
-	uint32 type;
-	int32 spell;
-	int32 spell_type;
-	int32 spell_refresh;
-	int32 classes;
-	int32 max_level;
-	int32 prev_id;
-	int32 next_id;
-	int32 total_cost;
-	int32 expansion;
-	int32 category;
-	uint32 charges;
-	uint8 grant_only;
-	uint32 total_effects;
-	uint32 total_prereqs;
-};
-
-struct AARankPrereq_Struct
-{
-	int32 aa_id;
-	int32 points;
-};
-
-struct AARankEffect_Struct
-{
-	int32 effect_id;
-	int32 base1;
-	int32 base2;
-	int32 slot;
-};
-
-//old AA stuff
-
 struct AA_Ability {
 /*00*/	uint32 skill_id;
 /*04*/	uint32 base1;
@@ -4272,7 +4292,7 @@ struct SendAA_Struct {
 struct AA_Action {
 /*00*/	uint32	action;
 /*04*/	uint32	ability;
-/*08*/	uint32	target_id;
+/*08*/	uint32	unknown08;
 /*12*/	uint32	exp_value;
 };
 
@@ -4677,22 +4697,6 @@ struct GuildBankItemUpdate_Struct
 /*226*/	uint16	Unknown226;
 };
 
-// newer clients (RoF+) send a list that contains 240 entries
-// The packets don't actually use all 64 chars in the strings, but we'll just overallocate for these
-struct GuildBankItemListEntry_Struct
-{
-	uint8 vaild;
-	uint32 permissions;
-	char whofor[64];
-	char donator[64];
-	uint32 item_id;
-	uint32 item_icon;
-	uint32 quantity;
-	uint8 allow_merge; // 1 here for non-full stacks
-	uint8 usable;
-	char item_name[64];
-};
-
 struct GuildBankClear_Struct
 {
 /*00*/	uint32	Action;
@@ -4749,7 +4753,6 @@ struct BuffIcon_Struct
 	uint8  all_buffs;
 	uint16 count;
 	uint8 type; // 0 = self buff window, 1 = self target window, 4 = group, 5 = PC, 7 = NPC
-	int32 tic_timer;
 	BuffIconEntry_Struct entries[0];
 };
 
@@ -5296,18 +5299,21 @@ struct ClientMarqueeMessage_Struct {
 
 typedef std::list<ServerLootItem_Struct*> ItemList;
 
-
-struct fling_struct {
-/* 00 */ uint32 collision; // 0 collision is off, anything else it's on
-/* 04 */ int32 travel_time; // ms -- UF we need to calc this, RoF+ -1 auto calcs
-/* 08 */ uint8 unk3; // bool, set to 1 has something to do with z-axis or something weird things happen if the new Z is above or equal to yours
-/* 09 */ uint8 disable_fall_damage; // 1 you take no fall damage, 0 you take fall damage
-/* 10 */ uint8 padding[2];
-/* 12 */ float speed_z;
-/* 16 */ float new_y;
-/* 20 */ float new_x;
-/* 24 */ float new_z;
-/* 28 */
+struct TextLinkBody_Struct {
+	// Current server mask: EQClientRoF2
+	uint8 unknown_1;		/* %1X */
+	uint32 item_id;			/* %05X */
+	uint32 augment_1;		/* %05X */
+	uint32 augment_2;		/* %05X */
+	uint32 augment_3;		/* %05X */
+	uint32 augment_4;		/* %05X */
+	uint32 augment_5;		/* %05X */
+	uint32 augment_6;		/* %05X */
+	uint8 is_evolving;		/* %1X */
+	uint32 evolve_group;	/* %05X */
+	uint8 evolve_level;		/* %02X */
+	uint32 ornament_icon;	/* %05X */
+	int hash;				/* %08X */
 };
 
 // Restore structure packing to default

common/eq_stream.cpp

@@ -75,7 +75,7 @@ void EQStream::init(bool resetSession) {
 	sent_packet_count = 0;
 	received_packet_count = 0;
 	SequencedBase = 0;
-	AverageDelta = 500;
+	NextSequencedSend = 0;
 
 	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 		retransmittimer = Timer::GetCurrentTime();
@@ -86,6 +86,10 @@ void EQStream::init(bool resetSession) {
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 		Log.Out(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
+	
+	if(NextSequencedSend > SequencedQueue.size()) {
+		Log.Out(Logs::Detail, Logs::Netcode, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	}
 }
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
@@ -288,8 +292,10 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_KeepAlive: {
+#ifndef COLLECTOR
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
+#endif
 		}
 		break;
 		case OP_Ack: {
@@ -298,12 +304,14 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
+#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			AckPackets(seq);
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 				retransmittimer = Timer::GetCurrentTime();
 			}
+#endif
 		}
 		break;
 		case OP_SessionRequest: {
@@ -312,6 +320,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
+#ifndef COLLECTOR
 			if (GetState()==ESTABLISHED) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
 
@@ -324,6 +333,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					break;
 				}
 			}
+#endif
 			sessionAttempts++;
 			// we set established below, so statistics will not be reset for session attempts/stream active.
 			init(GetState()!=ESTABLISHED);
@@ -333,8 +343,10 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SetMaxLen(ntohl(Request->MaxLength));
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
+#ifndef COLLECTOR
 			Key=0x11223344;
 			SendSessionResponse();
+#endif
 		}
 		break;
 		case OP_SessionResponse: {
@@ -400,6 +412,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
+#ifndef COLLECTOR
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();
 
@@ -407,30 +420,36 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
+			if(NextSequencedSend > SequencedQueue.size()) {
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+			}
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
 			if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
-					seq, SequencedBase, SequencedBase+SequencedQueue.size());
+					seq, SequencedBase, SequencedBase+NextSequencedSend);
 
-				uint16 sqsize = SequencedQueue.size();
-				uint16 index = seq - SequencedBase;
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
-				if (index < sqsize) {
-					SequencedQueue[index]->acked = true;
-					// flag packets for a resend
-					uint16 count = 0;
-					uint32 timeout = AverageDelta * 2 + 100;
-					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
-						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
-							(*sitr)->sent_time = 0;
-							Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
-						}
+				bool retransmit_acked_packets = false;
+				if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
+					retransmit_acked_packets = RETRANSMIT_ACKED_PACKETS;
+				}
+
+				if(!retransmit_acked_packets) {
+					uint16 sqsize = SequencedQueue.size();
+					uint16 index = seq - SequencedBase;
+					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+					if (index < sqsize) {
+						std::deque<EQProtocolPacket *>::iterator sitr;
+						sitr = SequencedQueue.begin();
+						sitr += index;
+						(*sitr)->acked = true;
 					}
 				}
 
 				if(RETRANSMIT_TIMEOUT_MULT) {
 					retransmittimer = Timer::GetCurrentTime();
 				}
+
+				NextSequencedSend = 0;
 			} else {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
 			}
@@ -439,7 +458,11 @@ 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: {
@@ -448,6 +471,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
+#ifndef COLLECTOR
 			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(ClientStats->packets_received), (unsigned long)ntohl(ClientStats->packets_sent), (unsigned long)ntohl(ClientStats->last_local_delta),
@@ -465,7 +489,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					} else {
 						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);
@@ -482,6 +505,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			ServerStats->packets_received = htonll(GetPacketsReceived());
 
 			NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse, p->pBuffer, p->size));
+#endif
 		}
 		break;
 		case OP_SessionStatResponse: {
@@ -561,12 +585,12 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 	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());
 
-		auto tmpbuff = new unsigned char[p->size + 3];
+		unsigned char *tmpbuff=new unsigned char[p->size+3];
 		length=p->serialize(opcode, tmpbuff);
 		if (length != p->Size())
 			Log.Out(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
 
-		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
+		EQProtocolPacket *out=new EQProtocolPacket(OP_Fragment,nullptr,MaxLen-4);
 		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
@@ -587,10 +611,10 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 		delete[] tmpbuff;
 	} else {
 
-		auto tmpbuff = new unsigned char[p->Size() + 3];
+		unsigned char *tmpbuff=new unsigned char[p->Size()+3];
 		length=p->serialize(opcode, tmpbuff+2) + 2;
 
-		auto out = new EQProtocolPacket(OP_Packet, tmpbuff, length);
+		EQProtocolPacket *out=new EQProtocolPacket(OP_Packet,tmpbuff,length);
 
 		delete[] tmpbuff;
 		SequencedPush(out);
@@ -600,32 +624,42 @@ 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(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+}
+if(NextSequencedSend > SequencedQueue.size()) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+}
 
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
-		NextOutSeq, p->size, SequencedBase);
-	*(uint16 *)(p->pBuffer) = htons(NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase);
+	*(uint16 *)(p->pBuffer)=htons(NextOutSeq);
 	SequencedQueue.push_back(p);
 	NextOutSeq++;
 
-	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
-			SequencedBase, SequencedQueue.size(), NextOutSeq);
-	}
-
+if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+}
+if(NextSequencedSend > SequencedQueue.size()) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+}
 	MOutboundQueue.unlock();
+#endif
 }
 
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
+#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)
@@ -669,15 +703,21 @@ void EQStream::Write(int eq_fd)
 	// Place to hold the base packet t combine into
 	EQProtocolPacket *p=nullptr;
 
+	if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
+		// if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue
+		if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend &&
+			(GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) {
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
+				"buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend);
+			NextSequencedSend = 0;
+			retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet
+		}
+	}
+
 	// Find the next sequenced packet to send from the "queue"
 	sitr = SequencedQueue.begin();
-
-	uint16 count = 0;
-	// get to start of packets
-	while (sitr != SequencedQueue.end() && (*sitr)->sent_time > 0) {
-		++sitr;
-		++count;
-	}
+	if (sitr!=SequencedQueue.end())
+	sitr += NextSequencedSend;
 
 	// Loop until both are empty or MaxSends is reached
 	while(!SeqEmpty || !NonSeqEmpty) {
@@ -691,7 +731,7 @@ void EQStream::Write(int eq_fd)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
-				// Trying to combine this packet with the base didn't work (too big maybe)
+				// Tryint to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
@@ -714,9 +754,16 @@ void EQStream::Write(int eq_fd)
 			NonSeqEmpty=true;
 		}
 
-		if (sitr != SequencedQueue.end()) {
-			uint16 seq_send = SequencedBase + count;	//just for logging...
+		if (sitr!=SequencedQueue.end()) {
+			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
+			}
 
+			if(NextSequencedSend > SequencedQueue.size()) {
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+			}
+			uint16 seq_send = SequencedBase + NextSequencedSend;	//just for logging...
+			
 			if(SequencedQueue.empty()) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
@@ -724,61 +771,17 @@ void EQStream::Write(int eq_fd)
 			}
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
-				if ((*sitr)->acked || (*sitr)->sent_time != 0) {
-					++sitr;
-					++count;
-					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
-						ReadyToSend.push(p);
-						BytesWritten += p->size;
-						p = nullptr;
-					}
+				if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
+					sitr++;
+					NextSequencedSend++;
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
-					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
-					++count;
-				} else if (!p->combine(*sitr)) {
-					// Trying to combine this packet with the base didn't work (too big maybe)
-					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
-					ReadyToSend.push(p);
-					BytesWritten+=p->size;
-					p=nullptr;
-					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
-						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
-						break;
-					}
-				} else {
-					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
-					(*sitr)->sent_time = Timer::GetCurrentTime();
-					++sitr;
-					++count;
-				}
-			} else {
-				if ((*sitr)->sent_time != 0) {
-					++sitr;
-					++count;
-					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
-						ReadyToSend.push(p);
-						BytesWritten += p->size;
-						p = nullptr;
-					}
-				} else if (!p) {
-					// If we don't have a packet to try to combine into, use this one as the base
-					// Copy it first as it will still live until it is acked
-					p=(*sitr)->Copy();
-					(*sitr)->sent_time = Timer::GetCurrentTime();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
-					++sitr;
-					++count;
+					NextSequencedSend++;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
@@ -794,16 +797,45 @@ void EQStream::Write(int eq_fd)
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
-					(*sitr)->sent_time = Timer::GetCurrentTime();
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
 					++sitr;
-					++count;
+					NextSequencedSend++;
+				}
+			} else {
+				if (!p) {
+					// If we don't have a packet to try to combine into, use this one as the base
+					// Copy it first as it will still live until it is acked
+					p=(*sitr)->Copy();
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					++sitr;
+					NextSequencedSend++;
+				} else if (!p->combine(*sitr)) {
+					// Trying to combine this packet with the base didn't work (too big maybe)
+					// So just send the base packet (we'll try this packet again later)
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					ReadyToSend.push(p);
+					BytesWritten+=p->size;
+					p=nullptr;
+
+					if (BytesWritten > threshold) {
+						// Sent enough this round, lets stop to be fair
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						break;
+					}
+				} else {
+					// Combine worked
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					++sitr;
+					NextSequencedSend++;
 				}
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
 				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
+			if(NextSequencedSend > SequencedQueue.size()) {
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+			}
 		} else {
 			// No more sequenced packets
 			SeqEmpty=true;
@@ -862,11 +894,9 @@ sockaddr_in address;
 	length=p->serialize(buffer);
 	if (p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
 		if (compressed) {
-			BytesWritten -= p->size;
 			uint32 newlen=EQProtocolPacket::Compress(buffer,length, _tempBuffer, 2048);
 			memcpy(buffer,_tempBuffer,newlen);
 			length=newlen;
-			BytesWritten += newlen;
 		}
 		if (encoded) {
 			EQProtocolPacket::ChatEncode(buffer,length,Key);
@@ -882,7 +912,7 @@ sockaddr_in address;
 
 void EQStream::SendSessionResponse()
 {
-	auto out = new EQProtocolPacket(OP_SessionResponse, nullptr, sizeof(SessionResponse));
+EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(SessionResponse));
 	SessionResponse *Response=(SessionResponse *)out->pBuffer;
 	Response->Session=htonl(Session);
 	Response->MaxLength=htonl(MaxLen);
@@ -904,7 +934,7 @@ void EQStream::SendSessionResponse()
 
 void EQStream::SendSessionRequest()
 {
-	auto out = new EQProtocolPacket(OP_SessionRequest, nullptr, sizeof(SessionRequest));
+EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(SessionRequest));
 	SessionRequest *Request=(SessionRequest *)out->pBuffer;
 	memset(Request,0,sizeof(SessionRequest));
 	Request->Session=htonl(time(nullptr));
@@ -920,7 +950,7 @@ void EQStream::_SendDisconnect()
 	if(GetState() == CLOSED)
 		return;
 
-	auto out = new EQProtocolPacket(OP_SessionDisconnect, nullptr, sizeof(uint32));
+	EQProtocolPacket *out=new EQProtocolPacket(OP_SessionDisconnect,nullptr,sizeof(uint32));
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
@@ -939,8 +969,8 @@ EQApplicationPacket *EQStream::PopPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -964,8 +994,8 @@ EQRawApplicationPacket *EQStream::PopRawPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 		InboundQueue.erase(itr);
 	}
@@ -991,8 +1021,8 @@ EQRawApplicationPacket *EQStream::PeekPacket()
 EQRawApplicationPacket *p=nullptr;
 
 	MInboundQueue.lock();
-	if (!InboundQueue.empty()) {
-		auto itr = InboundQueue.begin();
+	if (InboundQueue.size()) {
+		std::vector<EQRawApplicationPacket *>::iterator itr=InboundQueue.begin();
 		p=*itr;
 	}
 	MInboundQueue.unlock();
@@ -1128,6 +1158,13 @@ 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) {
@@ -1143,21 +1180,28 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 		//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, SequencedQueue.size());
-				SequencedBase = NextOutSeq;
-				break;
-			}
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
+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);
 			//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(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
+}
+if(NextSequencedSend > SequencedQueue.size()) {
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+}
 	}
 
 	MOutboundQueue.unlock();
@@ -1335,18 +1379,6 @@ 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)
@@ -1354,24 +1386,18 @@ 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

@@ -153,6 +153,7 @@ class EQStream : public EQStreamInterface {
 		std::deque<EQProtocolPacket *> SequencedQueue;
 		uint16 NextOutSeq;
 		uint16 SequencedBase;	//the sequence number of SequencedQueue[0]
+		long NextSequencedSend;	//index into SequencedQueue
 		Mutex MOutboundQueue;
 
 		//a buffer we use for compression/decompression
@@ -173,7 +174,7 @@ class EQStream : public EQStreamInterface {
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
-		uint32 AverageDelta;
+
 
 		OpcodeManager **OpMgr;
 
@@ -241,7 +242,7 @@ class EQStream : public EQStreamInterface {
 		virtual bool CheckState(EQStreamState state) { return GetState() == state; }
 		virtual std::string Describe() const { return("Direct EQStream"); }
 
-		virtual void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
+		void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
 
 		void CheckTimeout(uint32 now, uint32 timeout=30);
 		bool HasOutgoingData();
@@ -250,13 +251,13 @@ class EQStream : public EQStreamInterface {
 		void Write(int eq_fd);
 
 		// whether or not the stream has been assigned (we passed our stream match)
-		virtual void SetActive(bool val) { streamactive = val; }
+		void SetActive(bool val) { streamactive = val; }
 
 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }
 
-		virtual EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
+		inline EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
 
 		static SeqOrder CompareSequence(uint16 expected_seq , uint16 seq);
 
@@ -306,7 +307,19 @@ class EQStream : public EQStreamInterface {
 		const uint64 GetPacketsReceived() { return received_packet_count; }
 
 		//used for dynamic stream identification
-		virtual MatchState CheckSignature(const Signature *sig);
+		class Signature {
+		public:
+			//this object could get more complicated if needed...
+			uint16 ignore_eq_opcode;		//0=dont ignore
+			uint16 first_eq_opcode;
+			uint32 first_length;			//0=dont check length
+		};
+		typedef enum {
+			MatchNotReady,
+			MatchSuccessful,
+			MatchFailed
+		} MatchState;
+		MatchState CheckSignature(const Signature *sig);
 
 };
 

common/eq_stream_factory.cpp

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

common/eq_stream_ident.cpp

@@ -1,5 +1,3 @@
-#include <utility>
-
 #include "global_define.h"
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
@@ -26,8 +24,8 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 	}
 }
 
-void EQStreamIdentifier::RegisterPatch(const EQStreamInterface::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
-	auto p = new Patch;
+void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
+	Patch *p = new Patch;
 	p->signature = sig;
 	p->name = name;
 	p->opcodes = opcodes;
@@ -144,7 +142,7 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }
 
-void EQStreamIdentifier::AddStream(std::shared_ptr<EQStreamInterface> &eqs) {
+void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
 	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
@@ -157,8 +155,8 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }
 
-EQStreamIdentifier::Record::Record(std::shared_ptr<EQStreamInterface> s)
-:	stream(std::move(s)),
+EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
+:	stream(s),
 	expire(STREAM_IDENT_WAIT_MS)
 {
 }

common/eq_stream_ident.h

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

common/eq_stream_intf.h

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

common/eq_stream_proxy.cpp

@@ -5,7 +5,7 @@
 #include "struct_strategy.h"
 
 
-EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -21,19 +21,9 @@ std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
+const ClientVersion EQStreamProxy::GetClientVersion() const
 {
-	return m_structs->ClientVersion();
-}
-
-EQStreamState EQStreamProxy::GetState()
-{
-	return m_stream->GetState();
-}
-
-void EQStreamProxy::SetOpcodeManager(OpcodeManager **opm)
-{
-	return m_stream->SetOpcodeManager(opm);
+	return m_structs->GetClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {

common/eq_stream_proxy.h

@@ -14,7 +14,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();
 
 	//EQStreamInterface:
@@ -28,9 +28,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const EQEmu::versions::ClientVersion ClientVersion() const;
-	virtual EQStreamState GetState();
-	virtual void SetOpcodeManager(OpcodeManager **opm);
+	virtual const ClientVersion GetClientVersion() const;
 
 	virtual const uint32 GetBytesSent() const;
 	virtual const uint32 GetBytesRecieved() const;
@@ -38,8 +36,8 @@ public:
 	virtual const uint32 GetBytesRecvPerSecond() const;
 
 protected:
-	std::shared_ptr<EQStreamInterface> const m_stream;	//we own this stream object.
-	const StructStrategy *const	m_structs;	//we do not own this object.
+	std::shared_ptr<EQStream> const					m_stream;	//we own this stream object.
+	const StructStrategy *const		m_structs;	//we do not own this object.
 	//this is a pointer to a pointer to make it less likely that a packet will
 	//reference an invalid opcode manager when they are being reloaded.
 	OpcodeManager **const			m_opcodes;	//we do not own this object.

common/eqdb.cpp

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

common/eqemu_config.cpp

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

common/eqemu_config.h

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

common/eqemu_logsys.cpp

@@ -102,7 +102,6 @@ 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
@@ -117,7 +116,7 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		platform_file_name = "ucs";
 	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
 		platform_file_name = "login";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
 		platform_file_name = "launcher";
 }
 

common/eqemu_logsys.h

@@ -82,8 +82,6 @@ namespace Logs {
 		Client_Server_Packet_Unhandled,
 		Server_Client_Packet_With_Dump,
 		Client_Server_Packet_With_Dump,
-		Login_Server,
-		Client_Login,
 		MaxCategoryID	/* Don't Remove this*/
 	};
 
@@ -132,8 +130,6 @@ namespace Logs {
 		"Packet :: Client -> Server Unhandled",
 		"Packet :: Server -> Client (Dump)",
 		"Packet :: Client -> Server (Dump)",
-		"Login Server",
-		"Client Login"
 	};
 }
 

common/eqtime.cpp

@@ -133,6 +133,72 @@ int EQTime::SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t 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)
 		return(true);

common/eqtime.h

@@ -39,6 +39,12 @@ public:
 
 	static void ToString(TimeOfDay_Struct *t, std::string &str);
 
+	//Database functions
+	//bool loadDB(Database q);
+	//bool setDB(Database q);
+	bool loadFile(const char *filename);
+	bool saveFile(const char *filename);
+
 private:
 	//This is our reference clock.
 	eqTimeOfDay eqTime;

common/extprofile.h

@@ -40,7 +40,7 @@ struct ExtendedProfile_Struct {
 	uint16				old_pet_hp; /* Not Used */
 	uint16				old_pet_mana; /* Not Used */
 	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
-	EQEmu::TextureShortProfile	pet_items; /* Not Used */
+	uint32				pet_items[_MaterialCount]; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */
@@ -54,8 +54,6 @@ struct ExtendedProfile_Struct {
 	uint32				mercTimerRemaining; /* Not Used */
 	uint8				mercGender; /* Not Used */
 	int32				mercState; /* Not Used */
-	uint32				last_invsnapshot_time; /* Used */
-	uint32				next_invsnapshot_time; /* Used */
 };
 
 #pragma pack()

common/features.h

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

common/global_define.h

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

common/guild_base.cpp

@@ -179,7 +179,7 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 	}
 
 	//make the new entry and store it into the map.
-	auto info = new GuildInfo;
+	GuildInfo *info = new GuildInfo;
 	info->name = guild_name;
 	info->leader_char_id = leader_char_id;
 	info->minstatus = minstatus;
@@ -236,9 +236,9 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	results = m_db->QueryDatabase(query);
 
 	//escape our strings.
-	auto name_esc = new char[info->name.length() * 2 + 1];
-	auto motd_esc = new char[info->motd.length() * 2 + 1];
-	auto motd_set_esc = new char[info->motd_setter.length() * 2 + 1];
+	char *name_esc = new char[info->name.length()*2+1];
+	char *motd_esc = new char[info->motd.length()*2+1];
+	char *motd_set_esc = new char[info->motd_setter.length()*2+1];
 	m_db->DoEscapeString(name_esc, info->name.c_str(), info->name.length());
 	m_db->DoEscapeString(motd_esc, info->motd.c_str(), info->motd.length());
 	m_db->DoEscapeString(motd_set_esc, info->motd_setter.c_str(), info->motd_setter.length());
@@ -264,7 +264,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 	for(rank = 0; rank <= GUILD_MAX_RANK; rank++) {
 		const RankInfo &rankInfo = info->ranks[rank];
 
-		auto title_esc = new char[rankInfo.name.length() * 2 + 1];
+		char *title_esc = new char[rankInfo.name.length()*2+1];
 		m_db->DoEscapeString(title_esc, rankInfo.name.c_str(), rankInfo.name.length());
 
         query = StringFormat("INSERT INTO guild_ranks "
@@ -564,7 +564,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 
 	//escape our strings.
 	uint32 len = strlen(name);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, name, len);
 
 	//insert the new `guilds` entry
@@ -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);
-	auto esc = new char[len * 2 + 1];
-	auto esc_set = new char[len2 * 2 + 1];
+	char *esc = new char[len*2+1];
+	char *esc_set = new char[len2*2+1];
 	m_db->DoEscapeString(esc, motd, len);
 	m_db->DoEscapeString(esc_set, setter, len2);
 
@@ -675,7 +675,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 	//escape our strings.
 	uint32 len = strlen(URL);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, URL, len);
 
     std::string query = StringFormat("UPDATE guilds SET url='%s' WHERE id=%d", esc, GuildID);
@@ -709,7 +709,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 
 	//escape our strings.
 	uint32 len = strlen(Channel);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, Channel, len);
 
     std::string query = StringFormat("UPDATE guilds SET channel='%s' WHERE id=%d", esc, GuildID);
@@ -832,7 +832,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 
 	//escape our strings.
 	uint32 len = strlen(note);
-	auto esc = new char[len * 2 + 1];
+	char *esc = new char[len*2+1];
 	m_db->DoEscapeString(esc, note, len);
 
 	//insert the new `guilds` entry
@@ -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.`last_login`, c.`zone_id`," \
-" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
-" g.`banker`, g.`public_note`, g.`alt`" \
-" FROM `vw_bot_character_mobs` AS c LEFT JOIN `vw_guild_members` AS g ON c.`id` = g.`char_id` AND c.`mob_type` = g.`mob_type` "
+"SELECT c.id,c.name,c.class,c.level,c.timelaston,c.zoneid," \
+" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
+" g.banker,g.public_note,g.alt" \
+" FROM vwBotCharacterMobs AS c LEFT JOIN vwGuildMembers AS g ON c.id=g.char_id AND c.mobtype = g.mobtype "
 #else
 #define GuildMemberBaseQuery \
-"SELECT c.`id`, c.`name`, c.`class`, c.`level`, c.`last_login`, c.`zone_id`," \
-" g.`guild_id`, g.`rank`, g.`tribute_enable`, g.`total_tribute`, g.`last_tribute`," \
-" g.`banker`, g.`public_note`, g.`alt` " \
-" FROM `character_data` AS c LEFT JOIN `guild_members` AS g ON c.`id` = g.`char_id` "
+"SELECT c.id,c.name,c.class,c.level,c.last_login,c.zone_id," \
+" g.guild_id,g.rank,g.tribute_enable,g.total_tribute,g.last_tribute," \
+" g.banker,g.public_note,g.alt " \
+" FROM `character_data` AS c LEFT JOIN guild_members AS g ON c.id=g.char_id "
 #endif
 static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
 	//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) {
-		auto ci = new CharGuildInfo;
+    for (auto row = results.begin(); row != results.end(); ++row) {
+		CharGuildInfo *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);
-	auto esc = new char[nl * 2 + 1];
+	char *esc = new char[nl*2+1];
 	m_db->DoEscapeString(esc, char_name, nl);
 
 	//load up the rank info for each guild.
@@ -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.mob_type = 'C'", char_id);
+    query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id);
 #else
     query = StringFormat(GuildMemberBaseQuery " WHERE c.id=%d", char_id);
 #endif
@@ -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);
-	auto buffer = new uint8[length];
+	uint8 *buffer = new uint8[length];
 
 	//a bit little better than memsetting the whole thing...
 	uint32 r,pos;

common/inventory.cpp

@@ -0,0 +1,782 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 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.h"
+#include "inventory_null_data_model.h"
+#include "item_container_personal_serialization.h"
+#include "data_verification.h"
+#include "string_util.h"
+#include <map>
+
+bool EQEmu::InventorySlot::IsValid() const {
+	if(type_ == InvTypePersonal && EQEmu::ValueWithin(slot_, PersonalSlotCharm, PersonalSlotCursor)) {
+		return true;
+	}
+
+	if(type_ == InvTypeBank && EQEmu::ValueWithin(slot_, 0, 23)) {
+		return true;
+	}
+
+	if(type_ == InvTypeSharedBank && EQEmu::ValueWithin(slot_, 0, 1)) {
+		return true;
+	}
+
+	if(type_ == InvTypeTribute && EQEmu::ValueWithin(slot_, 0, 4)) {
+		return true;
+	}
+
+	if(type_ == InvTypeTrade && EQEmu::ValueWithin(slot_, 0, 7)) {
+		return true;
+	}
+
+	if(type_ == InvTypeWorld && EQEmu::ValueWithin(slot_, 0, 255)) {
+		return true;
+	}
+
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsDelete() const {
+	return type_ == -1 && slot_ == -1 && bag_index_ == -1 && aug_index_ == -1;
+}
+
+bool EQEmu::InventorySlot::IsBank() const {
+	if(type_ == InvTypeBank && EQEmu::ValueWithin(slot_, 0, 23)) {
+		return true;
+	}
+
+	if(type_ == InvTypeSharedBank && EQEmu::ValueWithin(slot_, 0, 1)) {
+		return true;
+	}
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsCursor() const {
+	if(type_ == InvTypePersonal && slot_ == PersonalSlotCursor) {
+		return true;
+	}
+
+	if(type_ == InvTypeCursorBuffer) {
+		return true;
+	}
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsEquipment() const {
+	if(type_ == InvTypePersonal && EQEmu::ValueWithin(slot_, PersonalSlotCharm, PersonalSlotAmmo)) {
+		return true;
+	}
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsGeneral() const {
+	if(type_ == InvTypePersonal && EQEmu::ValueWithin(slot_, PersonalSlotGeneral1, PersonalSlotGeneral10)) {
+		return true;
+	}
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsWeapon() const {
+	if(type_ == InvTypePersonal && 
+	   (EQEmu::ValueWithin(slot_, PersonalSlotPrimary, PersonalSlotSecondary) || slot_ == PersonalSlotRange))
+	{
+		return true;
+	}
+
+	return false;
+}
+
+bool EQEmu::InventorySlot::IsTrade() const {
+	if(type_ == InvTypeTrade) {
+		return true;
+	}
+
+	return false;
+}
+
+const std::string EQEmu::InventorySlot::ToString() const {
+	return StringFormat("(%i, %i, %i, %i)", type_, slot_, bag_index_, aug_index_);
+}
+
+struct EQEmu::Inventory::impl
+{
+	std::map<int, ItemContainer> containers_;
+	int race_;
+	int class_;
+	int deity_;
+	std::unique_ptr<InventoryDataModel> data_model_;
+};
+
+EQEmu::Inventory::Inventory(int race, int class_, int deity) {
+	impl_ = new impl;
+	impl_->race_ = race;
+	impl_->class_ = class_;
+	impl_->deity_ = deity;
+	impl_->data_model_ = std::unique_ptr<InventoryDataModel>(new InventoryNullDataModel());
+}
+
+EQEmu::Inventory::~Inventory() {
+	delete impl_;
+}
+
+void EQEmu::Inventory::SetRace(int race) {
+	impl_->race_ = race;
+}
+
+void EQEmu::Inventory::SetClass(int class_) {
+	impl_->class_ = class_;
+}
+
+void EQEmu::Inventory::SetDeity(int deity) {
+	impl_->deity_ = deity;
+}
+
+void EQEmu::Inventory::SetDataModel(InventoryDataModel *dm) {
+	impl_->data_model_ = std::unique_ptr<InventoryDataModel>(dm);
+}
+
+EQEmu::ItemInstance::pointer EQEmu::Inventory::Get(const InventorySlot &slot) {
+	auto iter = impl_->containers_.find(slot.Type());
+	if(iter != impl_->containers_.end()) {
+		auto item = iter->second.Get(slot.Slot());
+		if(item) {
+			if(slot.BagIndex() > -1) {
+				auto sub_item = item->Get(slot.BagIndex());
+				if(sub_item) {
+					if(slot.AugIndex() > -1) {
+						return sub_item->Get(slot.AugIndex());
+					} else {
+						return sub_item;
+					}
+				}
+			} else {
+				return item;
+			}
+		}
+	}
+
+	return ItemInstance::pointer(nullptr);
+}
+
+bool EQEmu::Inventory::Put(const InventorySlot &slot, ItemInstance::pointer &inst) {
+	if(impl_->containers_.count(slot.Type()) == 0) {
+		if(slot.Type() == 0) {
+			impl_->containers_.insert(std::pair<int, ItemContainer>(slot.Type(), ItemContainer(new ItemContainerPersonalSerialization())));
+		} else {
+			impl_->containers_.insert(std::pair<int, ItemContainer>(slot.Type(), ItemContainer()));
+		}
+	}
+
+	//Verify item can be put into the slot requested
+
+	auto &container = impl_->containers_[slot.Type()];
+	if(slot.BagIndex() > -1) {
+		auto item = container.Get(slot.Slot());
+		if(!item)
+			return false;
+
+		if(slot.AugIndex() > -1) {
+			auto bag_item = item->Get(slot.BagIndex());
+			if(!bag_item) {
+				return false;
+			}
+			
+			return bag_item->Put(slot.AugIndex(), inst);
+		} else {
+			return item->Put(slot.BagIndex(), inst);
+		}
+	} else {
+		if(slot.AugIndex() > -1) {
+			auto item = container.Get(slot.Slot());
+			if(!item)
+				return false;
+
+			return item->Put(slot.AugIndex(), inst);
+		}
+
+		return container.Put(slot.Slot(), inst);
+	}
+
+	return false;
+}
+
+bool EQEmu::Inventory::Swap(const InventorySlot &src, const InventorySlot &dest, int charges) {
+	if(src == dest) {
+		return true;
+	}
+
+	if(!src.IsValid()) {
+		return false;
+	}
+
+	if(src.Type() == InvTypeCursorBuffer || dest.Type() == InvTypeCursorBuffer) {
+		return true;
+	}
+
+	if(dest.IsDelete()) {
+		impl_->data_model_->Begin();
+		bool v = _destroy(src);
+		if(v) {
+			impl_->data_model_->Commit();
+		}
+		else {
+			impl_->data_model_->Rollback();
+		}
+
+		return v;
+	}
+
+	if(!dest.IsValid()) {
+		return false;
+	}
+
+	auto i_src = Get(src);
+	auto i_dest = Get(dest);
+
+	if(!i_src) {
+		return false;
+	}
+
+	if(i_src->GetBaseItem()->ItemClass == ItemClassContainer && dest.BagIndex() > -1) {
+		if(i_src->GetContainer()->Size() > 0) {
+			return false;
+		}
+	}
+
+	if(dest.IsEquipment() && !CanEquip(i_src, dest)) {
+		return false;
+	}
+
+	//Check this -> trade no drop
+	if(dest.IsTrade() && i_src->IsNoDrop()) {
+		return false;
+	}
+
+	impl_->data_model_->Begin();
+	if(i_src->IsStackable()) {
+		//move # charges from src to dest
+
+		//0 means *all* the charges
+		if(charges == 0) {
+			charges = i_src->GetCharges();
+		}
+
+		//src needs to have that many charges
+		if(i_src->GetCharges() < charges) {
+			impl_->data_model_->Rollback();
+			return false;
+		}
+
+		//if dest exists it needs to not only be the same item id but also be able to hold enough charges to combine
+		//we can also swap if src id != dest id
+		if(i_dest) {
+			uint32 src_id = i_src->GetBaseItem()->ID;
+			uint32 dest_id = i_dest->GetBaseItem()->ID;
+			if(src_id != dest_id) {
+				bool v = _swap(src, dest);
+				if(v) {
+					impl_->data_model_->Commit();
+				}
+				else {
+					impl_->data_model_->Rollback();
+				}
+
+				return v;
+			}
+
+			int charges_avail = i_dest->GetBaseItem()->StackSize - i_dest->GetCharges();
+			if(charges_avail < charges) {
+				impl_->data_model_->Rollback();
+				return false;
+			}
+
+			if(i_src->GetCharges() == charges) {
+				if(!_destroy(src)) {
+					impl_->data_model_->Rollback();
+					return false;
+				}
+			} else {
+				i_src->SetCharges(i_src->GetCharges() - charges);
+				impl_->data_model_->Insert(src, i_src);
+			}
+
+			i_dest->SetCharges(i_dest->GetCharges() + charges);
+			impl_->data_model_->Delete(dest);
+			impl_->data_model_->Insert(dest, i_dest);
+			impl_->data_model_->Commit();
+			return true;
+		} else {
+			//if dest does not exist and src charges > # charges then we need to create a new item with # charges in dest
+			//if dest does not exist and src charges == # charges then we need to swap src to dest
+			if(i_src->GetCharges() > charges) {
+				auto split = i_src->Split(charges);
+				if(!split) {
+					impl_->data_model_->Rollback();
+					return false;
+				}
+
+				Put(dest, split);
+				impl_->data_model_->Delete(src);
+				impl_->data_model_->Delete(dest);
+				impl_->data_model_->Insert(src, i_src);
+				impl_->data_model_->Insert(dest, split);
+				impl_->data_model_->Commit();
+				return true;
+			} else {
+				bool v = _swap(src, dest);
+				if(v) {
+					impl_->data_model_->Commit();
+				} else {
+					impl_->data_model_->Rollback();
+				}
+
+				return v;
+			}
+		}
+	} else {
+		bool v = _swap(src, dest);
+		if(v) {
+			impl_->data_model_->Commit();
+		}
+		else {
+			impl_->data_model_->Rollback();
+		}
+
+		return v;
+	}
+
+	impl_->data_model_->Commit();
+	return true;
+}
+
+bool EQEmu::Inventory::Summon(const InventorySlot &slot, ItemInstance::pointer &inst) {
+	if(!inst)
+		return false;
+
+	if(CheckLoreConflict(inst->GetBaseItem())) {
+		return false;
+	}
+
+	auto cur = Get(slot);
+	if(cur) {
+		if(slot.IsCursor()) {
+			PushToCursorBuffer(inst);
+		}
+
+		return false;
+	}
+
+	impl_->data_model_->Begin();
+	bool v = Put(slot, inst);
+	if(v) {
+		impl_->data_model_->Insert(slot, inst);
+		impl_->data_model_->Commit();
+	} else {
+		impl_->data_model_->Rollback();
+	}
+
+	return v;
+}
+
+bool EQEmu::Inventory::PushToCursorBuffer(ItemInstance::pointer &inst) {
+	if(impl_->containers_.count(InvTypeCursorBuffer) == 0) {
+		impl_->containers_.insert(std::pair<int, ItemContainer>(InvTypeCursorBuffer, ItemContainer()));
+	}
+
+	int32 top = 0;
+	auto &container = impl_->containers_[InvTypeCursorBuffer];
+	auto iter = container.Begin();
+	while(iter != container.End()) {
+		top = iter->first;
+		++iter;
+	}
+
+	InventorySlot slot(InvTypeCursorBuffer, top + 1);
+	impl_->data_model_->Begin();
+	bool v = Put(slot, inst);
+	if(v) {
+		impl_->data_model_->Insert(slot, inst);
+		impl_->data_model_->Commit();
+	}
+	else {
+		impl_->data_model_->Rollback();
+	}
+
+	return v;
+}
+
+bool EQEmu::Inventory::PopFromCursorBuffer() {
+	InventorySlot cursor(InvTypePersonal, PersonalSlotCursor);
+	auto inst = Get(cursor);
+	if(inst) {
+		return false;
+	}
+
+	if(impl_->containers_.count(InvTypeCursorBuffer) == 0) {
+		return false;
+	}
+
+	int32 top = 0;
+	auto &container = impl_->containers_[InvTypeCursorBuffer];
+	auto iter = container.Begin();
+	while(iter != container.End()) {
+		top = iter->first;
+		++iter;
+	}
+
+	InventorySlot slot(InvTypeCursorBuffer, top);
+	inst = Get(slot);
+
+	if(inst) {
+		impl_->data_model_->Begin();
+
+		bool v = _destroy(slot);
+		impl_->data_model_->Delete(slot);
+
+		if(!v) {
+			impl_->data_model_->Rollback();
+			return false;
+		}
+
+		v = Put(cursor, inst);
+		impl_->data_model_->Insert(cursor, inst);
+		if(!v) {
+			impl_->data_model_->Rollback();
+			return false;
+		}
+
+		impl_->data_model_->Commit();
+		return true;
+	}
+
+	return false;
+}
+
+EQEmu::InventorySlot EQEmu::Inventory::FindFreeSlot(ItemInstance::pointer &inst, int container_id, int slot_id_start, int slot_id_end) {
+	bool for_bag = inst->GetItem()->ItemClass == ItemClassContainer;
+	int min_size = inst->GetItem()->Size;
+	bool is_arrow = inst->GetItem()->ItemType == ItemTypeArrow;
+
+	//check upper level inventory
+	for(int i = slot_id_start; i <= slot_id_end; ++i) {
+		EQEmu::InventorySlot slot(container_id, i);
+		if(!Get(slot)) {
+			return slot;
+		}
+	}
+	
+	//if not for a bag then check inside bags
+	if (!for_bag) {
+		for(int i = slot_id_start; i <= slot_id_end; ++i) {
+			EQEmu::InventorySlot slot(container_id, i);
+			auto inst = Get(slot);
+
+			if(inst && inst->GetBaseItem()->ItemClass == ItemClassContainer && inst->GetBaseItem()->BagSize >= min_size)
+			{
+				if(inst->GetBaseItem()->BagType == BagTypeQuiver && !is_arrow)
+				{
+					continue;
+				}
+
+				int slots = inst->GetBaseItem()->BagSlots;
+				for(int b_i = 0; b_i < slots; ++b_i) {
+					EQEmu::InventorySlot bag_slot(container_id, i, b_i);
+
+					if(!Get(bag_slot)) {
+						return bag_slot;
+					}
+				}
+			}
+		}
+	}
+
+	return EQEmu::InventorySlot();
+}
+
+int EQEmu::Inventory::FindFreeStackSlots(ItemInstance::pointer &inst, int container_id, int slot_id_start, int slot_id_end) {
+	if(!inst->IsStackable()) {
+		return 0;
+	}
+
+	bool is_arrow = inst->GetItem()->ItemType == ItemTypeArrow;
+	int item_id = inst->GetItem()->ID;
+
+	int charges_to_check = inst->GetCharges();
+	int charges = 0;
+
+	auto iter = impl_->containers_.find(container_id);
+	if(iter == impl_->containers_.end()) {
+		return 0;
+	}
+
+	auto &container = iter->second;
+	for(int i = slot_id_start; i <= slot_id_end; ++i) {
+		auto current = container.Get(i);
+		if(!current) {
+			continue;
+		}
+
+		if(current->GetItem()->ID == item_id) {
+			int free_charges = current->GetItem()->StackSize - current->GetCharges();
+			if(free_charges)
+				charges += free_charges;
+
+			if(charges >= charges_to_check) {
+				return charges_to_check;
+			}
+		} else if(current->GetItem()->ItemClass == ItemClassContainer) {
+			int sz = current->GetItem()->BagSlots;
+			for(int i = 0; i < sz; ++i) {
+				auto sub_item = current->Get(i);
+				if(!sub_item) {
+					continue;
+				}
+
+				if(sub_item->GetItem()->ID == item_id) {
+					int free_charges = sub_item->GetItem()->StackSize - sub_item->GetCharges();
+					if(free_charges)
+						charges += free_charges;
+
+					if(charges >= charges_to_check) {
+						return charges_to_check;
+					}
+				}
+			}
+		}
+	}
+
+	if(charges >= charges_to_check) {
+		return charges_to_check;
+	}
+
+	return charges;
+}
+
+void EQEmu::Inventory::UpdateSlot(const InventorySlot &slot, ItemInstance::pointer &inst) {
+	impl_->data_model_->Begin();
+
+	impl_->data_model_->Delete(slot);
+	if(inst) {
+		impl_->data_model_->Insert(slot, inst);
+	}
+
+	impl_->data_model_->Commit();
+}
+
+int EQEmu::Inventory::CalcMaterialFromSlot(const InventorySlot &slot) {
+	if(slot.Type() != 0)
+		return _MaterialInvalid;
+
+	switch(slot.Slot()) {
+	case PersonalSlotHead:
+		return MaterialHead;
+	case PersonalSlotChest:
+		return MaterialChest;
+	case PersonalSlotArms:
+		return MaterialArms;
+	case PersonalSlotWrist1:
+		return MaterialWrist;
+	case PersonalSlotHands:
+		return MaterialHands;
+	case PersonalSlotLegs:
+		return MaterialLegs;
+	case PersonalSlotFeet:
+		return MaterialFeet;
+	case PersonalSlotPrimary:
+		return MaterialPrimary;
+	case PersonalSlotSecondary:
+		return MaterialSecondary;
+	default:
+		return _MaterialInvalid;
+	}
+}
+
+EQEmu::InventorySlot EQEmu::Inventory::CalcSlotFromMaterial(int material) {
+	switch(material)
+	{
+	case MaterialHead:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotHead);
+	case MaterialChest:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotChest);
+	case MaterialArms:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotArms);
+	case MaterialWrist:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotWrist1);
+	case MaterialHands:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotHands);
+	case MaterialLegs:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotLegs);
+	case MaterialFeet:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotFeet);
+	case MaterialPrimary:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotPrimary);
+	case MaterialSecondary:
+		return EQEmu::InventorySlot(InvTypePersonal, PersonalSlotSecondary);
+	default:
+		return EQEmu::InventorySlot(-1, -1);
+	}
+}
+
+bool EQEmu::Inventory::CanEquip(EQEmu::ItemInstance::pointer &inst, const EQEmu::InventorySlot &slot) {
+	if(!inst) {
+		return false;
+	}
+	
+	if(slot.Type() != 0) {
+		return false;
+	}
+	
+	if(!EQEmu::ValueWithin(slot.Slot(), EQEmu::PersonalSlotCharm, EQEmu::PersonalSlotAmmo)) {
+		return false;
+	}
+	
+	auto item = inst->GetItem();
+	//check slot
+	
+	int use_slot = -1;
+	if(slot.Slot() == EQEmu::PersonalSlotPowerSource) {
+		use_slot = EQEmu::PersonalSlotAmmo;
+	}
+	else if(slot.Slot() == EQEmu::PersonalSlotAmmo) {
+		use_slot = EQEmu::PersonalSlotPowerSource;
+	}
+	else {
+		use_slot = slot.Slot();
+	}
+	
+	if(!(item->Slots & (1 << use_slot))) {
+		return false;
+	}
+	
+	//todo: check deity
+	if(!item->IsEquipable(impl_->race_, impl_->class_)) {
+		return false;
+	}
+
+	//Checking augments
+	auto iter = inst->GetContainer()->Begin();
+	auto end = inst->GetContainer()->End();
+	while(iter != end) {
+		EQEmu::ItemInstance::pointer itm = iter->second;
+		if(!CanEquip(itm, InventorySlot(slot.Type(), slot.Slot(), slot.BagIndex(), iter->first))) {
+			return false;
+		}
+		++iter;
+	}
+
+	return true;
+}
+
+bool EQEmu::Inventory::CheckLoreConflict(const ItemData *item) {
+	if(!item)
+		return false;
+
+	if(!item->LoreFlag)
+		return false;
+
+	if(item->LoreGroup == 0)
+		return false;
+
+	if(item->LoreGroup == 0xFFFFFFFF) {
+		//look everywhere except shared bank
+		for(auto &container : impl_->containers_) {
+			if(container.first != InvTypeSharedBank && container.second.HasItem(item->ID)) {
+				return true;
+			}
+		}
+	}
+	else {
+		//look everywhere except shared bank
+		for(auto &container : impl_->containers_) {
+			if(container.first != InvTypeSharedBank && container.second.HasItemByLoreGroup(item->LoreGroup)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+bool EQEmu::Inventory::Serialize(MemoryBuffer &buf) {
+	buf.SetWritePosition(0);
+	buf.SetReadPosition(0);
+	buf.Resize(0);
+	buf.Write<int32>(105);
+
+	bool value = false;
+	for(auto &iter : impl_->containers_) {
+		bool v = iter.second.Serialize(buf, iter.first);
+		if(v && !value) {
+			value = true;
+		}
+	}
+
+	return value;
+}
+
+void EQEmu::Inventory::Interrogate() {
+	printf("Inventory:\n");
+	printf("Class: %u, Race: %u, Deity: %u\n", impl_->class_, impl_->race_, impl_->deity_);
+	for(auto &iter : impl_->containers_) {
+		printf("Container: %u\n", iter.first);
+		iter.second.Interrogate(1);
+	}
+	printf("\n");
+}
+
+bool EQEmu::Inventory::_swap(const InventorySlot &src, const InventorySlot &dest) {
+	auto src_i = Get(src);
+	auto dest_i = Get(dest);
+
+	if(src_i) {
+		if(!_destroy(src)) {
+			return false;
+		}
+	}
+
+	if(dest_i) {
+		if(!_destroy(dest)) {
+			return false;
+		}
+
+		impl_->data_model_->Insert(src, dest_i);
+		if(!Put(src, dest_i)) {
+			return false;
+		}
+	}
+
+	if(src_i) {
+		impl_->data_model_->Insert(dest, src_i);
+		if(!Put(dest, src_i)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool EQEmu::Inventory::_destroy(const InventorySlot &slot) {
+	bool v = Put(slot, EQEmu::ItemInstance::pointer(nullptr));
+	impl_->data_model_->Delete(slot);
+	return v;
+}

common/inventory.h

@@ -0,0 +1,165 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 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_H
+#define COMMON_INVENTORY_H
+
+#include "item_container.h"
+#include <string>
+
+namespace EQEmu
+{
+	enum InventoryType : int
+	{
+		InvTypePersonal = 0,
+		InvTypeBank,
+		InvTypeSharedBank,
+		InvTypeTrade,
+		InvTypeWorld,
+		InvTypeCursorBuffer,
+		InvTypeTribute,
+		InvTypeTrophyTribute,
+		InvTypeGuildTribute,
+		InvTypeMerchant
+	};
+
+	enum PersonaInventorySlot : int
+	{
+		PersonalSlotCharm = 0,
+		PersonalSlotEar1,
+		PersonalSlotHead,
+		PersonalSlotFace,
+		PersonalSlotEar2,
+		PersonalSlotNeck,
+		PersonalSlotShoulders,
+		PersonalSlotArms,
+		PersonalSlotBack,
+		PersonalSlotWrist1,
+		PersonalSlotWrist2,
+		PersonalSlotRange,
+		PersonalSlotHands,
+		PersonalSlotPrimary,
+		PersonalSlotSecondary,
+		PersonalSlotFinger1,
+		PersonalSlotFinger2,
+		PersonalSlotChest,
+		PersonalSlotLegs,
+		PersonalSlotFeet,
+		PersonalSlotWaist,
+		PersonalSlotPowerSource,
+		PersonalSlotAmmo,
+		PersonalSlotGeneral1,
+		PersonalSlotGeneral2,
+		PersonalSlotGeneral3,
+		PersonalSlotGeneral4,
+		PersonalSlotGeneral5,
+		PersonalSlotGeneral6,
+		PersonalSlotGeneral7,
+		PersonalSlotGeneral8,
+		PersonalSlotGeneral9,
+		PersonalSlotGeneral10,
+		PersonalSlotCursor
+	};
+
+	class InventorySlot
+	{
+	public:
+		InventorySlot() : type_(-1), slot_(-1), bag_index_(-1), aug_index_(-1) { }
+		InventorySlot(int type, int slot) 
+			: type_(type), slot_(slot), bag_index_(-1), aug_index_(-1) { }
+		InventorySlot(int type, int slot, int bag_index) 
+			: type_(type), slot_(slot), bag_index_(bag_index), aug_index_(-1) { }
+		InventorySlot(int type, int slot, int bag_index, int aug_index) 
+			: type_(type), slot_(slot), bag_index_(bag_index), aug_index_(aug_index) { }
+
+		bool IsValid() const;
+		bool IsDelete() const;
+		bool IsBank() const;
+		bool IsCursor() const;
+		bool IsEquipment() const;
+		bool IsGeneral() const;
+		bool IsWeapon() const;
+		bool IsTrade() const;
+
+		const std::string ToString() const;
+
+		inline int Type() { return type_; }
+		inline int Type() const { return type_; }
+		inline int Slot() { return slot_; }
+		inline int Slot() const { return slot_; }
+		inline int BagIndex() { return bag_index_; }
+		inline int BagIndex() const { return bag_index_; }
+		inline int AugIndex() { return aug_index_; }
+		inline int AugIndex() const { return aug_index_; }
+
+	private:
+		int type_;
+		int slot_;
+		int bag_index_;
+		int aug_index_;
+	};
+
+	inline bool operator==(const InventorySlot &lhs, const InventorySlot &rhs) { 
+		return lhs.Type() == rhs.Type() && 
+			lhs.Slot() == rhs.Slot() && 
+			lhs.BagIndex() == rhs.BagIndex() &&
+			lhs.AugIndex() == rhs.AugIndex(); }
+	inline bool operator!=(const InventorySlot &lhs, const InventorySlot &rhs) { return !(lhs == rhs); }
+
+	class InventoryDataModel;
+	class Inventory
+	{
+	public:
+		Inventory(int race, int class_, int deity);
+		~Inventory();
+
+		void SetRace(int race);
+		void SetClass(int class_);
+		void SetDeity(int deity);
+		void SetDataModel(InventoryDataModel *dm);
+
+		ItemInstance::pointer Get(const InventorySlot &slot);
+		bool Put(const InventorySlot &slot, ItemInstance::pointer &inst);
+		bool Swap(const InventorySlot &src, const InventorySlot &dest, int charges);
+		bool Summon(const InventorySlot &slot, ItemInstance::pointer &inst);
+		bool PushToCursorBuffer(ItemInstance::pointer &inst);
+		bool PopFromCursorBuffer();
+		InventorySlot FindFreeSlot(ItemInstance::pointer &inst, int container_id, int slot_id_start, int slot_id_end);
+		int FindFreeStackSlots(ItemInstance::pointer &inst, int container_id, int slot_id_start, int slot_id_end);
+		void UpdateSlot(const InventorySlot &slot, ItemInstance::pointer &inst);
+
+		//utility
+		static int CalcMaterialFromSlot(const InventorySlot &slot);
+		static InventorySlot CalcSlotFromMaterial(int material);
+		bool CanEquip(EQEmu::ItemInstance::pointer &inst, const EQEmu::InventorySlot &slot);
+		bool CheckLoreConflict(const ItemData *item);
+		bool Serialize(MemoryBuffer &buf);
+
+		//testing
+		void Interrogate();
+	private:
+		bool _swap(const InventorySlot &src, const InventorySlot &dest);
+		bool _destroy(const InventorySlot &slot);
+
+		struct impl;
+		impl *impl_;
+	};
+
+} // EQEmu
+
+#endif

common/inventory_data_model.h

@@ -16,23 +16,25 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#ifndef EQEMU_ZONE_AA_RANK_EFFECTS_H
-#define EQEMU_ZONE_AA_RANK_EFFECTS_H
+#ifndef COMMON_INVENTORY_DATA_MODEL_H
+#define COMMON_INVENTORY_DATA_MODEL_H
 
-#include "../common/global_define.h"
-#include <string>
+#include "inventory.h"
 
-namespace AA
+namespace EQEmu
 {
-
-struct RankEffect
-{
-	int slot;
-	int effect_id;
-	int base1;
-	int base2;
-};
-
-}
+	class InventoryDataModel
+	{
+	public:
+		InventoryDataModel() { }
+		virtual ~InventoryDataModel() { }
+		
+		virtual void Begin() = 0;
+		virtual bool Commit() = 0;
+		virtual void Rollback() = 0;
+		virtual void Insert(const InventorySlot &slot, ItemInstance::pointer &inst) = 0;
+		virtual void Delete(const InventorySlot &slot) = 0;
+	};
+} // EQEmu
 
 #endif

common/inventory_db_data_model.cpp

@@ -0,0 +1,212 @@
+#include "inventory_db_data_model.h"
+#include "shareddb.h"
+#include "string_util.h"
+#include <list>
+#include <string>
+
+enum DataEventTypes
+{
+	DB_Insert,
+	DB_Delete
+};
+
+struct DataEvent
+{
+	DataEventTypes evt;
+	EQEmu::InventorySlot slot;
+	EQEmu::ItemInstance::pointer inst;
+};
+
+struct EQEmu::InventoryDatabaseDataModel::impl {
+	SharedDatabase *db_;
+	std::list<DataEvent> events_;
+	uint32 char_id_;
+};
+
+EQEmu::InventoryDatabaseDataModel::InventoryDatabaseDataModel(SharedDatabase *db, uint32 char_id) {
+	impl_ = new impl;
+	impl_->db_ = db;
+	impl_->char_id_ = char_id;
+}
+
+EQEmu::InventoryDatabaseDataModel::~InventoryDatabaseDataModel() {
+	delete impl_;
+}
+
+void EQEmu::InventoryDatabaseDataModel::Begin() {
+	impl_->db_->TransactionBegin();
+	impl_->events_.clear();
+}
+
+bool EQEmu::InventoryDatabaseDataModel::Commit() {
+	std::string base_insert = "INSERT INTO character_inventory(id, type, slot, bag_index, aug_index, "
+		"item_id, charges, color, attuned, custom_data, ornament_icon, ornament_idfile, ornament_hero_model"
+		", tracking_id) VALUES";
+
+	std::string current_insert = base_insert;
+	bool insert = false;
+	for(auto iter : impl_->events_) {
+		if(iter.evt == DB_Delete) {
+			if(insert) {
+				insert = false;
+
+				//commit the current_insert
+				auto res = impl_->db_->QueryDatabase(current_insert);
+				if(!res.Success()) {
+					Rollback();
+					return false;
+				}
+				
+				current_insert = base_insert;
+			}
+
+			std::string current_delete;
+			if(iter.slot.BagIndex() > -1) {
+				if(iter.slot.AugIndex() > -1) {
+					current_delete = StringFormat("DELETE FROM character_inventory WHERE id=%u AND type=%u AND slot=%u AND bag_index=%u AND aug_index=%u",
+												  impl_->char_id_, iter.slot.Type(), iter.slot.Slot(), iter.slot.BagIndex(), iter.slot.AugIndex());
+				}
+				else {
+					current_delete = StringFormat("DELETE FROM character_inventory WHERE id=%u AND type=%u AND slot=%u AND bag_index=%u",
+												  impl_->char_id_, iter.slot.Type(), iter.slot.Slot(), iter.slot.BagIndex());
+				}
+			}
+			else if(iter.slot.AugIndex() > -1) {
+				current_delete = StringFormat("DELETE FROM character_inventory WHERE id=%u AND type=%u AND slot=%u AND aug_index=%u",
+											  impl_->char_id_, iter.slot.Type(), iter.slot.Slot(), iter.slot.AugIndex());
+			}
+			else {
+				current_delete = StringFormat("DELETE FROM character_inventory WHERE id=%u AND type=%u AND slot=%u",
+											  impl_->char_id_, iter.slot.Type(), iter.slot.Slot());
+			}
+
+			auto res = impl_->db_->QueryDatabase(current_delete);
+			if(!res.Success()) {
+				Rollback();
+				return false;
+			}
+
+		} else {
+			//insert
+			if(!insert) {
+				insert = true;
+			} else {
+				current_insert += ",";
+			}
+
+			current_insert += StringFormat("(%u, %i, %i, %i, %i, %u, %i, %u, %u, '%s', %u, %u, %u, %llu)", 
+										   impl_->char_id_, 
+										   iter.slot.Type(), 
+										   iter.slot.Slot(), 
+										   iter.slot.BagIndex(), 
+										   iter.slot.AugIndex(),
+										   iter.inst->GetBaseItem()->ID,
+										   iter.inst->GetCharges(),
+										   iter.inst->GetColor(),
+										   iter.inst->GetAttuned(),
+										   EscapeString(iter.inst->GetCustomData()).c_str(),
+										   iter.inst->GetOrnamentIcon(),
+										   iter.inst->GetOrnamentIDFile(),
+										   iter.inst->GetOrnamentHeroModel(),
+										   iter.inst->GetTrackingID());
+		}
+	}
+
+	if(insert) {
+		insert = false;
+
+		//commit the current_insert
+		auto res = impl_->db_->QueryDatabase(current_insert);
+		if(!res.Success()) {
+			Rollback();
+			return false;
+		}
+
+		current_insert = base_insert;
+	}
+
+	impl_->db_->TransactionCommit();
+	impl_->events_.clear();
+	return true;
+}
+
+void EQEmu::InventoryDatabaseDataModel::Rollback() {
+	impl_->db_->TransactionRollback();
+	impl_->events_.clear();
+}
+
+void EQEmu::InventoryDatabaseDataModel::Insert(const InventorySlot &slot, ItemInstance::pointer &inst) {
+	DataEvent evt;
+	evt.evt = DB_Insert;
+	evt.inst = inst;
+	evt.slot = slot;
+	impl_->events_.push_back(evt);
+
+	//insert current item
+	if(slot.BagIndex() < 0 && slot.AugIndex() < 0) {
+		//if bag put all bag contents in
+		//if common put all augment contents in
+		if(inst->GetBaseItem()->ItemClass == ItemClassContainer) {
+			auto container = inst->GetContainer();
+			auto iter = container->Begin();
+			while(iter != container->End()) {
+				DataEvent evt;
+				evt.evt = DB_Insert;
+				evt.inst = iter->second;
+				evt.slot = InventorySlot(slot.Type(), slot.Slot(), iter->first, -1);
+				impl_->events_.push_back(evt);
+
+				//do augments here
+				if(evt.inst->GetBaseItem()->ItemClass == ItemClassCommon) {
+					auto inst_container = evt.inst->GetContainer();
+					auto inst_iter = inst_container->Begin();
+					while(inst_iter != inst_container->End()) {
+						DataEvent evt;
+						evt.evt = DB_Insert;
+						evt.inst = inst_iter->second;
+						evt.slot = InventorySlot(slot.Type(), slot.Slot(), iter->first, inst_iter->first);
+						impl_->events_.push_back(evt);
+						++inst_iter;
+					}
+				}
+
+				++iter;
+			}
+		}
+		else if(inst->GetBaseItem()->ItemClass == ItemClassCommon) {
+			auto container = inst->GetContainer();
+			auto iter = container->Begin();
+			while(iter != container->End()) {
+				DataEvent evt;
+				evt.evt = DB_Insert;
+				evt.inst = iter->second;
+				evt.slot = InventorySlot(slot.Type(), slot.Slot(), -1, iter->first);
+				impl_->events_.push_back(evt);
+
+				++iter;
+			}
+		}
+	}
+	else if(slot.AugIndex() < 0 && inst->GetBaseItem()->ItemClass == ItemClassCommon) {
+		//bag item that can have augs
+		//if common put all augment contents in
+		auto container = inst->GetContainer();
+		auto iter = container->Begin();
+		while(iter != container->End()) {
+			DataEvent evt;
+			evt.evt = DB_Insert;
+			evt.inst = iter->second;
+			evt.slot = InventorySlot(slot.Type(), slot.Slot(), slot.BagIndex(), iter->first);
+			impl_->events_.push_back(evt);
+		
+			++iter;
+		}
+	}
+}
+
+void EQEmu::InventoryDatabaseDataModel::Delete(const InventorySlot &slot) {
+	DataEvent evt;
+	evt.evt = DB_Delete;
+	evt.slot = slot;
+	impl_->events_.push_back(evt);
+}

common/inventory_db_data_model.h

@@ -16,46 +16,30 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#ifndef EQEMU_ZONE_AA_ABILITY_H
-#define EQEMU_ZONE_AA_ABILITY_H
+#ifndef COMMON_INVENTORY_DB_DATA_MODEL_H
+#define COMMON_INVENTORY_DB_DATA_MODEL_H
 
-#include "../common/global_define.h"
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include "aa_rank_effects.h"
-#include "aa_rank.h"
+#include "inventory_data_model.h"
 
-class Mob;
+class SharedDatabase;
 
-namespace AA
+namespace EQEmu
 {
-
-class Ability
-{
-public:
-	Ability() { }
-	~Ability() { }
-
-	Rank *GetMaxRank();
-	Rank *GetRankByPointsSpent(int current_level);
-	int GetMaxLevel(Mob *who);
-
-	int id;
-	std::string name;
-	int category;
-	int classes;
-	int races;
-	int deities;
-	int drakkin_heritage;
-	int status;
-	bool grant_only;
-	int type;
-	int charges;
-	int first_rank_id;
-	Rank *first;
-};
-
-}
+	class InventoryDatabaseDataModel : public InventoryDataModel
+	{
+	public:
+		InventoryDatabaseDataModel(SharedDatabase *db, uint32 char_id);
+		virtual ~InventoryDatabaseDataModel();
+		
+		virtual void Begin();
+		virtual bool Commit();
+		virtual void Rollback();
+		virtual void Insert(const InventorySlot &slot, ItemInstance::pointer &inst);
+		virtual void Delete(const InventorySlot &slot);
+	private:
+		struct impl;
+		impl *impl_;
+	};
+} // EQEmu
 
 #endif

common/inventory_null_data_model.h

@@ -16,41 +16,25 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#ifndef EQEMU_ZONE_AA_RANK_H
-#define EQEMU_ZONE_AA_RANK_H
+#ifndef COMMON_INVENTORY_NULL_DATA_MODEL_H
+#define COMMON_INVENTORY_NULL_DATA_MODEL_H
 
-namespace AA
+#include "inventory_data_model.h"
+
+namespace EQEmu
 {
-
-class Ability;
-class Rank
-{
-public:
-	Rank() { }
-	~Rank() { }
-
-	int id;
-	int upper_hotkey_sid;
-	int lower_hotkey_sid;
-	int title_sid;
-	int desc_sid;
-	int cost;
-	int level_req;
-	int spell;
-	int spell_type;
-	int recast_time;
-	int prev_id;
-	Rank *prev;
-	int next_id;
-	Rank *next;
-	int current_value;
-	int expansion;
-	int total_cost;
-	Ability *base_ability;
-	std::vector<RankEffect> effects;
-	std::map<int, int> prereqs;
-};
-
-}
+	class InventoryNullDataModel : public InventoryDataModel
+	{
+	public:
+		InventoryNullDataModel() { }
+		virtual ~InventoryNullDataModel() { }
+		
+		virtual void Begin() { }
+		virtual bool Commit() { return true; }
+		virtual void Rollback() { }
+		virtual void Insert(const InventorySlot &slot, ItemInstance::pointer &inst) { }
+		virtual void Delete(const InventorySlot &slot) { }
+	};
+} // EQEmu
 
 #endif

common/ipc_mutex.cpp

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

common/item.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2003 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -14,26 +13,22 @@
 
 	You should have received a copy of the GNU General Public License
 	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 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 COMMON_ITEM_H
-#define COMMON_ITEM_H
-
+#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_base.h"
+#include "../common/item_data.h"
 #include "../common/timer.h"
-#include "../common/bodytypes.h"
-#include "../common/deity.h"
-#include "../common/memory_buffer.h"
 
 #include <list>
 #include <map>
@@ -76,7 +71,6 @@ enum {
 	invWhereCursor		= 0x20
 };
 
-class ItemInst;
 
 // ########################################
 // Class: Queue
@@ -110,32 +104,31 @@ protected:
 };
 
 // ########################################
-// Class: Inventory
+// Class: InventoryOld
 //	Character inventory
-class Inventory
+class InventoryOld
 {
 	friend class ItemInst;
 public:
 	///////////////////////////////
 	// Public Methods
 	///////////////////////////////
-	
-	Inventory() { m_inventory_version = EQEmu::versions::InventoryVersion::Unknown; m_inventory_version_set = false; }
-	~Inventory();
 
-	// inv2 creep
-	bool SetInventoryVersion(EQEmu::versions::InventoryVersion inventory_version) {
-		if (!m_inventory_version_set) {
-			m_inventory_version = EQEmu::versions::ValidateInventoryVersion(inventory_version);
-			return (m_inventory_version_set = true);
+	InventoryOld() { m_version = ClientVersion::Unknown; m_versionset = false; }
+	~InventoryOld();
+
+	// Inventory v2 creep
+	bool SetInventoryVersion(ClientVersion version) {
+		if (!m_versionset) {
+			m_version = version;
+			return (m_versionset = true);
 		}
 		else {
 			return false;
 		}
 	}
-	bool SetInventoryVersion(EQEmu::versions::ClientVersion client_version) { return SetInventoryVersion(EQEmu::versions::ConvertClientVersionToInventoryVersion(client_version)); }
 
-	EQEmu::versions::InventoryVersion InventoryVersion() { return m_inventory_version; }
+	ClientVersion GetInventoryVersion() { return m_version; }
 
 	static void CleanDirty();
 	static void MarkDirty(ItemInst *inst);
@@ -175,7 +168,7 @@ public:
 	ItemInst* PopItem(int16 slot_id);
 
 	// Check whether there is space for the specified number of the specified item.
-	bool HasSpaceForItem(const EQEmu::ItemBase *ItemToTry, int16 Quantity);
+	bool HasSpaceForItem(const ItemData *ItemToTry, int16 Quantity);
 
 	// Check whether item exists in inventory
 	// where argument specifies OR'd list of invWhere constants to look
@@ -200,7 +193,7 @@ public:
 	static int16 CalcSlotFromMaterial(uint8 material);
 	static uint8 CalcMaterialFromSlot(int16 equipslot);
 
-	static bool CanItemFitInContainer(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container);
+	static bool CanItemFitInContainer(const ItemData *ItemToTry, const ItemData *Container);
 
 	//  Test for valid inventory casting slot
 	bool SupportsClickCasting(int16 slot_id);
@@ -258,8 +251,8 @@ protected:
 
 private:
 	// Active inventory version
-	EQEmu::versions::InventoryVersion m_inventory_version;
-	bool m_inventory_version_set;
+	ClientVersion m_version;
+	bool m_versionset;
 };
 
 class SharedDatabase;
@@ -277,7 +270,7 @@ public:
 	/////////////////////////
 
 	// Constructors/Destructor
-	ItemInst(const EQEmu::ItemBase* item = nullptr, int16 charges = 0);
+	ItemInst(const ItemData* item = nullptr, int16 charges = 0);
 
 	ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0);
 
@@ -288,15 +281,7 @@ public:
 	~ItemInst();
 
 	// Query item type
-	bool IsType(EQEmu::item::ItemClass item_class) const;
-
-	bool IsClassCommon();
-	bool IsClassBag();
-	bool IsClassBook();
-
-	bool IsClassCommon() const { return const_cast<ItemInst*>(this)->IsClassCommon(); }
-	bool IsClassBag() const { return const_cast<ItemInst*>(this)->IsClassBag(); }
-	bool IsClassBook() const { return const_cast<ItemInst*>(this)->IsClassBook(); }
+	bool IsType(ItemClassTypes item_class) const;
 
 	// Can item be stacked?
 	bool IsStackable() const;
@@ -315,7 +300,7 @@ public:
 	bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
 	inline int32 GetAugmentType() const { return ((m_item) ? m_item->AugType : NO_ITEM); }
 
-	inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == EQEmu::item::ItemEffectExpendable) || (m_item->ItemType == EQEmu::item::ItemTypePotion)) : false); }
+	inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == ET_Expendable ) || (m_item->ItemType == ItemTypePotion)) : false); }
 
 	//
 	// Contents
@@ -346,7 +331,7 @@ public:
 	bool IsAugmented();
 	ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const;
 	bool UpdateOrnamentationInfo();
-	static bool CanTransform(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container, bool AllowAll = false);
+	static bool CanTransform(const ItemData *ItemToTry, const ItemData *Container, bool AllowAll = false);
 	
 	// Has attack/delay?
 	bool IsWeapon() const;
@@ -355,8 +340,8 @@ public:
 	// Accessors
 	const uint32 GetID() const { return ((m_item) ? m_item->ID : NO_ITEM); }
 	const uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : NO_ITEM); }
-	const EQEmu::ItemBase* GetItem() const;
-	const EQEmu::ItemBase* GetUnscaledItem() const;
+	const ItemData* GetItem() const;
+	const ItemData* GetUnscaledItem() const;
 
 	int16 GetCharges() const				{ return m_charges; }
 	void SetCharges(int16 charges)			{ m_charges = charges; }
@@ -391,7 +376,7 @@ public:
 	// 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
+	// Compare inner ItemData 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); }
 
@@ -424,9 +409,7 @@ public:
 	int8 GetMaxEvolveLvl() const;
 	uint32 GetKillsNeeded(uint8 currentlevel);
 
-	std::string Serialize(int16 slot_id) const { EQEmu::InternalSerializedItem_Struct s; s.slot_id = slot_id; s.inst = (const void*)this; std::string ser; ser.assign((char*)&s, sizeof(EQEmu::InternalSerializedItem_Struct)); return ser; }
-	void Serialize(EQEmu::OutBuffer& ob, int16 slot_id) const { EQEmu::InternalSerializedItem_Struct isi; isi.slot_id = slot_id; isi.inst = (const void*)this; ob.write((const char*)&isi, sizeof(isi)); }
-	
+	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; }
 
@@ -435,58 +418,6 @@ public:
 	void StopTimer(std::string name);
 	void ClearTimers();
 
-	// Get a total of a stat, including augs
-	// These functions should be used in place of other code manually totaling
-	// to centralize where it is done to make future changes easier (ex. whenever powersources come around)
-	// and to minimize errors. CalcItemBonuses however doesn't use these in interest of performance
-	// by default these do not recurse into augs
-	int GetItemArmorClass(bool augments = false) const;
-	int GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments = false) const;
-	// These two differ in the fact that they're quick checks (they are checked BEFORE the one above
-	int GetItemElementalFlag(bool augments = false) const;
-	int GetItemElementalDamage(bool augments = false) const;
-	int GetItemRecommendedLevel(bool augments = false) const;
-	int GetItemRequiredLevel(bool augments = false) const;
-	int GetItemWeaponDamage(bool augments = false) const;
-	int GetItemBackstabDamage(bool augments = false) const;
-	// these two are just quick checks
-	int GetItemBaneDamageBody(bool augments = false) const;
-	int GetItemBaneDamageRace(bool augments = false) const;
-	int GetItemBaneDamageBody(bodyType against, bool augments = false) const;
-	int GetItemBaneDamageRace(uint16 against, bool augments = false) const;
-	int GetItemMagical(bool augments = false) const;
-	int GetItemHP(bool augments = false) const;
-	int GetItemMana(bool augments = false) const;
-	int GetItemEndur(bool augments = false) const;
-	int GetItemAttack(bool augments = false) const;
-	int GetItemStr(bool augments = false) const;
-	int GetItemSta(bool augments = false) const;
-	int GetItemDex(bool augments = false) const;
-	int GetItemAgi(bool augments = false) const;
-	int GetItemInt(bool augments = false) const;
-	int GetItemWis(bool augments = false) const;
-	int GetItemCha(bool augments = false) const;
-	int GetItemMR(bool augments = false) const;
-	int GetItemFR(bool augments = false) const;
-	int GetItemCR(bool augments = false) const;
-	int GetItemPR(bool augments = false) const;
-	int GetItemDR(bool augments = false) const;
-	int GetItemCorrup(bool augments = false) const;
-	int GetItemHeroicStr(bool augments = false) const;
-	int GetItemHeroicSta(bool augments = false) const;
-	int GetItemHeroicDex(bool augments = false) const;
-	int GetItemHeroicAgi(bool augments = false) const;
-	int GetItemHeroicInt(bool augments = false) const;
-	int GetItemHeroicWis(bool augments = false) const;
-	int GetItemHeroicCha(bool augments = false) const;
-	int GetItemHeroicMR(bool augments = false) const;
-	int GetItemHeroicFR(bool augments = false) const;
-	int GetItemHeroicCR(bool augments = false) const;
-	int GetItemHeroicPR(bool augments = false) const;
-	int GetItemHeroicDR(bool augments = false) const;
-	int GetItemHeroicCorrup(bool augments = false) const;
-	int GetItemHaste(bool augments = false) const;
-
 protected:
 	//////////////////////////
 	// Protected Members
@@ -494,13 +425,13 @@ protected:
 	std::map<uint8, ItemInst*>::const_iterator _cbegin() { return m_contents.cbegin(); }
 	std::map<uint8, ItemInst*>::const_iterator _cend() { return m_contents.cend(); }
 
-	friend class Inventory;
+	friend class InventoryOld;
 
 
 	void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; }
 
 	ItemInstTypes		m_use_type;	// Usage type for item
-	const EQEmu::ItemBase*	m_item;		// Ptr to item data
+	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;
@@ -512,7 +443,7 @@ protected:
 	uint32				m_exp;
 	int8				m_evolveLvl;
 	bool				m_activated;
-	EQEmu::ItemBase*		m_scaledItem;
+	ItemData*			m_scaledItem;
 	EvolveInfo*			m_evolveInfo;
 	bool				m_scaling;
 	uint32				m_ornamenticon;
@@ -541,4 +472,43 @@ public:
 	~EvolveInfo();
 };
 
-#endif /*COMMON_ITEM_H*/
+struct LightProfile_Struct
+{
+	/*
+	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
+	*/
+
+	static uint8 TypeToLevel(uint8 lightType);
+	static bool IsLevelGreater(uint8 leftType, uint8 rightType);
+
+	// Light types (classifications)
+	struct {
+		uint8 Innate;		// Defined by db field `npc_types`.`light` - where appropriate
+		uint8 Equipment;	// Item_Struct::light value of worn/carried equipment
+		uint8 Spell;		// Set value of any light-producing spell (can be modded to mimic equip_light behavior)
+		uint8 Active;		// Highest value of all light sources
+	} Type;
+
+	// Light levels (intensities) - used to determine which light source should be active
+	struct {
+		uint8 Innate;
+		uint8 Equipment;
+		uint8 Spell;
+		uint8 Active;
+	} Level;
+};
+
+#endif // #define __ITEM_H

common/item_base.cpp

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

common/item_base.h

@@ -1,565 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
-*/
-
-#ifndef COMMON_ITEM_BASE_H
-#define COMMON_ITEM_BASE_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 ItemAttributeBit : uint32 {
-			bit_ItemAttributeNone = 0x00000000,
-			bit_ItemAttributeLore = 0x00000001,
-			bit_ItemAttributeArtifact = 0x00000002,
-			bit_ItemAttributeSummoned = 0x00000004,
-			bit_ItemAttributeMagic = 0x00000008,
-			bit_ItemAttributeAugment = 0x00000010,
-			bit_ItemAttributePendingLore = 0x00000020,
-			bit_ItemAttributeUnknown = 0xFFFFFFFF
-		};
-
-		enum ItemClass {
-			ItemClassCommon = 0,
-			ItemClassBag,
-			ItemClassBook,
-			ItemClassCount
-		};
-
-		enum ItemType : uint8 {
-/*9138*/	ItemType1HSlash = 0,
-/*9141*/	ItemType2HSlash,
-/*9140*/	ItemType1HPiercing,
-/*9139*/	ItemType1HBlunt,
-/*9142*/	ItemType2HBlunt,
-/*5504*/	ItemTypeBow, // 5
-/*----*/	ItemTypeUnknown1,
-/*----*/	ItemTypeLargeThrowing,
-/*5505*/	ItemTypeShield,
-/*5506*/	ItemTypeScroll,
-/*5507*/	ItemTypeArmor, // 10
-/*5508*/	ItemTypeMisc,			// a lot of random crap has this item use.
-/*7564*/	ItemTypeLockPick,
-/*----*/	ItemTypeUnknown2,
-/*5509*/	ItemTypeFood,
-/*5510*/	ItemTypeDrink, // 15
-/*5511*/	ItemTypeLight,
-/*5512*/	ItemTypeCombinable,		// not all stackable items are this use...
-/*5513*/	ItemTypeBandage,
-/*----*/	ItemTypeSmallThrowing,
-/*----*/	ItemTypeSpell, // 20	// spells and tomes
-/*5514*/	ItemTypePotion,
-/*----*/	ItemTypeUnknown3,
-/*0406*/	ItemTypeWindInstrument,
-/*0407*/	ItemTypeStringedInstrument,
-/*0408*/	ItemTypeBrassInstrument, // 25
-/*0405*/	ItemTypePercussionInstrument,
-/*5515*/	ItemTypeArrow,
-/*----*/	ItemTypeUnknown4,
-/*5521*/	ItemTypeJewelry,
-/*----*/	ItemTypeSkull, // 30
-/*5516*/	ItemTypeBook,			// skill-up tomes/books? (would probably need a pp flag if true...)
-/*5517*/	ItemTypeNote,
-/*5518*/	ItemTypeKey,
-/*----*/	ItemTypeCoin,
-/*5520*/	ItemType2HPiercing, // 35
-/*----*/	ItemTypeFishingPole,
-/*----*/	ItemTypeFishingBait,
-/*5519*/	ItemTypeAlcohol,
-/*----*/	ItemTypeKey2,			// keys and satchels?? (questable keys?)
-/*----*/	ItemTypeCompass, // 40
-/*----*/	ItemTypeUnknown5,
-/*----*/	ItemTypePoison,			// might be wrong, but includes poisons
-/*----*/	ItemTypeUnknown6,
-/*----*/	ItemTypeUnknown7,
-/*5522*/	ItemTypeMartial, // 45
-/*----*/	ItemTypeUnknown8,
-/*----*/	ItemTypeUnknown9,
-/*----*/	ItemTypeUnknown10,
-/*----*/	ItemTypeUnknown11,
-/*----*/	ItemTypeSinging, // 50
-/*5750*/	ItemTypeAllInstrumentTypes,
-/*5776*/	ItemTypeCharm,
-/*----*/	ItemTypeDye,
-/*----*/	ItemTypeAugmentation,
-/*----*/	ItemTypeAugmentationSolvent, // 55
-/*----*/	ItemTypeAugmentationDistiller,
-/*----*/	ItemTypeUnknown12,
-/*----*/	ItemTypeFellowshipKit,
-/*----*/	ItemTypeUnknown13,
-/*----*/	ItemTypeRecipe, // 60
-/*----*/	ItemTypeAdvancedRecipe,
-/*----*/	ItemTypeJournal,		// only one(1) database entry
-/*----*/	ItemTypeAltCurrency,	// alt-currency (as opposed to coinage)
-/*5881*/	ItemTypePerfectedAugmentationDistiller,
-/*----*/	ItemTypeCount
-
-/*
-			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
-		};
-
-		extern uint32 ConvertAugTypeToAugTypeBit(uint8 aug_type);
-		extern uint8 ConvertAugTypeBitToAugType(uint32 aug_type_bit);
-
-	} /*item*/
-
-	struct InternalSerializedItem_Struct {
-		int16 slot_id;
-		const void * inst;
-	};
-
-	struct ItemBase {
-		// Non packet based fields
-		uint8	MinStatus;
-		uint8	ItemDataType; // memset to item::ItemDataBase ('0') during mmf load
-
-		// 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[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Type
-		uint8	AugSlotVisible[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Visible
-		uint8	AugSlotUnk2[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
-		uint32	LDoNTheme;
-		uint32	LDoNPrice;
-		uint32	LDoNSold;
-		uint32	BaneDmgRaceAmt;
-		uint32	AugRestrict;
-		uint32	Endur;
-		uint32	DotShielding;
-		uint32	Attack;
-		uint32	Regen;
-		uint32	ManaRegen;
-		uint32	EnduranceRegen;
-		uint32	Haste;
-		uint32	DamageShield;
-		uint32	RecastDelay;
-		uint32	RecastType;
-		uint32	AugDistiller;
-		bool	Attuneable;
-		bool	NoPet;
-		bool	PotionBelt;
-		bool	Stackable;
-		bool	NoTransfer;
-		bool	QuestItemFlag;
-		int16	StackSize;
-		uint8	PotionBeltSlots;
-		item::ItemEffect_Struct Click, Proc, Worn, Focus, Scroll, Bard;
-
-		uint8	Book;			// 0=Not book, 1=Book
-		uint32	BookType;
-		char	Filename[33];	// Filename for book data
-		// Begin SoF Fields
-		int32 SVCorruption;
-		uint32 Purity;
-		uint8 EvolvingItem;
-		uint32 EvolvingID;
-		uint8 EvolvingLevel;
-		uint8 EvolvingMax;
-		uint32 BackstabDmg;
-		uint32 DSMitigation;
-		int32 HeroicStr;
-		int32 HeroicInt;
-		int32 HeroicWis;
-		int32 HeroicAgi;
-		int32 HeroicDex;
-		int32 HeroicSta;
-		int32 HeroicCha;
-		int32 HeroicMR;
-		int32 HeroicFR;
-		int32 HeroicCR;
-		int32 HeroicDR;
-		int32 HeroicPR;
-		int32 HeroicSVCorrup;
-		int32 HealAmt;
-		int32 SpellDmg;
-		uint32 LDoNSellBackRate;
-		uint32 ScriptFileID;
-		uint16 ExpendableArrow;
-		uint32 Clairvoyance;
-		char	ClickName[65];
-		char	ProcName[65];
-		char	WornName[65];
-		char	FocusName[65];
-		char	ScrollName[65];
-		//BardName
-
-		bool IsEquipable(uint16 Race, uint16 Class);
-		bool IsClassCommon();
-		bool IsClassBag();
-		bool IsClassBook();
-		bool IsType1HWeapon();
-		bool IsType2HWeapon();
-		bool IsTypeShield();
-
-		bool IsEquipable(uint16 Race, uint16 Class) const { return const_cast<ItemBase*>(this)->IsEquipable(Race, Class); }
-		bool IsClassCommon() const { return const_cast<ItemBase*>(this)->IsClassCommon(); }
-		bool IsClassBag() const { return const_cast<ItemBase*>(this)->IsClassBag(); }
-		bool IsClassBook() const { return const_cast<ItemBase*>(this)->IsClassBook(); }
-		bool IsType1HWeapon() const { return const_cast<ItemBase*>(this)->IsType1HWeapon(); }
-		bool IsType2HWeapon() const { return const_cast<ItemBase*>(this)->IsType2HWeapon(); }
-		bool IsTypeShield() const { return const_cast<ItemBase*>(this)->IsTypeShield(); }
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_ITEM_BASE_H*/

common/item_container.cpp

@@ -0,0 +1,135 @@
+#include "item_container.h"
+#include "item_container_default_serialization.h"
+#include <utility>
+
+struct EQEmu::ItemContainer::impl
+{
+	std::map<int, ItemInstance::pointer> items_;
+	ItemContainerSerializationStrategy *serialize_strat_;
+};
+
+EQEmu::ItemContainer::ItemContainer()
+{
+	impl_ = new impl();
+	impl_->serialize_strat_ = new ItemContainerDefaultSerialization();
+}
+
+EQEmu::ItemContainer::ItemContainer(ItemContainerSerializationStrategy *strategy) {
+	impl_ = new impl();
+	impl_->serialize_strat_ = strategy;
+}
+
+EQEmu::ItemContainer::~ItemContainer()
+{
+	if(impl_) {
+		delete impl_->serialize_strat_;
+		delete impl_;
+	}
+}
+
+EQEmu::ItemContainer::ItemContainer(ItemContainer &&other) {
+	impl_ = other.impl_;
+	other.impl_ = nullptr;
+}
+
+EQEmu::ItemContainer& EQEmu::ItemContainer::operator=(ItemContainer &&other) {
+	if(this == &other)
+		return *this;
+
+	impl_ = other.impl_;
+	other.impl_ = nullptr;
+	return *this;
+}
+
+EQEmu::ItemInstance::pointer EQEmu::ItemContainer::Get(const int slot_id) {
+	auto iter = impl_->items_.find(slot_id);
+	if(iter != impl_->items_.end()) {
+		return iter->second;
+	}
+
+	return EQEmu::ItemInstance::pointer(nullptr);
+}
+
+bool EQEmu::ItemContainer::Put(const int slot_id, ItemInstance::pointer &inst) {
+	if(!inst) {
+		impl_->items_.erase(slot_id);
+		return true;
+	} else {
+		auto iter = impl_->items_.find(slot_id);
+		if(iter == impl_->items_.end()) {
+			impl_->items_[slot_id] = inst;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool EQEmu::ItemContainer::HasItem(uint32 item_id) {
+	for(auto &item : impl_->items_) {
+		if(item.second->GetBaseItem()->ID == item_id) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool EQEmu::ItemContainer::HasItemByLoreGroup(uint32 loregroup) {
+	if(loregroup == 0xFFFFFFFF)
+		return false;
+
+	for(auto &item : impl_->items_) {
+		if(item.second->GetBaseItem()->LoreGroup == loregroup) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+uint32 EQEmu::ItemContainer::Size() {
+	return (uint32)impl_->items_.size();
+}
+
+uint32 EQEmu::ItemContainer::Size() const {
+	return (uint32)impl_->items_.size();
+}
+
+bool EQEmu::ItemContainer::Delete(const int slot_id) {
+	auto iter = impl_->items_.find(slot_id);
+	if(iter == impl_->items_.end()) {
+		return false;
+	} else {
+		impl_->items_.erase(iter);
+		return true;
+	}
+}
+
+bool EQEmu::ItemContainer::Serialize(MemoryBuffer &buf, int container_number) {
+	if(impl_->serialize_strat_) {
+		return impl_->serialize_strat_->Serialize(buf, container_number, impl_->items_);
+	}
+
+	return false;
+}
+
+EQEmu::ItemContainer::ItemContainerIter EQEmu::ItemContainer::Begin() {
+	return impl_->items_.begin();
+}
+
+EQEmu::ItemContainer::ItemContainerIter EQEmu::ItemContainer::End() {
+	return impl_->items_.end();
+}
+
+void EQEmu::ItemContainer::Interrogate(int level) {
+	char buffer[16] = { 0 };
+	for(int i = 0; i < level; ++i) {
+		buffer[i] = '\t';
+	}
+
+	for(auto &iter : impl_->items_) {
+		printf("%s%u: (%u)%s (%u)\n", buffer, iter.first, iter.second->GetBaseItem()->ID, iter.second->GetBaseItem()->Name, iter.second->GetCharges());
+		iter.second->Interrogate(level + 1);
+	}
+}

common/item_container.h

@@ -0,0 +1,70 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 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_ITEM_CONTAINER_H
+#define COMMON_ITEM_CONTAINER_H
+
+#include "item_instance.h"
+#include "item_container_serialization_strategy.h"
+#include "memory_buffer.h"
+#include <memory>
+#include <map>
+
+namespace EQEmu
+{
+	class ItemContainerSerializationStrategy;
+	class ItemContainer
+	{
+	public:
+		typedef std::map<int, ItemInstance::pointer>::const_iterator ItemContainerIter;
+
+		ItemContainer();
+		ItemContainer(ItemContainerSerializationStrategy *strategy);
+		~ItemContainer();
+		ItemContainer(ItemContainer &&other);
+		ItemContainer& operator=(ItemContainer &&other);
+
+		ItemInstance::pointer Get(const int slot_id);
+		bool Put(const int slot_id, ItemInstance::pointer &inst);
+		bool Delete(const int slot_id);
+
+		//Utility
+		bool HasItem(uint32 item_id);
+		bool HasItemByLoreGroup(uint32 loregroup);
+
+		uint32 Size();
+		uint32 Size() const;
+
+		//Low level interface for encode/decode
+		bool Serialize(MemoryBuffer &buf, int container_number);
+		ItemContainerIter Begin();
+		ItemContainerIter End();
+
+		//testing
+		void Interrogate(int level);
+	protected:
+		struct impl;
+		impl *impl_;
+
+	private:
+		ItemContainer(const ItemContainer &other);
+		ItemContainer& operator=(const ItemContainer &other);
+	};
+} // EQEmu
+
+#endif

common/item_container_default_serialization.cpp

@@ -0,0 +1,19 @@
+#include "item_container_default_serialization.h"
+
+bool EQEmu::ItemContainerDefaultSerialization::Serialize(MemoryBuffer &buf, const int container_number, const std::map<int, ItemInstance::pointer>& items) {
+	if(items.size() == 0) {
+		return false;
+	}
+
+	bool ret = false;
+	for(auto &iter : items) {
+		buf.Write<int32>(container_number);
+		buf.Write<int32>(iter.first);
+		buf.Write<int32>(-1);
+		buf.Write<int32>(-1);
+		buf.Write<void*>(iter.second.get());
+		ret = true;
+	}
+
+	return ret;
+}

common/item_container_default_serialization.h

@@ -0,0 +1,35 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 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_ITEM_CONTAINER_DEFAULT_SERIALIZATION_H
+#define COMMON_ITEM_CONTAINER_DEFAULT_SERIALIZATION_H
+
+#include "item_container_serialization_strategy.h"
+
+namespace EQEmu
+{
+	class ItemContainerDefaultSerialization : public ItemContainerSerializationStrategy
+	{
+	public:
+		ItemContainerDefaultSerialization() { }
+		virtual ~ItemContainerDefaultSerialization() { }
+		virtual bool Serialize(MemoryBuffer &buf, const int container_number, const std::map<int, ItemInstance::pointer>& items);
+	};
+} // EQEmu
+
+#endif

common/item_container_personal_serialization.cpp

@@ -0,0 +1,21 @@
+#include "item_container_personal_serialization.h"
+
+bool EQEmu::ItemContainerPersonalSerialization::Serialize(MemoryBuffer &buf, const int container_number, const std::map<int, ItemInstance::pointer>& items) {
+	if(items.size() == 0) {
+		return false;
+	}
+
+	bool ret = false;
+	for(auto &iter : items) {
+		if(iter.first < 33) {
+			buf.Write<int32>(container_number);
+			buf.Write<int32>(iter.first);
+			buf.Write<int32>(-1);
+			buf.Write<int32>(-1);
+			buf.Write<void*>(iter.second.get());
+			ret = true;
+		}
+	}
+
+	return ret;
+}

common/item_container_personal_serialization.h

@@ -0,0 +1,35 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 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_ITEM_CONTAINER_PERSONAL_SERIALIZATION_H
+#define COMMON_ITEM_CONTAINER_PERSONAL_SERIALIZATION_H
+
+#include "item_container_serialization_strategy.h"
+
+namespace EQEmu
+{
+	class ItemContainerPersonalSerialization : public ItemContainerSerializationStrategy
+	{
+	public:
+		ItemContainerPersonalSerialization() { }
+		virtual ~ItemContainerPersonalSerialization() { }
+		virtual bool Serialize(MemoryBuffer &buf, const int container_number, const std::map<int, ItemInstance::pointer>& items);
+	};
+} // EQEmu
+
+#endif

common/item_container_serialization_strategy.h

@@ -0,0 +1,37 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 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_ITEM_CONTAINER_SERIALIZATION_STRATEGY_H
+#define COMMON_ITEM_CONTAINER_SERIALIZATION_STRATEGY_H
+
+#include "item_container.h"
+#include "memory_buffer.h"
+#include <map>
+
+namespace EQEmu
+{
+	class ItemContainerSerializationStrategy
+	{
+	public:
+		ItemContainerSerializationStrategy() { }
+		virtual ~ItemContainerSerializationStrategy() { }
+		virtual bool Serialize(MemoryBuffer &buf, const int container_number, const std::map<int, ItemInstance::pointer>& items) = 0;
+	};
+} // EQEmu
+
+#endif

common/item_data.h

@@ -0,0 +1,248 @@
+/*	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 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. ItemData 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 ItemData:
+**	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;
+};
+
+struct SerializedItemInstance_Struct {
+	int32 container_id;
+	int32 slot_id;
+	int32 bag_id;
+	int32 aug_id;
+	void *inst;
+};
+
+// use EmuConstants::ITEM_COMMON_SIZE
+//#define MAX_AUGMENT_SLOTS 5
+
+struct ItemData {
+	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;
+	uint8	BagType;		// 0:Small Bag, 1:Large Bag, 2:Quiver, 3:Belt Pouch ... there are 50 types
+	uint8	BagSlots;		// Number of slots
+	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
+	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#)
+	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
+	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 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;
+	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/item_fieldlist.h

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

common/item_instance.cpp

@@ -0,0 +1,389 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 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_instance.h"
+#include "data_verification.h"
+#include "item_container.h"
+
+uint32 ItemInstanceSerial = 1;
+uint32 EQEmu::GetNextItemInstanceSerial() {
+	ItemInstanceSerial++;
+	return ItemInstanceSerial;
+}
+
+struct EQEmu::ItemInstance::impl {
+	const ItemData *base_item_;
+	ItemData *modified_item_;
+	int16 charges_;
+	uint32 color_;
+	bool attuned_;
+	std::string custom_data_;
+	uint32 ornament_idfile_;
+	uint32 ornament_icon_;
+	uint32 ornament_hero_model_;
+	char tracking_id_[17];
+	uint32 serial_id_;
+	uint32 recast_timestamp_;
+	uint32 merchant_slot_;
+	uint32 merchant_count_;
+	uint32 price_;
+	ItemContainer contents_;
+};
+
+EQEmu::ItemInstance::ItemInstance(const ItemData* idata) {
+	impl_ = new impl;
+	impl_->base_item_ = idata;
+	impl_->modified_item_ = nullptr;
+	impl_->charges_ = -1;
+	impl_->color_ = 0;
+	impl_->attuned_ = false;
+	impl_->ornament_idfile_ = 0;
+	impl_->ornament_icon_ = 0;
+	impl_->ornament_hero_model_ = 0;
+	impl_->serial_id_ = 0;
+	impl_->recast_timestamp_ = 0;
+	impl_->merchant_slot_ = 0;
+	impl_->merchant_count_ = 0;
+	impl_->price_ = 0;
+	memset(impl_->tracking_id_, 0, 17);
+}
+
+EQEmu::ItemInstance::ItemInstance(const ItemData* idata, int16 charges) {
+	impl_ = new impl;
+	impl_->base_item_ = idata;
+	impl_->modified_item_ = nullptr;
+	impl_->charges_ = charges;
+	impl_->color_ = 0;
+	impl_->attuned_ = false;
+	impl_->ornament_idfile_ = 0;
+	impl_->ornament_icon_ = 0;
+	impl_->ornament_hero_model_ = 0;
+	impl_->recast_timestamp_ = 0;
+	impl_->serial_id_ = 0;
+	impl_->merchant_slot_ = 0;
+	impl_->merchant_count_ = 0;
+	impl_->price_ = 0;
+	memset(impl_->tracking_id_, 0, 17);
+}
+
+EQEmu::ItemInstance::~ItemInstance() {
+	delete impl_;
+}
+
+
+EQEmu::ItemInstance::pointer EQEmu::ItemInstance::Split(int charges) {
+	if(!IsStackable()) {
+		//Can't split non stackable items!
+		return pointer(nullptr);
+	}
+
+	if(charges >= GetCharges()) {
+		return pointer(nullptr);
+	}
+
+	if(impl_->contents_.Size() > 0) {
+		return pointer(nullptr);
+	}
+
+	pointer split = pointer(new EQEmu::ItemInstance(impl_->base_item_, charges));
+	split->SetSerialNumber(EQEmu::GetNextItemInstanceSerial());
+	//Set Tracking here
+	split->impl_->attuned_ = impl_->attuned_;
+	split->impl_->custom_data_ = impl_->custom_data_;
+	split->impl_->recast_timestamp_ = impl_->recast_timestamp_;
+	split->impl_->price_ = impl_->price_;
+	split->impl_->color_ = impl_->color_;
+	split->impl_->merchant_count_ = impl_->merchant_count_;
+	split->impl_->merchant_slot_ = impl_->merchant_slot_;
+	split->impl_->ornament_hero_model_ = impl_->ornament_hero_model_;
+	split->impl_->ornament_icon_ = impl_->ornament_icon_;
+	split->impl_->ornament_idfile_ = impl_->ornament_idfile_;
+
+	SetCharges(GetCharges() - charges);
+	return split;
+}
+
+const ItemData *EQEmu::ItemInstance::GetItem() {
+	return impl_->modified_item_ ? impl_->modified_item_ : impl_->base_item_;
+}
+
+const ItemData *EQEmu::ItemInstance::GetBaseItem() {
+	return impl_->base_item_;
+}
+
+const ItemData *EQEmu::ItemInstance::GetBaseItem() const {
+	return impl_->base_item_;
+}
+
+EQEmu::ItemInstance::pointer EQEmu::ItemInstance::Get(const int index) {
+	if(EQEmu::ValueWithin(index, 0, 255)) {
+		return impl_->contents_.Get(index);
+	}
+	
+	return pointer(nullptr);
+}
+
+bool EQEmu::ItemInstance::Put(const int index, pointer &inst) {
+	if(!impl_->base_item_) {
+		return false;
+	}
+
+	auto item = impl_->base_item_;
+	if(item->ItemClass == ItemClassContainer) { // Bag
+		if(!EQEmu::ValueWithin(index, 0, item->BagSlots)) {
+			return false;
+		}
+
+		return impl_->contents_.Put(index, inst);
+	}
+	else if(item->ItemClass == ItemClassCommon) { // Augment
+		if(!EQEmu::ValueWithin(index, 0, EmuConstants::ITEM_COMMON_SIZE)) {
+			return false;
+		}
+
+		if(!item->AugSlotVisible[index]) {
+			return false;
+		}
+
+		if(inst) {
+			auto *aug_item = inst->GetItem();
+			int aug_type = aug_item->AugType;
+			if(aug_type == -1 || (1 << (item->AugSlotType[index] - 1)) & aug_type) {
+				return impl_->contents_.Put(index, inst);
+			}
+		} else {
+			return impl_->contents_.Put(index, inst);
+		}
+		
+		return false;
+	}
+
+	return false;
+}
+
+int16 EQEmu::ItemInstance::GetCharges() {
+	return impl_->charges_;
+}
+
+int16 EQEmu::ItemInstance::GetCharges() const {
+	return impl_->charges_;
+}
+
+void EQEmu::ItemInstance::SetCharges(const int16 charges) {
+	impl_->charges_ = charges;
+}
+
+uint32 EQEmu::ItemInstance::GetColor() {
+	return impl_->color_;
+}
+
+uint32 EQEmu::ItemInstance::GetColor() const {
+	return impl_->color_;
+}
+
+void EQEmu::ItemInstance::SetColor(const uint32 color) {
+	impl_->color_ = color;
+}
+
+bool EQEmu::ItemInstance::GetAttuned() {
+	return impl_->attuned_;
+}
+
+bool EQEmu::ItemInstance::GetAttuned() const {
+	return impl_->attuned_;
+}
+
+void EQEmu::ItemInstance::SetAttuned(const bool attuned) {
+	impl_->attuned_ = attuned;
+}
+
+std::string EQEmu::ItemInstance::GetCustomData() {
+	return impl_->custom_data_;
+}
+
+std::string EQEmu::ItemInstance::GetCustomData() const {
+	return impl_->custom_data_;
+}
+
+void EQEmu::ItemInstance::SetCustomData(const std::string &custom_data) {
+	//We need to actually set the custom data stuff based on this string
+	impl_->custom_data_ = custom_data;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentIDFile() {
+	return impl_->ornament_idfile_;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentIDFile() const {
+	return impl_->ornament_idfile_;
+}
+
+void EQEmu::ItemInstance::SetOrnamentIDFile(const uint32 ornament_idfile) {
+	impl_->ornament_idfile_ = ornament_idfile;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentIcon() {
+	return impl_->ornament_icon_;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentIcon() const {
+	return impl_->ornament_icon_;
+}
+
+void EQEmu::ItemInstance::SetOrnamentIcon(const uint32 ornament_icon) {
+	impl_->ornament_icon_ = ornament_icon;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentHeroModel() {
+	return impl_->ornament_hero_model_;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentHeroModel() const {
+	return impl_->ornament_hero_model_;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentHeroModel(int material_slot) {
+	uint32 hero_model = 0;
+	if(impl_->ornament_hero_model_ > 0)
+	{
+		hero_model = impl_->ornament_hero_model_;
+		if(material_slot >= 0)
+		{
+			hero_model = (impl_->ornament_hero_model_ * 100) + material_slot;
+		}
+	}
+	return hero_model;
+}
+
+uint32 EQEmu::ItemInstance::GetOrnamentHeroModel(int material_slot) const {
+	uint32 hero_model = 0;
+	if(impl_->ornament_hero_model_ > 0)
+	{
+		hero_model = impl_->ornament_hero_model_;
+		if(material_slot >= 0)
+		{
+			hero_model = (impl_->ornament_hero_model_ * 100) + material_slot;
+		}
+	}
+	return hero_model;
+}
+
+void EQEmu::ItemInstance::SetOrnamentHeroModel(const uint32 ornament_hero_model) {
+	impl_->ornament_hero_model_ = ornament_hero_model;
+}
+
+const char* EQEmu::ItemInstance::GetTrackingID() {
+	return impl_->tracking_id_;
+}
+
+const char* EQEmu::ItemInstance::GetTrackingID() const {
+	return impl_->tracking_id_;
+}
+
+void EQEmu::ItemInstance::SetTrackingID(const char *tracking_id) {
+	size_t len = strlen(tracking_id);
+	if(len > 16) {
+		return;
+	}
+
+	strncpy(impl_->tracking_id_, tracking_id, 16);
+}
+
+uint32 EQEmu::ItemInstance::GetRecastTimestamp() {
+	return impl_->recast_timestamp_;
+}
+
+uint32 EQEmu::ItemInstance::GetRecastTimestamp() const {
+	return impl_->recast_timestamp_;
+}
+
+void EQEmu::ItemInstance::SetRecastTimestamp(const uint32 recast_timestamp) {
+	impl_->recast_timestamp_ = recast_timestamp;
+}
+
+uint32 EQEmu::ItemInstance::GetMerchantSlot() {
+	return impl_->merchant_slot_;
+}
+
+uint32 EQEmu::ItemInstance::GetMerchantSlot() const {
+	return impl_->merchant_slot_;
+}
+
+void EQEmu::ItemInstance::SetMerchantSlot(uint32 slot) {
+	impl_->merchant_slot_ = slot;
+}
+
+uint32 EQEmu::ItemInstance::GetMerchantCount() {
+	return impl_->merchant_count_;
+}
+
+uint32 EQEmu::ItemInstance::GetMerchantCount() const {
+	return impl_->merchant_count_;
+}
+
+void EQEmu::ItemInstance::SetMerchantCount(const uint32 cnt) {
+	impl_->merchant_count_ = cnt;
+}
+
+uint32 EQEmu::ItemInstance::GetPrice() {
+	return impl_->price_;
+}
+
+uint32 EQEmu::ItemInstance::GetPrice() const {
+	return impl_->price_;
+}
+
+void EQEmu::ItemInstance::SetPrice(const uint32 p) {
+	impl_->price_ = p;
+}
+
+uint32 EQEmu::ItemInstance::GetSerialNumber() {
+	return impl_->serial_id_;
+}
+
+uint32 EQEmu::ItemInstance::GetSerialNumber() const {
+	return impl_->serial_id_;
+}
+
+void EQEmu::ItemInstance::SetSerialNumber(const uint32 sn) {
+	impl_->serial_id_ = sn;
+}
+
+bool EQEmu::ItemInstance::IsStackable() {
+	return impl_->base_item_->Stackable;
+}
+
+bool EQEmu::ItemInstance::IsStackable() const {
+	return impl_->base_item_->Stackable;
+}
+
+bool EQEmu::ItemInstance::IsNoDrop() {
+	return GetAttuned() || GetBaseItem()->NoDrop == 0;
+}
+
+bool EQEmu::ItemInstance::IsNoDrop() const {
+	return GetAttuned() || GetBaseItem()->NoDrop == 0;
+}
+
+EQEmu::ItemContainer *EQEmu::ItemInstance::GetContainer() {
+	return &(impl_->contents_);
+}
+
+void EQEmu::ItemInstance::Interrogate(int level) {
+	impl_->contents_.Interrogate(level);
+}

common/item_instance.h

@@ -0,0 +1,126 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 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_ITEM_INSTANCE_H
+#define COMMON_ITEM_INSTANCE_H
+
+#include "item_data.h"
+#include <memory>
+
+namespace EQEmu
+{
+	uint32 GetNextItemInstanceSerial();
+
+	class ItemContainer;
+	class ItemInstance
+	{
+	public:
+		typedef std::shared_ptr<ItemInstance> pointer;
+		ItemInstance(const ItemData* idata);
+		ItemInstance(const ItemData* idata, const int16 charges);
+		~ItemInstance();
+
+		const ItemData *GetItem();
+		const ItemData *GetBaseItem();
+		const ItemData *GetBaseItem() const;
+
+		pointer Split(int charges);
+
+		//Container
+		pointer Get(const int index);
+		bool Put(const int index, pointer &inst);
+
+		//Persistent State
+		int16 GetCharges();
+		int16 GetCharges() const;
+		void SetCharges(const int16 charges);
+
+		uint32 GetColor();
+		uint32 GetColor() const;
+		void SetColor(const uint32 color);
+
+		bool GetAttuned();
+		bool GetAttuned() const;
+		void SetAttuned(const bool attuned);
+
+		std::string GetCustomData();
+		std::string GetCustomData() const;
+		void SetCustomData(const std::string &custom_data);
+
+		uint32 GetOrnamentIDFile();
+		uint32 GetOrnamentIDFile() const;
+		void SetOrnamentIDFile(const uint32 ornament_idfile);
+
+		uint32 GetOrnamentIcon();
+		uint32 GetOrnamentIcon() const;
+		void SetOrnamentIcon(const uint32 ornament_icon);
+
+		uint32 GetOrnamentHeroModel();
+		uint32 GetOrnamentHeroModel() const;
+		uint32 GetOrnamentHeroModel(int material_slot);
+		uint32 GetOrnamentHeroModel(int material_slot) const;
+		void SetOrnamentHeroModel(const uint32 ornament_hero_model);
+
+		const char* GetTrackingID();
+		const char* GetTrackingID() const;
+		void SetTrackingID(const char *tracking_id);
+
+		uint32 GetRecastTimestamp();
+		uint32 GetRecastTimestamp() const;
+		void SetRecastTimestamp(const uint32 recast_timestamp);
+
+		//Merchant
+		uint32 GetMerchantSlot();
+		uint32 GetMerchantSlot() const;
+		void SetMerchantSlot(const uint32 slot);
+
+		uint32 GetMerchantCount();
+		uint32 GetMerchantCount() const;
+		void SetMerchantCount(const uint32 cnt);
+
+		uint32 GetPrice();
+		uint32 GetPrice() const;
+		void SetPrice(const uint32 p);
+
+		//Serial Number
+		uint32 GetSerialNumber();
+		uint32 GetSerialNumber() const;
+		void SetSerialNumber(uint32 sn);
+
+		//Basic Stats
+		bool IsStackable();
+		bool IsStackable() const;
+
+		bool IsNoDrop();
+		bool IsNoDrop() const;
+
+		void CheckStackRemaining(pointer &insert, int &charges);
+
+		//Internal state
+		//Used for low level operations such as encode/decode
+		ItemContainer *GetContainer();
+
+		void Interrogate(int level);
+	private:
+		struct impl;
+		impl *impl_;
+	};
+
+} // EQEmu
+
+#endif

common/light_source.cpp

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

common/light_source.h

@@ -1,115 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-	
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-	
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#ifndef COMMON_LIGHT_SOURCE_H
-#define COMMON_LIGHT_SOURCE_H
-
-#include "types.h"
-
-
-namespace EQEmu
-{
-	namespace lightsource {
-		enum LightSlot {
-			LightInnate = 0,	// Defined by db field `npc_types`.`light` - where appropriate
-			LightEquipment,		// Item_Struct::light value of worn/carried equipment
-			LightSpell,			// Set value of any light-producing spell (can be modded to mimic equip_light behavior)
-			LightActive,		// Highest value of all light sources
-			LightCount
-		};
-
-		enum LightType {
-			LightTypeNone = 0,
-			LightTypeCandle,
-			LightTypeTorch,
-			LightTypeTinyGlowingSkull,
-			LightTypeSmallLantern,
-			LightTypeSteinOfMoggok, // 5
-			LightTypeLargeLantern,
-			LightTypeFlamelessLantern,
-			LightTypeGlobeOfStars,
-			LightTypeLightGlobe,
-			LightTypeLightstone, // 10
-			LightTypeGreaterLightstone,
-			LightTypeFireBeetleEye,
-			LightTypeColdlight,
-			LightTypeUnknown1,
-			LightTypeUnknown2, // 15
-			LightTypeCount
-		};
-
-		enum LightLevel {
-			LightLevelUnlit = 0,
-			LightLevelCandle,
-			LightLevelTorch,
-			LightLevelSmallMagic,
-			LightLevelRedLight,
-			LightLevelBlueLight, // 5
-			LightLevelSmallLantern,
-			LightLevelMagicLantern,
-			LightLevelLargeLantern,
-			LightLevelLargeMagic,
-			LightLevelBrilliant, // 10
-			LightLevelCount
-		};
-
-		extern uint8 TypeToLevel(uint8 light_type);
-		extern bool IsLevelGreater(uint8 left_type, uint8 right_type);
-	
-	}; /*lightsource*/
-
-	struct LightSource_Struct {
-		uint8 Slot[lightsource::LightCount];
-
-		LightSource_Struct();
-
-		void Clear();
-
-		inline uint8& operator[](lightsource::LightSlot index) { return Slot[index]; }
-	};
-
-	struct LightSourceProfile {
-		/*
-		Current criteria (light types):
-		Equipment:	{ 0 .. 15 }
-		General:	{ 9 .. 13 }
-
-		Notes:
-		- Initial character load and item movement updates use different light source update behaviors
-		-- Server procedure matches the item movement behavior since most updates occur post-character load
-		- MainAmmo is not considered when determining light sources
-		- No 'Sub' or 'Aug' items are recognized as light sources
-		- Light types '< 9' and '> 13' are not considered for general (carried) light sources
-		- If values > 0x0F are valid, then assignment limiters will need to be removed
-		- MainCursor 'appears' to be a valid light source update slot..but, have not experienced updates during debug sessions
-		- All clients have a bug regarding stackable items (light and sound updates are not processed when picking up an item)
-		-- The timer-based update cancels out the invalid light source
-		*/
-
-		LightSource_Struct Type; // Light types (classifications)
-		LightSource_Struct Level; // Light levels (intensities) - used to determine which light source should be active
-
-		LightSourceProfile() { }
-
-		void Clear();
-	};
-
-} /*EQEmu*/
-
-#endif /*COMMON_LIGHT_SOURCE_H*/

common/memory_buffer.cpp

@@ -1,27 +1,6 @@
-/*	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()
-{
+EQEmu::MemoryBuffer::MemoryBuffer() {
 	buffer_ = nullptr;
 	size_ = 0;
 	capacity_ = 0;
@@ -29,8 +8,7 @@ EQEmu::MemoryBuffer::MemoryBuffer()
 	write_pos_ = 0;
 }
 
-EQEmu::MemoryBuffer::MemoryBuffer(size_t sz)
-{
+EQEmu::MemoryBuffer::MemoryBuffer(size_t sz) {
 	buffer_ = nullptr;
 	size_ = 0;
 	capacity_ = 0;
@@ -39,8 +17,7 @@ EQEmu::MemoryBuffer::MemoryBuffer(size_t sz)
 	Resize(sz);
 }
 
-EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
-{
+EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other) {
 	if(other.capacity_) {
 		buffer_ = new uchar[other.capacity_];
 		memcpy(buffer_, other.buffer_, other.capacity_);
@@ -54,8 +31,7 @@ EQEmu::MemoryBuffer::MemoryBuffer(const MemoryBuffer &other)
 	read_pos_ = other.read_pos_;
 }
 
-EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
-{
+EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other) {
 	uchar *tbuf = other.buffer_;
 	size_t tsz = other.size_;
 	size_t tcapacity = other.capacity_;
@@ -75,8 +51,7 @@ EQEmu::MemoryBuffer::MemoryBuffer(MemoryBuffer &&other)
 	read_pos_ = tread_pos;
 }
 
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other)
-{
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other) {
 	if(this == &other) {
 		return *this;
 	}
@@ -100,8 +75,7 @@ EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(const MemoryBuffer &other)
 	return *this;
 }
 
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other)
-{
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other) {
 	uchar *tbuf = other.buffer_;
 	size_t tsz = other.size_;
 	size_t tcapacity = other.capacity_;
@@ -122,8 +96,7 @@ EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator=(MemoryBuffer &&other)
 	return *this;
 }
 
-EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
-{
+EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator+=(const MemoryBuffer &rhs) {
 	if(!rhs.buffer_) {
 		return *this;
 	}
@@ -142,53 +115,41 @@ EQEmu::MemoryBuffer& EQEmu::MemoryBuffer::operator+=(const MemoryBuffer &rhs)
 	return *this;
 }
 
-EQEmu::MemoryBuffer::~MemoryBuffer()
-{
-	Clear();
-}
+EQEmu::MemoryBuffer::~MemoryBuffer() { Clear(); }
 
-uchar& EQEmu::MemoryBuffer::operator[](size_t pos)
-{
+uchar& EQEmu::MemoryBuffer::operator[](size_t pos) {
 	return buffer_[pos];
 }
 
-const uchar& EQEmu::MemoryBuffer::operator[](size_t pos) const
-{
+const uchar& EQEmu::MemoryBuffer::operator[](size_t pos) const {
 	return buffer_[pos];
 }
 
-bool EQEmu::MemoryBuffer::Empty()
-{
+bool EQEmu::MemoryBuffer::Empty() {
 	return size_ == 0;
 }
 
-bool EQEmu::MemoryBuffer::Empty() const
-{
+bool EQEmu::MemoryBuffer::Empty() const {
 	return size_ == 0;
 }
 
-size_t EQEmu::MemoryBuffer::Size()
-{
+size_t EQEmu::MemoryBuffer::Size() {
 	return size_;
 }
 
-size_t EQEmu::MemoryBuffer::Size() const
-{
+size_t EQEmu::MemoryBuffer::Size() const {
 	return size_;
 }
 
-size_t EQEmu::MemoryBuffer::Capacity()
-{
+size_t EQEmu::MemoryBuffer::Capacity() {
 	return capacity_;
 }
 
-size_t EQEmu::MemoryBuffer::Capacity() const
-{
+size_t EQEmu::MemoryBuffer::Capacity() const {
 	return capacity_;
 }
 
-void EQEmu::MemoryBuffer::Resize(size_t sz)
-{
+void EQEmu::MemoryBuffer::Resize(size_t sz) {
 	if(!buffer_) {
 		size_t new_size = sz + 64;
 		buffer_ = new uchar[new_size];
@@ -213,8 +174,7 @@ void EQEmu::MemoryBuffer::Resize(size_t sz)
 	}
 }
 
-void EQEmu::MemoryBuffer::Clear()
-{
+void EQEmu::MemoryBuffer::Clear() {
 	if(buffer_) {
 		delete[] buffer_;
 		buffer_ = nullptr;
@@ -226,15 +186,13 @@ void EQEmu::MemoryBuffer::Clear()
 	read_pos_ = 0;
 }
 
-void EQEmu::MemoryBuffer::Zero()
-{
+void EQEmu::MemoryBuffer::Zero() {
 	if(buffer_) {
 		memset(buffer_, 0, capacity_);
 	}
 }
 
-void EQEmu::MemoryBuffer::Write(const char *val, size_t len)
-{
+void EQEmu::MemoryBuffer::Write(const char *val, size_t len) {
 	size_t size_needed = write_pos_ + len;
 	Resize(size_needed);
 
@@ -242,36 +200,13 @@ void EQEmu::MemoryBuffer::Write(const char *val, size_t len)
 	write_pos_ += len;
 }
 
-void EQEmu::MemoryBuffer::Read(uchar *buf, size_t 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)
-{
+void EQEmu::MemoryBuffer::Read(char *str) {
 	size_t len = strlen((const char*)&buffer_[read_pos_]);
 	memcpy(str, &buffer_[read_pos_], len);
 	read_pos_ += len;
 }
-
-void EQEmu::OutBuffer::overwrite(OutBuffer::pos_type position, const char *_Str, std::streamsize _Count)
-{
-	auto last_pos = tellp();
-	seekp(position);
-	write(_Str, _Count);
-	seekp(last_pos);
-}
-
-uchar* EQEmu::OutBuffer::detach()
-{
-	size_t buffer_size = tellp();
-	if (buffer_size == 0)
-		return nullptr;
-
-	auto out_buffer = new uchar[buffer_size];
-	memcpy(out_buffer, str().c_str(), buffer_size);
-	flush();
-
-	return out_buffer;
-}

common/memory_buffer.h

@@ -1,6 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -14,23 +13,21 @@
 
 	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_MEMORY_BUFFER
-#define COMMON_MEMORY_BUFFER
+#ifndef COMMON_MEMORY_BUFFER_H
+#define COMMON_MEMORY_BUFFER_H
 
 #include "types.h"
-
 #include <type_traits>
 #include <string.h>
 #include <string>
-#include <sstream>
-
 
 namespace EQEmu
 {
-	class MemoryBuffer {
+	class MemoryBuffer
+	{
 	public:
 		MemoryBuffer();
 		MemoryBuffer(size_t sz);
@@ -111,7 +108,7 @@ namespace EQEmu
 		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 SetReadPosition(size_t wp) { read_pos_ = wp; }
 		inline void ReadSkipBytes(size_t skip) { read_pos_ += skip; }
 		
 	private:
@@ -122,13 +119,6 @@ namespace EQEmu
 		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
 
-} /*EQEmu*/
-
-#endif /*COMMON_MEMORY_BUFFER*/
+#endif

common/mutex.h

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

common/mysql_request_result.h

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

common/mysql_request_row.h

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

common/opcode_dispatch.h

@@ -146,7 +146,6 @@ INr(OP_GuildDelete);	//?
 IN(OP_GuildPublicNote, GuildUpdate_PublicNote);
 INz(OP_GetGuildsList);	//?
 IN(OP_SetGuildMOTD, GuildMOTD_Struct);
-IN(OP_SetRunMode, SetRunMode_Struct);
 INz(OP_GuildPeace);		//?
 INz(OP_GuildWar);		//?
 IN(OP_GuildLeader, GuildMakeLeader);
@@ -173,7 +172,7 @@ IN(OP_TradeAcceptClick, TradeAccept_Struct);
 IN(OP_BoardBoat, EntityId_Struct);		//not really the struct, just 4 bytes
 INz(OP_LeaveBoat);		//?
 IN(OP_RandomReq, RandomReq_Struct);
-IN(OP_Buff, SpellBuffPacket_Struct);
+IN(OP_Buff, SpellBuffFade_Struct);
 IN(OP_GMHideMe, SpawnAppearance_Struct);
 IN(OP_GMNameChange, GMName_Struct);
 IN(OP_GMKill, GMKill_Struct);
@@ -415,7 +414,7 @@ OUTv(OP_SendAATable, SendAA_Struct);
 OUT(OP_AAAction, UseAA_Struct);
 OUT(OP_Bazaar, BazaarReturnDone_Struct);
 //alt:OUT(OP_Bazaar, BazaarWelcome_Struct);
-OUT(OP_Buff, SpellBuffPacket_Struct);
+OUT(OP_Buff, SpellBuffFade_Struct);
 OUT(OP_ClickObject, ClickObject_Struct);
 OUT(OP_ClientUpdate, PlayerPositionUpdateServer_Struct);
 OUT(OP_SpawnPositionUpdate, SpawnPositionUpdate_Struct);

common/packet_dump.cpp

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

common/packet_dump_file.cpp

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

common/patches/deprecated_titanium_itemfields_a.h

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

common/patches/makepatch

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

common/patches/patches.cpp

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

common/patches/patches.h

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

common/patches/rof.h

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

common/patches/rof2.h

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

common/patches/rof2_constants.h

@@ -0,0 +1,222 @@
+/*
+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 size_t CHARACTER_CREATION_LIMIT = 12;
+
+		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 size_t BANDOLIERS_SIZE = 20;		// number of bandolier instances
+		static const size_t BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
+
+		static const size_t POTION_BELT_ITEM_COUNT = 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 )
+
+*/