Merge fix

changelog.txt

@@ -1,5 +1,24 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+== 10/17/2016 ==
+Uleat: Moved namespace ItemField from item_instance.h to shareddb.cpp - the only place it is used
+Uleat: Separated class Inventory from item_instance files into inventory_profile files
+Uleat: Renamed class Inventory to EQEmu::InventoryProfile
+Uleat: Renamed enum class InventoryVersion to MobVersion
+
+== 10/16/2016 ==
+Uleat: Renamed struct EQEmu::ItemBase to EQEmu::ItemData and class ItemInst to EQEmu::ItemInstance
+Uleat: Added class EQEmu::InventorySlot. Re-attached pertinent inventory token references to EQDictionary
+
+== 10/15/2016 ==
+Uleat: Changed filenames to facilitate future inventory naming conventions
+
+== 10/09/2016 ==
+Noudess: Rogue usage of merchants while utilizing sneak was limited to
+temporary items, as the code that checked faction per item sold did not
+take into account that rogue was sneaking.  Now sneaking rogues can see full
+inventory on merchants (well, unless an item requires a + faction value).
+
 == 09/12/2016 ==
 Akkadius: Massive overhaul of the update system and EQEmu Server management utility framework 
 	(known as eqemu_update.pl) now known as eqemu_server.pl

common/CMakeLists.txt

@@ -33,9 +33,13 @@ SET(common_sources
 	faction.cpp
 	guild_base.cpp
 	guilds.cpp
+	inventory_profile.cpp
+	inventory_slot.cpp
 	ipc_mutex.cpp
 	item.cpp
 	item_base.cpp
+	item_data.cpp
+	item_instance.cpp
 	json_config.cpp
 	light_source.cpp
 	md5.cpp
@@ -163,10 +167,12 @@ SET(common_headers
 	global_define.h
 	guild_base.h
 	guilds.h
+	inventory_profile.h
+	inventory_slot.h
 	ipc_mutex.h
-	item.h
+	item_data.h
-	item_base.h
 	item_fieldlist.h
+	item_instance.h
 	json_config.h
 	languages.h
 	light_source.h
@@ -239,37 +245,29 @@ SET(common_headers
 	net/tcp_server.h
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
 	patches/sod_limits.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_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_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
 	patches/rof2_limits.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_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
@@ -337,37 +335,29 @@ SOURCE_GROUP(Net FILES
 SOURCE_GROUP(Patches FILES
 	patches/patches.h
 	patches/sod.h
-#	patches/sod_itemfields.h
 	patches/sod_limits.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_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_ops.h
 	patches/rof_structs.h
 	patches/rof2.h
-#	patches/rof2_itemfields.h
 	patches/rof2_limits.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_ops.h
 	patches/titanium_structs.h
 	patches/uf.h
-#	patches/uf_itemfields.h
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h

common/database.cpp

@@ -638,6 +638,13 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 		character_id, pp->binds[4].zoneId, 0, pp->binds[4].x, pp->binds[4].y, pp->binds[4].z, pp->binds[4].heading, 4
 	); results = QueryDatabase(query);
 
+        /* HoTT Ability */
+        if(RuleB(Character, GrantHoTTOnCreate))
+        {
+                query = StringFormat("INSERT INTO `character_leadership_abilities` (id, slot, rank) VALUES (%u, %i, %i)", character_id, 14, 1);
+                results = QueryDatabase(query);
+        }
+
 	/* Save Skills */
 	int firstquery = 0;
 	for (int i = 0; i < MAX_PP_SKILL; i++){
@@ -672,7 +679,7 @@ bool Database::SaveCharacterCreate(uint32 character_id, uint32 account_id, Playe
 }
 
 /* This only for new Character creation storing */
-bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv) {
+bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv) {
 	uint32 charid = 0; 
 	char zone[50]; 
 	float x, y, z; 
@@ -701,7 +708,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;) {
-		const ItemInst* newinv = inv->GetItem(i);
+		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
 				charid, i, newinv->GetItem()->ID, newinv->GetCharges(), newinv->GetColor()); 
@@ -709,7 +716,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inven
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == EQEmu::legacy::SlotCursor) {
+		if (i == EQEmu::inventory::slotCursor) {
 			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
 			continue;
 		}

common/database.h

@@ -37,10 +37,14 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
-class Inventory;
 class MySQLRequestResult;
 class Client;
 
+namespace EQEmu
+{
+	class InventoryProfile;
+}
+
 struct EventLogDetails_Struct {
 	uint32	id;
 	char	accountname[64];
@@ -109,7 +113,7 @@ public:
 	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
 	bool	SetHackerFlag(const char* accountname, const char* charactername, const char* hacked);
 	bool	SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone);
-	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
+	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv);
 	bool	UpdateName(const char* oldname, const char* newname);
 
 	/* General Information Queries */

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[EQEmu::textures::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[EQEmu::textures::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[EQEmu::textures::materialCount];
 		/*0428*/	Convert::AA_Array				aa_array[MAX_PP_AA_ARRAY];
 		/*2348*/	float							unknown2384;		//seen ~128, ~47
 		/*2352*/	char							servername[32];		// length probably not right
@@ -1403,7 +1403,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 = EQEmu::textures::textureBegin; i < EQEmu::textures::materialCount; i++){
 					if (pp->item_tint[i].color > 0){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_material` (id, slot, blue, green, red, use_tint, color) VALUES (%u, %u, %u, %u, %u, %u, %u)", character_id, i, pp->item_tint[i].rgb.blue, pp->item_tint[i].rgb.green, pp->item_tint[i].rgb.red, pp->item_tint[i].rgb.use_tint, pp->item_tint[i].color);

common/emu_constants.h

@@ -35,6 +35,79 @@ namespace EQEmu
 		//using namespace RoF2::invbag;
 		//using namespace RoF2::invaug;
 
+		enum : int16 { typeInvalid = -1, slotInvalid = -1, containerInvalid = -1, socketInvalid = -1 }; // temporary
+		enum : int16 { typeBegin = 0, slotBegin = 0, containerBegin = 0, socketBegin = 0 }; // temporary
+
+		enum PossessionsSlots : int16 { // temporary
+			slotCharm = 0,
+			slotEar1,
+			slotHead,
+			slotFace,
+			slotEar2,
+			slotNeck, // 5
+			slotShoulders,
+			slotArms,
+			slotBack,
+			slotWrist1,
+			slotWrist2, // 10
+			slotRange,
+			slotHands,
+			slotPrimary,
+			slotSecondary,
+			slotFinger1, // 15
+			slotFinger2,
+			slotChest,
+			slotLegs,
+			slotFeet,
+			slotWaist, // 20
+			slotPowerSource = 9999,
+			slotAmmo = 21,
+			slotGeneral1,
+			slotGeneral2,
+			slotGeneral3,
+			slotGeneral4, // 25
+			slotGeneral5,
+			slotGeneral6,
+			slotGeneral7,
+			slotGeneral8,
+			slotCursor, // 30
+			slotCount
+		};
+
+		enum InventoryTypes : int16 { // temporary
+			typePossessions = 0,
+			typeBank,
+			typeSharedBank,
+			typeTrade,
+			typeWorld,
+			typeLimbo, // 5
+			typeTribute,
+			typeTrophyTribute,
+			typeGuildTribute,
+			typeMerchant,
+			typeDeleted, // 10
+			typeCorpse,
+			typeBazaar,
+			typeInspect,
+			typeRealEstate,
+			typeViewMODPC, // 15
+			typeViewMODBank,
+			typeViewMODSharedBank,
+			typeViewMODLimbo,
+			typeAltStorage,
+			typeArchived, // 20
+			typeMail,
+			typeGuildTrophyTribute,
+			typeKrono,
+			typeOther,
+			typeCount
+		};
+
+		static int16 SlotCount(int16 type_index) { return 0; } // temporary
+
+		const int16 ContainerCount = 10; // temporary
+		const int16 SocketCount = 6; // temporary
+
 	} /*inventory*/
 
 	namespace constants {
@@ -43,7 +116,16 @@ namespace EQEmu
 
 		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
 
+		const int LongBuffs = RoF2::constants::LongBuffs;
+		const int ShortBuffs = RoF2::constants::ShortBuffs;
+		const int DiscBuffs = RoF2::constants::DiscBuffs;
+		const int TotalBuffs = RoF2::constants::TotalBuffs;
+		const int NPCBuffs = RoF2::constants::NPCBuffs;
+		const int PetBuffs = RoF2::constants::PetBuffs;
+		const int MercBuffs = RoF2::constants::MercBuffs;
+
 	} /*constants*/
+
 	enum class CastingSlot : uint32 {
 		Gem1       = 0,
 		Gem2       = 1,
@@ -68,3 +150,9 @@ namespace EQEmu
 } /*EQEmu*/
 
 #endif /*COMMON_EMU_CONSTANTS_H*/
+
+/*	hack list to prevent circular references
+	
+	eq_limits.h:EQEmu::inventory::LookupEntry::InventoryTypeSize[n];
+
+*/

common/emu_legacy.h

@@ -61,8 +61,6 @@ namespace EQEmu
 			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,
@@ -96,75 +94,8 @@ namespace EQEmu
 			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_POSSESSIONS_SIZE = 31;
 		static const uint16 TYPE_BANK_SIZE = 24;
 		static const uint16 TYPE_SHARED_BANK_SIZE = 2;
 		static const uint16 TYPE_TRADE_SIZE = 8;
@@ -175,14 +106,14 @@ namespace EQEmu
 		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_CORPSE_SIZE = 31; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
 		static const uint16 TYPE_BAZAAR_SIZE = 80;
 		static const uint16 TYPE_INSPECT_SIZE = 22;
 		static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;//NOT_USED;
+		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;//NOT_USED;
+		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;//NOT_USED;
+		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;//NOT_USED;
+		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;
 		static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
 		static const uint16 TYPE_ARCHIVED_SIZE = 0;
 		static const uint16 TYPE_MAIL_SIZE = 0;
@@ -192,12 +123,12 @@ namespace EQEmu
 
 		// 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_BEGIN = 0;
-		static const int16 EQUIPMENT_END = SlotAmmo;
+		static const int16 EQUIPMENT_END = 21;
 		static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
 
-		static const int16 GENERAL_BEGIN = SlotGeneral1;
+		static const int16 GENERAL_BEGIN = 22;
-		static const int16 GENERAL_END = SlotGeneral8;
+		static const int16 GENERAL_END = 29;
 		static const uint16 GENERAL_SIZE = 8;
 		static const int16 GENERAL_BAGS_BEGIN = 251;
 		static const int16 GENERAL_BAGS_END_OFFSET = 79;
@@ -235,22 +166,17 @@ namespace EQEmu
 		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 BANDOLIERS_SIZE = 20;		// number of bandolier instances
-		static const size_t BANDOLIER_ITEM_COUNT = 4;//RoF2::consts::BANDOLIER_ITEM_COUNT;	// number of equipment slots in bandolier instance
+		static const size_t BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
 
 		// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t POTION_BELT_ITEM_COUNT = 5;//RoF2::consts::POTION_BELT_ITEM_COUNT;
+		static const size_t POTION_BELT_ITEM_COUNT = 5;
 
-		static const size_t TEXT_LINK_BODY_LENGTH = 56;//RoF2::consts::TEXT_LINK_BODY_LENGTH;
+		static const size_t TEXT_LINK_BODY_LENGTH = 56;
 	}
+
 }
 
 #endif /* COMMON_EMU_LEGACY_H */

common/emu_versions.cpp

@@ -127,244 +127,244 @@ uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_ver
 	}
 }
 
-bool EQEmu::versions::IsValidInventoryVersion(InventoryVersion inventory_version)
+bool EQEmu::versions::IsValidMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
+	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
 		return false;
 
 	return true;
 }
 
-bool EQEmu::versions::IsValidPCInventoryVersion(InventoryVersion inventory_version)
+bool EQEmu::versions::IsValidPCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
+	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
 		return false;
 
 	return true;
 }
 
-bool EQEmu::versions::IsValidNonPCInventoryVersion(InventoryVersion inventory_version)
+bool EQEmu::versions::IsValidNonPCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
+	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
 		return false;
 
 	return true;
 }
 
-bool EQEmu::versions::IsValidOfflinePCInventoryVersion(InventoryVersion inventory_version)
+bool EQEmu::versions::IsValidOfflinePCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= LastNonPCInventoryVersion || inventory_version > LastOfflinePCInventoryVersion)
+	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
 		return false;
 
 	return true;
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ValidateInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastInventoryVersion)
+	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 
-	return inventory_version;
+	return mob_version;
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ValidatePCInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidatePCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= InventoryVersion::Unknown || inventory_version > LastPCInventoryVersion)
+	if (mob_version <= MobVersion::Unknown || mob_version > LastPCMobVersion)
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 
-	return inventory_version;
+	return mob_version;
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ValidateNonPCInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateNonPCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= LastPCInventoryVersion || inventory_version > LastNonPCInventoryVersion)
+	if (mob_version <= LastPCMobVersion || mob_version > LastNonPCMobVersion)
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 
-	return inventory_version;
+	return mob_version;
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ValidateOfflinePCInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ValidateOfflinePCMobVersion(MobVersion mob_version)
 {
-	if (inventory_version <= LastNonPCInventoryVersion || inventory_version > LastOfflinePCInventoryVersion)
+	if (mob_version <= LastNonPCMobVersion || mob_version > LastOfflinePCMobVersion)
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 
-	return inventory_version;
+	return mob_version;
 }
 
-const char* EQEmu::versions::InventoryVersionName(InventoryVersion inventory_version)
+const char* EQEmu::versions::MobVersionName(MobVersion mob_version)
 {
-	switch (inventory_version) {
+	switch (mob_version) {
-	case InventoryVersion::Unknown:
+	case MobVersion::Unknown:
 		return "Unknown Version";
-	case InventoryVersion::Client62:
+	case MobVersion::Client62:
 		return "Client 6.2";
-	case InventoryVersion::Titanium:
+	case MobVersion::Titanium:
 		return "Titanium";
-	case InventoryVersion::SoF:
+	case MobVersion::SoF:
 		return "SoF";
-	case InventoryVersion::SoD:
+	case MobVersion::SoD:
 		return "SoD";
-	case InventoryVersion::UF:
+	case MobVersion::UF:
 		return "UF";
-	case InventoryVersion::RoF:
+	case MobVersion::RoF:
 		return "RoF";
-	case InventoryVersion::RoF2:
+	case MobVersion::RoF2:
 		return "RoF2";
-	case InventoryVersion::NPC:
+	case MobVersion::NPC:
 		return "NPC";
-	case InventoryVersion::NPCMerchant:
+	case MobVersion::NPCMerchant:
 		return "NPC Merchant";
-	case InventoryVersion::Merc:
+	case MobVersion::Merc:
 		return "Merc";
-	case InventoryVersion::Bot:
+	case MobVersion::Bot:
 		return "Bot";
-	case InventoryVersion::ClientPet:
+	case MobVersion::ClientPet:
 		return "Client Pet";
-	case InventoryVersion::NPCPet:
+	case MobVersion::NPCPet:
 		return "NPC Pet";
-	case InventoryVersion::MercPet:
+	case MobVersion::MercPet:
 		return "Merc Pet";
-	case InventoryVersion::BotPet:
+	case MobVersion::BotPet:
 		return "Bot Pet";
-	case InventoryVersion::OfflineTitanium:
+	case MobVersion::OfflineTitanium:
 		return "Offline Titanium";
-	case InventoryVersion::OfflineSoF:
+	case MobVersion::OfflineSoF:
 		return "Offline SoF";
-	case InventoryVersion::OfflineSoD:
+	case MobVersion::OfflineSoD:
 		return "Offline SoD";
-	case InventoryVersion::OfflineUF:
+	case MobVersion::OfflineUF:
 		return "Offline UF";
-	case InventoryVersion::OfflineRoF:
+	case MobVersion::OfflineRoF:
 		return "Offline RoF";
-	case InventoryVersion::OfflineRoF2:
+	case MobVersion::OfflineRoF2:
 		return "Offline RoF2";
 	default:
 		return "Invalid Version";
 	};
 }
 
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version)
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertMobVersionToClientVersion(MobVersion mob_version)
 {
-	switch (inventory_version) {
+	switch (mob_version) {
-	case InventoryVersion::Unknown:
+	case MobVersion::Unknown:
-	case InventoryVersion::Client62:
+	case MobVersion::Client62:
 		return ClientVersion::Unknown;
-	case InventoryVersion::Titanium:
+	case MobVersion::Titanium:
 		return ClientVersion::Titanium;
-	case InventoryVersion::SoF:
+	case MobVersion::SoF:
 		return ClientVersion::SoF;
-	case InventoryVersion::SoD:
+	case MobVersion::SoD:
 		return ClientVersion::SoD;
-	case InventoryVersion::UF:
+	case MobVersion::UF:
 		return ClientVersion::UF;
-	case InventoryVersion::RoF:
+	case MobVersion::RoF:
 		return ClientVersion::RoF;
-	case InventoryVersion::RoF2:
+	case MobVersion::RoF2:
 		return ClientVersion::RoF2;
 	default:
 		return ClientVersion::Unknown;
 	}
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion client_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Unknown:
 	case ClientVersion::Client62:
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 	case ClientVersion::Titanium:
-		return InventoryVersion::Titanium;
+		return MobVersion::Titanium;
 	case ClientVersion::SoF:
-		return InventoryVersion::SoF;
+		return MobVersion::SoF;
 	case ClientVersion::SoD:
-		return InventoryVersion::SoD;
+		return MobVersion::SoD;
 	case ClientVersion::UF:
-		return InventoryVersion::UF;
+		return MobVersion::UF;
 	case ClientVersion::RoF:
-		return InventoryVersion::RoF;
+		return MobVersion::RoF;
 	case ClientVersion::RoF2:
-		return InventoryVersion::RoF2;
+		return MobVersion::RoF2;
 	default:
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 	}
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ConvertPCInventoryVersionToOfflinePCInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version)
 {
-	switch (inventory_version) {
+	switch (mob_version) {
-	case InventoryVersion::Titanium:
+	case MobVersion::Titanium:
-		return InventoryVersion::OfflineTitanium;
+		return MobVersion::OfflineTitanium;
-	case InventoryVersion::SoF:
+	case MobVersion::SoF:
-		return InventoryVersion::OfflineSoF;
+		return MobVersion::OfflineSoF;
-	case InventoryVersion::SoD:
+	case MobVersion::SoD:
-		return InventoryVersion::OfflineSoD;
+		return MobVersion::OfflineSoD;
-	case InventoryVersion::UF:
+	case MobVersion::UF:
-		return InventoryVersion::OfflineUF;
+		return MobVersion::OfflineUF;
-	case InventoryVersion::RoF:
+	case MobVersion::RoF:
-		return InventoryVersion::OfflineRoF;
+		return MobVersion::OfflineRoF;
-	case InventoryVersion::RoF2:
+	case MobVersion::RoF2:
-		return InventoryVersion::OfflineRoF2;
+		return MobVersion::OfflineRoF2;
 	default:
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 	}
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ConvertOfflinePCInventoryVersionToPCInventoryVersion(InventoryVersion inventory_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version)
 {
-	switch (inventory_version) {
+	switch (mob_version) {
-	case InventoryVersion::OfflineTitanium:
+	case MobVersion::OfflineTitanium:
-		return InventoryVersion::Titanium;
+		return MobVersion::Titanium;
-	case InventoryVersion::OfflineSoF:
+	case MobVersion::OfflineSoF:
-		return InventoryVersion::SoF;
+		return MobVersion::SoF;
-	case InventoryVersion::OfflineSoD:
+	case MobVersion::OfflineSoD:
-		return InventoryVersion::SoD;
+		return MobVersion::SoD;
-	case InventoryVersion::OfflineUF:
+	case MobVersion::OfflineUF:
-		return InventoryVersion::UF;
+		return MobVersion::UF;
-	case InventoryVersion::OfflineRoF:
+	case MobVersion::OfflineRoF:
-		return InventoryVersion::RoF;
+		return MobVersion::RoF;
-	case InventoryVersion::OfflineRoF2:
+	case MobVersion::OfflineRoF2:
-		return InventoryVersion::RoF2;
+		return MobVersion::RoF2;
 	default:
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 	}
 }
 
-EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCInventoryVersionToClientVersion(InventoryVersion inventory_version)
+EQEmu::versions::ClientVersion EQEmu::versions::ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version)
 {
-	switch (inventory_version) {
+	switch (mob_version) {
-	case InventoryVersion::OfflineTitanium:
+	case MobVersion::OfflineTitanium:
 		return ClientVersion::Titanium;
-	case InventoryVersion::OfflineSoF:
+	case MobVersion::OfflineSoF:
 		return ClientVersion::SoF;
-	case InventoryVersion::OfflineSoD:
+	case MobVersion::OfflineSoD:
 		return ClientVersion::SoD;
-	case InventoryVersion::OfflineUF:
+	case MobVersion::OfflineUF:
 		return ClientVersion::UF;
-	case InventoryVersion::OfflineRoF:
+	case MobVersion::OfflineRoF:
 		return ClientVersion::RoF;
-	case InventoryVersion::OfflineRoF2:
+	case MobVersion::OfflineRoF2:
 		return ClientVersion::RoF2;
 	default:
 		return ClientVersion::Unknown;
 	}
 }
 
-EQEmu::versions::InventoryVersion EQEmu::versions::ConvertClientVersionToOfflinePCInventoryVersion(ClientVersion client_version)
+EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version)
 {
 	switch (client_version) {
 	case ClientVersion::Titanium:
-		return InventoryVersion::OfflineTitanium;
+		return MobVersion::OfflineTitanium;
 	case ClientVersion::SoF:
-		return InventoryVersion::OfflineSoF;
+		return MobVersion::OfflineSoF;
 	case ClientVersion::SoD:
-		return InventoryVersion::OfflineSoD;
+		return MobVersion::OfflineSoD;
 	case ClientVersion::UF:
-		return InventoryVersion::OfflineUF;
+		return MobVersion::OfflineUF;
 	case ClientVersion::RoF:
-		return InventoryVersion::OfflineRoF;
+		return MobVersion::OfflineRoF;
 	case ClientVersion::RoF2:
-		return InventoryVersion::OfflineRoF2;
+		return MobVersion::OfflineRoF2;
 	default:
-		return InventoryVersion::Unknown;
+		return MobVersion::Unknown;
 	}
 }

common/emu_versions.h

@@ -64,17 +64,15 @@ namespace EQEmu
 		const ClientVersion LastClientVersion = ClientVersion::RoF2;
 		const size_t ClientVersionCount = (static_cast<size_t>(LastClientVersion) + 1);
 
-		extern bool IsValidClientVersion(ClientVersion client_version);
+		bool IsValidClientVersion(ClientVersion client_version);
-		extern ClientVersion ValidateClientVersion(ClientVersion client_version);
+		ClientVersion ValidateClientVersion(ClientVersion client_version);
-		extern const char* ClientVersionName(ClientVersion client_version);
+		const char* ClientVersionName(ClientVersion client_version);
-		extern uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
+		uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
-		extern ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
+		ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
-		extern uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
+		uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
 
-	} /*versions*/
 
-	namespace versions {
+		enum class MobVersion {
-		enum class InventoryVersion {
 			Unknown = 0,
 			Client62,
 			Titanium,
@@ -99,29 +97,29 @@ namespace EQEmu
 			OfflineRoF2
 		};
 
-		const InventoryVersion LastInventoryVersion = InventoryVersion::OfflineRoF2;
+		const MobVersion LastMobVersion = MobVersion::OfflineRoF2;
-		const InventoryVersion LastPCInventoryVersion = InventoryVersion::RoF2;
+		const MobVersion LastPCMobVersion = MobVersion::RoF2;
-		const InventoryVersion LastNonPCInventoryVersion = InventoryVersion::BotPet;
+		const MobVersion LastNonPCMobVersion = MobVersion::BotPet;
-		const InventoryVersion LastOfflinePCInventoryVersion = InventoryVersion::OfflineRoF2;
+		const MobVersion LastOfflinePCMobVersion = MobVersion::OfflineRoF2;
-		const size_t InventoryVersionCount = (static_cast<size_t>(LastInventoryVersion) + 1);
+		const size_t MobVersionCount = (static_cast<size_t>(LastMobVersion) + 1);
 
-		extern bool IsValidInventoryVersion(InventoryVersion inventory_version);
+		bool IsValidMobVersion(MobVersion mob_version);
-		extern bool IsValidPCInventoryVersion(InventoryVersion inventory_version);
+		bool IsValidPCMobVersion(MobVersion mob_version);
-		extern bool IsValidNonPCInventoryVersion(InventoryVersion inventory_version);
+		bool IsValidNonPCMobVersion(MobVersion mob_version);
-		extern bool IsValidOfflinePCInventoryVersion(InventoryVersion inventory_version);
+		bool IsValidOfflinePCMobVersion(MobVersion mob_version);
 
-		extern InventoryVersion ValidateInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ValidateMobVersion(MobVersion mob_version);
-		extern InventoryVersion ValidatePCInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ValidatePCMobVersion(MobVersion mob_version);
-		extern InventoryVersion ValidateNonPCInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ValidateNonPCMobVersion(MobVersion mob_version);
-		extern InventoryVersion ValidateOfflinePCInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ValidateOfflinePCMobVersion(MobVersion mob_version);
 
-		extern const char* InventoryVersionName(InventoryVersion inventory_version);
+		const char* MobVersionName(MobVersion mob_version);
-		extern ClientVersion ConvertInventoryVersionToClientVersion(InventoryVersion inventory_version);
+		ClientVersion ConvertMobVersionToClientVersion(MobVersion mob_version);
-		extern InventoryVersion ConvertClientVersionToInventoryVersion(ClientVersion client_version);
+		MobVersion ConvertClientVersionToMobVersion(ClientVersion client_version);
-		extern InventoryVersion ConvertPCInventoryVersionToOfflinePCInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ConvertPCMobVersionToOfflinePCMobVersion(MobVersion mob_version);
-		extern InventoryVersion ConvertOfflinePCInventoryVersionToPCInventoryVersion(InventoryVersion inventory_version);
+		MobVersion ConvertOfflinePCMobVersionToPCMobVersion(MobVersion mob_version);
-		extern ClientVersion ConvertOfflinePCInventoryVersionToClientVersion(InventoryVersion inventory_version);
+		ClientVersion ConvertOfflinePCMobVersionToClientVersion(MobVersion mob_version);
-		extern InventoryVersion ConvertClientVersionToOfflinePCInventoryVersion(ClientVersion client_version);
+		MobVersion ConvertClientVersionToOfflinePCMobVersion(ClientVersion client_version);
 
 	} /*versions*/
 

common/eq_constants.h

@@ -516,14 +516,6 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 */
 
 #define INVALID_INDEX	-1
-#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
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 

common/eq_limits.h

@@ -38,6 +38,13 @@ namespace EQEmu
 		class LookupEntry {
 		public:
 			size_t CharacterCreationLimit;
+			int LongBuffs;
+			int ShortBuffs;
+			int DiscBuffs;
+			int TotalBuffs;
+			int NPCBuffs;
+			int PetBuffs;
+			int MercBuffs;
 		};
 
 		const LookupEntry* Lookup(versions::ClientVersion client_version);
@@ -47,7 +54,7 @@ namespace EQEmu
 	namespace inventory {
 		class LookupEntry {
 		public:
-			size_t InventoryTypeSize[legacy::TypeCount];
+			size_t InventoryTypeSize[25]; // should reflect EQEmu::inventory::typeCount referenced in emu_constants.h
 
 			uint64 PossessionsBitmask;
 			size_t ItemBagSize;
@@ -59,7 +66,7 @@ namespace EQEmu
 			bool AllowOverLevelEquipment;
 		};
 
-		const LookupEntry* Lookup(versions::InventoryVersion inventory_version);
+		const LookupEntry* Lookup(versions::MobVersion mob_version);
 
 	} /*inventory*/
 	
@@ -69,7 +76,7 @@ namespace EQEmu
 			bool CoinHasWeight;
 		};
 
-		const LookupEntry* Lookup(versions::InventoryVersion inventory_version);
+		const LookupEntry* Lookup(versions::MobVersion mob_version);
 
 	} /*behavior*/
 

common/eq_packet_structs.h

@@ -127,7 +127,7 @@ struct LDoNTrapTemplate
 
 // All clients translate the character select information to some degree
 
-struct CharSelectEquip : EQEmu::Texture_Struct, EQEmu::Tint_Struct {};
+struct CharSelectEquip : EQEmu::textures::Texture_Struct, EQEmu::textures::Tint_Struct {};
 
 // RoF2-based hybrid struct
 struct CharacterSelectEntry_Struct
@@ -142,7 +142,7 @@ struct CharacterSelectEntry_Struct
 	uint16 Instance;
 	uint8 Gender;
 	uint8 Face;
-	CharSelectEquip	Equip[EQEmu::textures::TextureCount];
+	CharSelectEquip	Equip[EQEmu::textures::materialCount];
 	uint8 Unknown15;			// Seen FF
 	uint8 Unknown19;			// Seen FF
 	uint32 DrakkinTattoo;
@@ -834,7 +834,7 @@ struct SuspendedMinion_Struct
 	/*002*/	uint32 HP;
 	/*006*/	uint32 Mana;
 	/*010*/	SpellBuff_Struct Buffs[BUFF_COUNT];
-	/*510*/	EQEmu::TextureShortProfile Items;
+	/*510*/	EQEmu::TextureMaterialProfile Items;
 	/*546*/	char Name[64];
 	/*610*/
 };
@@ -942,7 +942,7 @@ 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*/	EQEmu::TextureMaterialProfile	item_material;	// Item texture/material of worn/held items
 /*0348*/	uint8				unknown0348[44];
 /*0392*/	EQEmu::TintProfile	item_tint;
 /*0428*/	AA_Array			aa_array[MAX_PP_AA_ARRAY];
@@ -1179,7 +1179,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*/ EQEmu::textures::Tint_Struct color;
 /*026*/ uint8 wear_slot_id;
 /*027*/
 };
@@ -2071,7 +2071,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	EQEmu::ItemBase item;
+	EQEmu::ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 
@@ -3517,6 +3517,20 @@ struct RecipeAutoCombine_Struct {
 								// f5 ff ff ff in 'you dont have all the stuff' reply
 };
 
+// this is the "value#a" data
+enum EParticlePoint {
+	eDefault,
+	eChest,
+	eHead,
+	eLeftHand,
+	eRigthHand,
+	eLeftFoot,
+	eRightFood,
+	eLeftEye,
+	eRightEye,
+	eMouth
+};
+
 struct LevelAppearance_Struct { //Sends a little graphic on level up
 	uint32	spawn_id;
 	uint32	parm1;

common/extprofile.h

@@ -19,7 +19,7 @@
 #define EXTENDED_PROFILE_H
 
 #include "eq_packet_structs.h"
-#include "item.h"
+#include "inventory_profile.h"
 
 #pragma pack(1)
 
@@ -40,7 +40,7 @@ struct ExtendedProfile_Struct {
 	uint16				old_pet_hp; /* Not Used */
 	uint16				old_pet_mana; /* Not Used */
 	SpellBuff_Struct	pet_buffs[BUFF_COUNT]; /* Not Used */
-	EQEmu::TextureShortProfile	pet_items; /* Not Used */
+	EQEmu::TextureMaterialProfile	pet_items; /* Not Used */
 	char				merc_name[64]; /* Used */
 
 	uint32				aa_effects; /* Used */

common/inventory_profile.h

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

common/inventory_slot.cpp

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

common/inventory_slot.h

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

common/item.h

@@ -1,544 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-
-	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
-*/
-
-// @merth notes:
-// These classes could be optimized with database reads/writes by storing
-// a status flag indicating how object needs to interact with database
-
-#ifndef COMMON_ITEM_H
-#define COMMON_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/timer.h"
-#include "../common/bodytypes.h"
-#include "../common/deity.h"
-#include "../common/memory_buffer.h"
-
-#include <list>
-#include <map>
-
-
-namespace ItemField
-{
-	enum
-	{
-		source = 0,
-#define F(x) x,
-#include "item_fieldlist.h"
-#undef F
-		updated
-	};
-};
-
-// Specifies usage type for item inside ItemInst
-enum ItemInstTypes
-{
-	ItemInstNormal = 0,
-	ItemInstWorldContainer
-};
-
-typedef enum {
-	byFlagIgnore,	//do not consider this flag
-	byFlagSet,		//apply action if the flag is set
-	byFlagNotSet	//apply action if the flag is NOT set
-} byFlagSetting;
-
-
-//FatherNitwit: location bits for searching specific
-//places with HasItem() and HasItemByUse()
-enum {
-	invWhereWorn		= 0x01,
-	invWherePersonal	= 0x02,	//in the character's inventory
-	invWhereBank		= 0x04,
-	invWhereSharedBank	= 0x08,
-	invWhereTrading		= 0x10,
-	invWhereCursor		= 0x20
-};
-
-class ItemInst;
-
-// ########################################
-// Class: Queue
-//	Queue that allows a read-only iterator
-class ItemInstQueue
-{
-public:
-	~ItemInstQueue();
-	/////////////////////////
-	// Public Methods
-	/////////////////////////
-
-	inline std::list<ItemInst*>::const_iterator cbegin() { return m_list.cbegin(); }
-	inline std::list<ItemInst*>::const_iterator cend() { return m_list.cend(); }
-
-	inline int size() { return static_cast<int>(m_list.size()); } // TODO: change to size_t
-	inline bool empty() { return m_list.empty(); }
-
-	void push(ItemInst* inst);
-	void push_front(ItemInst* inst);
-	ItemInst* pop();
-	ItemInst* pop_back();
-	ItemInst* peek_front() const;
-
-protected:
-	/////////////////////////
-	// Protected Members
-	/////////////////////////
-
-	std::list<ItemInst*> m_list;
-};
-
-// ########################################
-// Class: Inventory
-//	Character inventory
-class Inventory
-{
-	friend class ItemInst;
-public:
-	///////////////////////////////
-	// Public Methods
-	///////////////////////////////
-	
-	Inventory() { m_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);
-		}
-		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; }
-
-	static void CleanDirty();
-	static void MarkDirty(ItemInst *inst);
-
-	// Retrieve a writeable item at specified slot
-	ItemInst* GetItem(int16 slot_id) const;
-	ItemInst* GetItem(int16 slot_id, uint8 bagidx) const;
-
-	inline std::list<ItemInst*>::const_iterator cursor_cbegin() { return m_cursor.cbegin(); }
-	inline std::list<ItemInst*>::const_iterator cursor_cend() { return m_cursor.cend(); }
-
-	inline int CursorSize() { return m_cursor.size(); }
-	inline bool CursorEmpty() { return m_cursor.empty(); }
-
-	// Retrieve a read-only item from inventory
-	inline const ItemInst* operator[](int16 slot_id) const { return GetItem(slot_id); }
-
-	// Add item to inventory
-	int16 PutItem(int16 slot_id, const ItemInst& inst);
-
-	// Add item to cursor queue
-	int16 PushCursor(const ItemInst& inst);
-
-	// Get cursor item in front of queue
-	ItemInst* GetCursorItem();
-
-	// Swap items in inventory
-	bool SwapItem(int16 slot_a, int16 slot_b);
-
-	// Remove item from inventory
-	bool DeleteItem(int16 slot_id, uint8 quantity=0);
-
-	// Checks All items in a bag for No Drop
-	bool CheckNoDrop(int16 slot_id);
-
-	// Remove item from inventory (and take control of memory)
-	ItemInst* PopItem(int16 slot_id);
-
-	// Check whether there is space for the specified number of the specified item.
-	bool HasSpaceForItem(const EQEmu::ItemBase *ItemToTry, int16 Quantity);
-
-	// Check whether item exists in inventory
-	// where argument specifies OR'd list of invWhere constants to look
-	int16 HasItem(uint32 item_id, uint8 quantity = 0, uint8 where = 0xFF);
-
-	// Check whether item exists in inventory
-	// where argument specifies OR'd list of invWhere constants to look
-	int16 HasItemByUse(uint8 use, uint8 quantity=0, uint8 where=0xFF);
-
-	// Check whether item exists in inventory
-	// where argument specifies OR'd list of invWhere constants to look
-	int16 HasItemByLoreGroup(uint32 loregroup, uint8 where=0xFF);
-
-	// Locate an available inventory slot
-	int16 FindFreeSlot(bool for_bag, bool try_cursor, uint8 min_size = 0, bool is_arrow = false);
-	int16 FindFreeSlotForTradeItem(const ItemInst* inst);
-
-	// Calculate slot_id for an item within a bag
-	static int16 CalcSlotId(int16 slot_id); // Calc parent bag's slot_id
-	static int16 CalcSlotId(int16 bagslot_id, uint8 bagidx); // Calc slot_id for item inside bag
-	static uint8 CalcBagIdx(int16 slot_id); // Calc bagidx for slot_id
-	static int16 CalcSlotFromMaterial(uint8 material);
-	static uint8 CalcMaterialFromSlot(int16 equipslot);
-
-	static bool CanItemFitInContainer(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container);
-
-	//  Test for valid inventory casting slot
-	bool SupportsClickCasting(int16 slot_id);
-	bool SupportsPotionBeltCasting(int16 slot_id);
-
-	// Test whether a given slot can support a container item
-	static bool SupportsContainers(int16 slot_id);
-
-	int GetSlotByItemInst(ItemInst *inst);
-
-	uint8 FindBrightestLightType();
-
-	void dumpEntireInventory();
-	void dumpWornItems();
-	void dumpInventory();
-	void dumpBankItems();
-	void dumpSharedBankItems();
-
-	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, std::string value);
-	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, int value);
-	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, float value);
-	void SetCustomItemData(uint32 character_id, int16 slot_id, std::string identifier, bool value);
-	std::string GetCustomItemData(int16 slot_id, std::string identifier);
-protected:
-	///////////////////////////////
-	// Protected Methods
-	///////////////////////////////
-
-	int GetSlotByItemInstCollection(const std::map<int16, ItemInst*> &collection, ItemInst *inst);
-	void dumpItemCollection(const std::map<int16, ItemInst*> &collection);
-	void dumpBagContents(ItemInst *inst, std::map<int16, ItemInst*>::const_iterator *it);
-
-	// Retrieves item within an inventory bucket
-	ItemInst* _GetItem(const std::map<int16, ItemInst*>& bucket, int16 slot_id) const;
-
-	// Private "put" item into bucket, without regard for what is currently in bucket
-	int16 _PutItem(int16 slot_id, ItemInst* inst);
-
-	// Checks an inventory bucket for a particular item
-	int16 _HasItem(std::map<int16, ItemInst*>& bucket, uint32 item_id, uint8 quantity);
-	int16 _HasItem(ItemInstQueue& iqueue, uint32 item_id, uint8 quantity);
-	int16 _HasItemByUse(std::map<int16, ItemInst*>& bucket, uint8 use, uint8 quantity);
-	int16 _HasItemByUse(ItemInstQueue& iqueue, uint8 use, uint8 quantity);
-	int16 _HasItemByLoreGroup(std::map<int16, ItemInst*>& bucket, uint32 loregroup);
-	int16 _HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup);
-
-
-	// Player inventory
-	std::map<int16, ItemInst*>	m_worn;		// Items worn by character
-	std::map<int16, ItemInst*>	m_inv;		// Items in character personal inventory
-	std::map<int16, ItemInst*>	m_bank;		// Items in character bank
-	std::map<int16, ItemInst*>	m_shbank;	// Items in character shared bank
-	std::map<int16, ItemInst*>	m_trade;	// Items in a trade session
-	ItemInstQueue				m_cursor;	// Items on cursor: FIFO
-
-private:
-	// Active inventory version
-	EQEmu::versions::InventoryVersion m_inventory_version;
-	bool m_inventory_version_set;
-};
-
-class SharedDatabase;
-
-// ########################################
-// Class: ItemInst
-//	Base class for an instance of an item
-//	An item instance encapsulates item data + data specific
-//	to an item instance (includes dye, augments, charges, etc)
-class ItemInst
-{
-public:
-	/////////////////////////
-	// Methods
-	/////////////////////////
-
-	// Constructors/Destructor
-	ItemInst(const EQEmu::ItemBase* item = nullptr, int16 charges = 0);
-
-	ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0);
-
-	ItemInst(ItemInstTypes use_type);
-
-	ItemInst(const ItemInst& copy);
-
-	~ItemInst();
-
-	// Query item type
-	bool IsType(EQEmu::item::ItemClass item_class) const;
-
-	bool IsClassCommon();
-	bool IsClassBag();
-	bool IsClassBook();
-
-	bool IsClassCommon() const { return const_cast<ItemInst*>(this)->IsClassCommon(); }
-	bool IsClassBag() const { return const_cast<ItemInst*>(this)->IsClassBag(); }
-	bool IsClassBook() const { return const_cast<ItemInst*>(this)->IsClassBook(); }
-
-	// Can item be stacked?
-	bool IsStackable() const;
-	bool IsCharged() const;
-
-	// Can item be equipped by/at?
-	bool IsEquipable(uint16 race, uint16 class_) const;
-	bool IsEquipable(int16 slot_id) const;
-
-	//
-	// Augments
-	//
-	bool IsAugmentable() const;
-	bool AvailableWearSlot(uint32 aug_wear_slots) const;
-	int8 AvailableAugmentSlot(int32 augtype) const;
-	bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
-	inline int32 GetAugmentType() const { return ((m_item) ? m_item->AugType : NO_ITEM); }
-
-	inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == EQEmu::item::ItemEffectExpendable) || (m_item->ItemType == EQEmu::item::ItemTypePotion)) : false); }
-
-	//
-	// Contents
-	//
-	ItemInst* GetItem(uint8 slot) const;
-	uint32 GetItemID(uint8 slot) const;
-	inline const ItemInst* operator[](uint8 slot) const { return GetItem(slot); }
-	void PutItem(uint8 slot, const ItemInst& inst);
-	void PutItem(SharedDatabase *db, uint8 slot, uint32 item_id) { return; } // not defined anywhere...
-	void DeleteItem(uint8 slot);
-	ItemInst* PopItem(uint8 index);
-	void Clear();
-	void ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent);
-	uint8 FirstOpenSlot() const;
-	uint8 GetTotalItemCount() const;
-	bool IsNoneEmptyContainer();
-	std::map<uint8, ItemInst*>* GetContents() { return &m_contents; }
-
-	//
-	// Augments
-	//
-	ItemInst* GetAugment(uint8 slot) const;
-	uint32 GetAugmentItemID(uint8 slot) const;
-	void PutAugment(uint8 slot, const ItemInst& inst);
-	void PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id);
-	void DeleteAugment(uint8 slot);
-	ItemInst* RemoveAugment(uint8 index);
-	bool IsAugmented();
-	ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const;
-	bool UpdateOrnamentationInfo();
-	static bool CanTransform(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container, bool AllowAll = false);
-	
-	// Has attack/delay?
-	bool IsWeapon() const;
-	bool IsAmmo() const;
-
-	// Accessors
-	const uint32 GetID() const { return ((m_item) ? m_item->ID : NO_ITEM); }
-	const uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : NO_ITEM); }
-	const EQEmu::ItemBase* GetItem() const;
-	const EQEmu::ItemBase* GetUnscaledItem() const;
-
-	int16 GetCharges() const				{ return m_charges; }
-	void SetCharges(int16 charges)			{ m_charges = charges; }
-
-	uint32 GetPrice() const					{ return m_price; }
-	void SetPrice(uint32 price)				{ m_price = price; }
-
-	void SetColor(uint32 color)				{ m_color = color; }
-	uint32 GetColor() const					{ return m_color; }
-
-	uint32 GetMerchantSlot() const			{ return m_merchantslot; }
-	void SetMerchantSlot(uint32 slot)		{ m_merchantslot = slot; }
-
-	int32 GetMerchantCount() const			{ return m_merchantcount; }
-	void SetMerchantCount(int32 count)		{ m_merchantcount = count; }
-
-	int16 GetCurrentSlot() const			{ return m_currentslot; }
-	void SetCurrentSlot(int16 curr_slot)	{ m_currentslot = curr_slot; }
-
-	// Is this item already attuned?
-	bool IsAttuned() const					{ return m_attuned; }
-	void SetAttuned(bool flag)				{ m_attuned=flag; }
-
-	std::string GetCustomDataString() const;
-	std::string GetCustomData(std::string identifier);
-	void SetCustomData(std::string identifier, std::string value);
-	void SetCustomData(std::string identifier, int value);
-	void SetCustomData(std::string identifier, float value);
-	void SetCustomData(std::string identifier, bool value);
-	void DeleteCustomData(std::string identifier);
-
-	// Allows treatment of this object as though it were a pointer to m_item
-	operator bool() const { return (m_item != nullptr); }
-
-	// Compare inner Item_Struct of two ItemInst objects
-	bool operator==(const ItemInst& right) const { return (this->m_item == right.m_item); }
-	bool operator!=(const ItemInst& right) const { return (this->m_item != right.m_item); }
-
-	// Clone current item
-	ItemInst* Clone() const;
-
-	bool IsSlotAllowed(int16 slot_id) const;
-
-	bool IsScaling() const				{ return m_scaling; }
-	bool IsEvolving() const				{ return (m_evolveLvl >= 1); }
-	uint32 GetExp() const				{ return m_exp; }
-	void SetExp(uint32 exp)				{ m_exp = exp; }
-	void AddExp(uint32 exp)				{ m_exp += exp; }
-	bool IsActivated()					{ return m_activated; }
-	void SetActivated(bool activated)	{ m_activated = activated; }
-	int8 GetEvolveLvl() const			{ return m_evolveLvl; }
-	void SetScaling(bool v)				{ m_scaling = v; }
-	uint32 GetOrnamentationIcon() const							{ return m_ornamenticon; }
-	void SetOrnamentIcon(uint32 ornament_icon)					{ m_ornamenticon = ornament_icon; }
-	uint32 GetOrnamentationIDFile() const						{ return m_ornamentidfile; }
-	void SetOrnamentationIDFile(uint32 ornament_idfile)			{ m_ornamentidfile = ornament_idfile; }
-	uint32 GetOrnamentHeroModel(int32 material_slot = -1) const;
-	void SetOrnamentHeroModel(uint32 ornament_hero_model)		{ m_ornament_hero_model = ornament_hero_model; }
-	uint32 GetRecastTimestamp() const							{ return m_recast_timestamp; }
-	void SetRecastTimestamp(uint32 in)							{ m_recast_timestamp = in; }
-
-	void Initialize(SharedDatabase *db = nullptr);
-	void ScaleItem();
-	bool EvolveOnAllKills() const;
-	int8 GetMaxEvolveLvl() const;
-	uint32 GetKillsNeeded(uint8 currentlevel);
-
-	std::string Serialize(int16 slot_id) const { EQEmu::InternalSerializedItem_Struct s; s.slot_id = slot_id; s.inst = (const void*)this; std::string ser; ser.assign((char*)&s, sizeof(EQEmu::InternalSerializedItem_Struct)); return ser; }
-	void Serialize(EQEmu::OutBuffer& ob, int16 slot_id) const { EQEmu::InternalSerializedItem_Struct isi; isi.slot_id = slot_id; isi.inst = (const void*)this; ob.write((const char*)&isi, sizeof(isi)); }
-	
-	inline int32 GetSerialNumber() const { return m_SerialNumber; }
-	inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
-
-	std::map<std::string, Timer>& GetTimers() { return m_timers; }
-	void SetTimer(std::string name, uint32 time);
-	void StopTimer(std::string name);
-	void ClearTimers();
-
-	// Get a total of a stat, including augs
-	// These functions should be used in place of other code manually totaling
-	// to centralize where it is done to make future changes easier (ex. whenever powersources come around)
-	// and to minimize errors. CalcItemBonuses however doesn't use these in interest of performance
-	// by default these do not recurse into augs
-	int GetItemArmorClass(bool augments = false) const;
-	int GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments = false) const;
-	// These two differ in the fact that they're quick checks (they are checked BEFORE the one above
-	int GetItemElementalFlag(bool augments = false) const;
-	int GetItemElementalDamage(bool augments = false) const;
-	int GetItemRecommendedLevel(bool augments = false) const;
-	int GetItemRequiredLevel(bool augments = false) const;
-	int GetItemWeaponDamage(bool augments = false) const;
-	int GetItemBackstabDamage(bool augments = false) const;
-	// these two are just quick checks
-	int GetItemBaneDamageBody(bool augments = false) const;
-	int GetItemBaneDamageRace(bool augments = false) const;
-	int GetItemBaneDamageBody(bodyType against, bool augments = false) const;
-	int GetItemBaneDamageRace(uint16 against, bool augments = false) const;
-	int GetItemMagical(bool augments = false) const;
-	int GetItemHP(bool augments = false) const;
-	int GetItemMana(bool augments = false) const;
-	int GetItemEndur(bool augments = false) const;
-	int GetItemAttack(bool augments = false) const;
-	int GetItemStr(bool augments = false) const;
-	int GetItemSta(bool augments = false) const;
-	int GetItemDex(bool augments = false) const;
-	int GetItemAgi(bool augments = false) const;
-	int GetItemInt(bool augments = false) const;
-	int GetItemWis(bool augments = false) const;
-	int GetItemCha(bool augments = false) const;
-	int GetItemMR(bool augments = false) const;
-	int GetItemFR(bool augments = false) const;
-	int GetItemCR(bool augments = false) const;
-	int GetItemPR(bool augments = false) const;
-	int GetItemDR(bool augments = false) const;
-	int GetItemCorrup(bool augments = false) const;
-	int GetItemHeroicStr(bool augments = false) const;
-	int GetItemHeroicSta(bool augments = false) const;
-	int GetItemHeroicDex(bool augments = false) const;
-	int GetItemHeroicAgi(bool augments = false) const;
-	int GetItemHeroicInt(bool augments = false) const;
-	int GetItemHeroicWis(bool augments = false) const;
-	int GetItemHeroicCha(bool augments = false) const;
-	int GetItemHeroicMR(bool augments = false) const;
-	int GetItemHeroicFR(bool augments = false) const;
-	int GetItemHeroicCR(bool augments = false) const;
-	int GetItemHeroicPR(bool augments = false) const;
-	int GetItemHeroicDR(bool augments = false) const;
-	int GetItemHeroicCorrup(bool augments = false) const;
-	int GetItemHaste(bool augments = false) const;
-
-protected:
-	//////////////////////////
-	// Protected Members
-	//////////////////////////
-	std::map<uint8, ItemInst*>::const_iterator _cbegin() { return m_contents.cbegin(); }
-	std::map<uint8, ItemInst*>::const_iterator _cend() { return m_contents.cend(); }
-
-	friend class Inventory;
-
-
-	void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; }
-
-	ItemInstTypes		m_use_type;	// Usage type for item
-	const EQEmu::ItemBase*	m_item;		// Ptr to item data
-	int16				m_charges;	// # of charges for chargeable items
-	uint32				m_price;	// Bazaar /trader price
-	uint32				m_color;
-	uint32				m_merchantslot;
-	int16				m_currentslot;
-	bool				m_attuned;
-	int32				m_merchantcount;		//number avaliable on the merchant, -1=unlimited
-	int32				m_SerialNumber;	// Unique identifier for this instance of an item. Needed for Bazaar.
-	uint32				m_exp;
-	int8				m_evolveLvl;
-	bool				m_activated;
-	EQEmu::ItemBase*		m_scaledItem;
-	EvolveInfo*			m_evolveInfo;
-	bool				m_scaling;
-	uint32				m_ornamenticon;
-	uint32				m_ornamentidfile;
-	uint32				m_ornament_hero_model;
-	uint32				m_recast_timestamp;
-
-	//
-	// Items inside of this item (augs or contents);
-	std::map<uint8, ItemInst*>			m_contents; // Zero-based index: min=0, max=9
-	std::map<std::string, std::string>	m_custom_data;
-	std::map<std::string, Timer>		m_timers;
-};
-
-class EvolveInfo {
-public:
-	friend class ItemInst;
-	//temporary
-	uint16				LvlKills[9];
-	uint32				FirstItem;
-	uint8				MaxLvl;
-	bool				AllKills;
-
-	EvolveInfo();
-	EvolveInfo(uint32 first, uint8 max, bool allkills, uint32 L2, uint32 L3, uint32 L4, uint32 L5, uint32 L6, uint32 L7, uint32 L8, uint32 L9, uint32 L10);
-	~EvolveInfo();
-};
-
-#endif /*COMMON_ITEM_H*/

common/item_data.cpp

@@ -17,7 +17,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
-#include "item_base.h"
+#include "item_data.h"
 #include "classes.h"
 #include "races.h"
 //#include "deity.h"
@@ -167,7 +167,7 @@ uint8 EQEmu::item::ConvertAugTypeBitToAugType(uint32 aug_type_bit)
 	}
 }
 
-bool EQEmu::ItemBase::IsEquipable(uint16 race_id, uint16 class_id)
+bool EQEmu::ItemData::IsEquipable(uint16 race_id, uint16 class_id) const
 {
 	if (!(Races & GetPlayerRaceBit(race_id)))
 		return false;
@@ -178,32 +178,32 @@ bool EQEmu::ItemBase::IsEquipable(uint16 race_id, uint16 class_id)
 	return true;
 }
 
-bool EQEmu::ItemBase::IsClassCommon()
+bool EQEmu::ItemData::IsClassCommon() const
 {
 	return (ItemClass == item::ItemClassCommon);
 }
 
-bool EQEmu::ItemBase::IsClassBag()
+bool EQEmu::ItemData::IsClassBag() const
 {
 	return (ItemClass == item::ItemClassBag);
 }
 
-bool EQEmu::ItemBase::IsClassBook()
+bool EQEmu::ItemData::IsClassBook() const
 {
 	return (ItemClass == item::ItemClassBook);
 }
 
-bool EQEmu::ItemBase::IsType1HWeapon()
+bool EQEmu::ItemData::IsType1HWeapon() const
 {
 	return ((ItemType == item::ItemType1HBlunt) || (ItemType == item::ItemType1HSlash) || (ItemType == item::ItemType1HPiercing));
 }
 
-bool EQEmu::ItemBase::IsType2HWeapon()
+bool EQEmu::ItemData::IsType2HWeapon() const
 {
 	return ((ItemType == item::ItemType2HBlunt) || (ItemType == item::ItemType2HSlash) || (ItemType == item::ItemType2HPiercing));
 }
 
-bool EQEmu::ItemBase::IsTypeShield()
+bool EQEmu::ItemData::IsTypeShield() const
 {
 	return (ItemType == item::ItemTypeShield);
 }

common/item_data.h

@@ -17,8 +17,8 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
 */
 
-#ifndef COMMON_ITEM_BASE_H
+#ifndef COMMON_ITEM_DATA_H
-#define COMMON_ITEM_BASE_H
+#define COMMON_ITEM_DATA_H
 
 
 /*
@@ -50,17 +50,6 @@
 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,
@@ -354,8 +343,8 @@ namespace EQEmu
 			//ProcRate
 		};
 
-		extern uint32 ConvertAugTypeToAugTypeBit(uint8 aug_type);
+		uint32 ConvertAugTypeToAugTypeBit(uint8 aug_type);
-		extern uint8 ConvertAugTypeBitToAugType(uint32 aug_type_bit);
+		uint8 ConvertAugTypeBitToAugType(uint32 aug_type_bit);
 
 	} /*item*/
 
@@ -364,10 +353,9 @@ namespace EQEmu
 		const void * inst;
 	};
 
-	struct ItemBase {
+	struct ItemData {
 		// 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
@@ -476,9 +464,9 @@ namespace EQEmu
 		int32	FactionAmt4;	// Faction Amt 4
 		char	CharmFile[32];	// ?
 		uint32	AugType;
-		uint8	AugSlotType[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Type
+		uint8	AugSlotType[inventory::SocketCount];	// RoF: Augment Slot 1-6 Type
-		uint8	AugSlotVisible[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Visible
+		uint8	AugSlotVisible[inventory::SocketCount];	// RoF: Augment Slot 1-6 Visible
-		uint8	AugSlotUnk2[EQEmu::legacy::ITEM_COMMON_SIZE];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
+		uint8	AugSlotUnk2[inventory::SocketCount];	// RoF: Augment Slot 1-6 Unknown Most likely Powersource related
 		uint32	LDoNTheme;
 		uint32	LDoNPrice;
 		uint32	LDoNSold;
@@ -543,23 +531,15 @@ namespace EQEmu
 		char	ScrollName[65];
 		//BardName
 
-		bool IsEquipable(uint16 Race, uint16 Class);
+		bool IsEquipable(uint16 Race, uint16 Class) const;
-		bool IsClassCommon();
+		bool IsClassCommon() const;
-		bool IsClassBag();
+		bool IsClassBag() const;
-		bool IsClassBook();
+		bool IsClassBook() const;
-		bool IsType1HWeapon();
+		bool IsType1HWeapon() const;
-		bool IsType2HWeapon();
+		bool IsType2HWeapon() const;
-		bool IsTypeShield();
+		bool IsTypeShield() const;
-
-		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*/
+#endif /*COMMON_ITEM_DATA_H*/

common/item_instance.h

@@ -0,0 +1,332 @@
+/*	EQEMu: Everquest Server Emulator
+
+	Copyright (C) 2001-2016 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  04111-1307  USA
+*/
+
+// @merth notes:
+// These classes could be optimized with database reads/writes by storing
+// a status flag indicating how object needs to interact with database
+
+#ifndef COMMON_ITEM_INSTANCE_H
+#define COMMON_ITEM_INSTANCE_H
+
+
+class ItemParse;			// Parses item packets
+class EvolveInfo;			// Stores information about an evolving item family
+
+#include "../common/eq_constants.h"
+#include "../common/item_data.h"
+#include "../common/timer.h"
+#include "../common/bodytypes.h"
+#include "../common/deity.h"
+#include "../common/memory_buffer.h"
+
+#include <map>
+
+
+// Specifies usage type for item inside EQEmu::ItemInstance
+enum ItemInstTypes
+{
+	ItemInstNormal = 0,
+	ItemInstWorldContainer
+};
+
+typedef enum {
+	byFlagIgnore,	//do not consider this flag
+	byFlagSet,		//apply action if the flag is set
+	byFlagNotSet	//apply action if the flag is NOT set
+} byFlagSetting;
+
+class SharedDatabase;
+
+// ########################################
+// Class: EQEmu::ItemInstance
+//	Base class for an instance of an item
+//	An item instance encapsulates item data + data specific
+//	to an item instance (includes dye, augments, charges, etc)
+namespace EQEmu
+{
+	class InventoryProfile;
+	
+	class ItemInstance {
+	public:
+		/////////////////////////
+		// Methods
+		/////////////////////////
+
+		// Constructors/Destructor
+		ItemInstance(const ItemData* item = nullptr, int16 charges = 0);
+
+		ItemInstance(SharedDatabase *db, uint32 item_id, int16 charges = 0);
+
+		ItemInstance(ItemInstTypes use_type);
+
+		ItemInstance(const ItemInstance& copy);
+
+		~ItemInstance();
+
+		// Query item type
+		bool IsType(item::ItemClass item_class) const;
+
+		bool IsClassCommon() const;
+		bool IsClassBag() const;
+		bool IsClassBook() const;
+
+		// Can item be stacked?
+		bool IsStackable() const;
+		bool IsCharged() const;
+
+		// Can item be equipped by/at?
+		bool IsEquipable(uint16 race, uint16 class_) const;
+		bool IsEquipable(int16 slot_id) const;
+
+		//
+		// Augments
+		//
+		bool IsAugmentable() const;
+		bool AvailableWearSlot(uint32 aug_wear_slots) const;
+		int8 AvailableAugmentSlot(int32 augtype) const;
+		bool IsAugmentSlotAvailable(int32 augtype, uint8 slot) const;
+		inline int32 GetAugmentType() const { return ((m_item) ? m_item->AugType : 0); }
+
+		inline bool IsExpendable() const { return ((m_item) ? ((m_item->Click.Type == item::ItemEffectExpendable) || (m_item->ItemType == item::ItemTypePotion)) : false); }
+
+		//
+		// Contents
+		//
+		ItemInstance* GetItem(uint8 slot) const;
+		uint32 GetItemID(uint8 slot) const;
+		inline const ItemInstance* operator[](uint8 slot) const { return GetItem(slot); }
+		void PutItem(uint8 slot, const ItemInstance& inst);
+		void PutItem(SharedDatabase *db, uint8 slot, uint32 item_id) { return; } // not defined anywhere...
+		void DeleteItem(uint8 slot);
+		ItemInstance* PopItem(uint8 index);
+		void Clear();
+		void ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent);
+		uint8 FirstOpenSlot() const;
+		uint8 GetTotalItemCount() const;
+		bool IsNoneEmptyContainer();
+		std::map<uint8, ItemInstance*>* GetContents() { return &m_contents; }
+
+		//
+		// Augments
+		//
+		ItemInstance* GetAugment(uint8 slot) const;
+		uint32 GetAugmentItemID(uint8 slot) const;
+		void PutAugment(uint8 slot, const ItemInstance& inst);
+		void PutAugment(SharedDatabase *db, uint8 slot, uint32 item_id);
+		void DeleteAugment(uint8 slot);
+		ItemInstance* RemoveAugment(uint8 index);
+		bool IsAugmented();
+		ItemInstance* GetOrnamentationAug(int32 ornamentationAugtype) const;
+		bool UpdateOrnamentationInfo();
+		static bool CanTransform(const ItemData *ItemToTry, const ItemData *Container, bool AllowAll = false);
+
+		// Has attack/delay?
+		bool IsWeapon() const;
+		bool IsAmmo() const;
+
+		// Accessors
+		const uint32 GetID() const { return ((m_item) ? m_item->ID : 0); }
+		const uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : 0); }
+		const ItemData* GetItem() const;
+		const ItemData* GetUnscaledItem() const;
+
+		int16 GetCharges() const				{ return m_charges; }
+		void SetCharges(int16 charges)			{ m_charges = charges; }
+
+		uint32 GetPrice() const					{ return m_price; }
+		void SetPrice(uint32 price)				{ m_price = price; }
+
+		void SetColor(uint32 color)				{ m_color = color; }
+		uint32 GetColor() const					{ return m_color; }
+
+		uint32 GetMerchantSlot() const			{ return m_merchantslot; }
+		void SetMerchantSlot(uint32 slot)		{ m_merchantslot = slot; }
+
+		int32 GetMerchantCount() const			{ return m_merchantcount; }
+		void SetMerchantCount(int32 count)		{ m_merchantcount = count; }
+
+		int16 GetCurrentSlot() const			{ return m_currentslot; }
+		void SetCurrentSlot(int16 curr_slot)	{ m_currentslot = curr_slot; }
+
+		// Is this item already attuned?
+		bool IsAttuned() const					{ return m_attuned; }
+		void SetAttuned(bool flag)				{ m_attuned = flag; }
+
+		std::string GetCustomDataString() const;
+		std::string GetCustomData(std::string identifier);
+		void SetCustomData(std::string identifier, std::string value);
+		void SetCustomData(std::string identifier, int value);
+		void SetCustomData(std::string identifier, float value);
+		void SetCustomData(std::string identifier, bool value);
+		void DeleteCustomData(std::string identifier);
+
+		// Allows treatment of this object as though it were a pointer to m_item
+		operator bool() const { return (m_item != nullptr); }
+
+		// Compare inner Item_Struct of two ItemInstance objects
+		bool operator==(const ItemInstance& right) const { return (this->m_item == right.m_item); }
+		bool operator!=(const ItemInstance& right) const { return (this->m_item != right.m_item); }
+
+		// Clone current item
+		ItemInstance* Clone() const;
+
+		bool IsSlotAllowed(int16 slot_id) const;
+
+		bool IsScaling() const				{ return m_scaling; }
+		bool IsEvolving() const				{ return (m_evolveLvl >= 1); }
+		uint32 GetExp() const				{ return m_exp; }
+		void SetExp(uint32 exp)				{ m_exp = exp; }
+		void AddExp(uint32 exp)				{ m_exp += exp; }
+		bool IsActivated()					{ return m_activated; }
+		void SetActivated(bool activated)	{ m_activated = activated; }
+		int8 GetEvolveLvl() const			{ return m_evolveLvl; }
+		void SetScaling(bool v)				{ m_scaling = v; }
+		uint32 GetOrnamentationIcon() const							{ return m_ornamenticon; }
+		void SetOrnamentIcon(uint32 ornament_icon)					{ m_ornamenticon = ornament_icon; }
+		uint32 GetOrnamentationIDFile() const						{ return m_ornamentidfile; }
+		void SetOrnamentationIDFile(uint32 ornament_idfile)			{ m_ornamentidfile = ornament_idfile; }
+		uint32 GetOrnamentHeroModel(int32 material_slot = -1) const;
+		void SetOrnamentHeroModel(uint32 ornament_hero_model)		{ m_ornament_hero_model = ornament_hero_model; }
+		uint32 GetRecastTimestamp() const							{ return m_recast_timestamp; }
+		void SetRecastTimestamp(uint32 in)							{ m_recast_timestamp = in; }
+
+		void Initialize(SharedDatabase *db = nullptr);
+		void ScaleItem();
+		bool EvolveOnAllKills() const;
+		int8 GetMaxEvolveLvl() const;
+		uint32 GetKillsNeeded(uint8 currentlevel);
+
+		std::string Serialize(int16 slot_id) const { InternalSerializedItem_Struct s; s.slot_id = slot_id; s.inst = (const void*)this; std::string ser; ser.assign((char*)&s, sizeof(InternalSerializedItem_Struct)); return ser; }
+		void Serialize(OutBuffer& ob, int16 slot_id) const { InternalSerializedItem_Struct isi; isi.slot_id = slot_id; isi.inst = (const void*)this; ob.write((const char*)&isi, sizeof(isi)); }
+
+		inline int32 GetSerialNumber() const { return m_SerialNumber; }
+		inline void SetSerialNumber(int32 id) { m_SerialNumber = id; }
+
+		std::map<std::string, Timer>& GetTimers() { return m_timers; }
+		void SetTimer(std::string name, uint32 time);
+		void StopTimer(std::string name);
+		void ClearTimers();
+
+		// Get a total of a stat, including augs
+		// These functions should be used in place of other code manually totaling
+		// to centralize where it is done to make future changes easier (ex. whenever powersources come around)
+		// and to minimize errors. CalcItemBonuses however doesn't use these in interest of performance
+		// by default these do not recurse into augs
+		int GetItemArmorClass(bool augments = false) const;
+		int GetItemElementalDamage(int &magic, int &fire, int &cold, int &poison, int &disease, int &chromatic, int &prismatic, int &physical, int &corruption, bool augments = false) const;
+		// These two differ in the fact that they're quick checks (they are checked BEFORE the one above
+		int GetItemElementalFlag(bool augments = false) const;
+		int GetItemElementalDamage(bool augments = false) const;
+		int GetItemRecommendedLevel(bool augments = false) const;
+		int GetItemRequiredLevel(bool augments = false) const;
+		int GetItemWeaponDamage(bool augments = false) const;
+		int GetItemBackstabDamage(bool augments = false) const;
+		// these two are just quick checks
+		int GetItemBaneDamageBody(bool augments = false) const;
+		int GetItemBaneDamageRace(bool augments = false) const;
+		int GetItemBaneDamageBody(bodyType against, bool augments = false) const;
+		int GetItemBaneDamageRace(uint16 against, bool augments = false) const;
+		int GetItemMagical(bool augments = false) const;
+		int GetItemHP(bool augments = false) const;
+		int GetItemMana(bool augments = false) const;
+		int GetItemEndur(bool augments = false) const;
+		int GetItemAttack(bool augments = false) const;
+		int GetItemStr(bool augments = false) const;
+		int GetItemSta(bool augments = false) const;
+		int GetItemDex(bool augments = false) const;
+		int GetItemAgi(bool augments = false) const;
+		int GetItemInt(bool augments = false) const;
+		int GetItemWis(bool augments = false) const;
+		int GetItemCha(bool augments = false) const;
+		int GetItemMR(bool augments = false) const;
+		int GetItemFR(bool augments = false) const;
+		int GetItemCR(bool augments = false) const;
+		int GetItemPR(bool augments = false) const;
+		int GetItemDR(bool augments = false) const;
+		int GetItemCorrup(bool augments = false) const;
+		int GetItemHeroicStr(bool augments = false) const;
+		int GetItemHeroicSta(bool augments = false) const;
+		int GetItemHeroicDex(bool augments = false) const;
+		int GetItemHeroicAgi(bool augments = false) const;
+		int GetItemHeroicInt(bool augments = false) const;
+		int GetItemHeroicWis(bool augments = false) const;
+		int GetItemHeroicCha(bool augments = false) const;
+		int GetItemHeroicMR(bool augments = false) const;
+		int GetItemHeroicFR(bool augments = false) const;
+		int GetItemHeroicCR(bool augments = false) const;
+		int GetItemHeroicPR(bool augments = false) const;
+		int GetItemHeroicDR(bool augments = false) const;
+		int GetItemHeroicCorrup(bool augments = false) const;
+		int GetItemHaste(bool augments = false) const;
+
+	protected:
+		//////////////////////////
+		// Protected Members
+		//////////////////////////
+		friend class InventoryProfile;
+
+		std::map<uint8, ItemInstance*>::const_iterator _cbegin() { return m_contents.cbegin(); }
+		std::map<uint8, ItemInstance*>::const_iterator _cend() { return m_contents.cend(); }
+
+		void _PutItem(uint8 index, ItemInstance* inst) { m_contents[index] = inst; }
+
+		ItemInstTypes		m_use_type;	// Usage type for item
+		const ItemData*		m_item;		// Ptr to item data
+		int16				m_charges;	// # of charges for chargeable items
+		uint32				m_price;	// Bazaar /trader price
+		uint32				m_color;
+		uint32				m_merchantslot;
+		int16				m_currentslot;
+		bool				m_attuned;
+		int32				m_merchantcount;		//number avaliable on the merchant, -1=unlimited
+		int32				m_SerialNumber;	// Unique identifier for this instance of an item. Needed for Bazaar.
+		uint32				m_exp;
+		int8				m_evolveLvl;
+		bool				m_activated;
+		ItemData*			m_scaledItem;
+		::EvolveInfo*		m_evolveInfo;
+		bool				m_scaling;
+		uint32				m_ornamenticon;
+		uint32				m_ornamentidfile;
+		uint32				m_ornament_hero_model;
+		uint32				m_recast_timestamp;
+
+		//
+		// Items inside of this item (augs or contents);
+		std::map<uint8, ItemInstance*>		m_contents; // Zero-based index: min=0, max=9
+		std::map<std::string, std::string>	m_custom_data;
+		std::map<std::string, Timer>		m_timers;
+	};
+}
+
+class EvolveInfo {
+public:
+	friend class EQEmu::ItemInstance;
+	//temporary
+	uint16				LvlKills[9];
+	uint32				FirstItem;
+	uint8				MaxLvl;
+	bool				AllKills;
+
+	EvolveInfo();
+	EvolveInfo(uint32 first, uint8 max, bool allkills, uint32 L2, uint32 L3, uint32 L4, uint32 L5, uint32 L6, uint32 L7, uint32 L8, uint32 L9, uint32 L10);
+	~EvolveInfo();
+};
+
+#endif /*COMMON_ITEM_INSTANCE_H*/

common/patches/rof.cpp

@@ -29,7 +29,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../inventory_profile.h"
 #include "rof_structs.h"
 #include "../rulesys.h"
 
@@ -45,7 +45,7 @@ namespace RoF
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id, uint8 depth);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id, uint8 depth);
 
 	// server to client inventory location converters
 	static inline structs::InventorySlot_Struct ServerToRoFSlot(uint32 serverSlot);
@@ -66,6 +66,9 @@ namespace RoF
 	static inline CastingSlot ServerToRoFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot RoFToServerCastingSlot(CastingSlot slot);
 
+	static inline int ServerToRoFBuffSlot(int index);
+	static inline int RoFToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		//create our opcode manager if we havent already
@@ -423,15 +426,8 @@ namespace RoF
 		OUT(buff.y);
 		OUT(buff.x);
 		OUT(buff.z);
-		uint16 buffslot = emu->slotid;
-		// Not sure if this is needs amending for RoF yet.
-		if (buffslot >= 25)
-		{
-			buffslot += 17;
-		}
-
 		// TODO: implement slot_data stuff
-		eq->slotid = buffslot;
+		eq->slotid = ServerToRoFBuffSlot(emu->slotid);
 
 		if (emu->bufffade == 1)
 			eq->bufffade = 1;
@@ -447,10 +443,10 @@ namespace RoF
 			outapp->WriteUInt32(0);	// tic timer
 			outapp->WriteUInt8(0);		// Type of OP_BuffCreate packet ?
 			outapp->WriteUInt16(1);		// 1 buff in this packet
-			outapp->WriteUInt32(buffslot);
+			outapp->WriteUInt32(eq->slotid);
 			outapp->WriteUInt32(0xffffffff);		// SpellID (0xffff to remove)
 			outapp->WriteUInt32(0);			// Duration
-			outapp->WriteUInt32(0);			// ?
+			outapp->WriteUInt32(0);			// numhits
 			outapp->WriteUInt8(0);		// Caster name
 			outapp->WriteUInt8(0);		// Type
 		}
@@ -474,17 +470,9 @@ namespace RoF
 		__packet->WriteUInt8(emu->all_buffs);			// 1 indicates all buffs on the player (0 to add or remove a single buff)
 		__packet->WriteUInt16(emu->count);
 
-		for (uint16 i = 0; i < emu->count; ++i)
+		for (int i = 0; i < emu->count; ++i)
 		{
-			uint16 buffslot = emu->entries[i].buff_slot;
+			__packet->WriteUInt32(emu->type == 0 ? ServerToRoFBuffSlot(emu->entries[i].buff_slot) : emu->entries[i].buff_slot);
-			if (emu->type == 0) { // only correct for self packets
-				if (emu->entries[i].buff_slot >= 25)
-					buffslot += 17;
-				if (buffslot == 54)
-					buffslot = 62;
-			}
-
-			__packet->WriteUInt32(buffslot);
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits); // Unknown
@@ -596,7 +584,7 @@ namespace RoF
 		ob.write((const char*)&item_count, sizeof(uint32));
 
 		for (int index = 0; index < item_count; ++index, ++eq) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 
@@ -1533,7 +1521,7 @@ namespace RoF
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -2079,7 +2067,7 @@ namespace RoF
 
 		outapp->WriteUInt32(22);		// Equipment count
 
-		for (int r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++)
+		for (int r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++)
 		{
 			outapp->WriteUInt32(emu->item_material.Slot[r].Material);
 			outapp->WriteUInt32(0);
@@ -2099,9 +2087,9 @@ namespace RoF
 			outapp->WriteUInt32(0);
 		}
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Equipment2 count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Equipment2 count
 
-		for (int r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++)
+		for (int r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++)
 		{
 			outapp->WriteUInt32(0);
 			outapp->WriteUInt32(0);
@@ -2110,7 +2098,7 @@ namespace RoF
 			outapp->WriteUInt32(0);
 		}
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Tint Count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Tint Count
 
 		for (int r = 0; r < 7; r++)
 		{
@@ -2120,7 +2108,7 @@ namespace RoF
 		outapp->WriteUInt32(0);
 		outapp->WriteUInt32(0);
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Tint2 Count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Tint2 Count
 
 		for (int r = 0; r < 7; r++)
 		{
@@ -3059,12 +3047,12 @@ namespace RoF
 			eq_cse->Gender = emu_cse->Gender;
 			eq_cse->Face = emu_cse->Face;
 
-			for (int equip_index = 0; equip_index < EQEmu::textures::TextureCount; equip_index++) {
+			for (int equip_index = 0; equip_index < EQEmu::textures::materialCount; equip_index++) {
 				eq_cse->Equip[equip_index].Material = emu_cse->Equip[equip_index].Material;
 				eq_cse->Equip[equip_index].Unknown1 = emu_cse->Equip[equip_index].Unknown1;
-				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteMaterial;
+				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteModel;
-				eq_cse->Equip[equip_index].HeroForgeModel = emu_cse->Equip[equip_index].HeroForgeModel;
+				eq_cse->Equip[equip_index].HeroForgeModel = emu_cse->Equip[equip_index].HerosForgeModel;
-				eq_cse->Equip[equip_index].Material2 = emu_cse->Equip[equip_index].Material2;
+				eq_cse->Equip[equip_index].Material2 = emu_cse->Equip[equip_index].Unknown2;
 				eq_cse->Equip[equip_index].Color = emu_cse->Equip[equip_index].Color;
 			}
 
@@ -4096,7 +4084,7 @@ namespace RoF
 
 			if ((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522))
 			{
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; ++k)
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; ++k)
 				{
 					{
 						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment_tint.Slot[k].Color);
@@ -4105,15 +4093,15 @@ namespace RoF
 
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;
 
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 					Equipment[k].Material = emu->equipment.Slot[k].Material;
 					Equipment[k].Unknown1 = emu->equipment.Slot[k].Unknown1;
-					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteMaterial;
+					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteModel;
-					Equipment[k].HeroForgeModel = emu->equipment.Slot[k].HeroForgeModel;
+					Equipment[k].HeroForgeModel = emu->equipment.Slot[k].HerosForgeModel;
-					Equipment[k].Material2 = emu->equipment.Slot[k].Material2;
+					Equipment[k].Material2 = emu->equipment.Slot[k].Unknown2;
 				}
 
-				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 			}
 			else
 			{
@@ -4312,7 +4300,7 @@ namespace RoF
 		IN(buff.unknown003);
 		IN(buff.spellid);
 		IN(buff.duration);
-		IN(slotid);
+		emu->slotid = RoFToServerBuffSlot(eq->slotid);
 		IN(bufffade);
 
 		FINISH_DIRECT_DECODE();
@@ -4325,7 +4313,7 @@ namespace RoF
 		DECODE_LENGTH_EXACT(structs::BuffRemoveRequest_Struct);
 		SETUP_DIRECT_DECODE(BuffRemoveRequest_Struct, structs::BuffRemoveRequest_Struct);
 
-		emu->SlotID = (eq->SlotID < 42) ? eq->SlotID : (eq->SlotID - 17);
+		emu->SlotID = RoFToServerBuffSlot(eq->SlotID);
 
 		IN(EntityID);
 
@@ -4829,10 +4817,9 @@ namespace RoF
 
 		IN(item_id);
 		int r;
-		for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
+		for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
 			IN(augments[r]);
 		}
-		// Max Augs is now 6, but no code to support that many yet
 		IN(link_hash);
 		IN(icon);
 
@@ -5209,9 +5196,9 @@ namespace RoF
 		return NextItemInstSerialNumber;
 	}
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth)
 	{
-		const EQEmu::ItemBase *item = inst->GetUnscaledItem();
+		const EQEmu::ItemData *item = inst->GetUnscaledItem();
 		
 		RoF::structs::ItemSerializationHeader hdr;
 
@@ -5265,7 +5252,7 @@ namespace RoF
 
 		if (inst->GetOrnamentationIDFile() && inst->GetOrnamentationIcon()) {
 			ornaIcon = inst->GetOrnamentationIcon();
-			heroModel = inst->GetOrnamentHeroModel(Inventory::CalcMaterialFromSlot(slot_id_in));
+			heroModel = inst->GetOrnamentHeroModel(EQEmu::InventoryProfile::CalcMaterialFromSlot(slot_id_in));
 
 			char tmp[30]; memset(tmp, 0x0, 30); sprintf(tmp, "IT%d", inst->GetOrnamentationIDFile());
 
@@ -5622,18 +5609,18 @@ namespace RoF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++index) {
+		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
 			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
 			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
 			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -5659,17 +5646,17 @@ namespace RoF
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::legacy::SlotPowerSource) { // Main Inventory and Cursor
+		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // Main Inventory and Cursor
 			RoFSlot.Type = invtype::InvTypePossessions;
 			RoFSlot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::legacy::SlotPowerSource)
+			if (serverSlot == EQEmu::inventory::slotPowerSource)
 				RoFSlot.Slot = invslot::PossessionsPowerSource;
 
-			else if (serverSlot >= EQEmu::legacy::SlotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
 				RoFSlot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::legacy::SlotAmmo) // (> 20)
+			else if (serverSlot >= EQEmu::inventory::slotAmmo) // (> 20)
 				RoFSlot.Slot += 1;
 		}
 
@@ -5681,8 +5668,8 @@ namespace RoF
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) { // (> 250 && < 341)
 			RoFSlot.Type = invtype::InvTypePossessions;
 			TempSlot = serverSlot - 1;
-			RoFSlot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 2;
+			RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
 
 			if (RoFSlot.Slot >= invslot::PossessionsGeneral9) // (> 30)
 				RoFSlot.Slot = invslot::PossessionsCursor;
@@ -5699,8 +5686,8 @@ namespace RoF
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 		}
 
@@ -5710,8 +5697,8 @@ namespace RoF
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoFSlot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 		}
 
@@ -5721,8 +5708,8 @@ namespace RoF
 			RoFSlot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoFSlot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 
 			/*
@@ -5760,16 +5747,16 @@ namespace RoF
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::legacy::SlotPowerSource) { // (< 52)
+		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // (< 52)
 			RoFSlot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::legacy::SlotPowerSource)
+			if (serverSlot == EQEmu::inventory::slotPowerSource)
 				RoFSlot.Slot = invslot::PossessionsPowerSource;
 
-			else if (serverSlot >= EQEmu::legacy::SlotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
 				RoFSlot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::legacy::SlotAmmo) // Ammo and Personl Inventory
+			else if (serverSlot >= EQEmu::inventory::slotAmmo) // Ammo and Personl Inventory
 				RoFSlot.Slot += 1;
 
 			/*else if (ServerSlot >= MainCursor) { // Cursor
@@ -5782,8 +5769,8 @@ namespace RoF
 
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) {
 			TempSlot = serverSlot - 1;
-			RoFSlot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 2;
+			RoFSlot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+			RoFSlot.SubIndex = TempSlot - ((RoFSlot.Slot + 2) * EQEmu::inventory::ContainerCount);
 		}
 
 		Log.Out(Logs::General, Logs::Netcode, "[ERROR] Convert Server Slot %i to RoF Slots: Main %i, Sub %i, Aug %i, Unk1 %i", serverSlot, RoFSlot.Slot, RoFSlot.SubIndex, RoFSlot.AugIndex, RoFSlot.Unknown01);
@@ -5803,7 +5790,7 @@ namespace RoF
 
 		if (rofSlot.Type == invtype::InvTypePossessions && rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
 			if (rofSlot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::legacy::SlotPowerSource;
+				TempSlot = EQEmu::inventory::slotPowerSource;
 
 			else if (rofSlot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rofSlot.Slot - 3;
@@ -5825,8 +5812,8 @@ namespace RoF
 			else // Worn Slots
 				TempSlot = rofSlot.Slot;
 
-			if (rofSlot.SubIndex >= SUB_INDEX_BEGIN) // Bag Slots
+			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rofSlot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -5834,8 +5821,8 @@ namespace RoF
 		else if (rofSlot.Type == invtype::InvTypeBank) {
 			TempSlot = EQEmu::legacy::BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rofSlot.SubIndex + 1;
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
 
 			else
 				TempSlot += rofSlot.Slot;
@@ -5846,8 +5833,8 @@ namespace RoF
 		else if (rofSlot.Type == invtype::InvTypeSharedBank) {
 			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
 
-			if (rofSlot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rofSlot.SubIndex + 1;
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
 
 			else
 				TempSlot += rofSlot.Slot;
@@ -5858,10 +5845,10 @@ namespace RoF
 		else if (rofSlot.Type == invtype::InvTypeTrade) {
 			TempSlot = EQEmu::legacy::TRADE_BEGIN;
 
-			if (rofSlot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rofSlot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rofSlot.SubIndex + 1;
+				TempSlot += ((rofSlot.Slot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
 			// OLD CODE:
-			//TempSlot += 100 + (RoFSlot.MainSlot * EQEmu::legacy::ITEM_CONTAINER_SIZE) + RoFSlot.SubSlot;
+			//TempSlot += 100 + (RoFSlot.MainSlot * EQEmu::inventory::ContainerCount) + RoFSlot.SubSlot;
 
 			else
 				TempSlot += rofSlot.Slot;
@@ -5872,7 +5859,7 @@ namespace RoF
 		else if (rofSlot.Type == invtype::InvTypeWorld) {
 			TempSlot = EQEmu::legacy::WORLD_BEGIN;
 
-			if (rofSlot.Slot >= SUB_INDEX_BEGIN)
+			if (rofSlot.Slot >= EQEmu::inventory::containerBegin)
 				TempSlot += rofSlot.Slot;
 
 			ServerSlot = TempSlot;
@@ -5903,7 +5890,7 @@ namespace RoF
 
 		if (rofSlot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 33)
 			if (rofSlot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::legacy::SlotPowerSource;
+				TempSlot = EQEmu::inventory::slotPowerSource;
 
 			else if (rofSlot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rofSlot.Slot - 3;
@@ -5920,8 +5907,8 @@ namespace RoF
 			else
 				TempSlot = rofSlot.Slot;
 
-			if (rofSlot.SubIndex >= SUB_INDEX_BEGIN) // Bag Slots
+			if (rofSlot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rofSlot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rofSlot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -6085,4 +6072,32 @@ namespace RoF
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	// these should be optimized out for RoF since they should all boil down to return index :P
+	// but lets leave it here for future proofing
+	static inline int ServerToRoFBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int RoFToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*RoF*/

common/patches/rof2.cpp

@@ -29,7 +29,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../inventory_profile.h"
 #include "rof2_structs.h"
 #include "../rulesys.h"
 
@@ -45,7 +45,7 @@ namespace RoF2
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id, uint8 depth, ItemPacketType packet_type);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id, uint8 depth, ItemPacketType packet_type);
 
 	// server to client inventory location converters
 	static inline structs::InventorySlot_Struct ServerToRoF2Slot(uint32 serverSlot, ItemPacketType PacketType = ItemPacketInvalid);
@@ -66,6 +66,9 @@ namespace RoF2
 	static inline CastingSlot ServerToRoF2CastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot RoF2ToServerCastingSlot(CastingSlot slot);
 
+	static inline int ServerToRoF2BuffSlot(int index);
+	static inline int RoF2ToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		//create our opcode manager if we havent already
@@ -492,18 +495,7 @@ namespace RoF2
 		OUT(buff.y);
 		OUT(buff.x);
 		OUT(buff.z);
-		uint16 buffslot = emu->slotid;
+		eq->slotid = ServerToRoF2BuffSlot(emu->slotid);
-		// Not sure if this is needs amending for RoF2 yet.
-		if (buffslot >= 25)
-		{
-			buffslot += 17;
-		}
-		// TODO: We should really just deal with these "server side"
-		// so we can have clients not limited to other clients.
-		// This fixes discs, songs were changed to 20
-		if (buffslot == 54)
-			buffslot = 62;
-		eq->slotid = buffslot;
 		// TODO: implement slot_data stuff
 		if (emu->bufffade == 1)
 			eq->bufffade = 1;
@@ -519,10 +511,10 @@ namespace RoF2
 			outapp->WriteUInt32(0);	// tic timer
 			outapp->WriteUInt8(0);		// Type of OP_BuffCreate packet ?
 			outapp->WriteUInt16(1);		// 1 buff in this packet
-			outapp->WriteUInt32(buffslot);
+			outapp->WriteUInt32(eq->slotid);
 			outapp->WriteUInt32(0xffffffff);		// SpellID (0xffff to remove)
 			outapp->WriteUInt32(0);			// Duration
-			outapp->WriteUInt32(0);			// ?
+			outapp->WriteUInt32(0);			// numhits
 			outapp->WriteUInt8(0);		// Caster name
 			outapp->WriteUInt8(0);		// Type
 		}
@@ -546,20 +538,9 @@ namespace RoF2
 		__packet->WriteUInt8(emu->all_buffs);			// 1 indicates all buffs on the player (0 to add or remove a single buff)
 		__packet->WriteUInt16(emu->count);
 
-		for (uint16 i = 0; i < emu->count; ++i)
+		for (int i = 0; i < emu->count; ++i)
 		{
-			uint16 buffslot = emu->entries[i].buff_slot;
+			__packet->WriteUInt32(emu->type == 0 ? ServerToRoF2BuffSlot(emu->entries[i].buff_slot) : emu->entries[i].buff_slot);
-			if (emu->type == 0) { // only correct for self packets
-				if (emu->entries[i].buff_slot >= 25)
-					buffslot += 17;
-				// TODO: We should really just deal with these "server side"
-				// so we can have clients not limited to other clients.
-				// This fixes discs, songs were changed to 20
-				if (buffslot == 54)
-					buffslot = 62;
-			}
-
-			__packet->WriteUInt32(buffslot);
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits); // Unknown
@@ -671,7 +652,7 @@ namespace RoF2
 		ob.write((const char*)&item_count, sizeof(uint32));
 
 		for (int index = 0; index < item_count; ++index, ++eq) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0, ItemPacketCharInventory);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0, ItemPacketCharInventory);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 
@@ -1609,7 +1590,7 @@ namespace RoF2
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0, old_item_pkt->PacketType);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0, old_item_pkt->PacketType);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -2164,7 +2145,7 @@ namespace RoF2
 
 		outapp->WriteUInt32(22);		// Equipment count
 
-		for (int r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++)
+		for (int r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++)
 		{
 			outapp->WriteUInt32(emu->item_material.Slot[r].Material);
 			outapp->WriteUInt32(0);
@@ -2184,9 +2165,9 @@ namespace RoF2
 			outapp->WriteUInt32(0);
 		}
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Equipment2 count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Equipment2 count
 
-		for (int r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++)
+		for (int r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++)
 		{
 			outapp->WriteUInt32(0);
 			outapp->WriteUInt32(0);
@@ -2195,7 +2176,7 @@ namespace RoF2
 			outapp->WriteUInt32(0);
 		}
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Tint Count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Tint Count
 
 		for (int r = 0; r < 7; r++)
 		{
@@ -2205,7 +2186,7 @@ namespace RoF2
 		outapp->WriteUInt32(0);
 		outapp->WriteUInt32(0);
 
-		outapp->WriteUInt32(EQEmu::textures::TextureCount);		// Tint2 Count
+		outapp->WriteUInt32(EQEmu::textures::materialCount);		// Tint2 Count
 
 		for (int r = 0; r < 7; r++)
 		{
@@ -3154,12 +3135,12 @@ namespace RoF2
 			eq_cse->Gender = emu_cse->Gender;
 			eq_cse->Face = emu_cse->Face;
 
-			for (int equip_index = 0; equip_index < EQEmu::textures::TextureCount; equip_index++) {
+			for (int equip_index = 0; equip_index < EQEmu::textures::materialCount; equip_index++) {
 				eq_cse->Equip[equip_index].Material = emu_cse->Equip[equip_index].Material;
 				eq_cse->Equip[equip_index].Unknown1 = emu_cse->Equip[equip_index].Unknown1;
-				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteMaterial;
+				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteModel;
-				eq_cse->Equip[equip_index].HeroForgeModel = emu_cse->Equip[equip_index].HeroForgeModel;
+				eq_cse->Equip[equip_index].HeroForgeModel = emu_cse->Equip[equip_index].HerosForgeModel;
-				eq_cse->Equip[equip_index].Material2 = emu_cse->Equip[equip_index].Material2;
+				eq_cse->Equip[equip_index].Material2 = emu_cse->Equip[equip_index].Unknown2;
 				eq_cse->Equip[equip_index].Color = emu_cse->Equip[equip_index].Color;
 			}
 
@@ -4321,7 +4302,7 @@ namespace RoF2
 
 			if ((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522))
 			{
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; ++k)
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; ++k)
 				{
 					{
 						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment_tint.Slot[k].Color);
@@ -4330,15 +4311,15 @@ namespace RoF2
 
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;
 
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 					Equipment[k].Material = emu->equipment.Slot[k].Material;
 					Equipment[k].Unknown1 = emu->equipment.Slot[k].Unknown1;
-					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteMaterial;
+					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteModel;
-					Equipment[k].HeroForgeModel = emu->equipment.Slot[k].HeroForgeModel;
+					Equipment[k].HeroForgeModel = emu->equipment.Slot[k].HerosForgeModel;
-					Equipment[k].Material2 = emu->equipment.Slot[k].Material2;
+					Equipment[k].Material2 = emu->equipment.Slot[k].Unknown2;
 				}
 
-				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 			}
 			else
 			{
@@ -4550,7 +4531,7 @@ namespace RoF2
 		IN(buff.unknown003);
 		IN(buff.spellid);
 		IN(buff.duration);
-		IN(slotid);
+		emu->slotid = RoF2ToServerBuffSlot(eq->slotid);
 		IN(bufffade);
 
 		FINISH_DIRECT_DECODE();
@@ -4563,7 +4544,7 @@ namespace RoF2
 		DECODE_LENGTH_EXACT(structs::BuffRemoveRequest_Struct);
 		SETUP_DIRECT_DECODE(BuffRemoveRequest_Struct, structs::BuffRemoveRequest_Struct);
 
-		emu->SlotID = (eq->SlotID < 42) ? eq->SlotID : (eq->SlotID - 17);
+		emu->SlotID = RoF2ToServerBuffSlot(eq->SlotID);
 
 		IN(EntityID);
 
@@ -5066,7 +5047,7 @@ namespace RoF2
 
 		IN(item_id);
 		int r;
-		for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
+		for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
 			IN(augments[r]);
 		}
 		IN(link_hash);
@@ -5499,9 +5480,9 @@ namespace RoF2
 		return NextItemInstSerialNumber;
 	}
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth, ItemPacketType packet_type)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth, ItemPacketType packet_type)
 	{
-		const EQEmu::ItemBase *item = inst->GetUnscaledItem();
+		const EQEmu::ItemData *item = inst->GetUnscaledItem();
 		
 		RoF2::structs::ItemSerializationHeader hdr;
 
@@ -5555,7 +5536,7 @@ namespace RoF2
 
 		if (inst->GetOrnamentationIDFile() && inst->GetOrnamentationIcon()) {
 			ornaIcon = inst->GetOrnamentationIcon();
-			heroModel = inst->GetOrnamentHeroModel(Inventory::CalcMaterialFromSlot(slot_id_in));
+			heroModel = inst->GetOrnamentHeroModel(EQEmu::InventoryProfile::CalcMaterialFromSlot(slot_id_in));
 
 			char tmp[30]; memset(tmp, 0x0, 30); sprintf(tmp, "IT%d", inst->GetOrnamentationIDFile());
 
@@ -5922,18 +5903,18 @@ namespace RoF2
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++index) {
+		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
 			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
 			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
 			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -5959,7 +5940,7 @@ namespace RoF2
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::legacy::SlotPowerSource) { // Main Inventory and Cursor
+		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // Main Inventory and Cursor
 			if (PacketType == ItemPacketLoot)
 			{
 				RoF2Slot.Type = invtype::InvTypeCorpse;
@@ -5971,13 +5952,13 @@ namespace RoF2
 				RoF2Slot.Slot = serverSlot;
 			}
 
-			if (serverSlot == EQEmu::legacy::SlotPowerSource)
+			if (serverSlot == EQEmu::inventory::slotPowerSource)
 				RoF2Slot.Slot = invslot::PossessionsPowerSource;
 
-			else if (serverSlot >= EQEmu::legacy::SlotCursor && PacketType != ItemPacketLoot) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::inventory::slotCursor && PacketType != ItemPacketLoot) // Cursor and Extended Corpse Inventory
 				RoF2Slot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::legacy::SlotAmmo) // (> 20)
+			else if (serverSlot >= EQEmu::inventory::slotAmmo) // (> 20)
 				RoF2Slot.Slot += 1;
 		}
 
@@ -5989,8 +5970,8 @@ namespace RoF2
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) { // (> 250 && < 341)
 			RoF2Slot.Type = invtype::InvTypePossessions;
 			TempSlot = serverSlot - 1;
-			RoF2Slot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 2;
+			RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
 
 			if (RoF2Slot.Slot >= invslot::PossessionsGeneral9) // (> 30)
 				RoF2Slot.Slot = invslot::PossessionsCursor;
@@ -6007,8 +5988,8 @@ namespace RoF2
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 		}
 
@@ -6018,8 +5999,8 @@ namespace RoF2
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) { // (> 30)
-				RoF2Slot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 		}
 
@@ -6029,8 +6010,8 @@ namespace RoF2
 			RoF2Slot.Slot = TempSlot;
 
 			if (TempSlot > 30) {
-				RoF2Slot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 3;
+				RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 3;
-				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+				RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 3) * EQEmu::inventory::ContainerCount);
 			}
 
 			/*
@@ -6068,16 +6049,16 @@ namespace RoF2
 
 		uint32 TempSlot = 0;
 
-		if (serverSlot < 56 || serverSlot == EQEmu::legacy::SlotPowerSource) { // (< 52)
+		if (serverSlot < 56 || serverSlot == EQEmu::inventory::slotPowerSource) { // (< 52)
 			RoF2Slot.Slot = serverSlot;
 
-			if (serverSlot == EQEmu::legacy::SlotPowerSource)
+			if (serverSlot == EQEmu::inventory::slotPowerSource)
 				RoF2Slot.Slot = invslot::PossessionsPowerSource;
 
-			else if (serverSlot >= EQEmu::legacy::SlotCursor) // Cursor and Extended Corpse Inventory
+			else if (serverSlot >= EQEmu::inventory::slotCursor) // Cursor and Extended Corpse Inventory
 				RoF2Slot.Slot += 3;
 
-			else if (serverSlot >= EQEmu::legacy::SlotAmmo) // Ammo and Personl Inventory
+			else if (serverSlot >= EQEmu::inventory::slotAmmo) // Ammo and Personl Inventory
 				RoF2Slot.Slot += 1;
 
 			/*else if (ServerSlot >= MainCursor) { // Cursor
@@ -6090,8 +6071,8 @@ namespace RoF2
 
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END) {
 			TempSlot = serverSlot - 1;
-			RoF2Slot.Slot = int(TempSlot / EQEmu::legacy::ITEM_CONTAINER_SIZE) - 2;
+			RoF2Slot.Slot = int(TempSlot / EQEmu::inventory::ContainerCount) - 2;
-			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::legacy::ITEM_CONTAINER_SIZE);
+			RoF2Slot.SubIndex = TempSlot - ((RoF2Slot.Slot + 2) * EQEmu::inventory::ContainerCount);
 		}
 
 		Log.Out(Logs::General, Logs::Netcode, "[ERROR] Convert Server Slot %i to RoF2 Slots: Main %i, Sub %i, Aug %i, Unk1 %i", serverSlot, RoF2Slot.Slot, RoF2Slot.SubIndex, RoF2Slot.AugIndex, RoF2Slot.Unknown01);
@@ -6111,7 +6092,7 @@ namespace RoF2
 
 		if (rof2Slot.Type == invtype::InvTypePossessions && rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 51)
 			if (rof2Slot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::legacy::SlotPowerSource;
+				TempSlot = EQEmu::inventory::slotPowerSource;
 
 			else if (rof2Slot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rof2Slot.Slot - 3;
@@ -6133,8 +6114,8 @@ namespace RoF2
 			else // Worn Slots
 				TempSlot = rof2Slot.Slot;
 
-			if (rof2Slot.SubIndex >= SUB_INDEX_BEGIN) // Bag Slots
+			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rof2Slot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -6142,8 +6123,8 @@ namespace RoF2
 		else if (rof2Slot.Type == invtype::InvTypeBank) {
 			TempSlot = EQEmu::legacy::BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rof2Slot.SubIndex + 1;
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
 
 			else
 				TempSlot += rof2Slot.Slot;
@@ -6154,8 +6135,8 @@ namespace RoF2
 		else if (rof2Slot.Type == invtype::InvTypeSharedBank) {
 			TempSlot = EQEmu::legacy::SHARED_BANK_BEGIN;
 
-			if (rof2Slot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rof2Slot.SubIndex + 1;
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
 
 			else
 				TempSlot += rof2Slot.Slot;
@@ -6166,8 +6147,8 @@ namespace RoF2
 		else if (rof2Slot.Type == invtype::InvTypeTrade) {
 			TempSlot = EQEmu::legacy::TRADE_BEGIN;
 
-			if (rof2Slot.SubIndex >= SUB_INDEX_BEGIN)
+			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin)
-				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rof2Slot.SubIndex + 1;
+				TempSlot += ((rof2Slot.Slot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
 			// OLD CODE:
 			//TempSlot += 100 + (RoF2Slot.MainSlot * EmuConstants::ITEM_CONTAINER_SIZE) + RoF2Slot.SubSlot;
 
@@ -6180,7 +6161,7 @@ namespace RoF2
 		else if (rof2Slot.Type == invtype::InvTypeWorld) {
 			TempSlot = EQEmu::legacy::WORLD_BEGIN;
 
-			if (rof2Slot.Slot >= SUB_INDEX_BEGIN)
+			if (rof2Slot.Slot >= EQEmu::inventory::containerBegin)
 				TempSlot += rof2Slot.Slot;
 
 			ServerSlot = TempSlot;
@@ -6215,7 +6196,7 @@ namespace RoF2
 
 		if (rof2Slot.Slot < 57) { // Worn/Personal Inventory and Cursor (< 33)
 			if (rof2Slot.Slot == invslot::PossessionsPowerSource)
-				TempSlot = EQEmu::legacy::SlotPowerSource;
+				TempSlot = EQEmu::inventory::slotPowerSource;
 
 			else if (rof2Slot.Slot >= invslot::PossessionsCursor) // Cursor and Extended Corpse Inventory
 				TempSlot = rof2Slot.Slot - 3;
@@ -6232,8 +6213,8 @@ namespace RoF2
 			else
 				TempSlot = rof2Slot.Slot;
 
-			if (rof2Slot.SubIndex >= SUB_INDEX_BEGIN) // Bag Slots
+			if (rof2Slot.SubIndex >= EQEmu::inventory::containerBegin) // Bag Slots
-				TempSlot = ((TempSlot + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + rof2Slot.SubIndex + 1;
+				TempSlot = ((TempSlot + 3) * EQEmu::inventory::ContainerCount) + rof2Slot.SubIndex + 1;
 
 			ServerSlot = TempSlot;
 		}
@@ -6388,4 +6369,32 @@ namespace RoF2
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	// these should be optimized out for RoF2 since they should all boil down to return index :P
+	// but lets leave it here for future proofing
+	static inline int ServerToRoF2BuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int RoF2ToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*RoF2*/

common/patches/rof2_limits.h

@@ -277,6 +277,14 @@ namespace RoF2
 
 		const size_t SayLinkBodySize = 56;
 
+		const int LongBuffs = 42;
+		const int ShortBuffs = 20;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 97;
+		const int PetBuffs = NPCBuffs;
+		const int MercBuffs = LongBuffs;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/rof2_structs.h

@@ -190,7 +190,7 @@ struct TintProfile
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -1082,7 +1082,7 @@ union
 	/*00184*/ Texture_Struct equipment[22];		// Total Slots
 };
 /*00624*/ uint32 equip2_count;			// Seen 9
-/*00628*/ Texture_Struct equipment2[EQEmu::textures::TextureCount];	// Appears to be Visible slots, but all 0s
+/*00628*/ Texture_Struct equipment2[EQEmu::textures::materialCount];	// Appears to be Visible slots, but all 0s
 /*00808*/ uint32 tint_count;			// Seen 9
 /*00812*/ TintProfile item_tint;		// RR GG BB 00
 /*00848*/ uint32 tint_count2;			// Seen 9
@@ -2423,7 +2423,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	ItemBase item;
+	ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 

common/patches/rof_limits.h

@@ -268,6 +268,14 @@ namespace RoF
 
 		const size_t SayLinkBodySize = 55;
 
+		const int LongBuffs = 42;
+		const int ShortBuffs = 20;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 97;
+		const int PetBuffs = NPCBuffs;
+		const int MercBuffs = LongBuffs;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/rof_structs.h

@@ -190,7 +190,7 @@ struct TintProfile
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -2450,7 +2450,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	ItemBase item;
+	ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 

common/patches/sod.cpp

@@ -29,7 +29,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../item_instance.h"
 #include "sod_structs.h"
 #include "../rulesys.h"
 
@@ -43,7 +43,7 @@ namespace SoD
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id, uint8 depth);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id, uint8 depth);
 
 	// server to client inventory location converters
 	static inline uint32 ServerToSoDSlot(uint32 ServerSlot);
@@ -62,6 +62,9 @@ namespace SoD
 	static inline CastingSlot ServerToSoDCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot SoDToServerCastingSlot(CastingSlot slot);
 
+	static inline int ServerToSoDBuffSlot(int index);
+	static inline int SoDToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		//create our opcode manager if we havent already
@@ -315,7 +318,7 @@ namespace SoD
 		OUT(buff.duration);
 		OUT(buff.counters);
 		OUT(buff.player_id);
-		OUT(slotid);
+		eq->slotid = ServerToSoDBuffSlot(emu->slotid);
 		OUT(bufffade);
 
 		FINISH_ENCODE();
@@ -396,7 +399,7 @@ namespace SoD
 		ob.write((const char*)&item_count, sizeof(uint32));
 
 		for (int index = 0; index < item_count; ++index, ++eq) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 
@@ -1060,7 +1063,7 @@ namespace SoD
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -1558,7 +1561,7 @@ namespace SoD
 		OUT(hairstyle);
 		OUT(beard);
 		//	OUT(unknown00178[10]);
-		for (r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++) {
+		for (r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++) {
 			eq->equipment.Slot[r].Material = emu->item_material.Slot[r].Material;
 			eq->equipment.Slot[r].Unknown1 = 0;
 			eq->equipment.Slot[r].EliteMaterial = 0;
@@ -1998,10 +2001,10 @@ namespace SoD
 			eq_cse->HairColor = emu_cse->HairColor;
 			eq_cse->Face = emu_cse->Face;
 
-			for (int equip_index = 0; equip_index < EQEmu::textures::TextureCount; equip_index++) {
+			for (int equip_index = EQEmu::textures::textureBegin; equip_index < EQEmu::textures::materialCount; equip_index++) {
 				eq_cse->Equip[equip_index].Material = emu_cse->Equip[equip_index].Material;
 				eq_cse->Equip[equip_index].Unknown1 = emu_cse->Equip[equip_index].Unknown1;
-				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteMaterial;
+				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteModel;
 				eq_cse->Equip[equip_index].Color = emu_cse->Equip[equip_index].Color;
 			}
 
@@ -2568,7 +2571,7 @@ namespace SoD
 			float SpawnSize = emu->size;
 			if (!((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522)))
 			{
-				PacketSize -= (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				PacketSize -= (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 
 				if (emu->size == 0)
 				{
@@ -2765,7 +2768,7 @@ namespace SoD
 
 			if ((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522))
 			{
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; ++k)
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; ++k)
 				{
 					{
 						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment_tint.Slot[k].Color);
@@ -2792,13 +2795,13 @@ namespace SoD
 			{
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;
 
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 					Equipment[k].Material = emu->equipment.Slot[k].Material;
 					Equipment[k].Unknown1 = emu->equipment.Slot[k].Unknown1;
-					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteMaterial;
+					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteModel;
 				}
 
-				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 			}
 			if (strlen(emu->title))
 			{
@@ -2921,8 +2924,8 @@ namespace SoD
 		IN(buff.bard_modifier);
 		IN(buff.spellid);
 		IN(buff.duration);
-		IN(buff.counters)
+		IN(buff.counters);
-		IN(slotid);
+		emu->slotid = SoDToServerBuffSlot(eq->slotid);
 		IN(bufffade);
 
 		FINISH_DIRECT_DECODE();
@@ -3553,9 +3556,9 @@ namespace SoD
 		return NextItemInstSerialNumber;
 	}
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth)
 	{
-		const EQEmu::ItemBase *item = inst->GetUnscaledItem();
+		const EQEmu::ItemData *item = inst->GetUnscaledItem();
 		
 		SoD::structs::ItemSerializationHeader hdr;
 
@@ -3869,18 +3872,18 @@ namespace SoD
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++index) {
+		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
 			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
 			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
 			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -3898,7 +3901,7 @@ namespace SoD
 	{
 		uint32 SoDSlot = 0;
 
-		if (serverSlot >= EQEmu::legacy::SlotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			SoDSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
 			SoDSlot = serverSlot + 11;
@@ -3906,7 +3909,7 @@ namespace SoD
 			SoDSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
 			SoDSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::legacy::SlotPowerSource)
+		else if (serverSlot == EQEmu::inventory::slotPowerSource)
 			SoDSlot = invslot::PossessionsPowerSource;
 		else
 			SoDSlot = serverSlot;
@@ -3932,7 +3935,7 @@ namespace SoD
 		else if (sodSlot >= invbag::SharedBankBagsBegin && sodSlot <= invbag::SharedBankBagsEnd)
 			ServerSlot = sodSlot - 1;
 		else if (sodSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::legacy::SlotPowerSource;
+			ServerSlot = EQEmu::inventory::slotPowerSource;
 		else
 			ServerSlot = sodSlot;
 		return ServerSlot;
@@ -4088,4 +4091,30 @@ namespace SoD
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	static inline int ServerToSoDBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int SoDToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*SoD*/

common/patches/sod_limits.h

@@ -295,6 +295,14 @@ namespace SoD
 
 		const size_t SayLinkBodySize = 50;
 
+		const int LongBuffs = 25;
+		const int ShortBuffs = 15;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 85;
+		const int PetBuffs = NPCBuffs;
+		const int MercBuffs = LongBuffs;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/sod_structs.h

@@ -149,7 +149,7 @@ struct TintProfile
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -178,7 +178,7 @@ struct TextureProfile
 			Texture_Struct Primary;
 			Texture_Struct Secondary;
 		};
-		Texture_Struct Slot[EQEmu::textures::TextureCount];
+		Texture_Struct Slot[EQEmu::textures::materialCount];
 	};
 
 	TextureProfile();
@@ -195,7 +195,7 @@ struct CharacterSelectEntry_Struct
 /*0000*/	uint8 Beard;				//
 /*0001*/	uint8 HairColor;			//
 /*0000*/	uint8 Face;					//
-/*0000*/	CharSelectEquip	Equip[EQEmu::textures::TextureCount];
+/*0000*/	CharSelectEquip	Equip[EQEmu::textures::materialCount];
 /*0000*/	uint32 PrimaryIDFile;		//
 /*0000*/	uint32 SecondaryIDFile;		//
 /*0000*/	uint8 Unknown15;			// 0xff
@@ -1970,7 +1970,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	ItemBase item;
+	ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 

common/patches/sof.cpp

@@ -29,7 +29,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../item_instance.h"
 #include "sof_structs.h"
 #include "../rulesys.h"
 
@@ -43,7 +43,7 @@ namespace SoF
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id, uint8 depth);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id, uint8 depth);
 
 	// server to client inventory location converters
 	static inline uint32 ServerToSoFSlot(uint32 serverSlot);
@@ -62,6 +62,9 @@ namespace SoF
 	static inline CastingSlot ServerToSoFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot SoFToServerCastingSlot(CastingSlot slot, uint32 itemlocation);
 
+	static inline int ServerToSoFBuffSlot(int index);
+	static inline int SoFToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		//create our opcode manager if we havent already
@@ -297,7 +300,7 @@ namespace SoF
 		OUT(buff.duration);
 		OUT(buff.counters);
 		OUT(buff.player_id);
-		OUT(slotid);
+		eq->slotid = ServerToSoFBuffSlot(emu->slotid);
 		OUT(bufffade);
 
 		FINISH_ENCODE();
@@ -378,7 +381,7 @@ namespace SoF
 		ob.write((const char*)&item_count, sizeof(uint32));
 
 		for (int index = 0; index < item_count; ++index, ++eq) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 
@@ -857,7 +860,7 @@ namespace SoF
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -1230,7 +1233,7 @@ namespace SoF
 		OUT(hairstyle);
 		OUT(beard);
 		//	OUT(unknown00178[10]);
-		for (r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++) {
+		for (r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++) {
 			eq->equipment.Slot[r].Material = emu->item_material.Slot[r].Material;
 			eq->equipment.Slot[r].Unknown1 = 0;
 			eq->equipment.Slot[r].EliteMaterial = 0;
@@ -1670,10 +1673,10 @@ namespace SoF
 			eq_cse->HairColor = emu_cse->HairColor;
 			eq_cse->Face = emu_cse->Face;
 
-			for (int equip_index = 0; equip_index < EQEmu::textures::TextureCount; equip_index++) {
+			for (int equip_index = EQEmu::textures::textureBegin; equip_index < EQEmu::textures::materialCount; equip_index++) {
 				eq_cse->Equip[equip_index].Material = emu_cse->Equip[equip_index].Material;
 				eq_cse->Equip[equip_index].Unknown1 = emu_cse->Equip[equip_index].Unknown1;
-				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteMaterial;
+				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteModel;
 				eq_cse->Equip[equip_index].Color = emu_cse->Equip[equip_index].Color;
 			}
 
@@ -2101,10 +2104,10 @@ namespace SoF
 			eq->deity = emu->deity;
 			eq->drakkin_heritage = emu->drakkin_heritage;
 			eq->gender = emu->gender;
-			for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+			for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 				eq->equipment.Slot[k].Material = emu->equipment.Slot[k].Material;
 				eq->equipment.Slot[k].Unknown1 = emu->equipment.Slot[k].Unknown1;
-				eq->equipment.Slot[k].EliteMaterial = emu->equipment.Slot[k].EliteMaterial;
+				eq->equipment.Slot[k].EliteMaterial = emu->equipment.Slot[k].EliteModel;
 				eq->equipment_tint.Slot[k].Color = emu->equipment_tint.Slot[k].Color;
 			}
 			eq->StandState = emu->StandState;
@@ -2167,7 +2170,7 @@ namespace SoF
 			strcpy(eq->name, emu->name);
 			eq->petOwnerId = emu->petOwnerId;
 			eq->pvp = 0;	// 0 = non-pvp colored name, 1 = red pvp name
-			for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+			for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 				eq->equipment_tint.Slot[k].Color = emu->equipment_tint.Slot[k].Color;
 			}
 			eq->anon = emu->anon;
@@ -2375,7 +2378,7 @@ namespace SoF
 		IN(buff.duration);
 		IN(buff.counters);
 		IN(buff.player_id);
-		IN(slotid);
+		emu->slotid = SoFToServerBuffSlot(eq->slotid);
 		IN(bufffade);
 
 		FINISH_DIRECT_DECODE();
@@ -2923,9 +2926,9 @@ namespace SoF
 		return NextItemInstSerialNumber;
 	}
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth)
 	{
-		const EQEmu::ItemBase *item = inst->GetUnscaledItem();
+		const EQEmu::ItemData *item = inst->GetUnscaledItem();
 		
 		SoF::structs::ItemSerializationHeader hdr;
 
@@ -3237,18 +3240,18 @@ namespace SoF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++index) {
+		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
 			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
 			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
 			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -3266,7 +3269,7 @@ namespace SoF
 	{
 		uint32 SoFSlot = 0;
 
-		if (serverSlot >= EQEmu::legacy::SlotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			SoFSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
 			SoFSlot = serverSlot + 11;
@@ -3274,7 +3277,7 @@ namespace SoF
 			SoFSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
 			SoFSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::legacy::SlotPowerSource)
+		else if (serverSlot == EQEmu::inventory::slotPowerSource)
 			SoFSlot = invslot::PossessionsPowerSource;
 		else
 			SoFSlot = serverSlot;
@@ -3301,7 +3304,7 @@ namespace SoF
 		else if (sofSlot >= invbag::SharedBankBagsBegin && sofSlot <= invbag::SharedBankBagsEnd)
 			ServerSlot = sofSlot - 1;
 		else if (sofSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::legacy::SlotPowerSource;
+			ServerSlot = EQEmu::inventory::slotPowerSource;
 		else
 			ServerSlot = sofSlot;
 
@@ -3461,4 +3464,30 @@ namespace SoF
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	static inline int ServerToSoFBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int SoFToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*SoF*/

common/patches/sof_limits.h

@@ -295,6 +295,14 @@ namespace SoF
 
 		const size_t SayLinkBodySize = 50;
 
+		const int LongBuffs = 25;
+		const int ShortBuffs = 15;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 60;
+		const int PetBuffs = 30;
+		const int MercBuffs = 0;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/sof_structs.h

@@ -149,7 +149,7 @@ struct TintProfile
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -178,7 +178,7 @@ struct TextureProfile
 			Texture_Struct Primary;
 			Texture_Struct Secondary;
 		};
-		Texture_Struct Slot[EQEmu::textures::TextureCount];
+		Texture_Struct Slot[EQEmu::textures::materialCount];
 	};
 
 	TextureProfile();
@@ -195,7 +195,7 @@ struct CharacterSelectEntry_Struct
 /*0000*/	uint8 Beard;				//
 /*0001*/	uint8 HairColor;			//
 /*0000*/	uint8 Face;					//
-/*0000*/	CharSelectEquip	Equip[EQEmu::textures::TextureCount];
+/*0000*/	CharSelectEquip	Equip[EQEmu::textures::materialCount];
 /*0000*/	uint32 PrimaryIDFile;		//
 /*0000*/	uint32 SecondaryIDFile;		//
 /*0000*/	uint8 Unknown15;			// 0xff

common/patches/titanium.cpp

@@ -30,7 +30,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../item_instance.h"
 #include "titanium_structs.h"
 
 #include <sstream>
@@ -42,7 +42,7 @@ namespace Titanium
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth);
 
 	// server to client inventory location converters
 	static inline int16 ServerToTitaniumSlot(uint32 serverSlot);
@@ -61,6 +61,9 @@ namespace Titanium
 	static inline CastingSlot ServerToTitaniumCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot TitaniumToServerCastingSlot(CastingSlot slot, uint32 itemlocation);
 
+	static inline int ServerToTitaniumBuffSlot(int index);
+	static inline int TitaniumToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		auto Config = EQEmuConfig::get();
@@ -270,7 +273,7 @@ namespace Titanium
 		OUT(buff.duration);
 		OUT(buff.counters);
 		OUT(buff.player_id);
-		OUT(slotid);
+		eq->slotid = ServerToTitaniumBuffSlot(emu->slotid);
 		OUT(bufffade);
 
 		FINISH_ENCODE();
@@ -329,7 +332,7 @@ namespace Titanium
 		EQEmu::OutBuffer::pos_type last_pos = ob.tellp();
 
 		for (int r = 0; r < itemcount; r++, eq++) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 			
@@ -815,7 +818,7 @@ namespace Titanium
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -981,7 +984,7 @@ namespace Titanium
 		OUT(hairstyle);
 		OUT(beard);
 		//	OUT(unknown00178[10]);
-		for (r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++) {
+		for (r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++) {
 			OUT(item_material.Slot[r].Material);
 			OUT(item_tint.Slot[r].Color);
 		}
@@ -1301,14 +1304,14 @@ namespace Titanium
 			if (eq->Race[char_index] > 473)
 				eq->Race[char_index] = 1;
 
-			for (int index = 0; index < EQEmu::textures::TextureCount; ++index) {
+			for (int index = 0; index < EQEmu::textures::materialCount; ++index) {
 				eq->CS_Colors[char_index].Slot[index].Color = emu_cse->Equip[index].Color;
 			}
 
 			eq->BeardColor[char_index] = emu_cse->BeardColor;
 			eq->HairStyle[char_index] = emu_cse->HairStyle;
 
-			for (int index = 0; index < EQEmu::textures::TextureCount; ++index) {
+			for (int index = 0; index < EQEmu::textures::materialCount; ++index) {
 				eq->Equip[char_index].Slot[index].Material = emu_cse->Equip[index].Material;
 			}
 
@@ -1338,14 +1341,14 @@ namespace Titanium
 		for (; char_index < 10; ++char_index) {
 			eq->Race[char_index] = 0;
 
-			for (int index = 0; index < EQEmu::textures::TextureCount; ++index) {
+			for (int index = 0; index < EQEmu::textures::materialCount; ++index) {
 				eq->CS_Colors[char_index].Slot[index].Color = 0;
 			}
 
 			eq->BeardColor[char_index] = 0;
 			eq->HairStyle[char_index] = 0;
 
-			for (int index = 0; index < EQEmu::textures::TextureCount; ++index) {
+			for (int index = 0; index < EQEmu::textures::materialCount; ++index) {
 				eq->Equip[char_index].Slot[index].Material = 0;
 			}
 
@@ -1677,7 +1680,7 @@ namespace Titanium
 			eq->petOwnerId = emu->petOwnerId;
 			eq->guildrank = emu->guildrank;
 			//		eq->unknown0194[3] = emu->unknown0194[3];
-			for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+			for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 				eq->equipment.Slot[k].Material = emu->equipment.Slot[k].Material;
 				eq->equipment_tint.Slot[k].Color = emu->equipment_tint.Slot[k].Color;
 			}
@@ -1779,7 +1782,7 @@ namespace Titanium
 		IN(buff.duration);
 		IN(buff.counters);
 		IN(buff.player_id);
-		IN(slotid);
+		emu->slotid = TitaniumToServerBuffSlot(eq->slotid);
 		IN(bufffade);
 
 		FINISH_DIRECT_DECODE();
@@ -2216,10 +2219,10 @@ namespace Titanium
 	}
 
 // file scope helper methods
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth)
 	{
 		const char* protection = "\\\\\\\\\\";
-		const EQEmu::ItemBase* item = inst->GetUnscaledItem();
+		const EQEmu::ItemData* item = inst->GetUnscaledItem();
 
 		ob << StringFormat("%.*s%s", (depth ? (depth - 1) : 0), protection, (depth ? "\"" : "")); // For leading quotes (and protection) if a subitem;
 		
@@ -2437,10 +2440,10 @@ namespace Titanium
 		ob << StringFormat("%.*s\"", depth, protection); // Quotes (and protection, if needed) around static data
 
 		// Sub data
-		for (int index = SUB_INDEX_BEGIN; index < invbag::ItemBagSize; ++index) {
+		for (int index = EQEmu::inventory::containerBegin; index < invbag::ItemBagSize; ++index) {
 			ob << '|';
 
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 			
@@ -2632,4 +2635,30 @@ namespace Titanium
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	static inline int ServerToTitaniumBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int TitaniumToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*Titanium*/

common/patches/titanium_limits.h

@@ -294,6 +294,14 @@ namespace Titanium
 
 		const size_t SayLinkBodySize = 45;
 
+		const int LongBuffs = 25;
+		const int ShortBuffs = 12;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 60;
+		const int PetBuffs = 30;
+		const int MercBuffs = 0;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/titanium_structs.h

@@ -144,7 +144,7 @@ struct TintProfile {
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -167,7 +167,7 @@ struct TextureProfile
 			Texture_Struct Primary;
 			Texture_Struct Secondary;
 		};
-		Texture_Struct Slot[EQEmu::textures::TextureCount];
+		Texture_Struct Slot[EQEmu::textures::materialCount];
 	};
 
 	TextureProfile();

common/patches/uf.cpp

@@ -29,7 +29,7 @@
 #include "../eq_packet_structs.h"
 #include "../misc_functions.h"
 #include "../string_util.h"
-#include "../item.h"
+#include "../item_instance.h"
 #include "uf_structs.h"
 #include "../rulesys.h"
 
@@ -43,7 +43,7 @@ namespace UF
 	static OpcodeManager *opcodes = nullptr;
 	static Strategy struct_strategy;
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id, uint8 depth);
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id, uint8 depth);
 
 	// server to client inventory location converters
 	static inline uint32 ServerToUFSlot(uint32 serverSlot);
@@ -62,6 +62,9 @@ namespace UF
 	static inline CastingSlot ServerToUFCastingSlot(EQEmu::CastingSlot slot);
 	static inline EQEmu::CastingSlot UFToServerCastingSlot(CastingSlot slot);
 
+	static inline int ServerToUFBuffSlot(int index);
+	static inline int UFToServerBuffSlot(int index);
+
 	void Register(EQStreamIdentifier &into)
 	{
 		//create our opcode manager if we havent already
@@ -377,17 +380,8 @@ namespace UF
 		OUT(buff.spellid);
 		OUT(buff.duration);
 		OUT(buff.num_hits);
-		uint16 buffslot = emu->slotid;
-		if (buffslot >= 25 && buffslot < 37)
-		{
-			buffslot += 5;
-		}
-		else if (buffslot >= 37)
-		{
-			buffslot += 14;
-		}
 		// TODO: implement slot_data stuff
-		eq->slotid = buffslot;
+		eq->slotid = ServerToUFBuffSlot(emu->slotid);
 		OUT(bufffade);	// Live (October 2011) sends a 2 rather than 0 when a buff is created, but it doesn't seem to matter.
 
 		FINISH_ENCODE();
@@ -407,17 +401,9 @@ namespace UF
 		__packet->WriteUInt8(emu->all_buffs); // 1 = all buffs, 0 = 1 buff
 		__packet->WriteUInt16(emu->count);
 
-		for (uint16 i = 0; i < emu->count; ++i)
+		for (int i = 0; i < emu->count; ++i)
 		{
-			uint16 buffslot = emu->entries[i].buff_slot;
+			__packet->WriteUInt32(emu->type == 0 ? ServerToUFBuffSlot(emu->entries[i].buff_slot) : emu->entries[i].buff_slot);
-			if (emu->type == 0) { // only correct for self packets
-				if (emu->entries[i].buff_slot >= 25 && emu->entries[i].buff_slot < 37)
-					buffslot += 5;
-				else if (emu->entries[i].buff_slot >= 37)
-					buffslot += 14;
-			}
-
-			__packet->WriteUInt32(buffslot);
 			__packet->WriteUInt32(emu->entries[i].spell_id);
 			__packet->WriteUInt32(emu->entries[i].tics_remaining);
 			__packet->WriteUInt32(emu->entries[i].num_hits);
@@ -541,7 +527,7 @@ namespace UF
 		ob.write((const char*)&item_count, sizeof(uint32));
 
 		for (int index = 0; index < item_count; ++index, ++eq) {
-			SerializeItem(ob, (const ItemInst*)eq->inst, eq->slot_id, 0);
+			SerializeItem(ob, (const EQEmu::ItemInstance*)eq->inst, eq->slot_id, 0);
 			if (ob.tellp() == last_pos)
 				Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d during OP_CharInventory.  Item skipped.", eq->slot_id);
 
@@ -1293,7 +1279,7 @@ namespace UF
 
 		ob.write((const char*)__emu_buffer, 4);
 
-		SerializeItem(ob, (const ItemInst*)int_struct->inst, int_struct->slot_id, 0);
+		SerializeItem(ob, (const EQEmu::ItemInstance*)int_struct->inst, int_struct->slot_id, 0);
 		if (ob.tellp() == last_pos) {
 			Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Serialization failed on item slot %d.", int_struct->slot_id);
 			delete in;
@@ -1817,7 +1803,7 @@ namespace UF
 		OUT(hairstyle);
 		OUT(beard);
 		//	OUT(unknown00178[10]);
-		for (r = EQEmu::textures::TextureBegin; r < EQEmu::textures::TextureCount; r++) {
+		for (r = EQEmu::textures::textureBegin; r < EQEmu::textures::materialCount; r++) {
 			eq->equipment.Slot[r].Material = emu->item_material.Slot[r].Material;
 			eq->equipment.Slot[r].Unknown1 = 0;
 			eq->equipment.Slot[r].EliteMaterial = 0;
@@ -2301,10 +2287,10 @@ namespace UF
 			eq_cse->HairColor = emu_cse->HairColor;
 			eq_cse->Face = emu_cse->Face;
 
-			for (int equip_index = 0; equip_index < EQEmu::textures::TextureCount; equip_index++) {
+			for (int equip_index = EQEmu::textures::textureBegin; equip_index < EQEmu::textures::materialCount; equip_index++) {
 				eq_cse->Equip[equip_index].Material = emu_cse->Equip[equip_index].Material;
 				eq_cse->Equip[equip_index].Unknown1 = emu_cse->Equip[equip_index].Unknown1;
-				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteMaterial;
+				eq_cse->Equip[equip_index].EliteMaterial = emu_cse->Equip[equip_index].EliteModel;
 				eq_cse->Equip[equip_index].Color = emu_cse->Equip[equip_index].Color;
 			}
 
@@ -2869,7 +2855,7 @@ namespace UF
 			float SpawnSize = emu->size;
 			if (!((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522)))
 			{
-				PacketSize -= (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				PacketSize -= (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 
 				if (emu->size == 0)
 				{
@@ -3068,7 +3054,7 @@ namespace UF
 
 			if ((emu->NPC == 0) || (emu->race <= 12) || (emu->race == 128) || (emu->race == 130) || (emu->race == 330) || (emu->race == 522))
 			{
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; ++k)
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; ++k)
 				{
 					{
 						VARSTRUCT_ENCODE_TYPE(uint32, Buffer, emu->equipment_tint.Slot[k].Color);
@@ -3104,17 +3090,17 @@ namespace UF
 			{
 				structs::Texture_Struct *Equipment = (structs::Texture_Struct *)Buffer;
 
-				for (k = EQEmu::textures::TextureBegin; k < EQEmu::textures::TextureCount; k++) {
+				for (k = EQEmu::textures::textureBegin; k < EQEmu::textures::materialCount; k++) {
 					if (emu->equipment.Slot[k].Material > 99999) {
 						Equipment[k].Material = 63;
 					} else {
 						Equipment[k].Material = emu->equipment.Slot[k].Material;
 					}
 					Equipment[k].Unknown1 = emu->equipment.Slot[k].Unknown1;
-					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteMaterial;
+					Equipment[k].EliteMaterial = emu->equipment.Slot[k].EliteModel;
 				}
 
-				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::TextureCount);
+				Buffer += (sizeof(structs::Texture_Struct) * EQEmu::textures::materialCount);
 			}
 			if (strlen(emu->title))
 			{
@@ -3236,6 +3222,7 @@ namespace UF
 		IN(buff.unknown003);
 		IN(buff.spellid);
 		IN(buff.duration);
+		emu->slotid = UFToServerBuffSlot(eq->slotid);
 		IN(slotid);
 		IN(bufffade);
 
@@ -3249,7 +3236,7 @@ namespace UF
 		DECODE_LENGTH_EXACT(structs::BuffRemoveRequest_Struct);
 		SETUP_DIRECT_DECODE(BuffRemoveRequest_Struct, structs::BuffRemoveRequest_Struct);
 
-		emu->SlotID = (eq->SlotID < 30) ? eq->SlotID : (eq->SlotID - 5);
+		emu->SlotID = UFToServerBuffSlot(eq->SlotID);
 
 		IN(EntityID);
 
@@ -3847,9 +3834,9 @@ namespace UF
 		return NextItemInstSerialNumber;
 	}
 
-	void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
+	void SerializeItem(EQEmu::OutBuffer& ob, const EQEmu::ItemInstance *inst, int16 slot_id_in, uint8 depth)
 	{
-		const EQEmu::ItemBase *item = inst->GetUnscaledItem();
+		const EQEmu::ItemData *item = inst->GetUnscaledItem();
 		
 		UF::structs::ItemSerializationHeader hdr;
 
@@ -3893,7 +3880,7 @@ namespace UF
 		int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
 		uint16 ornaIcon = 0;
 		if (inst->GetOrnamentationAug(ornamentationAugtype)) {
-			const EQEmu::ItemBase *aug_weap = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
+			const EQEmu::ItemData *aug_weap = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
 			ornaIcon = aug_weap->Icon;
 
 			ob.write(aug_weap->IDFile, strlen(aug_weap->IDFile));
@@ -4224,18 +4211,18 @@ namespace UF
 
 		ob.write((const char*)&subitem_count, sizeof(uint32));
 
-		for (uint32 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++index) {
+		for (uint32 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; ++index) {
-			ItemInst* sub = inst->GetItem(index);
+			EQEmu::ItemInstance* sub = inst->GetItem(index);
 			if (!sub)
 				continue;
 
 			int SubSlotNumber = INVALID_INDEX;
 			if (slot_id_in >= EQEmu::legacy::GENERAL_BEGIN && slot_id_in <= EQEmu::legacy::GENERAL_END)
-				SubSlotNumber = (((slot_id_in + 3) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + index + 1);
+				SubSlotNumber = (((slot_id_in + 3) * EQEmu::inventory::ContainerCount) + index + 1);
 			else if (slot_id_in >= EQEmu::legacy::BANK_BEGIN && slot_id_in <= EQEmu::legacy::BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::BANK_BAGS_BEGIN + index);
 			else if (slot_id_in >= EQEmu::legacy::SHARED_BANK_BEGIN && slot_id_in <= EQEmu::legacy::SHARED_BANK_END)
-				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::legacy::ITEM_CONTAINER_SIZE) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
+				SubSlotNumber = (((slot_id_in - EQEmu::legacy::SHARED_BANK_BEGIN) * EQEmu::inventory::ContainerCount) + EQEmu::legacy::SHARED_BANK_BAGS_BEGIN + index);
 			else
 				SubSlotNumber = slot_id_in;
 
@@ -4253,7 +4240,7 @@ namespace UF
 	{
 		uint32 UnderfootSlot = 0;
 
-		if (serverSlot >= EQEmu::legacy::SlotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
+		if (serverSlot >= EQEmu::inventory::slotAmmo && serverSlot <= 53) // Cursor/Ammo/Power Source and Normal Inventory Slots
 			UnderfootSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::GENERAL_BAGS_BEGIN && serverSlot <= EQEmu::legacy::CURSOR_BAG_END)
 			UnderfootSlot = serverSlot + 11;
@@ -4261,7 +4248,7 @@ namespace UF
 			UnderfootSlot = serverSlot + 1;
 		else if (serverSlot >= EQEmu::legacy::SHARED_BANK_BAGS_BEGIN && serverSlot <= EQEmu::legacy::SHARED_BANK_BAGS_END)
 			UnderfootSlot = serverSlot + 1;
-		else if (serverSlot == EQEmu::legacy::SlotPowerSource)
+		else if (serverSlot == EQEmu::inventory::slotPowerSource)
 			UnderfootSlot = invslot::PossessionsPowerSource;
 		else
 			UnderfootSlot = serverSlot;
@@ -4288,7 +4275,7 @@ namespace UF
 		else if (ufSlot >= invbag::SharedBankBagsBegin && ufSlot <= invbag::SharedBankBagsEnd)
 			ServerSlot = ufSlot - 1;
 		else if (ufSlot == invslot::PossessionsPowerSource)
-			ServerSlot = EQEmu::legacy::SlotPowerSource;
+			ServerSlot = EQEmu::inventory::slotPowerSource;
 		else
 			ServerSlot = ufSlot;
 
@@ -4453,4 +4440,30 @@ namespace UF
 			return EQEmu::CastingSlot::Discipline;
 		}
 	}
+
+	static inline int ServerToUFBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= EQEmu::constants::LongBuffs + EQEmu::constants::ShortBuffs)
+			return index - EQEmu::constants::LongBuffs - EQEmu::constants::ShortBuffs +
+			       constants::LongBuffs + constants::ShortBuffs;
+		// we're a song
+		if (index >= EQEmu::constants::LongBuffs)
+			return index - EQEmu::constants::LongBuffs + constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
+
+	static inline int UFToServerBuffSlot(int index)
+	{
+		// we're a disc
+		if (index >= constants::LongBuffs + constants::ShortBuffs)
+			return index - constants::LongBuffs - constants::ShortBuffs + EQEmu::constants::LongBuffs +
+			       EQEmu::constants::ShortBuffs;
+		// we're a song
+		if (index >= constants::LongBuffs)
+			return index - constants::LongBuffs + EQEmu::constants::LongBuffs;
+		// we're a normal buff
+		return index; // as long as we guard against bad slots server side, we should be fine
+	}
 } /*UF*/

common/patches/uf_limits.h

@@ -296,6 +296,14 @@ namespace UF
 
 		const size_t SayLinkBodySize = 50;
 
+		const int LongBuffs = 30;
+		const int ShortBuffs = 20;
+		const int DiscBuffs = 1;
+		const int TotalBuffs = LongBuffs + ShortBuffs + DiscBuffs;
+		const int NPCBuffs = 85;
+		const int PetBuffs = NPCBuffs;
+		const int MercBuffs = LongBuffs;
+
 	} /*constants*/
 
 	namespace behavior {

common/patches/uf_structs.h

@@ -149,7 +149,7 @@ struct TintProfile
 			Tint_Struct Primary;
 			Tint_Struct Secondary;
 		};
-		Tint_Struct Slot[EQEmu::textures::TextureCount];
+		Tint_Struct Slot[EQEmu::textures::materialCount];
 	};
 };
 
@@ -178,7 +178,7 @@ struct TextureProfile
 			Texture_Struct Primary;
 			Texture_Struct Secondary;
 		};
-		Texture_Struct Slot[EQEmu::textures::TextureCount];
+		Texture_Struct Slot[EQEmu::textures::materialCount];
 	};
 
 	TextureProfile();
@@ -195,7 +195,7 @@ struct CharacterSelectEntry_Struct
 /*0000*/	uint8 Beard;				//
 /*0001*/	uint8 HairColor;			//
 /*0000*/	uint8 Face;					//
-/*0000*/	CharSelectEquip	Equip[EQEmu::textures::TextureCount];
+/*0000*/	CharSelectEquip	Equip[EQEmu::textures::materialCount];
 /*0000*/	uint32 PrimaryIDFile;		//
 /*0000*/	uint32 SecondaryIDFile;		//
 /*0000*/	uint8 Unknown15;			// 0xff
@@ -2011,7 +2011,7 @@ struct AdventureLeaderboard_Struct
 /*struct Item_Shop_Struct {
 	uint16 merchantid;
 	uint8 itemtype;
-	ItemBase item;
+	ItemData item;
 	uint8 iss_unknown001[6];
 };*/
 

common/ruletypes.h

@@ -55,6 +55,7 @@ RULE_REAL(Character, AAExpMultiplier, 0.5)
 RULE_REAL(Character, GroupExpMultiplier, 0.5)
 RULE_REAL(Character, RaidExpMultiplier, 0.2)
 RULE_BOOL(Character, UseXPConScaling, true)
+RULE_INT(Character, ShowExpValues, 0) //0 - normal, 1 - Show raw experience values, 2 - Show raw experience values AND percent.
 RULE_INT(Character, LightBlueModifier, 40)
 RULE_INT(Character, BlueModifier, 90)
 RULE_INT(Character, WhiteModifier, 100)
@@ -146,7 +147,7 @@ RULE_BOOL(Character, EnableAvoidanceCap, false)
 RULE_INT(Character, AvoidanceCap, 750) // 750 Is a pretty good value, seen people dodge all attacks beyond 1,000 Avoidance
 RULE_BOOL(Character, AllowMQTarget, false) // Disables putting players in the 'hackers' list for targeting beyond the clip plane or attempting to target something untargetable
 RULE_BOOL(Character, UseOldBindWound, false) // Uses the original bind wound behavior
-
+RULE_BOOL(Character, GrantHoTTOnCreate, false) // Grant Health of Target's Target leadership AA on character creation
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(Mercs)
@@ -332,11 +333,11 @@ RULE_INT(Spells, SacrificeMinLevel, 46)	//first level Sacrifice will work on
 RULE_INT(Spells, SacrificeMaxLevel, 69)	//last level Sacrifice will work on
 RULE_INT(Spells, SacrificeItemID, 9963)	//Item ID of the item Sacrifice will return (defaults to an EE)
 RULE_BOOL(Spells, EnableSpellGlobals, false)	// If Enabled, spells check the spell_globals table and compare character data from the quest globals before allowing that spell to scribe with scribespells
-RULE_INT(Spells, MaxBuffSlotsNPC, 25)
+RULE_INT(Spells, MaxBuffSlotsNPC, 60)	// default to Tit's limit
-RULE_INT(Spells, MaxSongSlotsNPC, 10)
+RULE_INT(Spells, MaxSongSlotsNPC, 0)	// NPCs don't have songs ...
-RULE_INT(Spells, MaxDiscSlotsNPC, 1)
+RULE_INT(Spells, MaxDiscSlotsNPC, 0)	// NPCs don't have discs ...
-RULE_INT(Spells, MaxTotalSlotsNPC, 36)
+RULE_INT(Spells, MaxTotalSlotsNPC, 60)	// default to Tit's limit
-RULE_INT(Spells, MaxTotalSlotsPET, 30)	// do not set this higher than 25 until the player profile is removed from the blob
+RULE_INT(Spells, MaxTotalSlotsPET, 30)	// default to Tit's limit
 RULE_BOOL (Spells, EnableBlockedBuffs, true)
 RULE_INT(Spells, ReflectType, 1) //0 = disabled, 1 = single target player spells only, 2 = all player spells, 3 = all single target spells, 4 = all spells
 RULE_INT(Spells, VirusSpreadDistance, 30) // The distance a viral spell will jump to its next victim
@@ -490,6 +491,7 @@ RULE_BOOL(Combat, UseLiveCombatRounds, true) // turn this false if you don't wan
 RULE_INT(Combat, NPCAssistCap, 5) // Maxiumium number of NPCs that will assist another NPC at once
 RULE_INT(Combat, NPCAssistCapTimer, 6000) // Time in milliseconds a NPC will take to clear assist aggro cap space
 RULE_BOOL(Combat, UseRevampHandToHand, false) // use h2h revamped dmg/delays I believe this was implemented during SoF
+RULE_BOOL(Combat, ClassicMasterWu, false) // classic master wu uses a random special, modern doesn't
 RULE_CATEGORY_END()
 
 RULE_CATEGORY(NPC)

common/say_link.cpp

@@ -21,8 +21,8 @@
 #include "emu_constants.h"
 
 #include "string_util.h"
-#include "item.h"
+#include "item_instance.h"
-#include "item_base.h"
+#include "item_data.h"
 #include "../zone/zonedb.h"
 
 
@@ -147,7 +147,7 @@ void EQEmu::SayLinkEngine::generate_body()
 
 	memset(&m_LinkBodyStruct, 0, sizeof(SayLinkBody_Struct));
 
-	const EQEmu::ItemBase* item_data = nullptr;
+	const EQEmu::ItemData* item_data = nullptr;
 
 	switch (m_LinkType) {
 	case saylink::SayLinkBlank:
@@ -250,7 +250,7 @@ void EQEmu::SayLinkEngine::generate_text()
 		return;
 	}
 
-	const EQEmu::ItemBase* item_data = nullptr;
+	const EQEmu::ItemData* item_data = nullptr;
 
 	switch (m_LinkType) {
 	case saylink::SayLinkBlank:

common/say_link.h

@@ -26,11 +26,11 @@
 
 
 struct ServerLootItem_Struct;
-class ItemInst;
 
 namespace EQEmu
 {
-	struct ItemBase;
+	struct ItemData;
+	class ItemInstance;
 	struct SayLinkBody_Struct;
 
 	namespace saylink {
@@ -67,9 +67,9 @@ namespace EQEmu
 		SayLinkEngine();
 
 		void SetLinkType(saylink::SayLinkType link_type) { m_LinkType = link_type; }
-		void SetItemData(const EQEmu::ItemBase* item_data) { m_ItemData = item_data; }
+		void SetItemData(const EQEmu::ItemData* item_data) { m_ItemData = item_data; }
 		void SetLootData(const ServerLootItem_Struct* loot_data) { m_LootData = loot_data; }
-		void SetItemInst(const ItemInst* item_inst) { m_ItemInst = item_inst; }
+		void SetItemInst(const ItemInstance* item_inst) { m_ItemInst = item_inst; }
 
 		// mainly for saylinks..but, not limited to
 		void SetProxyUnknown1(uint8 proxy_unknown_1) { m_Proxy_unknown_1 = proxy_unknown_1; }
@@ -103,9 +103,9 @@ namespace EQEmu
 		void generate_text();
 
 		int m_LinkType;
-		const ItemBase* m_ItemData;
+		const ItemData* m_ItemData;
 		const ServerLootItem_Struct* m_LootData;
-		const ItemInst* m_ItemInst;
+		const ItemInstance* m_ItemInst;
 
 		uint8 m_Proxy_unknown_1;
 		uint32 m_ProxyItemID;

common/shareddb.cpp

@@ -29,7 +29,7 @@
 #include "faction.h"
 #include "features.h"
 #include "ipc_mutex.h"
-#include "item.h"
+#include "inventory_profile.h"
 #include "loottable.h"
 #include "memory_mapped_file.h"
 #include "mysql.h"
@@ -38,6 +38,17 @@
 #include "string_util.h"
 #include "eqemu_config.h"
 
+namespace ItemField
+{
+	enum {
+		source = 0,
+#define F(x) x,
+#include "item_fieldlist.h"
+#undef F
+		updated
+	};
+}
+
 SharedDatabase::SharedDatabase()
 : Database()
 {
@@ -99,13 +110,13 @@ uint32 SharedDatabase::GetTotalTimeEntitledOnAccount(uint32 AccountID) {
 	return EntitledTime;
 }
 
-bool SharedDatabase::SaveCursor(uint32 char_id, std::list<ItemInst*>::const_iterator &start, std::list<ItemInst*>::const_iterator &end)
+bool SharedDatabase::SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>::const_iterator &start, std::list<EQEmu::ItemInstance*>::const_iterator &end)
 {
 	// Delete cursor items
 	std::string query = StringFormat("DELETE FROM inventory WHERE charid = %i "
                                     "AND ((slotid >= 8000 AND slotid <= 8999) "
                                     "OR slotid = %i OR (slotid >= %i AND slotid <= %i) )",
-									char_id, EQEmu::legacy::SlotCursor,
+									char_id, EQEmu::inventory::slotCursor,
 									EQEmu::legacy::CURSOR_BAG_BEGIN, EQEmu::legacy::CURSOR_BAG_END);
     auto results = QueryDatabase(query);
     if (!results.Success()) {
@@ -116,8 +127,8 @@ bool SharedDatabase::SaveCursor(uint32 char_id, std::list<ItemInst*>::const_iter
     int i = 8000;
     for(auto it = start; it != end; ++it, i++) {
 		if (i > 8999) { break; } // shouldn't be anything in the queue that indexes this high
-        ItemInst *inst = *it;
+        EQEmu::ItemInstance *inst = *it;
-		int16 use_slot = (i == 8000) ? EQEmu::legacy::SlotCursor : i;
+		int16 use_slot = (i == 8000) ? EQEmu::inventory::slotCursor : i;
 		if (!SaveInventory(char_id, inst, use_slot)) {
 			return false;
 		}
@@ -126,7 +137,7 @@ bool SharedDatabase::SaveCursor(uint32 char_id, std::list<ItemInst*>::const_iter
 	return true;
 }
 
-bool SharedDatabase::VerifyInventory(uint32 account_id, int16 slot_id, const ItemInst* inst)
+bool SharedDatabase::VerifyInventory(uint32 account_id, int16 slot_id, const EQEmu::ItemInstance* inst)
 {
 	// Delete cursor items
 	std::string query = StringFormat("SELECT itemid, charges FROM sharedbank "
@@ -159,7 +170,7 @@ bool SharedDatabase::VerifyInventory(uint32 account_id, int16 slot_id, const Ite
 	return true;
 }
 
-bool SharedDatabase::SaveInventory(uint32 char_id, const ItemInst* inst, int16 slot_id) {
+bool SharedDatabase::SaveInventory(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 
 	//never save tribute slots:
 	if (slot_id >= EQEmu::legacy::TRIBUTE_BEGIN && slot_id <= EQEmu::legacy::TRIBUTE_END)
@@ -173,7 +184,7 @@ bool SharedDatabase::SaveInventory(uint32 char_id, const ItemInst* inst, int16 s
 		else {
 			// Needed to clear out bag slots that 'REPLACE' in UpdateSharedBankSlot does not overwrite..otherwise, duplication occurs
 			// (This requires that parent then child items be sent..which should be how they are currently passed)
-			if (Inventory::SupportsContainers(slot_id))
+			if (EQEmu::InventoryProfile::SupportsContainers(slot_id))
 				DeleteSharedBankSlot(char_id, slot_id);
 			return UpdateSharedBankSlot(char_id, inst, slot_id);
 		}
@@ -184,18 +195,18 @@ bool SharedDatabase::SaveInventory(uint32 char_id, const ItemInst* inst, int16 s
 
 	// Needed to clear out bag slots that 'REPLACE' in UpdateInventorySlot does not overwrite..otherwise, duplication occurs
 	// (This requires that parent then child items be sent..which should be how they are currently passed)
-	if (Inventory::SupportsContainers(slot_id))
+	if (EQEmu::InventoryProfile::SupportsContainers(slot_id))
 		DeleteInventorySlot(char_id, slot_id);
     return UpdateInventorySlot(char_id, inst, slot_id);
 }
 
-bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const ItemInst* inst, int16 slot_id) {
+bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 	// need to check 'inst' argument for valid pointer
 
-	uint32 augslot[EQEmu::legacy::ITEM_COMMON_SIZE] = { 0, 0, 0, 0, 0, 0 };
+	uint32 augslot[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
 	if (inst->IsClassCommon()) {
-		for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
-			ItemInst *auginst = inst->GetItem(i);
+			EQEmu::ItemInstance *auginst = inst->GetItem(i);
 			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
 		}
 	}
@@ -221,12 +232,12 @@ bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const ItemInst* inst, i
 	auto results = QueryDatabase(query);
 
     // Save bag contents, if slot supports bag contents
-	if (inst->IsClassBag() && Inventory::SupportsContainers(slot_id))
+	if (inst->IsClassBag() && EQEmu::InventoryProfile::SupportsContainers(slot_id))
 		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
 		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = SUB_INDEX_BEGIN; idx < inst->GetItem()->BagSlots && idx < EQEmu::legacy::ITEM_CONTAINER_SIZE; idx++) {
+		for (uint8 idx = EQEmu::inventory::containerBegin; idx < inst->GetItem()->BagSlots && idx < EQEmu::inventory::ContainerCount; idx++) {
-			const ItemInst* baginst = inst->GetItem(idx);
+			const EQEmu::ItemInstance* baginst = inst->GetItem(idx);
-			SaveInventory(char_id, baginst, Inventory::CalcSlotId(slot_id, idx));
+			SaveInventory(char_id, baginst, EQEmu::InventoryProfile::CalcSlotId(slot_id, idx));
 		}
 
     if (!results.Success()) {
@@ -236,13 +247,13 @@ bool SharedDatabase::UpdateInventorySlot(uint32 char_id, const ItemInst* inst, i
 	return true;
 }
 
-bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const ItemInst* inst, int16 slot_id) {
+bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id) {
 	// need to check 'inst' argument for valid pointer
 
-	uint32 augslot[EQEmu::legacy::ITEM_COMMON_SIZE] = { 0, 0, 0, 0, 0, 0 };
+	uint32 augslot[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
 	if (inst->IsClassCommon()) {
-		for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
-			ItemInst *auginst = inst->GetItem(i);
+			EQEmu::ItemInstance *auginst = inst->GetItem(i);
 			augslot[i] = (auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
 		}
 	}
@@ -267,12 +278,12 @@ bool SharedDatabase::UpdateSharedBankSlot(uint32 char_id, const ItemInst* inst,
     auto results = QueryDatabase(query);
 
     // Save bag contents, if slot supports bag contents
-	if (inst->IsClassBag() && Inventory::SupportsContainers(slot_id)) {
+	if (inst->IsClassBag() && EQEmu::InventoryProfile::SupportsContainers(slot_id)) {
 		// Limiting to bag slot count will get rid of 'hidden' duplicated items and 'Invalid Slot ID'
 		// messages through attrition (and the modded code in SaveInventory)
-		for (uint8 idx = SUB_INDEX_BEGIN; idx < inst->GetItem()->BagSlots && idx < EQEmu::legacy::ITEM_CONTAINER_SIZE; idx++) {
+		for (uint8 idx = EQEmu::inventory::containerBegin; idx < inst->GetItem()->BagSlots && idx < EQEmu::inventory::ContainerCount; idx++) {
-			const ItemInst* baginst = inst->GetItem(idx);
+			const EQEmu::ItemInstance* baginst = inst->GetItem(idx);
-			SaveInventory(char_id, baginst, Inventory::CalcSlotId(slot_id, idx));
+			SaveInventory(char_id, baginst, EQEmu::InventoryProfile::CalcSlotId(slot_id, idx));
 		}
 	}
 
@@ -293,10 +304,10 @@ bool SharedDatabase::DeleteInventorySlot(uint32 char_id, int16 slot_id) {
     }
 
     // Delete bag slots, if need be
-    if (!Inventory::SupportsContainers(slot_id))
+	if (!EQEmu::InventoryProfile::SupportsContainers(slot_id))
         return true;
 
-	int16 base_slot_id = Inventory::CalcSlotId(slot_id, SUB_INDEX_BEGIN);
+	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::inventory::containerBegin);
     query = StringFormat("DELETE FROM inventory WHERE charid = %i AND slotid >= %i AND slotid < %i",
                         char_id, base_slot_id, (base_slot_id+10));
     results = QueryDatabase(query);
@@ -319,10 +330,10 @@ bool SharedDatabase::DeleteSharedBankSlot(uint32 char_id, int16 slot_id) {
     }
 
 	// Delete bag slots, if need be
-	if (!Inventory::SupportsContainers(slot_id))
+	if (!EQEmu::InventoryProfile::SupportsContainers(slot_id))
         return true;
 
-	int16 base_slot_id = Inventory::CalcSlotId(slot_id, SUB_INDEX_BEGIN);
+	int16 base_slot_id = EQEmu::InventoryProfile::CalcSlotId(slot_id, EQEmu::inventory::containerBegin);
     query = StringFormat("DELETE FROM sharedbank WHERE acctid = %i "
                         "AND slotid >= %i AND slotid < %i",
                         account_id, base_slot_id, (base_slot_id+10));
@@ -362,9 +373,9 @@ bool SharedDatabase::SetSharedPlatinum(uint32 account_id, int32 amount_to_add) {
 	return true;
 }
 
-bool SharedDatabase::SetStartingItems(PlayerProfile_Struct* pp, Inventory* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin_level) {
+bool SharedDatabase::SetStartingItems(PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin_level) {
 
-	const EQEmu::ItemBase* myitem;
+	const EQEmu::ItemData* myitem;
 
     std::string query = StringFormat("SELECT itemid, item_charges, slot FROM starting_items "
                                     "WHERE (race = %i or race = 0) AND (class = %i or class = 0) AND "
@@ -385,7 +396,7 @@ bool SharedDatabase::SetStartingItems(PlayerProfile_Struct* pp, Inventory* inv,
 		if(!myitem)
 			continue;
 
-		ItemInst* myinst = CreateBaseItem(myitem, charges);
+		EQEmu::ItemInstance* myinst = CreateBaseItem(myitem, charges);
 
 		if(slot < 0)
 			slot = inv->FindFreeSlot(0, 0);
@@ -399,7 +410,7 @@ bool SharedDatabase::SetStartingItems(PlayerProfile_Struct* pp, Inventory* inv,
 
 
 // Retrieve shared bank inventory based on either account or character
-bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
+bool SharedDatabase::GetSharedBank(uint32 id, EQEmu::InventoryProfile *inv, bool is_charid)
 {
 	std::string query;
 
@@ -428,7 +439,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
 		uint32 item_id = (uint32)atoi(row[1]);
 		int8 charges = (int8)atoi(row[2]);
 
-		uint32 aug[EQEmu::legacy::ITEM_COMMON_SIZE];
+		uint32 aug[EQEmu::inventory::SocketCount];
 		aug[0] = (uint32)atoi(row[3]);
 		aug[1] = (uint32)atoi(row[4]);
 		aug[2] = (uint32)atoi(row[5]);
@@ -436,7 +447,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
 		aug[4] = (uint32)atoi(row[7]);
 		aug[5] = (uint32)atoi(row[8]);
 
-		const EQEmu::ItemBase *item = GetItem(item_id);
+		const EQEmu::ItemData *item = GetItem(item_id);
 
 		if (!item) {
 			Log.Out(Logs::General, Logs::Error,
@@ -447,9 +458,9 @@ bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
 
 		int16 put_slot_id = INVALID_INDEX;
 
-		ItemInst *inst = CreateBaseItem(item, charges);
+		EQEmu::ItemInstance *inst = CreateBaseItem(item, charges);
 		if (inst && item->IsClassCommon()) {
-			for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}
@@ -500,7 +511,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
 }
 
 // Overloaded: Retrieve character inventory based on character id
-bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
+bool SharedDatabase::GetInventory(uint32 char_id, EQEmu::InventoryProfile *inv)
 {
 	// Retrieve character inventory
 	std::string query =
@@ -524,7 +535,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 		uint16 charges = atoi(row[2]);
 		uint32 color = atoul(row[3]);
 
-		uint32 aug[EQEmu::legacy::ITEM_COMMON_SIZE];
+		uint32 aug[EQEmu::inventory::SocketCount];
 
 		aug[0] = (uint32)atoul(row[4]);
 		aug[1] = (uint32)atoul(row[5]);
@@ -539,7 +550,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 		uint32 ornament_idfile = (uint32)atoul(row[13]);
 		uint32 ornament_hero_model = (uint32)atoul(row[14]);
 
-		const EQEmu::ItemBase *item = GetItem(item_id);
+		const EQEmu::ItemData *item = GetItem(item_id);
 
 		if (!item) {
 			Log.Out(Logs::General, Logs::Error,
@@ -550,7 +561,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 
 		int16 put_slot_id = INVALID_INDEX;
 
-		ItemInst *inst = CreateBaseItem(item, charges);
+		EQEmu::ItemInstance *inst = CreateBaseItem(item, charges);
 
 		if (inst == nullptr)
 			continue;
@@ -587,7 +598,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 
 		if (instnodrop ||
 			(((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN && slot_id <= EQEmu::legacy::EQUIPMENT_END) ||
-			slot_id == EQEmu::legacy::SlotPowerSource) &&
+			slot_id == EQEmu::inventory::slotPowerSource) &&
 		     inst->GetItem()->Attuneable))
 			inst->SetAttuned(true);
 
@@ -609,7 +620,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 		}
 
 		if (item->IsClassCommon()) {
-			for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}
@@ -642,7 +653,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
 }
 
 // Overloaded: Retrieve character inventory based on account_id and character name
-bool SharedDatabase::GetInventory(uint32 account_id, char *name, Inventory *inv)
+bool SharedDatabase::GetInventory(uint32 account_id, char *name, EQEmu::InventoryProfile *inv)
 {
 	// Retrieve character inventory
 	std::string query =
@@ -666,7 +677,7 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, Inventory *inv)
 		int8 charges = atoi(row[2]);
 		uint32 color = atoul(row[3]);
 
-		uint32 aug[EQEmu::legacy::ITEM_COMMON_SIZE];
+		uint32 aug[EQEmu::inventory::SocketCount];
 		aug[0] = (uint32)atoi(row[4]);
 		aug[1] = (uint32)atoi(row[5]);
 		aug[2] = (uint32)atoi(row[6]);
@@ -679,12 +690,12 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, Inventory *inv)
 		uint32 ornament_idfile = (uint32)atoul(row[13]);
 		uint32 ornament_hero_model = (uint32)atoul(row[14]);
 
-		const EQEmu::ItemBase *item = GetItem(item_id);
+		const EQEmu::ItemData *item = GetItem(item_id);
 		int16 put_slot_id = INVALID_INDEX;
 		if (!item)
 			continue;
 
-		ItemInst *inst = CreateBaseItem(item, charges);
+		EQEmu::ItemInstance *inst = CreateBaseItem(item, charges);
 
 		if (inst == nullptr)
 			continue;
@@ -727,7 +738,7 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, Inventory *inv)
 		inst->SetCharges(charges);
 
 		if (item->IsClassCommon()) {
-			for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 				if (aug[i])
 					inst->PutAugment(this, i, aug[i]);
 			}
@@ -816,7 +827,7 @@ bool SharedDatabase::LoadItems(const std::string &prefix) {
 		mutex.Lock();
 		std::string file_name = Config->SharedMemDir + prefix + std::string("items");
 		items_mmf = std::unique_ptr<EQEmu::MemoryMappedFile>(new EQEmu::MemoryMappedFile(file_name));
-		items_hash = std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>>(new EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>(reinterpret_cast<uint8*>(items_mmf->Get()), items_mmf->Size()));
+		items_hash = std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemData>>(new EQEmu::FixedMemoryHashSet<EQEmu::ItemData>(reinterpret_cast<uint8*>(items_mmf->Get()), items_mmf->Size()));
 		mutex.Unlock();
 	} catch(std::exception& ex) {
 		Log.Out(Logs::General, Logs::Error, "Error Loading Items: %s", ex.what());
@@ -828,7 +839,7 @@ bool SharedDatabase::LoadItems(const std::string &prefix) {
 
 void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id)
 {
-	EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(reinterpret_cast<uint8 *>(data), size, items, max_item_id);
+	EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(reinterpret_cast<uint8 *>(data), size, items, max_item_id);
 
 	std::string ndbuffer;
 	bool disableNoRent = false;
@@ -856,7 +867,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
 		}
 	}
 
-	EQEmu::ItemBase item;
+	EQEmu::ItemData item;
 
 	const std::string query = "SELECT source,"
 #define F(x) "`"#x"`,"
@@ -869,7 +880,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
 	}
 
 	for (auto row = results.begin(); row != results.end(); ++row) {
-		memset(&item, 0, sizeof(EQEmu::ItemBase));
+		memset(&item, 0, sizeof(EQEmu::ItemData));
 
 		item.ItemClass = (uint8)atoi(row[ItemField::itemclass]);
 		strcpy(item.Name, row[ItemField::name]);
@@ -1086,7 +1097,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
 	}
 }
 
-const EQEmu::ItemBase* SharedDatabase::GetItem(uint32 id) {
+const EQEmu::ItemData* SharedDatabase::GetItem(uint32 id) {
 	if (id == 0)
 	{
 		return nullptr;
@@ -1105,7 +1116,7 @@ const EQEmu::ItemBase* SharedDatabase::GetItem(uint32 id) {
 	return nullptr;
 }
 
-const EQEmu::ItemBase* SharedDatabase::IterateItems(uint32* id) {
+const EQEmu::ItemData* SharedDatabase::IterateItems(uint32* id) {
 	if(!items_hash || !id) {
 		return nullptr;
 	}
@@ -1250,18 +1261,18 @@ bool SharedDatabase::LoadNPCFactionLists(const std::string &prefix) {
 	return true;
 }
 
-// Create appropriate ItemInst class
+// Create appropriate EQEmu::ItemInstance class
-ItemInst* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
+EQEmu::ItemInstance* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
 {
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
-	ItemInst* inst = nullptr;
+	EQEmu::ItemInstance* inst = nullptr;
 
 	item = GetItem(item_id);
 	if (item) {
 		inst = CreateBaseItem(item, charges);
 
 		if (inst == nullptr) {
-			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for ItemInst creation in SharedDatabase::CreateItem()");
+			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for EQEmu::ItemInstance creation in SharedDatabase::CreateItem()");
 			Log.Out(Logs::General, Logs::Error, "Item Data = ID: %u, Name: %s, Charges: %i", item->ID, item->Name, charges);
 			return nullptr;
 		}
@@ -1279,15 +1290,15 @@ ItemInst* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1,
 }
 
 
-// Create appropriate ItemInst class
+// Create appropriate EQEmu::ItemInstance class
-ItemInst* SharedDatabase::CreateItem(const EQEmu::ItemBase* item, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
+EQEmu::ItemInstance* SharedDatabase::CreateItem(const EQEmu::ItemData* item, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
 {
-	ItemInst* inst = nullptr;
+	EQEmu::ItemInstance* inst = nullptr;
 	if (item) {
 		inst = CreateBaseItem(item, charges);
 
 		if (inst == nullptr) {
-			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for ItemInst creation in SharedDatabase::CreateItem()");
+			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for EQEmu::ItemInstance creation in SharedDatabase::CreateItem()");
 			Log.Out(Logs::General, Logs::Error, "Item Data = ID: %u, Name: %s, Charges: %i", item->ID, item->Name, charges);
 			return nullptr;
 		}
@@ -1304,8 +1315,8 @@ ItemInst* SharedDatabase::CreateItem(const EQEmu::ItemBase* item, int16 charges,
 	return inst;
 }
 
-ItemInst* SharedDatabase::CreateBaseItem(const EQEmu::ItemBase* item, int16 charges) {
+EQEmu::ItemInstance* SharedDatabase::CreateBaseItem(const EQEmu::ItemData* item, int16 charges) {
-	ItemInst* inst = nullptr;
+	EQEmu::ItemInstance* inst = nullptr;
 	if (item) {
 		// if maxcharges is -1 that means it is an unlimited use item.
 		// set it to 1 charge so that it is usable on creation
@@ -1315,10 +1326,10 @@ ItemInst* SharedDatabase::CreateBaseItem(const EQEmu::ItemBase* item, int16 char
 		if(charges <= 0 && item->Stackable)
 			charges = 1;
 
-		inst = new ItemInst(item, charges);
+		inst = new EQEmu::ItemInstance(item, charges);
 
 		if (inst == nullptr) {
-			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for ItemInst creation in SharedDatabase::CreateBaseItem()");
+			Log.Out(Logs::General, Logs::Error, "Error: valid item data returned a null reference for EQEmu::ItemInstance creation in SharedDatabase::CreateBaseItem()");
 			Log.Out(Logs::General, Logs::Error, "Item Data = ID: %u, Name: %s, Charges: %i", item->ID, item->Name, charges);
 			return nullptr;
 		}

common/shareddb.h

@@ -33,8 +33,6 @@
 #include <memory>
 
 class EvolveInfo;
-class Inventory;
-class ItemInst;
 struct BaseDataStruct;
 struct InspectMessage_Struct;
 struct PlayerProfile_Struct;
@@ -45,7 +43,9 @@ struct LootDrop_Struct;
 
 namespace EQEmu
 {
-	struct ItemBase;
+	struct ItemData;
+	class ItemInstance;
+	class InventoryProfile;
 	class MemoryMappedFile;
 }
 
@@ -74,24 +74,24 @@ class SharedDatabase : public Database
 		uint32	GetTotalTimeEntitledOnAccount(uint32 AccountID);
 
 		/*
-		    Character Inventory
+		    Character InventoryProfile
 		*/
-		bool	SaveCursor(uint32 char_id, std::list<ItemInst*>::const_iterator &start, std::list<ItemInst*>::const_iterator &end);
+		bool	SaveCursor(uint32 char_id, std::list<EQEmu::ItemInstance*>::const_iterator &start, std::list<EQEmu::ItemInstance*>::const_iterator &end);
-		bool	SaveInventory(uint32 char_id, const ItemInst* inst, int16 slot_id);
+		bool	SaveInventory(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id);
 		bool    DeleteSharedBankSlot(uint32 char_id, int16 slot_id);
 		bool    DeleteInventorySlot(uint32 char_id, int16 slot_id);
-		bool    UpdateInventorySlot(uint32 char_id, const ItemInst* inst, int16 slot_id);
+		bool    UpdateInventorySlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id);
-		bool    UpdateSharedBankSlot(uint32 char_id, const ItemInst* inst, int16 slot_id);
+		bool    UpdateSharedBankSlot(uint32 char_id, const EQEmu::ItemInstance* inst, int16 slot_id);
-		bool	VerifyInventory(uint32 account_id, int16 slot_id, const ItemInst* inst);
+		bool	VerifyInventory(uint32 account_id, int16 slot_id, const EQEmu::ItemInstance* inst);
-		bool	GetSharedBank(uint32 id, Inventory* inv, bool is_charid);
+		bool	GetSharedBank(uint32 id, EQEmu::InventoryProfile* inv, bool is_charid);
 		int32	GetSharedPlatinum(uint32 account_id);
 		bool	SetSharedPlatinum(uint32 account_id, int32 amount_to_add);
-		bool	GetInventory(uint32 char_id, Inventory* inv);
+		bool	GetInventory(uint32 char_id, EQEmu::InventoryProfile* inv);
-		bool	GetInventory(uint32 account_id, char* name, Inventory* inv);
+		bool	GetInventory(uint32 account_id, char* name, EQEmu::InventoryProfile* inv);
 		std::map<uint32, uint32> GetItemRecastTimestamps(uint32 char_id);
 		uint32	GetItemRecastTimestamp(uint32 char_id, uint32 recast_type);
 		void	ClearOldRecastTimestamps(uint32 char_id);
-		bool	SetStartingItems(PlayerProfile_Struct* pp, Inventory* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin);
+		bool	SetStartingItems(PlayerProfile_Struct* pp, EQEmu::InventoryProfile* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin);
 
 
 		std::string	GetBook(const char *txtfile);
@@ -99,9 +99,9 @@ class SharedDatabase : public Database
 		/*
 		    Item Methods
 		*/
-		ItemInst* CreateItem(uint32 item_id, int16 charges = 0, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, uint8 attuned = 0);
+		EQEmu::ItemInstance* CreateItem(uint32 item_id, int16 charges = 0, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, uint8 attuned = 0);
-		ItemInst* CreateItem(const EQEmu::ItemBase* item, int16 charges = 0, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, uint8 attuned = 0);
+		EQEmu::ItemInstance* CreateItem(const EQEmu::ItemData* item, int16 charges = 0, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, uint8 attuned = 0);
-		ItemInst* CreateBaseItem(const EQEmu::ItemBase* item, int16 charges = 0);
+		EQEmu::ItemInstance* CreateBaseItem(const EQEmu::ItemData* item, int16 charges = 0);
 
 		/*
 		    Shared Memory crap
@@ -111,8 +111,8 @@ class SharedDatabase : public Database
 		void GetItemsCount(int32 &item_count, uint32 &max_id);
 		void LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id);
 		bool LoadItems(const std::string &prefix);
-		const EQEmu::ItemBase* IterateItems(uint32* id);
+		const EQEmu::ItemData* IterateItems(uint32* id);
-		const EQEmu::ItemBase* GetItem(uint32 id);
+		const EQEmu::ItemData* GetItem(uint32 id);
 		const EvolveInfo* GetEvolveInfo(uint32 loregroup);
 
 		//faction lists
@@ -149,7 +149,7 @@ class SharedDatabase : public Database
 
 		std::unique_ptr<EQEmu::MemoryMappedFile> skill_caps_mmf;
 		std::unique_ptr<EQEmu::MemoryMappedFile> items_mmf;
-		std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>> items_hash;
+		std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemData>> items_hash;
 		std::unique_ptr<EQEmu::MemoryMappedFile> faction_mmf;
 		std::unique_ptr<EQEmu::FixedMemoryHashSet<NPCFactionList>> faction_hash;
 		std::unique_ptr<EQEmu::MemoryMappedFile> loot_table_mmf;

common/spdat.h

@@ -485,7 +485,7 @@ typedef enum {
 #define SE_ManaAbsorbPercentDamage		329 // implemented
 #define SE_CriticalDamageMob			330	// implemented
 #define SE_Salvage						331 // implemented - chance to recover items that would be destroyed in failed tradeskill combine
-//#define SE_SummonToCorpse				332 // *not implemented AA - Call of the Wild (Druid/Shaman Res spell with no exp)
+#define SE_SummonToCorpse				332 // *not implemented AA - Call of the Wild (Druid/Shaman Res spell with no exp)
 #define SE_CastOnRuneFadeEffect			333 // implemented
 #define SE_BardAEDot					334	// implemented
 #define SE_BlockNextSpellFocus			335	// implemented - base1 chance to block next spell ie Puratus (8494)

common/textures.cpp

@@ -18,82 +18,3 @@
 */
 
 #include "textures.h"
-//#include "inventory_slot.h"
-
-#include <string.h> // temp
-
-
-//int EQEmu::textures::ConvertEquipmentSlotToTextureSlot(int equipment_slot)
-//{
-//	switch (equipment_slot) {
-//	case inventory::PossessionsHead:
-//		return textures::TextureHead;
-//	case inventory::PossessionsChest:
-//		return textures::TextureChest;
-//	case inventory::PossessionsArms:
-//		return textures::TextureArms;
-//	case inventory::PossessionsWrist1:
-//		return textures::TextureWrist;
-//	case inventory::PossessionsHands:
-//		return textures::TextureHands;
-//	case inventory::PossessionsLegs:
-//		return textures::TextureLegs;
-//	case inventory::PossessionsFeet:
-//		return textures::TextureFeet;
-//	case inventory::PossessionsPrimary:
-//		return textures::TexturePrimary;
-//	case inventory::PossessionsSecondary:
-//		return textures::TextureSecondary;
-//	default:
-//		return textures::TextureInvalid;
-//	}
-//}
-
-//int EQEmu::textures::ConvertEquipmentSlotToTextureSlot(const InventorySlot &equipment_slot)
-//{
-//	if (equipment_slot.Type() != inventory::InvTypePossessions || equipment_slot.Bag() != inventory::InvBagInvalid || equipment_slot.Aug() != inventory::InvAugInvalid)
-//		return textures::TextureInvalid;
-//
-//	return ConvertEquipmentSlotToTextureSlot(equipment_slot.Slot());
-//}
-
-//EQEmu::InventorySlot EQEmu::textures::ConvertTextureSlotToEquipmentSlot(int texture_slot)
-//{
-//	switch (texture_slot) {
-//	case textures::TextureHead:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsHead);
-//	case textures::TextureChest:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsChest);
-//	case textures::TextureArms:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsArms);
-//	case textures::TextureWrist:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsWrist1);
-//	case textures::TextureHands:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsHands);
-//	case textures::TextureLegs:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsLegs);
-//	case textures::TextureFeet:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsFeet);
-//	case textures::TexturePrimary:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsPrimary);
-//	case textures::TextureSecondary:
-//		return EQEmu::InventorySlot(inventory::InvTypePossessions, inventory::PossessionsSecondary);
-//	default:
-//		return EQEmu::InventorySlot();
-//	}
-//}
-
-EQEmu::TextureProfile::TextureProfile()
-{
-	memset(&Slot, 0, (sizeof(Texture_Struct) * textures::TextureCount));
-}
-
-EQEmu::TextureShortProfile::TextureShortProfile()
-{
-	memset(&Slot, 0, (sizeof(uint32) * textures::TextureCount));
-}
-
-EQEmu::TintProfile::TintProfile()
-{
-	memset(&Slot, 0, (sizeof(uint32) * textures::TextureCount));
-}

common/textures.h

@@ -25,116 +25,113 @@
 
 namespace EQEmu
 {
-	//class InventorySlot;
-	
 	namespace textures {
-		//enum : int { TextureInvalid = -1, TextureBegin };
+		enum : int8 { textureInvalid = -1, textureBegin };
-		enum : uint8 { TextureInvalid = 255, TextureBegin = 0 };
 
-		//enum TextureSlot : int {
+		enum TextureSlot : int8 {
-		enum TextureSlot : uint8 {
+			armorHead = textureBegin,
-			TextureHead = TextureBegin,
+			armorChest,
-			TextureChest,
+			armorArms,
-			TextureArms,
+			armorWrist,
-			TextureWrist,
+			armorHands,
-			TextureHands,
+			armorLegs,
-			TextureLegs,
+			armorFeet,
-			TextureFeet,
+			weaponPrimary,
-			TexturePrimary,
+			weaponSecondary,
-			TextureSecondary,
+			materialCount,
-			TextureCount
+			materialInvalid = textureInvalid
 		};
 
-		const int LastTexture = TextureSecondary;
+		enum TintSlot : int8 {
-		const int LastTintableTexture = TextureFeet;
+			tintHead = textureBegin,
+			tintChest,
+			tintArms,
+			tintWrist,
+			tintHands,
+			tintLegs,
+			tintFeet,
+			tintCount,
+			tintInvalid = textureInvalid
+		};
 
-		//extern int ConvertEquipmentSlotToTextureSlot(int equipment_slot);
+		const int8 LastTexture = weaponSecondary;
-		//extern int ConvertEquipmentSlotToTextureSlot(const InventorySlot &equipment_slot);
+		const int8 LastTintableTexture = tintFeet;
-		//extern InventorySlot ConvertTextureSlotToEquipmentSlot(int texture_slot);
-
-	} /*textures*/
 
 		struct Texture_Struct {
 			uint32 Material;
 			uint32 Unknown1;
-		uint32 EliteMaterial;
+			uint32 EliteModel;
-		uint32 HeroForgeModel;
+			uint32 HerosForgeModel;
-		uint32 Material2;	// Same as material?
+			uint32 Unknown2; // same as material?
 		};
 
-	struct TextureProfile {
+		struct TextureMaterial_Struct {
-		union {
-			struct {
-				Texture_Struct Head;
-				Texture_Struct Chest;
-				Texture_Struct Arms;
-				Texture_Struct Wrist;
-				Texture_Struct Hands;
-				Texture_Struct Legs;
-				Texture_Struct Feet;
-				Texture_Struct Primary;
-				Texture_Struct Secondary;
-			};
-			Texture_Struct Slot[textures::TextureCount];
-		};
-
-		TextureProfile();
-	};
-
-	struct TextureShort_Struct {
 			uint32 Material;
 		};
 
-	struct TextureShortProfile {
-		union {
-			struct {
-				TextureShort_Struct Head;
-				TextureShort_Struct Chest;
-				TextureShort_Struct Arms;
-				TextureShort_Struct Wrist;
-				TextureShort_Struct Hands;
-				TextureShort_Struct Legs;
-				TextureShort_Struct Feet;
-				TextureShort_Struct Primary;
-				TextureShort_Struct Secondary;
-			};
-			TextureShort_Struct Slot[textures::TextureCount];
-		};
-
-		TextureShortProfile();
-	};
-
 		struct Tint_Struct {
 			union {
 				struct {
 					uint8 Blue;
 					uint8 Green;
 					uint8 Red;
-				uint8 UseTint;	// if there's a tint this is FF
+					uint8 UseTint; // if there's a tint, this is FF
 				};
 				uint32 Color;
 			};
+		};
 
-		//Tint_Struct();
+	} /*textures*/
+
+	struct TextureProfile {
+		union {
+			struct {
+				textures::Texture_Struct Head;
+				textures::Texture_Struct Chest;
+				textures::Texture_Struct Arms;
+				textures::Texture_Struct Wrist;
+				textures::Texture_Struct Hands;
+				textures::Texture_Struct Legs;
+				textures::Texture_Struct Feet;
+				textures::Texture_Struct Primary;
+				textures::Texture_Struct Secondary;
+			};
+			textures::Texture_Struct Slot[textures::materialCount];
+		};
+	};
+
+	struct TextureMaterialProfile {
+		union {
+			struct {
+				textures::TextureMaterial_Struct Head;
+				textures::TextureMaterial_Struct Chest;
+				textures::TextureMaterial_Struct Arms;
+				textures::TextureMaterial_Struct Wrist;
+				textures::TextureMaterial_Struct Hands;
+				textures::TextureMaterial_Struct Legs;
+				textures::TextureMaterial_Struct Feet;
+				textures::TextureMaterial_Struct Primary;
+				textures::TextureMaterial_Struct Secondary;
+			};
+			textures::TextureMaterial_Struct Slot[textures::materialCount];
+		};
 	};
 
 	struct TintProfile {
 		union {
 			struct {
-				Tint_Struct Head;
+				textures::Tint_Struct Head;
-				Tint_Struct Chest;
+				textures::Tint_Struct Chest;
-				Tint_Struct Arms;
+				textures::Tint_Struct Arms;
-				Tint_Struct Wrist;
+				textures::Tint_Struct Wrist;
-				Tint_Struct Hands;
+				textures::Tint_Struct Hands;
-				Tint_Struct Legs;
+				textures::Tint_Struct Legs;
-				Tint_Struct Feet;
+				textures::Tint_Struct Feet;
-				Tint_Struct Primary;
+				textures::Tint_Struct Primary;
-				Tint_Struct Secondary;
+				textures::Tint_Struct Secondary;
 			};
-			Tint_Struct Slot[textures::TextureCount];
+			textures::Tint_Struct Slot[textures::materialCount]; // materialCount is correct..but, {[weaponPrimary],[weaponSecondary]} are not tintable...
 		};
-
-		TintProfile();
 	};
 
 } /*EQEmu*/

shared_memory/items.cpp

@@ -22,7 +22,7 @@
 #include "../common/ipc_mutex.h"
 #include "../common/memory_mapped_file.h"
 #include "../common/eqemu_exception.h"
-#include "../common/item_base.h"
+#include "../common/item_data.h"
 
 void LoadItems(SharedDatabase *database, const std::string &prefix) {
 	EQEmu::IPCMutex mutex("items");
@@ -35,7 +35,7 @@ void LoadItems(SharedDatabase *database, const std::string &prefix) {
 		EQ_EXCEPT("Shared Memory", "Unable to get any items from the database.");
 	}
 
-	uint32 size = static_cast<uint32>(EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>::estimated_size(items, max_item));
+	uint32 size = static_cast<uint32>(EQEmu::FixedMemoryHashSet<EQEmu::ItemData>::estimated_size(items, max_item));
 
 	auto Config = EQEmuConfig::get();
 	std::string file_name = Config->SharedMemDir + prefix + std::string("items");

shared_memory/main.cpp

@@ -36,6 +36,39 @@
 
 EQEmuLogSys Log;
 
+#ifdef _WINDOWS
+#include <direct.h>
+#else
+#include <unistd.h>
+#endif
+#include <sys/stat.h>
+
+inline bool MakeDirectory(const std::string &directory_name)
+{
+#ifdef _WINDOWS
+	struct _stat st;
+	if (_stat(directory_name.c_str(), &st) == 0) {
+		return false;
+	}
+	else {
+		_mkdir(directory_name.c_str());
+		return true;
+	}
+	
+#else
+	struct stat st;
+	if (stat(directory_name.c_str(), &st) == 0) {
+		return false;
+	}
+	else {
+		mkdir(directory_name.c_str(), 0755);
+		return true;
+	}
+
+#endif
+	return false;
+}
+
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformSharedMemory);
 	Log.LoadLogSettingsDefaults();
@@ -62,6 +95,11 @@ int main(int argc, char **argv) {
 	database.LoadLogSettings(Log.log_settings);
 	Log.StartFileLogs();
 
+	std::string shared_mem_directory = Config->SharedMemDir;
+	if (MakeDirectory(shared_mem_directory)) {
+		Log.Out(Logs::General, Logs::Status, "Shared Memory folder doesn't exist, so we created it... '%s'", shared_mem_directory.c_str());
+	}
+
 	database.LoadVariables();
 
 	/* If we're running shared memory and hotfix has no custom name, we probably want to start from scratch... */

tests/fixed_memory_test.h

@@ -21,13 +21,13 @@
 
 #include "cppunit/cpptest.h"
 #include "../common/fixed_memory_hash_set.h"
-#include "../common/item.h"
+#include "../common/item_instance.h"
 
 class FixedMemoryHashTest : public Test::Suite {
 	typedef void(FixedMemoryHashTest::*TestFunction)(void);
 public:
 	FixedMemoryHashTest() {
-		size_ = EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>::estimated_size(72000, 190000);
+		size_ = EQEmu::FixedMemoryHashSet<EQEmu::ItemData>::estimated_size(72000, 190000);
 		data_ = new uint8[size_];
 		memset(data_, 0, size_);
 		TEST_ADD(FixedMemoryHashTest::InitTest);
@@ -49,7 +49,7 @@ public:
 
 	private:
 	void InitTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_, 72000, 190000);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_, 72000, 190000);
 		TEST_ASSERT(!hash.exists(1001));
 		TEST_ASSERT(hash.size() == 0);
 		TEST_ASSERT(hash.max_size() == 72000);
@@ -57,7 +57,7 @@ public:
 	}
 
 	void LoadTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(!hash.exists(1001));
 		TEST_ASSERT(hash.size() == 0);
 		TEST_ASSERT(hash.max_size() == 72000);
@@ -65,8 +65,8 @@ public:
 	}
 
 	void InsertTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
-		EQEmu::ItemBase item;
+		EQEmu::ItemData item;
 		memset(&item, 0, sizeof(item));
 		strcpy(item.Name, "Iron Sword");
 		item.ID = 1001;
@@ -79,20 +79,20 @@ public:
 	}
 
 	void RetrieveTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(hash.exists(1001));
 		TEST_ASSERT(hash.size() == 1);
 		TEST_ASSERT(hash.max_size() == 72000);
 		TEST_ASSERT(!hash.empty());
 
-		EQEmu::ItemBase item = hash[1001];
+		EQEmu::ItemData item = hash[1001];
 		TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
 		TEST_ASSERT(item.ID == 1001);
 	}
 
 	void OverwriteTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
-		EQEmu::ItemBase item;
+		EQEmu::ItemData item;
 		memset(&item, 0, sizeof(item));
 		strcpy(item.Name, "Steel Sword");
 		item.ID = 1001;
@@ -105,20 +105,20 @@ public:
 	}
 
 	void OverwriteRetrieveTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(hash.exists(1001));
 		TEST_ASSERT(hash.size() == 1);
 		TEST_ASSERT((hash.max_size() == 72000));
 		TEST_ASSERT(!hash.empty());
 
-		EQEmu::ItemBase item = hash[1001];
+		EQEmu::ItemData item = hash[1001];
 		TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
 		TEST_ASSERT(item.ID == 1001);
 	}
 
 	void InsertAgainTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
-		EQEmu::ItemBase item;
+		EQEmu::ItemData item;
 		memset(&item, 0, sizeof(item));
 		strcpy(item.Name, "Iron Sword");
 		item.ID = 1000;
@@ -132,14 +132,14 @@ public:
 	}
 
 	void RetrieveAgainTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(hash.exists(1000));
 		TEST_ASSERT(hash.exists(1001));
 		TEST_ASSERT(hash.size() == 2);
 		TEST_ASSERT(hash.max_size() == 72000);
 		TEST_ASSERT(!hash.empty());
 
-		EQEmu::ItemBase item = hash[1000];
+		EQEmu::ItemData item = hash[1000];
 		TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
 		TEST_ASSERT(item.ID == 1000);
 
@@ -149,8 +149,8 @@ public:
 	}
 
 	void InsertBeginTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
-		EQEmu::ItemBase item;
+		EQEmu::ItemData item;
 		memset(&item, 0, sizeof(item));
 		strcpy(item.Name, "Bronze Sword");
 		item.ID = 0;
@@ -165,7 +165,7 @@ public:
 	}
 
 	void RetrieveBeginTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(hash.exists(1000));
 		TEST_ASSERT(hash.exists(1001));
 		TEST_ASSERT(hash.exists(0));
@@ -173,7 +173,7 @@ public:
 		TEST_ASSERT(hash.max_size() == 72000);
 		TEST_ASSERT(!hash.empty());
 
-		EQEmu::ItemBase item = hash[1000];
+		EQEmu::ItemData item = hash[1000];
 		TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
 		TEST_ASSERT(item.ID == 1000);
 
@@ -187,8 +187,8 @@ public:
 	}
 
 	void InsertEndTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
-		EQEmu::ItemBase item;
+		EQEmu::ItemData item;
 		memset(&item, 0, sizeof(item));
 		strcpy(item.Name, "Jade Sword");
 		item.ID = 190000;
@@ -204,7 +204,7 @@ public:
 	}
 
 	void RetrieveEndTest() {
-		EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(data_, size_);
+		EQEmu::FixedMemoryHashSet<EQEmu::ItemData> hash(data_, size_);
 		TEST_ASSERT(hash.exists(1000));
 		TEST_ASSERT(hash.exists(1001));
 		TEST_ASSERT(hash.exists(0));
@@ -213,7 +213,7 @@ public:
 		TEST_ASSERT(hash.max_size() == 72000);
 		TEST_ASSERT(!hash.empty());
 
-		EQEmu::ItemBase item = hash[1000];
+		EQEmu::ItemData item = hash[1000];
 		TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
 		TEST_ASSERT(item.ID == 1000);
 

utils/scripts/eqemu_server.pl

@@ -488,11 +488,11 @@ sub check_internet_connection {
 		$count = "n";
 	}
 
-	if (`ping 8.8.8.8 -$count 1 -w 500`=~/Reply from|1 received/i) { 
+	if (`ping 8.8.8.8 -$count 1 -w 500`=~/TTL|1 received/i) { 
 		# print "[Update] We have a connection to the internet, continuing...\n";
 		return 1;
 	}
-	elsif (`ping 4.2.2.2 -$count 1 -w 500`=~/Reply from|1 received/i) { 
+	elsif (`ping 4.2.2.2 -$count 1 -w 500`=~/TTL|1 received/i) { 
 		# print "[Update] We have a connection to the internet, continuing...\n";
 		return 1;
 	}
@@ -1063,17 +1063,50 @@ sub trim {
 }
 
 sub read_eqemu_config_xml {
-	my $confile = "eqemu_config.xml"; #default
+    open (CONFIG, "eqemu_config.xml");
-	open(F, "<$confile");
+    while (<CONFIG>){
-	my $indb = 0;
+        chomp;
-	while(<F>) {
+        $o = $_;
-		s/\r//g;
+		
-		if(/<host>(.*)<\/host>/i) { $host = $1; } 
+        if($o=~/\<\!--/i){
-		elsif(/<username>(.*)<\/username>/i) { $user = $1; } 
+            next; 
-		elsif(/<password>(.*)<\/password>/i) { $pass = $1; } 
-		elsif(/<db>(.*)<\/db>/i) { $db = $1; } 
-		if(/<longname>(.*)<\/longname>/i) { $long_name = $1; } 
         }
+        
+        if($o=~/database/i && $o=~/\<\//i){
+            $in_database_tag = 0;
+        }
+        if($o=~/<database>/i){
+			print "IN DATABASE TAG\n" if $debug;
+			$in_database_tag = 1;
+        }
+        if($o=~/<longname>/i){ 
+			($long_name) = $o =~ /<longname>(.*)<\/longname>/;
+			print "Long Name: '" . $long_name . "'\n" if $debug;
+        }
+        if($in_database_tag == 1){
+			@left = split (">", $o); 
+			@right = split("<", $left[1]);
+			$tag_data = trim($right[0]);
+		
+            if($o=~/<username>/i && $in_database_tag){
+				$user = $tag_data;
+				print "Database User: '" . $user . "'\n" if $debug;
+            }
+            if($o=~/<password>/i && $in_database_tag){
+				$pass = $tag_data;
+                print "Database Pass: '" . $pass . "'\n" if $debug;
+            }
+            if($o=~/<db>/i){
+                $db = $tag_data;
+                print "Database Name: '" . $db . "'\n" if $debug;
+            }
+            if($o=~/<host>/i){
+				$host = $tag_data;
+				print "Database Host: '" . $host . "'\n" if $debug;
+            }
+        }
+    }
+    close(CONFIG);
 }
 
 #::: Fetch Latest PEQ AA's

utils/sql/git/optional/2016_09_29_GroundSpawnsMaxZ.sql

@@ -0,0 +1 @@
+UPDATE ground_spawns SET max_z = -99999 WHERE max_x != min_x OR max_y != min_y

utils/sql/git/optional/2016_10_17_GrantHoTTOnCharacterCreate.sql

@@ -0,0 +1 @@
+INSERT INTO `rule_values` (`ruleset_id`, `rule_name`, `rule_value`, `notes`) VALUES (1, 'Character:GrantHoTTOnCreate', 'false', 'Grant Health of Target\'s Target leadership AA on character creation');

world/client.cpp

@@ -25,7 +25,7 @@
 #include "../common/eq_packet_structs.h"
 #include "../common/packet_dump.h"
 #include "../common/eq_stream_intf.h"
-#include "../common/item.h"
+#include "../common/inventory_profile.h"
 #include "../common/races.h"
 #include "../common/classes.h"
 #include "../common/languages.h"
@@ -1383,7 +1383,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc)
 {
 	PlayerProfile_Struct pp;
 	ExtendedProfile_Struct ext;
-	Inventory inv;
+	EQEmu::InventoryProfile inv;
 	time_t bday = time(nullptr);
 	char startzone[50]={0};
 	uint32 i;

world/worlddb.cpp

@@ -17,10 +17,9 @@
 */
 
 #include "worlddb.h"
-//#include "../common/item.h"
 #include "../common/string_util.h"
 #include "../common/eq_packet_structs.h"
-#include "../common/item.h"
+#include "../common/inventory_profile.h"
 #include "../common/rulesys.h"
 #include <iostream>
 #include <cstdlib>
@@ -97,7 +96,7 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
 	for (auto row = results.begin(); row != results.end(); ++row) {
 		CharacterSelectEntry_Struct *cse = (CharacterSelectEntry_Struct *)buff_ptr;
 		PlayerProfile_Struct pp;
-		Inventory inv;
+		EQEmu::InventoryProfile inv;
 		uint32 character_id = (uint32)atoi(row[0]);
 		uint8 has_home = 0;
 		uint8 has_bind = 0;
@@ -117,12 +116,12 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
 		cse->Gender = (uint8)atoi(row[2]);
 		cse->Face = (uint8)atoi(row[15]);
 
-		for (uint32 matslot = 0; matslot < EQEmu::textures::TextureCount; matslot++) {	// Processed below
+		for (uint32 matslot = 0; matslot < EQEmu::textures::materialCount; matslot++) {	// Processed below
 			cse->Equip[matslot].Material = 0;
 			cse->Equip[matslot].Unknown1 = 0;
-			cse->Equip[matslot].EliteMaterial = 0;
+			cse->Equip[matslot].EliteModel = 0;
-			cse->Equip[matslot].HeroForgeModel = 0;
+			cse->Equip[matslot].HerosForgeModel = 0;
-			cse->Equip[matslot].Material2 = 0;
+			cse->Equip[matslot].Unknown2 = 0;
 			cse->Equip[matslot].Color = 0;
 		}						
 
@@ -245,12 +244,12 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
 		/* Load Inventory */
 		// If we ensure that the material data is updated appropriately, we can do away with inventory loads
 		if (GetInventory(accountID, cse->Name, &inv)) {
-			const EQEmu::ItemBase* item = nullptr;
+			const EQEmu::ItemData* item = nullptr;
-			const ItemInst* inst = nullptr;
+			const EQEmu::ItemInstance* inst = nullptr;
 			int16 invslot = 0;
 
-			for (uint32 matslot = 0; matslot < EQEmu::textures::TextureCount; matslot++) {
+			for (uint32 matslot = EQEmu::textures::textureBegin; matslot < EQEmu::textures::materialCount; matslot++) {
-				invslot = Inventory::CalcSlotFromMaterial(matslot);
+				invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(matslot);
 				if (invslot == INVALID_INDEX) { continue; }
 				inst = inv.GetItem(invslot);
 				if (inst == nullptr) { continue; }
@@ -270,7 +269,7 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
 							cse->Equip[matslot].Material = idfile;
 						}
 					}
-					if (matslot == EQEmu::textures::TexturePrimary) {
+					if (matslot == EQEmu::textures::weaponPrimary) {
 						cse->PrimaryIDFile = idfile;
 					}
 					else {
@@ -288,8 +287,8 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
 
 					// Armor Materials/Models
 					cse->Equip[matslot].Material = item->Material;
-					cse->Equip[matslot].EliteMaterial = item->EliteMaterial;
+					cse->Equip[matslot].EliteModel = item->EliteMaterial;
-					cse->Equip[matslot].HeroForgeModel = inst->GetOrnamentHeroModel(matslot);
+					cse->Equip[matslot].HerosForgeModel = inst->GetOrnamentHeroModel(matslot);
 					cse->Equip[matslot].Color = color;
 				}
 			}

zone/aa.cpp

@@ -423,7 +423,7 @@ void Mob::WakeTheDead(uint16 spell_id, Mob *target, uint32 duration)
 		uint32 sitem = 0;
 		sitem = CorpseToUse->GetWornItem(x);
 		if(sitem){
-			const EQEmu::ItemBase * itm = database.GetItem(sitem);
+			const EQEmu::ItemData * itm = database.GetItem(sitem);
 			npca->AddLootDrop(itm, &npca->itemlist, 1, 1, 255, true, true);
 		}
 	}
@@ -1181,6 +1181,11 @@ void Client::ActivateAlternateAdvancementAbility(int rank_id, int target_id) {
 
 	if (!IsCastWhileInvis(rank->spell))
 		CommonBreakInvisible();
+
+	if (spells[rank->spell].sneak && (!hidden || (hidden && (Timer::GetCurrentTime() - tmHidden) < 4000))) {
+		Message_StringID(MT_SpellFailure, SNEAK_RESTRICT);
+		return;
+	}
 	// Bards can cast instant cast AAs while they are casting another song
 	if(spells[rank->spell].cast_time == 0 && GetClass() == BARD && IsBardSong(casting_spell_id)) {
 		if(!SpellFinished(rank->spell, entity_list.GetMob(target_id), EQEmu::CastingSlot::AltAbility, spells[rank->spell].mana, -1, spells[rank->spell].ResistDiff, false)) {

zone/aggro.cpp

@@ -1343,8 +1343,8 @@ bool Mob::PassCharismaCheck(Mob* caster, uint16 spell_id) {
 
 void Mob::RogueEvade(Mob *other)
 {
-	int amount = other->GetHateAmount(this) - (GetLevel() * 13);
+	int amount = other->GetHateAmount(this) * zone->random.Int(40, 70) / 100;
-	other->SetHateAmountOnEnt(this, std::max(1, amount));
+	other->SetHateAmountOnEnt(this, std::max(100, amount));
 
 	return;
 }

zone/attack.cpp

@@ -51,12 +51,12 @@ extern WorldServer worldserver;
 extern EntityList entity_list;
 extern Zone* zone;
 
-bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const ItemInst* weapon)
+bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const EQEmu::ItemInstance* weapon)
 {
 	// Determine animation
 	int type = 0;
 	if (weapon && weapon->IsClassCommon()) {
-		const EQEmu::ItemBase* item = weapon->GetItem();
+		const EQEmu::ItemData* item = weapon->GetItem();
 
 		Log.Out(Logs::Detail, Logs::Attack, "Weapon skill : %i", item->ItemType);
 
@@ -132,7 +132,7 @@ bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const
 	}
 
 	// If we're attacking with the secondary hand, play the dual wield anim
-	if (Hand == EQEmu::legacy::SlotSecondary)	// DW anim
+	if (Hand == EQEmu::inventory::slotSecondary)	// DW anim
 		type = animDualWield;
 
 	DoAnim(type);
@@ -373,7 +373,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
 	// riposte -- it may seem crazy, but if the attacker has SPA 173 on them, they are immune to Ripo
 	bool ImmuneRipo = attacker->aabonuses.RiposteChance || attacker->spellbonuses.RiposteChance || attacker->itembonuses.RiposteChance;
 	// Need to check if we have something in MainHand to actually attack with (or fists)
-	if (hand != EQEmu::legacy::SlotRange && (CanThisClassRiposte() || IsEnraged()) && InFront && !ImmuneRipo) {
+	if (hand != EQEmu::inventory::slotRange && (CanThisClassRiposte() || IsEnraged()) && InFront && !ImmuneRipo) {
 		if (IsEnraged()) {
 			damage = -3;
 			Log.Out(Logs::Detail, Logs::Combat, "I am enraged, riposting frontal attack.");
@@ -395,7 +395,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
 			chance -= chance * counter;
 		}
 		// AA Slippery Attacks
-		if (hand == EQEmu::legacy::SlotSecondary) {
+		if (hand == EQEmu::inventory::slotSecondary) {
 			int slip = aabonuses.OffhandRiposteFail + itembonuses.OffhandRiposteFail + spellbonuses.OffhandRiposteFail;
 			chance += chance * slip / 100;
 		}
@@ -440,7 +440,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
 	}
 
 	// parry
-	if (CanThisClassParry() && InFront && hand != EQEmu::legacy::SlotRange) {
+	if (CanThisClassParry() && InFront && hand != EQEmu::inventory::slotRange) {
 		if (IsClient())
 			CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillParry, other, -10);
 		// check auto discs ... I guess aa/items too :P
@@ -786,9 +786,9 @@ int32 Client::GetMeleeMitDmg(Mob *attacker, int32 damage, int32 minhit,
 //Returns the weapon damage against the input mob
 //if we cannot hit the mob with the current weapon we will get a value less than or equal to zero
 //Else we know we can hit.
-//GetWeaponDamage(mob*, const ItemBase*) is intended to be used for mobs or any other situation where we do not have a client inventory item
+//GetWeaponDamage(mob*, const EQEmu::ItemData*) is intended to be used for mobs or any other situation where we do not have a client inventory item
-//GetWeaponDamage(mob*, const ItemInst*) is intended to be used for situations where we have a client inventory item
+//GetWeaponDamage(mob*, const EQEmu::ItemInstance*) is intended to be used for situations where we have a client inventory item
-int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
+int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemData *weapon_item) {
 	int dmg = 0;
 	int banedmg = 0;
 
@@ -858,7 +858,7 @@ int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
 			}
 		}
 
-		if(!eledmg && !banedmg){
+		if(!banedmg){
 			if(!GetSpecialAbility(SPECATK_BANE))
 				return 0;
 			else
@@ -888,7 +888,7 @@ int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
 		return dmg;
 }
 
-int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate)
+int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemInstance *weapon_item, uint32 *hate)
 {
 	int dmg = 0;
 	int banedmg = 0;
@@ -927,7 +927,7 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
 		} else {
 			bool MagicGloves = false;
 			if (IsClient()) {
-				const ItemInst *gloves = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotHands);
+				const EQEmu::ItemInstance *gloves = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotHands);
 				if (gloves)
 					MagicGloves = gloves->GetItemMagical(true);
 			}
@@ -979,7 +979,7 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
 		banedmg = against->CheckBaneDamage(weapon_item);
 
 	if (against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)) {
-		if (!eledmg && !banedmg) {
+		if (!banedmg) {
 			if (!GetSpecialAbility(SPECATK_BANE))
 				return 0;
 			else
@@ -1035,13 +1035,13 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
 	if (GetFeigned())
 		return false; // Rogean: How can you attack while feigned? Moved up from Aggro Code.
 
-	ItemInst* weapon;
+	EQEmu::ItemInstance* weapon;
-	if (Hand == EQEmu::legacy::SlotSecondary){	// Kaiyodo - Pick weapon from the attacking hand
+	if (Hand == EQEmu::inventory::slotSecondary){	// Kaiyodo - Pick weapon from the attacking hand
-		weapon = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
+		weapon = GetInv().GetItem(EQEmu::inventory::slotSecondary);
 		OffHandAtk(true);
 	}
 	else{
-		weapon = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
+		weapon = GetInv().GetItem(EQEmu::inventory::slotPrimary);
 		OffHandAtk(false);
 	}
 
@@ -1109,12 +1109,12 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
 
 		int ucDamageBonus = 0;
 
-		if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass())
+		if (Hand == EQEmu::inventory::slotPrimary && GetLevel() >= 28 && IsWarriorClass())
 		{
 			// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above
 			// who belong to a melee class. If we're here, then all of these conditions apply.
 
-			ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
+			ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
 
 			min_hit += (int) ucDamageBonus;
 			max_hit += (int) ucDamageBonus;
@@ -1122,10 +1122,10 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
 		}
 #endif
 		//Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon.
-		if (Hand == EQEmu::legacy::SlotSecondary) {
+		if (Hand == EQEmu::inventory::slotSecondary) {
 			if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
 
-				ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr, true);
+				ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr, true);
 
 				min_hit += (int) ucDamageBonus;
 				max_hit += (int) ucDamageBonus;
@@ -1583,28 +1583,28 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
 	FaceTarget(GetTarget());
 
 	EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
-	if (Hand == EQEmu::legacy::SlotPrimary) {
+	if (Hand == EQEmu::inventory::slotPrimary) {
 		skillinuse = static_cast<EQEmu::skills::SkillType>(GetPrimSkill());
 		OffHandAtk(false);
 	}
-	if (Hand == EQEmu::legacy::SlotSecondary) {
+	if (Hand == EQEmu::inventory::slotSecondary) {
 		skillinuse = static_cast<EQEmu::skills::SkillType>(GetSecSkill());
 		OffHandAtk(true);
 	}
 
 	//figure out what weapon they are using, if any
-	const EQEmu::ItemBase* weapon = nullptr;
+	const EQEmu::ItemData* weapon = nullptr;
-	if (Hand == EQEmu::legacy::SlotPrimary && equipment[EQEmu::legacy::SlotPrimary] > 0)
+	if (Hand == EQEmu::inventory::slotPrimary && equipment[EQEmu::inventory::slotPrimary] > 0)
-		weapon = database.GetItem(equipment[EQEmu::legacy::SlotPrimary]);
+		weapon = database.GetItem(equipment[EQEmu::inventory::slotPrimary]);
-	else if (equipment[EQEmu::legacy::SlotSecondary])
+	else if (equipment[EQEmu::inventory::slotSecondary])
-		weapon = database.GetItem(equipment[EQEmu::legacy::SlotSecondary]);
+		weapon = database.GetItem(equipment[EQEmu::inventory::slotSecondary]);
 
 	//We dont factor much from the weapon into the attack.
 	//Just the skill type so it doesn't look silly using punching animations and stuff while wielding weapons
 	if(weapon) {
 		Log.Out(Logs::Detail, Logs::Combat, "Attacking with weapon: %s (%d) (too bad im not using it for much)", weapon->Name, weapon->ID);
 
-		if (Hand == EQEmu::legacy::SlotSecondary && weapon->ItemType == EQEmu::item::ItemTypeShield){
+		if (Hand == EQEmu::inventory::slotSecondary && weapon->ItemType == EQEmu::item::ItemTypeShield){
 			Log.Out(Logs::Detail, Logs::Combat, "Attack with shield canceled.");
 			return false;
 		}
@@ -1645,7 +1645,7 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
 
 	//do attack animation regardless of whether or not we can hit below
 	int16 charges = 0;
-	ItemInst weapon_inst(weapon, charges);
+	EQEmu::ItemInstance weapon_inst(weapon, charges);
 	AttackAnimation(skillinuse, Hand, &weapon_inst);
 
 	//basically "if not immune" then do the attack
@@ -2515,7 +2515,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) {
 	}
 }
 
-uint8 Mob::GetWeaponDamageBonus(const EQEmu::ItemBase *weapon, bool offhand)
+uint8 Mob::GetWeaponDamageBonus(const EQEmu::ItemData *weapon, bool offhand)
 {
 	// dev quote with old and new formulas
 	// https://forums.daybreakgames.com/eq/index.php?threads/test-update-09-17-15.226618/page-5#post-3326194
@@ -3497,7 +3497,7 @@ void Mob::TryDefensiveProc(Mob *on, uint16 hand) {
 		float ProcChance, ProcBonus;
 		on->GetDefensiveProcChances(ProcBonus, ProcChance, hand , this);
 
-		if (hand != EQEmu::legacy::SlotPrimary)
+		if (hand != EQEmu::inventory::slotPrimary)
 			ProcChance /= 2;
 
 		int level_penalty = 0;
@@ -3522,7 +3522,7 @@ void Mob::TryDefensiveProc(Mob *on, uint16 hand) {
 	}
 }
 
-void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
+void Mob::TryWeaponProc(const EQEmu::ItemInstance* weapon_g, Mob *on, uint16 hand) {
 	if(!on) {
 		SetTarget(nullptr);
 		Log.Out(Logs::General, Logs::Error, "A null Mob object was passed to Mob::TryWeaponProc for evaluation!");
@@ -3540,12 +3540,12 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
 	}
 
 	if(!weapon_g) {
-		TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
+		TrySpellProc(nullptr, (const EQEmu::ItemData*)nullptr, on);
 		return;
 	}
 
 	if (!weapon_g->IsClassCommon()) {
-		TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
+		TrySpellProc(nullptr, (const EQEmu::ItemData*)nullptr, on);
 		return;
 	}
 
@@ -3558,7 +3558,7 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
 	return;
 }
 
-void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
+void Mob::TryWeaponProc(const EQEmu::ItemInstance *inst, const EQEmu::ItemData *weapon, Mob *on, uint16 hand)
 {
 
 	if (!weapon)
@@ -3570,7 +3570,7 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
 	ProcBonus += static_cast<float>(itembonuses.ProcChance) / 10.0f; // Combat Effects
 	float ProcChance = GetProcChances(ProcBonus, hand);
 
-	if (hand != EQEmu::legacy::SlotPrimary) //Is Archery intened to proc at 50% rate?
+	if (hand != EQEmu::inventory::slotPrimary) //Is Archery intened to proc at 50% rate?
 		ProcChance /= 2;
 
 	// Try innate proc on weapon
@@ -3607,11 +3607,11 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
 		proced = false;
 
 	if (!proced && inst) {
-		for (int r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
+		for (int r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
-			const ItemInst *aug_i = inst->GetAugment(r);
+			const EQEmu::ItemInstance *aug_i = inst->GetAugment(r);
 			if (!aug_i) // no aug, try next slot!
 				continue;
-			const EQEmu::ItemBase *aug = aug_i->GetItem();
+			const EQEmu::ItemData *aug = aug_i->GetItem();
 			if (!aug)
 				continue;
 
@@ -3641,18 +3641,18 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
 	return;
 }
 
-void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
+void Mob::TrySpellProc(const EQEmu::ItemInstance *inst, const EQEmu::ItemData *weapon, Mob *on, uint16 hand)
 {
 	float ProcBonus = static_cast<float>(spellbonuses.SpellProcChance +
 			itembonuses.SpellProcChance + aabonuses.SpellProcChance);
 	float ProcChance = 0.0f;
 	ProcChance = GetProcChances(ProcBonus, hand);
 
-	if (hand != EQEmu::legacy::SlotPrimary) //Is Archery intened to proc at 50% rate?
+	if (hand != EQEmu::inventory::slotPrimary) //Is Archery intened to proc at 50% rate?
 		ProcChance /= 2;
 
 	bool rangedattk = false;
-	if (weapon && hand == EQEmu::legacy::SlotRange) {
+	if (weapon && hand == EQEmu::inventory::slotRange) {
 		if (weapon->ItemType == EQEmu::item::ItemTypeArrow ||
 			weapon->ItemType == EQEmu::item::ItemTypeLargeThrowing ||
 			weapon->ItemType == EQEmu::item::ItemTypeSmallThrowing ||
@@ -3661,11 +3661,11 @@ void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
 		}
 	}
 
-	if (!weapon && hand == EQEmu::legacy::SlotRange && GetSpecialAbility(SPECATK_RANGED_ATK))
+	if (!weapon && hand == EQEmu::inventory::slotRange && GetSpecialAbility(SPECATK_RANGED_ATK))
 		rangedattk = true;
 
 	for (uint32 i = 0; i < MAX_PROCS; i++) {
-		if (IsPet() && hand != EQEmu::legacy::SlotPrimary) //Pets can only proc spell procs from their primay hand (ie; beastlord pets)
+		if (IsPet() && hand != EQEmu::inventory::slotPrimary) //Pets can only proc spell procs from their primay hand (ie; beastlord pets)
 			continue; // If pets ever can proc from off hand, this will need to change
 
 		// Not ranged
@@ -3728,7 +3728,7 @@ void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
 		}
 	}
 
-	if (HasSkillProcs() && hand != EQEmu::legacy::SlotRange){ //We check ranged skill procs within the attack functions.
+	if (HasSkillProcs() && hand != EQEmu::inventory::slotRange){ //We check ranged skill procs within the attack functions.
 		uint16 skillinuse = 28;
 		if (weapon)
 			skillinuse = GetSkillByItemType(weapon->ItemType);
@@ -3976,7 +3976,7 @@ void Mob::DoRiposte(Mob *defender)
 	if (!defender)
 		return;
 
-	defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
+	defender->Attack(this, EQEmu::inventory::slotPrimary, true);
 	if (HasDied())
 		return;
 
@@ -3987,7 +3987,7 @@ void Mob::DoRiposte(Mob *defender)
 	if (DoubleRipChance && zone->random.Roll(DoubleRipChance)) {
 		Log.Out(Logs::Detail, Logs::Combat,
 			"Preforming a double riposted from SE_DoubleRiposte (%d percent chance)", DoubleRipChance);
-		defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
+		defender->Attack(this, EQEmu::inventory::slotPrimary, true);
 		if (HasDied())
 			return;
 	}
@@ -4000,7 +4000,7 @@ void Mob::DoRiposte(Mob *defender)
 		Log.Out(Logs::Detail, Logs::Combat,
 			"Preforming a double riposted from SE_GiveDoubleRiposte base1 == 0 (%d percent chance)",
 			DoubleRipChance);
-		defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
+		defender->Attack(this, EQEmu::inventory::slotPrimary, true);
 		if (HasDied())
 			return;
 	}
@@ -4284,7 +4284,7 @@ float Mob::GetSkillProcChances(uint16 ReuseTime, uint16 hand) {
 	if (!ReuseTime && hand) {
 		weapon_speed = GetWeaponSpeedbyHand(hand);
 		ProcChance = static_cast<float>(weapon_speed) * (RuleR(Combat, AvgProcsPerMinute) / 60000.0f);
-		if (hand != EQEmu::legacy::SlotPrimary)
+		if (hand != EQEmu::inventory::slotPrimary)
 			ProcChance /= 2;
 	}
 
@@ -4474,26 +4474,26 @@ void Client::SetAttackTimer()
 
 	Timer *TimerToUse = nullptr;
 
-	for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
+	for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
 		//pick a timer
-		if (i == EQEmu::legacy::SlotPrimary)
+		if (i == EQEmu::inventory::slotPrimary)
 			TimerToUse = &attack_timer;
-		else if (i == EQEmu::legacy::SlotRange)
+		else if (i == EQEmu::inventory::slotRange)
 			TimerToUse = &ranged_timer;
-		else if (i == EQEmu::legacy::SlotSecondary)
+		else if (i == EQEmu::inventory::slotSecondary)
 			TimerToUse = &attack_dw_timer;
 		else	//invalid slot (hands will always hit this)
 			continue;
 
-		const EQEmu::ItemBase *ItemToUse = nullptr;
+		const EQEmu::ItemData *ItemToUse = nullptr;
 
 		//find our item
-		ItemInst *ci = GetInv().GetItem(i);
+		EQEmu::ItemInstance *ci = GetInv().GetItem(i);
 		if (ci)
 			ItemToUse = ci->GetItem();
 
 		//special offhand stuff
-		if (i == EQEmu::legacy::SlotSecondary) {
+		if (i == EQEmu::inventory::slotSecondary) {
 			//if we cant dual wield, skip it
 			if (!CanThisClassDualWield() || HasTwoHanderEquipped()) {
 				attack_dw_timer.Disable();
@@ -4567,19 +4567,19 @@ void NPC::SetAttackTimer()
 	else
 		speed = static_cast<int>(((attack_delay / haste_mod) + ((hhe / 100.0f) * attack_delay)) * 100);
 
-	for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
+	for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
 		//pick a timer
-		if (i == EQEmu::legacy::SlotPrimary)
+		if (i == EQEmu::inventory::slotPrimary)
 			TimerToUse = &attack_timer;
-		else if (i == EQEmu::legacy::SlotRange)
+		else if (i == EQEmu::inventory::slotRange)
 			TimerToUse = &ranged_timer;
-		else if (i == EQEmu::legacy::SlotSecondary)
+		else if (i == EQEmu::inventory::slotSecondary)
 			TimerToUse = &attack_dw_timer;
 		else	//invalid slot (hands will always hit this)
 			continue;
 
 		//special offhand stuff
-		if (i == EQEmu::legacy::SlotSecondary) {
+		if (i == EQEmu::inventory::slotSecondary) {
 			// SPECATK_QUAD is uncheesable
 			if(!CanThisClassDualWield() || (HasTwoHanderEquipped() && !GetSpecialAbility(SPECATK_QUAD))) {
 				attack_dw_timer.Disable();
@@ -4601,7 +4601,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
 	bool candouble = CanThisClassDoubleAttack();
 	// extra off hand non-sense, can only double with skill of 150 or above
 	// or you have any amount of GiveDoubleAttack
-	if (candouble && hand == EQEmu::legacy::SlotSecondary)
+	if (candouble && hand == EQEmu::inventory::slotSecondary)
 		candouble = GetSkill(EQEmu::skills::SkillDoubleAttack) > 149 || (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack) > 0;
 
 	if (candouble) {
@@ -4609,7 +4609,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
 		if (CheckDoubleAttack()) {
 			Attack(target, hand, false, false, IsFromSpell);
 			// you can only triple from the main hand
-			if (hand == EQEmu::legacy::SlotPrimary && CanThisClassTripleAttack()) {
+			if (hand == EQEmu::inventory::slotPrimary && CanThisClassTripleAttack()) {
 				CheckIncreaseSkill(EQEmu::skills::SkillTripleAttack, target, -10);
 				if (CheckTripleAttack())
 					Attack(target, hand, false, false, IsFromSpell);
@@ -4617,7 +4617,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
 		}
 	}
 
-	if (hand == EQEmu::legacy::SlotPrimary) {
+	if (hand == EQEmu::inventory::slotPrimary) {
 		// According to http://www.monkly-business.net/forums/showpost.php?p=312095&postcount=168 a dev told them flurry isn't dependant on triple attack
 		// the parses kind of back that up and all of my parses seemed to be 4 or 5 attacks in the round which would work out to be
 		// doubles or triples with 2 from flurries or triple with 1 or 2 flurries ... Going with the "dev quote" I guess like we've always had it
@@ -4670,9 +4670,9 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
 	if (RuleB(Combat, UseLiveCombatRounds)) {
 		// A "quad" on live really is just a successful dual wield where both double attack
 		// The mobs that could triple lost the ability to when the triple attack skill was added in
-		Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+		Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 		if (CanThisClassDoubleAttack() && CheckDoubleAttack()){
-			Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+			Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 								
 			if ((IsPet() || IsTempPet()) && IsPetOwnerClient()){
 				int chance = spellbonuses.PC_Pet_Flurry + itembonuses.PC_Pet_Flurry + aabonuses.PC_Pet_Flurry;
@@ -4686,14 +4686,14 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
 	if (IsNPC()) {
 		int16 n_atk = CastToNPC()->GetNumberOfAttacks();
 		if (n_atk <= 1) {
-			Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+			Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 		} else {
 			for (int i = 0; i < n_atk; ++i) {
-				Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+				Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 			}
 		}
 	} else {
-		Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+		Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 	}
 
 	// we use this random value in three comparisons with different
@@ -4704,15 +4704,15 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
 	    // check double attack, this is NOT the same rules that clients use...
 	    &&
 	    RandRoll < (GetLevel() + NPCDualAttackModifier)) {
-		Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+		Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 		// lets see if we can do a triple attack with the main hand
 		// pets are excluded from triple and quads...
 		if ((GetSpecialAbility(SPECATK_TRIPLE) || GetSpecialAbility(SPECATK_QUAD)) && !IsPet() &&
 		    RandRoll < (GetLevel() + NPCTripleAttackModifier)) {
-			Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+			Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 			// now lets check the quad attack
 			if (GetSpecialAbility(SPECATK_QUAD) && RandRoll < (GetLevel() + NPCQuadAttackModifier)) {
-				Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
+				Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
 			}
 		}
 	}
@@ -4726,11 +4726,11 @@ void Mob::DoOffHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int speci
 	// For now, SPECATK_QUAD means innate DW when Combat:UseLiveCombatRounds is true
 	if ((GetSpecialAbility(SPECATK_INNATE_DW) ||
 	     (RuleB(Combat, UseLiveCombatRounds) && GetSpecialAbility(SPECATK_QUAD))) ||
-		 GetEquipment(EQEmu::textures::TextureSecondary) != 0) {
+		 GetEquipment(EQEmu::textures::weaponSecondary) != 0) {
 		if (CheckDualWield()) {
-			Attack(target, EQEmu::legacy::SlotSecondary, false, false, false, opts, special);
+			Attack(target, EQEmu::inventory::slotSecondary, false, false, false, opts, special);
 			if (CanThisClassDoubleAttack() && GetLevel() > 35 && CheckDoubleAttack()){
-				Attack(target, EQEmu::legacy::SlotSecondary, false, false, false, opts, special);
+				Attack(target, EQEmu::inventory::slotSecondary, false, false, false, opts, special);
 
 				if ((IsPet() || IsTempPet()) && IsPetOwnerClient()){
 					int chance = spellbonuses.PC_Pet_Flurry + itembonuses.PC_Pet_Flurry + aabonuses.PC_Pet_Flurry;

zone/beacon.h

@@ -36,7 +36,7 @@ public:
 	//abstract virtual function implementations requird by base abstract class
 	virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
 	virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
-	virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
+	virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
 		ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
 	virtual bool HasRaid() { return false; }
 	virtual bool HasGroup() { return false; }

zone/bonuses.cpp

@@ -17,7 +17,7 @@
 */
 #include "../common/classes.h"
 #include "../common/global_define.h"
-#include "../common/item.h"
+#include "../common/item_instance.h"
 #include "../common/rulesys.h"
 #include "../common/skills.h"
 #include "../common/spdat.h"
@@ -145,35 +145,35 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
 
 	unsigned int i;
 	// Update: MainAmmo should only calc skill mods (TODO: Check for other cases)
-	for (i = EQEmu::legacy::SlotCharm; i <= EQEmu::legacy::SlotAmmo; i++) {
+	for (i = EQEmu::inventory::slotCharm; i <= EQEmu::inventory::slotAmmo; i++) {
-		const ItemInst* inst = m_inv[i];
+		const EQEmu::ItemInstance* inst = m_inv[i];
 		if(inst == 0)
 			continue;
-		AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::legacy::SlotAmmo));
+		AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::inventory::slotAmmo));
 
 		//These are given special flags due to how often they are checked for various spell effects.
-		const EQEmu::ItemBase *item = inst->GetItem();
+		const EQEmu::ItemData *item = inst->GetItem();
-		if (i == EQEmu::legacy::SlotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
+		if (i == EQEmu::inventory::slotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
 			SetShieldEquiped(true);
-		else if (i == EQEmu::legacy::SlotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
+		else if (i == EQEmu::inventory::slotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
 			SetTwoHandBluntEquiped(true);
 			SetTwoHanderEquipped(true);
 		}
-		else if (i == EQEmu::legacy::SlotPrimary && (item && (item->ItemType == EQEmu::item::ItemType2HSlash || item->ItemType == EQEmu::item::ItemType2HPiercing)))
+		else if (i == EQEmu::inventory::slotPrimary && (item && (item->ItemType == EQEmu::item::ItemType2HSlash || item->ItemType == EQEmu::item::ItemType2HPiercing)))
 			SetTwoHanderEquipped(true);
 	}
 
 	//Power Source Slot
 	if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
 	{
-		const ItemInst* inst = m_inv[EQEmu::legacy::SlotPowerSource];
+		const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotPowerSource];
 		if(inst)
 			AddItemBonuses(inst, newbon);
 	}
 
 	//tribute items
 	for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++) {
-		const ItemInst* inst = m_inv[EQEmu::legacy::TRIBUTE_BEGIN + i];
+		const EQEmu::ItemInstance* inst = m_inv[EQEmu::legacy::TRIBUTE_BEGIN + i];
 		if(inst == 0)
 			continue;
 		AddItemBonuses(inst, newbon, false, true);
@@ -181,8 +181,8 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
 
 	//Optional ability to have worn effects calculate as an addititive bonus instead of highest value
 	if (RuleI(Spells, AdditiveBonusWornType) && RuleI(Spells, AdditiveBonusWornType) != EQEmu::item::ItemEffectWorn){
-		for (i = EQEmu::legacy::SlotCharm; i < EQEmu::legacy::SlotAmmo; i++) {
+		for (i = EQEmu::inventory::slotCharm; i < EQEmu::inventory::slotAmmo; i++) {
-			const ItemInst* inst = m_inv[i];
+			const EQEmu::ItemInstance* inst = m_inv[i];
 			if(inst == 0)
 				continue;
 			AdditiveWornBonuses(inst, newbon);
@@ -208,7 +208,7 @@ void Client::ProcessItemCaps()
 	itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap());
 }
 
-void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
+void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
 {
 	if (!inst || !inst->IsClassCommon()) {
 		return;
@@ -218,7 +218,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
 		return;
 	}
 
-	const EQEmu::ItemBase *item = inst->GetItem();
+	const EQEmu::ItemData *item = inst->GetItem();
 
 	if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
 		if (item->ItemType != EQEmu::item::ItemTypeFood && item->ItemType != EQEmu::item::ItemTypeDrink)
@@ -527,12 +527,12 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
 	}
 
 	if (!isAug) {
-		for (int i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++)
+		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++)
 			AddItemBonuses(inst->GetAugment(i), newbon, true, false, rec_level, ammo_slot_item);
 	}
 }
 
-void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug) {
+void Client::AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug) {
 
 	/*
 	Powerful Non-live like option allows developers to add worn effects on items that
@@ -550,7 +550,7 @@ void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool
 	if(inst->GetAugmentType()==0 && isAug == true)
 		return;
 
-	const EQEmu::ItemBase *item = inst->GetItem();
+	const EQEmu::ItemData *item = inst->GetItem();
 
 	if(!inst->IsEquipable(GetBaseRace(),GetClass()))
 		return;
@@ -565,7 +565,7 @@ void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool
 	if (!isAug)
 	{
 		int i;
-		for (i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+		for (i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 			AdditiveWornBonuses(inst->GetAugment(i),newbon,true);
 		}
 	}
@@ -580,9 +580,9 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
 	{
 		if (food && drink)
 			break;
-		const ItemInst* inst = GetInv().GetItem(i);
+		const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
 		if (inst && inst->GetItem() && inst->IsClassCommon()) {
-			const EQEmu::ItemBase *item = inst->GetItem();
+			const EQEmu::ItemData *item = inst->GetItem();
 			if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
 				food = true;
 			else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@@ -596,9 +596,9 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
 	{
 		if (food && drink)
 			break;
-		const ItemInst* inst = GetInv().GetItem(i);
+		const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
 		if (inst && inst->GetItem() && inst->IsClassCommon()) {
-			const EQEmu::ItemBase *item = inst->GetItem();
+			const EQEmu::ItemData *item = inst->GetItem();
 			if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
 				food = true;
 			else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@@ -3205,7 +3205,7 @@ void NPC::CalcItemBonuses(StatBonuses *newbon)
 	if(newbon){
 
 		for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){
-			const EQEmu::ItemBase *cur = database.GetItem(equipment[i]);
+			const EQEmu::ItemData *cur = database.GetItem(equipment[i]);
 			if(cur){
 				//basic stats
 				newbon->AC += cur->AC;
@@ -3299,7 +3299,7 @@ void Client::CalcItemScale() {
 	//Power Source Slot
 	if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
 	{
-		if (CalcItemScale(EQEmu::legacy::SlotPowerSource, EQEmu::legacy::SlotPowerSource))
+		if (CalcItemScale(EQEmu::inventory::slotPowerSource, EQEmu::inventory::slotPowerSource))
 			changed = true;
 	}
 
@@ -3314,10 +3314,10 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
 	bool changed = false;
 	uint32 i;
 	for (i = slot_x; i <= slot_y; i++) {
-		if (i == EQEmu::legacy::SlotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
+		if (i == EQEmu::inventory::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
 			continue;
 
-		ItemInst* inst = m_inv.GetItem(i);
+		EQEmu::ItemInstance* inst = m_inv.GetItem(i);
 
 		if(inst == nullptr)
 			continue;
@@ -3325,7 +3325,7 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
 		// TEST CODE: test for bazaar trader crashing with charm items
 		if (Trader)
 			if (i >= EQEmu::legacy::GENERAL_BAGS_BEGIN && i <= EQEmu::legacy::GENERAL_BAGS_END) {
-				ItemInst* parent_item = m_inv.GetItem(Inventory::CalcSlotId(i));
+				EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
 				if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
 					continue;
 			}
@@ -3344,9 +3344,9 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
 		}
 
 		//iterate all augments
-		for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
+		for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
 		{
-			ItemInst * a_inst = inst->GetAugment(x);
+			EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
 			if(!a_inst)
 				continue;
 
@@ -3393,7 +3393,7 @@ void Client::DoItemEnterZone() {
 	//Power Source Slot
 	if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
 	{
-		if (DoItemEnterZone(EQEmu::legacy::SlotPowerSource, EQEmu::legacy::SlotPowerSource))
+		if (DoItemEnterZone(EQEmu::inventory::slotPowerSource, EQEmu::inventory::slotPowerSource))
 			changed = true;
 	}
 
@@ -3407,10 +3407,10 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
 	// behavior change: 'slot_y' is now [RANGE]_END and not [RANGE]_END + 1
 	bool changed = false;
 	for(uint32 i = slot_x; i <= slot_y; i++) {
-		if (i == EQEmu::legacy::SlotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
+		if (i == EQEmu::inventory::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
 			continue;
 
-		ItemInst* inst = m_inv.GetItem(i);
+		EQEmu::ItemInstance* inst = m_inv.GetItem(i);
 
 		if(!inst)
 			continue;
@@ -3418,7 +3418,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
 		// TEST CODE: test for bazaar trader crashing with charm items
 		if (Trader)
 			if (i >= EQEmu::legacy::GENERAL_BAGS_BEGIN && i <= EQEmu::legacy::GENERAL_BAGS_END) {
-				ItemInst* parent_item = m_inv.GetItem(Inventory::CalcSlotId(i));
+				EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
 				if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
 					continue;
 			}
@@ -3429,7 +3429,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
 			uint16 oldexp = inst->GetExp();
 
 			parse->EventItem(EVENT_ITEM_ENTER_ZONE, this, inst, nullptr, "", 0);
-			if (i <= EQEmu::legacy::SlotAmmo || i == EQEmu::legacy::SlotPowerSource) {
+			if (i <= EQEmu::inventory::slotAmmo || i == EQEmu::inventory::slotPowerSource) {
 				parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
 			}
 
@@ -3439,7 +3439,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
 				update_slot = true;
 			}
 		} else {
-			if (i <= EQEmu::legacy::SlotAmmo || i == EQEmu::legacy::SlotPowerSource) {
+			if (i <= EQEmu::inventory::slotAmmo || i == EQEmu::inventory::slotPowerSource) {
 				parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
 			}
 
@@ -3447,9 +3447,9 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
 		}
 
 		//iterate all augments
-		for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
+		for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
 		{
-			ItemInst *a_inst = inst->GetAugment(x);
+			EQEmu::ItemInstance *a_inst = inst->GetAugment(x);
 			if(!a_inst)
 				continue;
 

zone/bot.cpp

@@ -229,13 +229,13 @@ void Bot::SetBotSpellID(uint32 newSpellID) {
 }
 
 uint32 Bot::GetBotArcheryRange() {
-	const ItemInst *range_inst = GetBotItem(EQEmu::legacy::SlotRange);
+	const EQEmu::ItemInstance *range_inst = GetBotItem(EQEmu::inventory::slotRange);
-	const ItemInst *ammo_inst = GetBotItem(EQEmu::legacy::SlotAmmo);
+	const EQEmu::ItemInstance *ammo_inst = GetBotItem(EQEmu::inventory::slotAmmo);
 	if (!range_inst || !ammo_inst)
 		return 0;
 
-	const EQEmu::ItemBase *range_item = range_inst->GetItem();
+	const EQEmu::ItemData *range_item = range_inst->GetItem();
-	const EQEmu::ItemBase *ammo_item = ammo_inst->GetItem();
+	const EQEmu::ItemData *ammo_item = ammo_inst->GetItem();
 	if (!range_item || !ammo_item || range_item->ItemType != EQEmu::item::ItemTypeBow || ammo_item->ItemType != EQEmu::item::ItemTypeArrow)
 		return 0;
 
@@ -246,15 +246,15 @@ uint32 Bot::GetBotArcheryRange() {
 void Bot::ChangeBotArcherWeapons(bool isArcher) {
 	if((GetClass()==WARRIOR) || (GetClass()==PALADIN) || (GetClass()==RANGER) || (GetClass()==SHADOWKNIGHT) || (GetClass()==ROGUE)) {
 		if(!isArcher) {
-			BotAddEquipItem(EQEmu::legacy::SlotPrimary, GetBotItemBySlot(EQEmu::legacy::SlotPrimary));
+			BotAddEquipItem(EQEmu::inventory::slotPrimary, GetBotItemBySlot(EQEmu::inventory::slotPrimary));
-			BotAddEquipItem(EQEmu::legacy::SlotSecondary, GetBotItemBySlot(EQEmu::legacy::SlotSecondary));
+			BotAddEquipItem(EQEmu::inventory::slotSecondary, GetBotItemBySlot(EQEmu::inventory::slotSecondary));
 			SetAttackTimer();
 			BotGroupSay(this, "My blade is ready");
 		} else {
-			BotRemoveEquipItem(EQEmu::legacy::SlotPrimary);
+			BotRemoveEquipItem(EQEmu::inventory::slotPrimary);
-			BotRemoveEquipItem(EQEmu::legacy::SlotSecondary);
+			BotRemoveEquipItem(EQEmu::inventory::slotSecondary);
-			BotAddEquipItem(EQEmu::legacy::SlotAmmo, GetBotItemBySlot(EQEmu::legacy::SlotAmmo));
+			BotAddEquipItem(EQEmu::inventory::slotAmmo, GetBotItemBySlot(EQEmu::inventory::slotAmmo));
-			BotAddEquipItem(EQEmu::legacy::SlotSecondary, GetBotItemBySlot(EQEmu::legacy::SlotRange));
+			BotAddEquipItem(EQEmu::inventory::slotSecondary, GetBotItemBySlot(EQEmu::inventory::slotRange));
 			SetAttackTimer();
 			BotGroupSay(this, "My bow is true and ready");
 		}
@@ -1175,11 +1175,11 @@ void Bot::GenerateArmorClass() {
 
 uint16 Bot::GetPrimarySkillValue() {
 	EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
-	bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
+	bool equiped = m_inv.GetItem(EQEmu::inventory::slotPrimary);
 	if(!equiped)
 		skill = EQEmu::skills::SkillHandtoHand;
 	else {
-		uint8 type = m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->ItemType; //is this the best way to do this?
+		uint8 type = m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->ItemType; //is this the best way to do this?
 		switch(type) {
 		case EQEmu::item::ItemType1HSlash:
 			skill = EQEmu::skills::Skill1HSlashing;
@@ -1900,13 +1900,13 @@ void Bot::BotRangedAttack(Mob* other) {
 		return;
 	}
 
-	ItemInst* rangedItem = GetBotItem(EQEmu::legacy::SlotRange);
+	EQEmu::ItemInstance* rangedItem = GetBotItem(EQEmu::inventory::slotRange);
-	const EQEmu::ItemBase* RangeWeapon = 0;
+	const EQEmu::ItemData* RangeWeapon = 0;
 	if(rangedItem)
 		RangeWeapon = rangedItem->GetItem();
 
-	ItemInst* ammoItem = GetBotItem(EQEmu::legacy::SlotAmmo);
+	EQEmu::ItemInstance* ammoItem = GetBotItem(EQEmu::inventory::slotAmmo);
-	const EQEmu::ItemBase* Ammo = 0;
+	const EQEmu::ItemData* Ammo = 0;
 	if(ammoItem)
 		Ammo = ammoItem->GetItem();
 
@@ -2002,7 +2002,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
 
 	int damage = 0;
 	uint32 hate = 0;
-	int Hand = EQEmu::legacy::SlotPrimary;
+	int Hand = EQEmu::inventory::slotPrimary;
 	if (hate == 0 && weapon_damage > 1)
 		hate = weapon_damage;
 
@@ -2015,7 +2015,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
 		int32 min_hit = 1;
 		int32 max_hit = ((2 * weapon_damage * GetDamageTable(skillinuse)) / 100);
 		if(GetLevel() >= 28 && IsWarriorClass()) {
-			int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemBase*) nullptr);
+			int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemData*) nullptr);
 			min_hit += (int) ucDamageBonus;
 			max_hit += (int) ucDamageBonus;
 			hate += ucDamageBonus;
@@ -2031,7 +2031,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
 		else
 			damage = zone->random.Int(min_hit, max_hit);
 
-		if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::legacy::SlotRange : EQEmu::legacy::SlotPrimary)) { // MainRange excludes ripo, primary doesn't have any extra behavior
+		if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::inventory::slotRange : EQEmu::inventory::slotPrimary)) { // MainRange excludes ripo, primary doesn't have any extra behavior
 			if (damage == -3) {
 				DoRiposte(other);
 				if (HasDied())
@@ -2056,8 +2056,8 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
 		damage = -5;
 
 	if (skillinuse == EQEmu::skills::SkillBash){
-		const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
+		const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
-		const EQEmu::ItemBase* botweapon = 0;
+		const EQEmu::ItemData* botweapon = 0;
 		if(inst)
 			botweapon = inst->GetItem();
 
@@ -2103,21 +2103,21 @@ void Bot::ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int3
 	case EQEmu::skills::SkillFlyingKick:
 	case EQEmu::skills::SkillRoundKick:
 	case EQEmu::skills::SkillKick:
-		item_slot = EQEmu::legacy::SlotFeet;
+		item_slot = EQEmu::inventory::slotFeet;
 		break;
 	case EQEmu::skills::SkillBash:
-		item_slot = EQEmu::legacy::SlotSecondary;
+		item_slot = EQEmu::inventory::slotSecondary;
 		break;
 	case EQEmu::skills::SkillDragonPunch:
 	case EQEmu::skills::SkillEagleStrike:
 	case EQEmu::skills::SkillTigerClaw:
-		item_slot = EQEmu::legacy::SlotHands;
+		item_slot = EQEmu::inventory::slotHands;
 		break;
 	}
 
 	if (item_slot >= EQEmu::legacy::EQUIPMENT_BEGIN){
-		const ItemInst* inst = GetBotItem(item_slot);
+		const EQEmu::ItemInstance* inst = GetBotItem(item_slot);
-		const EQEmu::ItemBase* botweapon = 0;
+		const EQEmu::ItemData* botweapon = 0;
 		if(inst)
 			botweapon = inst->GetItem();
 
@@ -2449,23 +2449,23 @@ void Bot::AI_Process() {
 				// First, special attack per class (kick, backstab etc..)
 				DoClassAttacks(GetTarget());
 				if(attack_timer.Check()) {
-					Attack(GetTarget(), EQEmu::legacy::SlotPrimary);
+					Attack(GetTarget(), EQEmu::inventory::slotPrimary);
-					TriggerDefensiveProcs(GetTarget(), EQEmu::legacy::SlotPrimary, false);
+					TriggerDefensiveProcs(GetTarget(), EQEmu::inventory::slotPrimary, false);
-					ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotPrimary);
+					EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotPrimary);
-					TryWeaponProc(wpn, GetTarget(), EQEmu::legacy::SlotPrimary);
+					TryWeaponProc(wpn, GetTarget(), EQEmu::inventory::slotPrimary);
 					bool tripleSuccess = false;
 					if(BotOwner && GetTarget() && CanThisClassDoubleAttack()) {
 						if(BotOwner && CheckBotDoubleAttack())
-							Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
+							Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
 
 						if(BotOwner && GetTarget() && GetSpecialAbility(SPECATK_TRIPLE) && CheckBotDoubleAttack(true)) {
 							tripleSuccess = true;
-							Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
+							Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
 						}
 
 						//quad attack, does this belong here??
 						if(BotOwner && GetTarget() && GetSpecialAbility(SPECATK_QUAD) && CheckBotDoubleAttack(true))
-							Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
+							Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
 					}
 
 					//Live AA - Flurry, Rapid Strikes ect (Flurry does not require Triple Attack).
@@ -2473,18 +2473,18 @@ void Bot::AI_Process() {
 					if (GetTarget() && flurrychance) {
 						if(zone->random.Int(0, 100) < flurrychance) {
 							Message_StringID(MT_NPCFlurry, YOU_FLURRY);
-							Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
+							Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
-							Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
+							Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
 						}
 					}
 
 					int32 ExtraAttackChanceBonus = (spellbonuses.ExtraAttackChance + itembonuses.ExtraAttackChance + aabonuses.ExtraAttackChance);
 					if (GetTarget() && ExtraAttackChanceBonus) {
-						ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotPrimary);
+						EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotPrimary);
 						if(wpn) {
 							if (wpn->GetItem()->IsType2HWeapon()) {
 								if(zone->random.Int(0, 100) < ExtraAttackChanceBonus)
-									Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
+									Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
 							}
 						}
 					}
@@ -2504,8 +2504,8 @@ void Bot::AI_Process() {
 
 				//now off hand
 				if(GetTarget() && attack_dw_timer.Check() && CanThisClassDualWield()) {
-					const ItemInst* instweapon = GetBotItem(EQEmu::legacy::SlotSecondary);
+					const EQEmu::ItemInstance* instweapon = GetBotItem(EQEmu::inventory::slotSecondary);
-					const EQEmu::ItemBase* weapon = 0;
+					const EQEmu::ItemData* weapon = 0;
 					//can only dual wield without a weapon if you're a monk
 					if(instweapon || (botClass == MONK)) {
 						if(instweapon)
@@ -2526,12 +2526,12 @@ void Bot::AI_Process() {
 							DualWieldProbability += (DualWieldProbability * float(DWBonus) / 100.0f);
 							float random = zone->random.Real(0, 1);
 							if (random < DualWieldProbability){ // Max 78% of DW
-								Attack(GetTarget(), EQEmu::legacy::SlotSecondary);	// Single attack with offhand
+								Attack(GetTarget(), EQEmu::inventory::slotSecondary);	// Single attack with offhand
-								ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotSecondary);
+								EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotSecondary);
-								TryWeaponProc(wpn, GetTarget(), EQEmu::legacy::SlotSecondary);
+								TryWeaponProc(wpn, GetTarget(), EQEmu::inventory::slotSecondary);
 								if( CanThisClassDoubleAttack() && CheckBotDoubleAttack()) {
 									if(GetTarget() && GetTarget()->GetHP() > -10)
-										Attack(GetTarget(), EQEmu::legacy::SlotSecondary);	// Single attack with offhand
+										Attack(GetTarget(), EQEmu::inventory::slotSecondary);	// Single attack with offhand
 								}
 							}
 						}
@@ -2702,12 +2702,12 @@ void Bot::PetAIProcess() {
 					if(!botPet->BehindMob(botPet->GetTarget(), botPet->GetX(), botPet->GetY()) && botPet->GetTarget()->IsEnraged())
 						return;
 
-					if (botPet->Attack(GetTarget(), EQEmu::legacy::SlotPrimary))	// try the main hand
+					if (botPet->Attack(GetTarget(), EQEmu::inventory::slotPrimary))	// try the main hand
 						if (botPet->GetTarget()) {
 							// We're a pet so we re able to dual attack
 							int32 RandRoll = zone->random.Int(0, 99);
 							if (botPet->CanThisClassDoubleAttack() && (RandRoll < (botPet->GetLevel() + NPCDualAttackModifier))) {
-								if (botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotPrimary)) {}
+								if (botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotPrimary)) {}
 							}
 						}
 
@@ -2745,11 +2745,11 @@ void Bot::PetAIProcess() {
 								float DualWieldProbability = ((botPet->GetSkill(EQEmu::skills::SkillDualWield) + botPet->GetLevel()) / 400.0f);
 								DualWieldProbability -= zone->random.Real(0, 1);
 								if(DualWieldProbability < 0) {
-									botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotSecondary);
+									botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotSecondary);
 									if (botPet->CanThisClassDoubleAttack()) {
 										int32 RandRoll = zone->random.Int(0, 99);
 										if (RandRoll < (botPet->GetLevel() + 20))
-											botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotSecondary);
+											botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotSecondary);
 									}
 								}
 							}
@@ -2875,7 +2875,7 @@ void Bot::Spawn(Client* botCharacterOwner) {
 		for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
 			itemID = GetBotItemBySlot(i);
 			if(itemID != 0) {
-				materialFromSlot = Inventory::CalcMaterialFromSlot(i);
+				materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(i);
 				if(materialFromSlot != 0xFF)
 					this->SendWearChange(materialFromSlot);
 			}
@@ -2897,7 +2897,7 @@ void Bot::RemoveBotItemBySlot(uint32 slotID, std::string *errorMessage)
 }
 
 // Retrieves all the inventory records from the database for this bot.
-void Bot::GetBotItems(Inventory &inv, std::string* errorMessage)
+void Bot::GetBotItems(EQEmu::InventoryProfile &inv, std::string* errorMessage)
 {
 	if(!GetBotID())
 		return;
@@ -2952,18 +2952,18 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
 		ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
 		ns->spawn.helm = helmtexture; //(GetShowHelm() ? helmtexture : 0); //0xFF;
 		ns->spawn.equip_chest2 = texture; //0xFF;
-		const EQEmu::ItemBase* item = 0;
+		const EQEmu::ItemData* item = 0;
-		const ItemInst* inst = 0;
+		const EQEmu::ItemInstance* inst = 0;
 		uint32 spawnedbotid = 0;
 		spawnedbotid = this->GetBotID();
-		for (int i = 0; i < EQEmu::textures::TexturePrimary; i++) {
+		for (int i = EQEmu::textures::textureBegin; i < EQEmu::textures::weaponPrimary; i++) {
 			inst = GetBotItem(i);
 			if (inst) {
 				item = inst->GetItem();
 				if (item != 0) {
 					ns->spawn.equipment.Slot[i].Material = item->Material;
-					ns->spawn.equipment.Slot[i].EliteMaterial = item->EliteMaterial;
+					ns->spawn.equipment.Slot[i].EliteModel = item->EliteMaterial;
-					ns->spawn.equipment.Slot[i].HeroForgeModel = item->HerosForgeModel;
+					ns->spawn.equipment.Slot[i].HerosForgeModel = item->HerosForgeModel;
 					if (armor_tint.Slot[i].Color)
 						ns->spawn.equipment_tint.Slot[i].Color = armor_tint.Slot[i].Color;
 					else
@@ -2975,25 +2975,25 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
 			}
 		}
 
-		inst = GetBotItem(EQEmu::legacy::SlotPrimary);
+		inst = GetBotItem(EQEmu::inventory::slotPrimary);
 		if(inst) {
 			item = inst->GetItem();
 			if(item) {
 				if(strlen(item->IDFile) > 2)
 					ns->spawn.equipment.Primary.Material = atoi(&item->IDFile[2]);
 
-				ns->spawn.equipment_tint.Primary.Color = GetEquipmentColor(EQEmu::textures::TexturePrimary);
+				ns->spawn.equipment_tint.Primary.Color = GetEquipmentColor(EQEmu::textures::weaponPrimary);
 			}
 		}
 
-		inst = GetBotItem(EQEmu::legacy::SlotSecondary);
+		inst = GetBotItem(EQEmu::inventory::slotSecondary);
 		if(inst) {
 			item = inst->GetItem();
 			if(item) {
 				if(strlen(item->IDFile) > 2)
 					ns->spawn.equipment.Secondary.Material = atoi(&item->IDFile[2]);
 
-				ns->spawn.equipment_tint.Secondary.Color = GetEquipmentColor(EQEmu::textures::TextureSecondary);
+				ns->spawn.equipment_tint.Secondary.Color = GetEquipmentColor(EQEmu::textures::weaponSecondary);
 			}
 		}
 	}
@@ -3224,8 +3224,8 @@ void Bot::SendBotArcheryWearChange(uint8 material_slot, uint32 material, uint32
 }
 
 // Returns the item id that is in the bot inventory collection for the specified slot.
-ItemInst* Bot::GetBotItem(uint32 slotID) {
+EQEmu::ItemInstance* Bot::GetBotItem(uint32 slotID) {
-	ItemInst* item = m_inv.GetItem(slotID);
+	EQEmu::ItemInstance* item = m_inv.GetItem(slotID);
 	if(item)
 		return item;
 
@@ -3235,9 +3235,9 @@ ItemInst* Bot::GetBotItem(uint32 slotID) {
 // Adds the specified item it bot to the NPC equipment array and to the bot inventory collection.
 void Bot::BotAddEquipItem(int slot, uint32 id) {
 	if(slot > 0 && id > 0) {
-		uint8 materialFromSlot = Inventory::CalcMaterialFromSlot(slot);
+		uint8 materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot);
 
-		if (materialFromSlot != EQEmu::textures::TextureInvalid) {
+		if (materialFromSlot != EQEmu::textures::materialInvalid) {
 			equipment[slot] = id; // npc has more than just material slots. Valid material should mean valid inventory index
 			SendWearChange(materialFromSlot);
 		}
@@ -3251,13 +3251,13 @@ void Bot::BotAddEquipItem(int slot, uint32 id) {
 // Erases the specified item from bot the NPC equipment array and from the bot inventory collection.
 void Bot::BotRemoveEquipItem(int slot) {
 	if(slot > 0) {
-		uint8 materialFromSlot = Inventory::CalcMaterialFromSlot(slot);
+		uint8 materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot);
 
-		if (materialFromSlot != EQEmu::textures::TextureInvalid) {
+		if (materialFromSlot != EQEmu::textures::materialInvalid) {
 			equipment[slot] = 0; // npc has more than just material slots. Valid material should mean valid inventory index
 			SendWearChange(materialFromSlot);
-			if (materialFromSlot == EQEmu::textures::TextureChest)
+			if (materialFromSlot == EQEmu::textures::armorChest)
-				SendWearChange(EQEmu::textures::TextureArms);
+				SendWearChange(EQEmu::textures::armorArms);
 		}
 
 		UpdateEquipmentLight();
@@ -3266,7 +3266,7 @@ void Bot::BotRemoveEquipItem(int slot) {
 	}
 }
 
-void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const ItemInst* inst, const ItemInst* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap) {
+void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap) {
 
 	if(!errorMessage->empty())
 		return;
@@ -3289,7 +3289,7 @@ void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const ItemInst* inst,
 	}
 }
 
-void Bot::BotTradeAddItem(uint32 id, const ItemInst* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb)
+void Bot::BotTradeAddItem(uint32 id, const EQEmu::ItemInstance* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb)
 {
 	if(addToDb) {
 		if (!botdb.SaveItemBySlot(this, lootSlot, inst)) {
@@ -3360,7 +3360,7 @@ void Bot::FinishTrade(Client* client, BotTradeType tradeType) {
 		else if(tradeType == BotTradeClientNoDropNoTrade) {
 			// Items being traded are found on the Client's cursor slot, slot id 30. This item can be either a single item or it can be a bag.
 			// If it is a bag, then we have to search for items in slots 331 thru 340
-			PerformTradeWithClient(EQEmu::legacy::SlotCursor, EQEmu::legacy::SlotCursor, client);
+			PerformTradeWithClient(EQEmu::inventory::slotCursor, EQEmu::inventory::slotCursor, client);
 
 			// TODO: Add logic here to test if the item in SLOT_CURSOR is a container type, if it is then we need to call the following:
 			// PerformTradeWithClient(331, 340, client);
@@ -3382,23 +3382,23 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 			bool UpdateClient = false;
 			bool already_returned = false;
 
-			Inventory& clientInventory = client->GetInv();
+			EQEmu::InventoryProfile& clientInventory = client->GetInv();
-			const ItemInst* inst = clientInventory[i];
+			const EQEmu::ItemInstance* inst = clientInventory[i];
 			if(inst) {
 				items[i] = inst->GetItem()->ID;
 				charges[i] = inst->GetCharges();
 			}
 
-			if (i == EQEmu::legacy::SlotCursor)
+			if (i == EQEmu::inventory::slotCursor)
 				UpdateClient = true;
 
 			//EQoffline: will give the items to the bots and change the bot stats
 			if(inst && (GetBotOwner() == client->CastToMob()) && !IsEngaged()) {
 				std::string TempErrorMessage;
-				const EQEmu::ItemBase* mWeaponItem = inst->GetItem();
+				const EQEmu::ItemData* mWeaponItem = inst->GetItem();
 				bool failedLoreCheck = false;
-				for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) {
+				for (int m = EQEmu::inventory::socketBegin; m < EQEmu::inventory::SocketCount; ++m) {
-					ItemInst *itm = inst->GetAugment(m);
+					EQEmu::ItemInstance *itm = inst->GetAugment(m);
 					if(itm)
 					{
 						if(CheckLoreConflict(itm->GetItem())) {
@@ -3415,7 +3415,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 				if(!failedLoreCheck && mWeaponItem && inst->IsEquipable(GetBaseRace(), GetClass()) && (GetLevel() >= mWeaponItem->ReqLevel)) {
 					BotCanWear = true;
 					botCanWear[i] = BotCanWear;
-					ItemInst* swap_item = nullptr;
+					EQEmu::ItemInstance* swap_item = nullptr;
 
 					const char* equipped[EQEmu::legacy::EQUIPMENT_SIZE + 1] = { "Charm", "Left Ear", "Head", "Face", "Right Ear", "Neck", "Shoulders", "Arms", "Back",
 												"Left Wrist", "Right Wrist", "Range", "Hands", "Primary Hand", "Secondary Hand",
@@ -3429,17 +3429,17 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 
 							how_many_slots++;
 							if(!GetBotItem(j)) {
-								if (j == EQEmu::legacy::SlotPrimary) {
+								if (j == EQEmu::inventory::slotPrimary) {
 									if (mWeaponItem->IsType2HWeapon()) {
-										if (GetBotItem(EQEmu::legacy::SlotSecondary)) {
+										if (GetBotItem(EQEmu::inventory::slotSecondary)) {
 											if (mWeaponItem && mWeaponItem->IsType2HWeapon()) {
-												if (client->CheckLoreConflict(GetBotItem(EQEmu::legacy::SlotSecondary)->GetItem())) {
+												if (client->CheckLoreConflict(GetBotItem(EQEmu::inventory::slotSecondary)->GetItem())) {
 													failedLoreCheck = true;
 												}
 											}
 											else {
-												ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotSecondary);
+												EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotSecondary);
-												BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
+												BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
 											}
 										}
 									}
@@ -3449,7 +3449,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 									}
 									break;
 								}
-								else if (j == EQEmu::legacy::SlotSecondary) {
+								else if (j == EQEmu::inventory::slotSecondary) {
 									if(inst->IsWeapon()) {
 										if(CanThisClassDualWield()) {
 											BotTradeAddItem(mWeaponItem->ID, inst, inst->GetCharges(), mWeaponItem->Slots, j, &TempErrorMessage);
@@ -3465,10 +3465,10 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 										success = true;
 									}
 									if(success) {
-										if (GetBotItem(EQEmu::legacy::SlotPrimary)) {
+										if (GetBotItem(EQEmu::inventory::slotPrimary)) {
-											ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotPrimary);
+											EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotPrimary);
 											if (remove_item->GetItem()->IsType2HWeapon()) {
-												BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
+												BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
 											}
 										}
 										break;
@@ -3490,8 +3490,8 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 
 								swap_item = GetBotItem(j);
 								failedLoreCheck = false;
-								for (int k = AUG_INDEX_BEGIN; k < EQEmu::legacy::ITEM_COMMON_SIZE; ++k) {
+								for (int k = EQEmu::inventory::socketBegin; k < EQEmu::inventory::SocketCount; ++k) {
-									ItemInst *itm = swap_item->GetAugment(k);
+									EQEmu::ItemInstance *itm = swap_item->GetAugment(k);
 									if(itm)
 									{
 										if(client->CheckLoreConflict(itm->GetItem())) {
@@ -3503,28 +3503,28 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 									failedLoreCheck = true;
 								}
 								if(!failedLoreCheck) {
-									if (j == EQEmu::legacy::SlotPrimary) {
+									if (j == EQEmu::inventory::slotPrimary) {
 										if (mWeaponItem->IsType2HWeapon()) {
-											if (GetBotItem(EQEmu::legacy::SlotSecondary)) {
+											if (GetBotItem(EQEmu::inventory::slotSecondary)) {
-												if (client->CheckLoreConflict(GetBotItem(EQEmu::legacy::SlotSecondary)->GetItem())) {
+												if (client->CheckLoreConflict(GetBotItem(EQEmu::inventory::slotSecondary)->GetItem())) {
 													failedLoreCheck = true;
 												}
 												else {
-													ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotSecondary);
+													EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotSecondary);
-													BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
+													BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
 												}
 											}
 										}
 										if(!failedLoreCheck) {
-											BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
+											BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
 											success = true;
 										}
 										break;
 									}
-									else if (j == EQEmu::legacy::SlotSecondary) {
+									else if (j == EQEmu::inventory::slotSecondary) {
 										if(inst->IsWeapon()) {
 											if(CanThisClassDualWield()) {
-												BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
+												BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
 												success = true;
 											}
 											else {
@@ -3533,13 +3533,13 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 											}
 										}
 										else {
-											BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
+											BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
 											success = true;
 										}
-										if (success && GetBotItem(EQEmu::legacy::SlotPrimary)) {
+										if (success && GetBotItem(EQEmu::inventory::slotPrimary)) {
-											ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotPrimary);
+											EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotPrimary);
 											if (remove_item->GetItem()->IsType2HWeapon()) {
-												BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
+												BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
 											}
 										}
 										break;
@@ -3574,7 +3574,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
 			}
 		}
 
-		const EQEmu::ItemBase* item2 = 0;
+		const EQEmu::ItemData* item2 = 0;
 		for(int y = beginSlotID; y <= endSlotID; ++y) {
 			item2 = database.GetItem(items[y]);
 			if(item2) {
@@ -3738,14 +3738,14 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
 	}
 
 	FaceTarget(GetTarget());
-	ItemInst* weapon = nullptr;
+	EQEmu::ItemInstance* weapon = nullptr;
-	if (Hand == EQEmu::legacy::SlotPrimary) {
+	if (Hand == EQEmu::inventory::slotPrimary) {
-		weapon = GetBotItem(EQEmu::legacy::SlotPrimary);
+		weapon = GetBotItem(EQEmu::inventory::slotPrimary);
 		OffHandAtk(false);
 	}
 
-	if (Hand == EQEmu::legacy::SlotSecondary) {
+	if (Hand == EQEmu::inventory::slotSecondary) {
-		weapon = GetBotItem(EQEmu::legacy::SlotSecondary);
+		weapon = GetBotItem(EQEmu::inventory::slotSecondary);
 		OffHandAtk(true);
 	}
 
@@ -3810,19 +3810,19 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
 		// This is not recommended for normal usage, as the damage bonus represents a non-trivial component of the DPS output
 		// of weapons wielded by higher-level melee characters (especially for two-handed weapons).
 		int ucDamageBonus = 0;
-		if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass()) {
+		if (Hand == EQEmu::inventory::slotPrimary && GetLevel() >= 28 && IsWarriorClass()) {
 			// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above
 			// who belong to a melee class. If we're here, then all of these conditions apply.
-			ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
+			ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
 			min_hit += (int) ucDamageBonus;
 			max_hit += (int) ucDamageBonus;
 			hate += ucDamageBonus;
 		}
 #endif
 		//Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon.
-		if (Hand == EQEmu::legacy::SlotSecondary) {
+		if (Hand == EQEmu::inventory::slotSecondary) {
 			if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
-				ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
+				ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
 				min_hit += (int) ucDamageBonus;
 				max_hit += (int) ucDamageBonus;
 				hate += ucDamageBonus;
@@ -4280,9 +4280,9 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
 
 	//Check if item focus effect exists for the client.
 	if (itembonuses.FocusEffects[bottype]) {
-		const EQEmu::ItemBase* TempItem = 0;
+		const EQEmu::ItemData* TempItem = 0;
-		const EQEmu::ItemBase* UsedItem = 0;
+		const EQEmu::ItemData* UsedItem = 0;
-		const ItemInst* TempInst = 0;
+		const EQEmu::ItemInstance* TempInst = 0;
 		uint16 UsedFocusID = 0;
 		int32 Total = 0;
 		int32 focus_max = 0;
@@ -4290,7 +4290,7 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
 		//item focus
 		for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++) {
 			TempItem = nullptr;
-			ItemInst* ins = GetBotItem(x);
+			EQEmu::ItemInstance* ins = GetBotItem(x);
 			if (!ins)
 				continue;
 
@@ -4313,11 +4313,11 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
 				}
 			}
 
-			for (int y = AUG_INDEX_BEGIN; y < EQEmu::legacy::ITEM_COMMON_SIZE; ++y) {
+			for (int y = EQEmu::inventory::socketBegin; y < EQEmu::inventory::SocketCount; ++y) {
-				ItemInst *aug = nullptr;
+				EQEmu::ItemInstance *aug = nullptr;
 				aug = ins->GetAugment(y);
 				if(aug) {
-					const EQEmu::ItemBase* TempItemAug = aug->GetItem();
+					const EQEmu::ItemData* TempItemAug = aug->GetItem();
 					if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) {
 						if(rand_effectiveness) {
 							focus_max = CalcBotFocusEffect(bottype, TempItemAug->Focus.Effect, spell_id, true);
@@ -4749,13 +4749,13 @@ float Bot::GetProcChances(float ProcBonus, uint16 hand) {
 	float ProcChance = 0.0f;
 	uint32 weapon_speed = 0;
 	switch (hand) {
-	case EQEmu::legacy::SlotPrimary:
+	case EQEmu::inventory::slotPrimary:
 		weapon_speed = attack_timer.GetDuration();
 		break;
-	case EQEmu::legacy::SlotSecondary:
+	case EQEmu::inventory::slotSecondary:
 		weapon_speed = attack_dw_timer.GetDuration();
 		break;
-	case EQEmu::legacy::SlotRange:
+	case EQEmu::inventory::slotRange:
 		weapon_speed = ranged_timer.GetDuration();
 		break;
 	}
@@ -4781,7 +4781,7 @@ int Bot::GetHandToHandDamage(void) {
 		// everyone uses this in the revamp!
 		int skill = GetSkill(EQEmu::skills::SkillHandtoHand);
 		int epic = 0;
-		if (CastToNPC()->GetEquipment(EQEmu::textures::TextureHands) == 10652 && GetLevel() > 46)
+		if (CastToNPC()->GetEquipment(EQEmu::textures::armorHands) == 10652 && GetLevel() > 46)
 			epic = 280;
 		if (epic > skill)
 			skill = epic;
@@ -4803,7 +4803,7 @@ int Bot::GetHandToHandDamage(void) {
 				9, 9, 9, 9, 9, 10, 10, 10, 10, 10,   // 31-40
 				10, 11, 11, 11, 11, 11, 11, 12, 12}; // 41-49
 	if (GetClass() == MONK) {
-		if (CastToNPC()->GetEquipment(EQEmu::textures::TextureHands) == 10652 && GetLevel() > 50)
+		if (CastToNPC()->GetEquipment(EQEmu::textures::armorHands) == 10652 && GetLevel() > 50)
 			return 9;
 		if (level > 62)
 			return 15;
@@ -4842,11 +4842,11 @@ void Bot::DoRiposte(Mob* defender) {
 	if (!defender)
 		return;
 
-	defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
+	defender->Attack(this, EQEmu::inventory::slotPrimary, true);
 	int32 DoubleRipChance = (defender->GetAABonuses().GiveDoubleRiposte[0] + defender->GetSpellBonuses().GiveDoubleRiposte[0] + defender->GetItemBonuses().GiveDoubleRiposte[0]);
 	if(DoubleRipChance && (DoubleRipChance >= zone->random.Int(0, 100))) {
 		Log.Out(Logs::Detail, Logs::Combat, "Preforming a double riposte (%d percent chance)", DoubleRipChance);
-		defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
+		defender->Attack(this, EQEmu::inventory::slotPrimary, true);
 	}
 
 	DoubleRipChance = defender->GetAABonuses().GiveDoubleRiposte[1];
@@ -4864,8 +4864,8 @@ void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
 		hate = hate_override;
 
 	if (skill == EQEmu::skills::SkillBash) {
-		const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
+		const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
-		const EQEmu::ItemBase* botweapon = 0;
+		const EQEmu::ItemData* botweapon = 0;
 		if(inst)
 			botweapon = inst->GetItem();
 
@@ -4878,14 +4878,14 @@ void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
 	}
 
 	min_damage += (min_damage * GetMeleeMinDamageMod_SE(skill) / 100);
-	int hand = EQEmu::legacy::SlotPrimary;
+	int hand = EQEmu::inventory::slotPrimary;
 	if (skill == EQEmu::skills::SkillThrowing || skill == EQEmu::skills::SkillArchery)
-		hand = EQEmu::legacy::SlotRange;
+		hand = EQEmu::inventory::slotRange;
 	if (who->AvoidDamage(this, max_damage, hand)) {
 		if (max_damage == -3)
 			DoRiposte(who);
 	} else {
-		if (HitChance || who->CheckHitChance(this, skill, EQEmu::legacy::SlotPrimary)) {
+		if (HitChance || who->CheckHitChance(this, skill, EQEmu::inventory::slotPrimary)) {
 			who->MeleeMitigation(this, max_damage, min_damage);
 			ApplyMeleeDamageBonus(skill, max_damage);
 			max_damage += who->GetFcDamageAmtIncoming(this, 0, true, skill);
@@ -4929,8 +4929,8 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
 
 	bool bIsBehind = false;
 	bool bCanFrontalBS = false;
-	const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotPrimary);
+	const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotPrimary);
-	const EQEmu::ItemBase* botpiercer = nullptr;
+	const EQEmu::ItemData* botpiercer = nullptr;
 	if(inst)
 		botpiercer = inst->GetItem();
 
@@ -4979,7 +4979,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
 		}
 	}
 	else
-		Attack(other, EQEmu::legacy::SlotPrimary);
+		Attack(other, EQEmu::inventory::slotPrimary);
 }
 
 void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
@@ -4989,12 +4989,12 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
 	int32 hate = 0;
 	int32 primaryweapondamage = 0;
 	int32 backstab_dmg = 0;
-	ItemInst* botweaponInst = GetBotItem(EQEmu::legacy::SlotPrimary);
+	EQEmu::ItemInstance* botweaponInst = GetBotItem(EQEmu::inventory::slotPrimary);
 	if(botweaponInst) {
 		primaryweapondamage = GetWeaponDamage(other, botweaponInst);
 		backstab_dmg = botweaponInst->GetItem()->BackstabDmg;
-		for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; ++i) {
+		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; ++i) {
-			ItemInst *aug = botweaponInst->GetAugment(i);
+			EQEmu::ItemInstance *aug = botweaponInst->GetAugment(i);
 			if(aug)
 				backstab_dmg += aug->GetItem()->BackstabDmg;
 		}
@@ -5037,7 +5037,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
 }
 
 void Bot::RogueAssassinate(Mob* other) {
-	ItemInst* botweaponInst = GetBotItem(EQEmu::legacy::SlotPrimary);
+	EQEmu::ItemInstance* botweaponInst = GetBotItem(EQEmu::inventory::slotPrimary);
 	if(botweaponInst) {
 		if(GetWeaponDamage(other, botweaponInst))
 			other->Damage(this, 32000, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
@@ -5103,7 +5103,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 		case WARRIOR:
 			if(level >= RuleI(Combat, NPCBashKickLevel)){
 				bool canBash = false;
-				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::legacy::SlotSecondary) && m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::legacy::SlotPrimary) && m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
+				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::inventory::slotSecondary) && m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::inventory::slotPrimary) && m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
 					canBash = true;
 
 				if(!canBash || zone->random.Int(0, 100) > 25)
@@ -5122,7 +5122,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 		case SHADOWKNIGHT:
 		case PALADIN:
 			if(level >= RuleI(Combat, NPCBashKickLevel)){
-				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::legacy::SlotSecondary) && m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::legacy::SlotPrimary) && m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
+				if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::inventory::slotSecondary) && m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::inventory::slotPrimary) && m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
 					skill_to_use = EQEmu::skills::SkillBash;
 			}
 			break;
@@ -5151,7 +5151,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 	if (skill_to_use == EQEmu::skills::SkillBash) {
 		if (target != this) {
 			DoAnim(animTailRake);
-			if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotSecondary)) <= 0 && GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotShoulders)) <= 0)
+			if (GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotSecondary)) <= 0 && GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotShoulders)) <= 0)
 				dmg = -5;
 			else {
 				if (!target->CheckHitChance(this, EQEmu::skills::SkillBash, 0))
@@ -5201,7 +5201,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
 	if (skill_to_use == EQEmu::skills::SkillKick) {
 		if(target != this) {
 			DoAnim(animKick);
-			if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotFeet)) <= 0)
+			if (GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotFeet)) <= 0)
 				dmg = -5;
 			else {
 				if (!target->CheckHitChance(this, EQEmu::skills::SkillKick, 0))
@@ -5366,8 +5366,8 @@ bool Bot::IsBotAttackAllowed(Mob* attacker, Mob* target, bool& hasRuleDefined) {
 
 void Bot::EquipBot(std::string* errorMessage) {
 	GetBotItems(m_inv, errorMessage);
-	const ItemInst* inst = 0;
+	const EQEmu::ItemInstance* inst = 0;
-	const EQEmu::ItemBase* item = 0;
+	const EQEmu::ItemData* item = 0;
 	for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
 		inst = GetBotItem(i);
 		if(inst) {
@@ -5494,23 +5494,23 @@ void Bot::SetAttackTimer() {
 	float haste_mod = (GetHaste() * 0.01f);
 	attack_timer.SetAtTrigger(4000, true);
 	Timer* TimerToUse = nullptr;
-	const EQEmu::ItemBase* PrimaryWeapon = nullptr;
+	const EQEmu::ItemData* PrimaryWeapon = nullptr;
-	for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
+	for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
-		if (i == EQEmu::legacy::SlotPrimary)
+		if (i == EQEmu::inventory::slotPrimary)
 			TimerToUse = &attack_timer;
-		else if (i == EQEmu::legacy::SlotRange)
+		else if (i == EQEmu::inventory::slotRange)
 			TimerToUse = &ranged_timer;
-		else if (i == EQEmu::legacy::SlotSecondary)
+		else if (i == EQEmu::inventory::slotSecondary)
 			TimerToUse = &attack_dw_timer;
 		else
 			continue;
 
-		const EQEmu::ItemBase* ItemToUse = nullptr;
+		const EQEmu::ItemData* ItemToUse = nullptr;
-		ItemInst* ci = GetBotItem(i);
+		EQEmu::ItemInstance* ci = GetBotItem(i);
 		if (ci)
 			ItemToUse = ci->GetItem();
 
-		if (i == EQEmu::legacy::SlotSecondary) {
+		if (i == EQEmu::inventory::slotSecondary) {
 			if (PrimaryWeapon != nullptr) {
 				if (PrimaryWeapon->IsClassCommon() && PrimaryWeapon->IsType2HWeapon()) {
 					attack_dw_timer.Disable();
@@ -5541,7 +5541,7 @@ void Bot::SetAttackTimer() {
 		speed = (RuleB(Spells, Jun182014HundredHandsRevamp) ? static_cast<int>(((delay / haste_mod) + ((hhe / 1000.0f) * (delay / haste_mod))) * 100) : static_cast<int>(((delay / haste_mod) + ((hhe / 100.0f) * delay)) * 100));
 		TimerToUse->SetAtTrigger(std::max(RuleI(Combat, MinHastedDelay), speed), true);
 
-		if (i == EQEmu::legacy::SlotPrimary)
+		if (i == EQEmu::inventory::slotPrimary)
 			PrimaryWeapon = ItemToUse;
 	}
 }
@@ -7180,13 +7180,13 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
 		insr->TargetID = inspectedBot->GetNPCTypeID();
 		insr->playerid = inspectedBot->GetID();
 
-		const EQEmu::ItemBase* item = 0;
+		const EQEmu::ItemData* item = 0;
-		const ItemInst* inst = 0;
+		const EQEmu::ItemInstance* inst = 0;
 
 		// Modded to display power source items (will only show up on SoF+ client inspect windows though.)
 		// I don't think bots are currently coded to use them..but, you'll have to use '#bot inventory list'
 		// to see them on a Titanium client when/if they are activated.
-		for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::legacy::SlotWaist; L++) {
+		for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::inventory::slotWaist; L++) {
 			inst = inspectedBot->GetBotItem(L);
 
 			if(inst) {
@@ -7200,7 +7200,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
 			}
 		}
 
-		inst = inspectedBot->GetBotItem(EQEmu::legacy::SlotPowerSource);
+		inst = inspectedBot->GetBotItem(EQEmu::inventory::slotPowerSource);
 
 		if(inst) {
 			item = inst->GetItem();
@@ -7212,7 +7212,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
 				insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
 		}
 
-		inst = inspectedBot->GetBotItem(EQEmu::legacy::SlotAmmo);
+		inst = inspectedBot->GetBotItem(EQEmu::inventory::slotAmmo);
 
 		if(inst) {
 			item = inst->GetItem();
@@ -7232,10 +7232,10 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
 
 void Bot::CalcItemBonuses(StatBonuses* newbon)
 {
-	const EQEmu::ItemBase* itemtmp = 0;
+	const EQEmu::ItemData* itemtmp = 0;
 
 	for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
-		const ItemInst* item = GetBotItem((i == 22 ? 9999 : i));
+		const EQEmu::ItemInstance* item = GetBotItem((i == 22 ? 9999 : i));
 		if(item) {
 			AddItemBonuses(item, newbon);
 		}
@@ -7252,7 +7252,7 @@ void Bot::CalcItemBonuses(StatBonuses* newbon)
 		newbon->EnduranceRegen = CalcEnduranceRegenCap();
 }
 
-void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute, int rec_override) {
+void Bot::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug, bool isTribute, int rec_override) {
 	if (!inst || !inst->IsClassCommon())
 	{
 		return;
@@ -7263,7 +7263,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
 		return;
 	}
 
-	const EQEmu::ItemBase *item = inst->GetItem();
+	const EQEmu::ItemData *item = inst->GetItem();
 
 	if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass()))
 	{
@@ -7547,7 +7547,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
 
 	if (!isAug)
 	{
-		for (int i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++)
+		for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++)
 			AddItemBonuses(inst->GetAugment(i),newbon,true, false, rec_level);
 	}
 
@@ -7630,7 +7630,7 @@ void Bot::CalcBotStats(bool showtext) {
 	}
 }
 
-bool Bot::CheckLoreConflict(const EQEmu::ItemBase* item) {
+bool Bot::CheckLoreConflict(const EQEmu::ItemData* item) {
 	if (!item || !(item->LoreFlag))
 		return false;
 
@@ -8036,12 +8036,12 @@ uint8 Bot::GetNumberNeedingHealedInGroup(uint8 hpr, bool includePets) {
 int Bot::GetRawACNoShield(int &shield_ac) {
 	int ac = itembonuses.AC + spellbonuses.AC;
 	shield_ac = 0;
-	ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
+	EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
 	if(inst) {
 		if (inst->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
 			ac -= inst->GetItem()->AC;
 			shield_ac = inst->GetItem()->AC;
-			for (uint8 i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (uint8 i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 				if(inst->GetAugment(i)) {
 					ac -= inst->GetAugment(i)->GetItem()->AC;
 					shield_ac += inst->GetAugment(i)->GetItem()->AC;
@@ -8053,8 +8053,8 @@ int Bot::GetRawACNoShield(int &shield_ac) {
 }
 
 uint32 Bot::CalcCurrentWeight() {
-	const EQEmu::ItemBase* TempItem = 0;
+	const EQEmu::ItemData* TempItem = 0;
-	ItemInst* inst;
+	EQEmu::ItemInstance* inst;
 	uint32 Total = 0;
 	for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
 		inst = GetBotItem(i);
@@ -8433,9 +8433,9 @@ bool Bot::DyeArmor(int16 slot_id, uint32 rgb, bool all_flag, bool save_flag)
 		if (slot_id != INVALID_INDEX)
 			return false;
 
-		for (uint8 i = 0; i < EQEmu::textures::TexturePrimary; ++i) {
+		for (uint8 i = EQEmu::textures::textureBegin; i < EQEmu::textures::weaponPrimary; ++i) {
-			uint8 inv_slot = Inventory::CalcSlotFromMaterial(i);
+			uint8 inv_slot = EQEmu::InventoryProfile::CalcSlotFromMaterial(i);
-			ItemInst* inst = m_inv.GetItem(inv_slot);
+			EQEmu::ItemInstance* inst = m_inv.GetItem(inv_slot);
 			if (!inst)
 				continue;
 
@@ -8444,11 +8444,11 @@ bool Bot::DyeArmor(int16 slot_id, uint32 rgb, bool all_flag, bool save_flag)
 		}
 	}
 	else {
-		uint8 mat_slot = Inventory::CalcMaterialFromSlot(slot_id);
+		uint8 mat_slot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot_id);
-		if (mat_slot == EQEmu::textures::TextureInvalid || mat_slot >= EQEmu::textures::TexturePrimary)
+		if (mat_slot == EQEmu::textures::materialInvalid || mat_slot >= EQEmu::textures::weaponPrimary)
 			return false;
 
-		ItemInst* inst = m_inv.GetItem(slot_id);
+		EQEmu::ItemInstance* inst = m_inv.GetItem(slot_id);
 		if (!inst)
 			return false;
 

zone/bot.h

@@ -77,7 +77,7 @@ static const std::string bot_stance_name[BOT_STANCE_COUNT] = {
 
 static const char* GetBotStanceName(int stance_id) { return bot_stance_name[VALIDBOTSTANCE(stance_id)].c_str(); }
 
-#define VALIDBOTEQUIPSLOT(x) ((x >= EQEmu::legacy::EQUIPMENT_BEGIN && x <= EQEmu::legacy::EQUIPMENT_END) ? (x) : ((x == EQEmu::legacy::SlotPowerSource) ? (22) : (23)))
+#define VALIDBOTEQUIPSLOT(x) ((x >= EQEmu::legacy::EQUIPMENT_BEGIN && x <= EQEmu::legacy::EQUIPMENT_END) ? (x) : ((x == EQEmu::inventory::slotPowerSource) ? (22) : (23)))
 
 static std::string bot_equip_slot_name[EQEmu::legacy::EQUIPMENT_SIZE + 2] =
 {
@@ -207,7 +207,7 @@ public:
 	//abstract virtual function implementations requird by base abstract class
 	virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
 	virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
-	virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
+	virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
 		ExtraAttackOptions *opts = nullptr, int special = 0);
 	virtual bool HasRaid() { return (GetRaid() ? true : false); }
 	virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -260,7 +260,7 @@ public:
 	virtual int32 CheckAggroAmount(uint16 spellid);
 	virtual void CalcBonuses();
 	void CalcItemBonuses(StatBonuses* newbon);
-	void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
+	void AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
 	int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
 	virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
 	virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther);
@@ -382,10 +382,10 @@ public:
 	virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQEmu::CastingSlot slot = EQEmu::CastingSlot::Item, int32 casttime = -1, int32 mana_cost = -1, uint32* oSpellWillFinish = 0, uint32 item_slot = 0xFFFFFFFF, uint32 aa_id = 0);
 
 	// Bot Equipment & Inventory Class Methods
-	void BotTradeSwapItem(Client* client, int16 lootSlot, const ItemInst* inst, const ItemInst* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap = true);
+	void BotTradeSwapItem(Client* client, int16 lootSlot, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap = true);
-	void BotTradeAddItem(uint32 id, const ItemInst* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
+	void BotTradeAddItem(uint32 id, const EQEmu::ItemInstance* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
 	void EquipBot(std::string* errorMessage);
-	bool CheckLoreConflict(const EQEmu::ItemBase* item);
+	bool CheckLoreConflict(const EQEmu::ItemData* item);
 	virtual void UpdateEquipmentLight() { m_Light.Type[EQEmu::lightsource::LightEquipment] = m_inv.FindBrightestLightType(); m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]); }
 
 	// Static Class Methods	
@@ -457,7 +457,7 @@ public:
 	uint32 GetBotSpellID() { return npc_spells_id; }
 	Mob* GetBotOwner() { return this->_botOwner; }
 	uint32 GetBotArcheryRange();
-	ItemInst* GetBotItem(uint32 slotID);
+	EQEmu::ItemInstance* GetBotItem(uint32 slotID);
 	virtual bool GetSpawnStatus() { return _spawnStatus; }
 	uint8 GetPetChooserID() { return _petChooserID; }
 	bool IsPetChooser() { return _petChooser; }
@@ -647,7 +647,7 @@ private:
 	bool _petChooser;
 	uint8 _petChooserID;
 	bool berserk;
-	Inventory m_inv;
+	EQEmu::InventoryProfile m_inv;
 	double _lastTotalPlayTime;
 	time_t _startTotalPlayTime;
 	Mob* _previousTarget;
@@ -711,7 +711,7 @@ private:
 	void SetBotID(uint32 botID);
 
 	// Private "Inventory" Methods
-	void GetBotItems(Inventory &inv, std::string* errorMessage);
+	void GetBotItems(EQEmu::InventoryProfile &inv, std::string* errorMessage);
 	void BotAddEquipItem(int slot, uint32 id);
 	uint32 GetBotItemBySlot(uint32 slotID);
 

zone/bot_command.cpp

@@ -2402,7 +2402,7 @@ namespace ActionableBots
 
 			mod_skill_value = base_skill_value;
 			for (int16 index = EQEmu::legacy::EQUIPMENT_BEGIN; index <= EQEmu::legacy::EQUIPMENT_END; ++index) {
-				const ItemInst* indexed_item = bot_iter->GetBotItem(index);
+				const EQEmu::ItemInstance* indexed_item = bot_iter->GetBotItem(index);
 				if (indexed_item && indexed_item->GetItem()->SkillModType == skill_type)
 					mod_skill_value += (base_skill_value * (((float)indexed_item->GetItem()->SkillModValue) / 100.0f));
 			}
@@ -3397,15 +3397,18 @@ void bot_command_movement_speed(Client *c, const Seperator *sep)
 	if (helper_spell_list_fail(c, local_list, BCEnum::SpT_MovementSpeed) || helper_command_alias_fail(c, "bot_command_movement_speed", sep->arg[0], "movementspeed"))
 		return;
 	if (helper_is_help_or_usage(sep->arg[1])) {
-		c->Message(m_usage, "usage: (<friendly_target>) %s ([group])", sep->arg[0]);
+		c->Message(m_usage, "usage: (<friendly_target>) %s ([group | sow])", sep->arg[0]);
 		helper_send_usage_required_bots(c, BCEnum::SpT_MovementSpeed);
 		return;
 	}
 
 	bool group = false;
-	std::string group_arg = sep->arg[1];
+	bool sow = false;
-	if (!group_arg.compare("group"))
+	std::string arg1 = sep->arg[1];
+	if (!arg1.compare("group"))
 		group = true;
+	else if (!arg1.compare("sow"))
+		sow = true;
 
 	ActionableTarget::Types actionable_targets;
 	Bot* my_bot = nullptr;
@@ -3417,7 +3420,9 @@ void bot_command_movement_speed(Client *c, const Seperator *sep)
 		auto local_entry = list_iter->SafeCastToMovementSpeed();
 		if (helper_spell_check_fail(local_entry))
 			continue;
-		if (local_entry->group != group)
+		if (!sow && (local_entry->group != group))
+			continue;
+		if (sow && (local_entry->spell_id != 278)) // '278' = single-target "Spirit of Wolf"
 			continue;
 
 		auto target_mob = actionable_targets.Select(c, local_entry->target_type, FRIENDLY);
@@ -4358,7 +4363,7 @@ void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep)
 	// TODO: Trouble-shoot model update issue
 	
 	const std::string msg_matslot = StringFormat("mat_slot: %c(All), %i(Head), %i(Chest), %i(Arms), %i(Wrists), %i(Hands), %i(Legs), %i(Feet)",
-		'*', EQEmu::textures::TextureHead, EQEmu::textures::TextureChest, EQEmu::textures::TextureArms, EQEmu::textures::TextureWrist, EQEmu::textures::TextureHands, EQEmu::textures::TextureLegs, EQEmu::textures::TextureFeet);
+		'*', EQEmu::textures::armorHead, EQEmu::textures::armorChest, EQEmu::textures::armorArms, EQEmu::textures::armorWrist, EQEmu::textures::armorHands, EQEmu::textures::armorLegs, EQEmu::textures::armorFeet);
 	
 	if (helper_command_alias_fail(c, "bot_subcommand_bot_dye_armor", sep->arg[0], "botdyearmor"))
 		return;
@@ -4369,15 +4374,15 @@ void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep)
 	}
 	const int ab_mask = ActionableBots::ABM_NoFilter;
 
-	uint8 material_slot = EQEmu::textures::TextureInvalid;
+	uint8 material_slot = EQEmu::textures::materialInvalid;
 	int16 slot_id = INVALID_INDEX;
 
 	bool dye_all = (sep->arg[1][0] == '*');
 	if (!dye_all) {
 		material_slot = atoi(sep->arg[1]);
-		slot_id = Inventory::CalcSlotFromMaterial(material_slot);
+		slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
 
-		if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQEmu::textures::TextureFeet) {
+		if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQEmu::textures::LastTintableTexture) {
 			c->Message(m_fail, "Valid [mat_slot]s for this command are:");
 			c->Message(m_fail, msg_matslot.c_str());
 			return;
@@ -7062,8 +7067,8 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
 		return;
 	}
 
-	const ItemInst* inst = nullptr;
+	const EQEmu::ItemInstance* inst = nullptr;
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
 	bool is2Hweapon = false;
 
 	std::string item_link;
@@ -7072,23 +7077,23 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
 
 	uint32 inventory_count = 0;
 	for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
-		if ((i == EQEmu::legacy::SlotSecondary) && is2Hweapon)
+		if ((i == EQEmu::inventory::slotSecondary) && is2Hweapon)
 			continue;
 
-		inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i);
+		inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::inventory::slotPowerSource : i);
 		if (!inst || !inst->GetItem()) {
-			c->Message(m_message, "I need something for my %s (slot %i)", GetBotEquipSlotName(i), (i == 22 ? EQEmu::legacy::SlotPowerSource : i));
+			c->Message(m_message, "I need something for my %s (slot %i)", GetBotEquipSlotName(i), (i == 22 ? EQEmu::inventory::slotPowerSource : i));
 			continue;
 		}
 		
 		item = inst->GetItem();
-		if ((i == EQEmu::legacy::SlotPrimary) && item->IsType2HWeapon()) {
+		if ((i == EQEmu::inventory::slotPrimary) && item->IsType2HWeapon()) {
 			is2Hweapon = true;
 		}
 
 		linker.SetItemInst(inst);
 		item_link = linker.GenerateLink();
-		c->Message(m_message, "Using %s in my %s (slot %i)", item_link.c_str(), GetBotEquipSlotName(i), (i == 22 ? EQEmu::legacy::SlotPowerSource : i));
+		c->Message(m_message, "Using %s in my %s (slot %i)", item_link.c_str(), GetBotEquipSlotName(i), (i == 22 ? EQEmu::inventory::slotPowerSource : i));
 
 		++inventory_count;
 	}
@@ -7127,13 +7132,13 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
 	}
 
 	int slotId = atoi(sep->arg[1]);
-	if (!sep->IsNumber(1) || ((slotId > EQEmu::legacy::EQUIPMENT_END || slotId < EQEmu::legacy::EQUIPMENT_BEGIN) && slotId != EQEmu::legacy::SlotPowerSource)) {
+	if (!sep->IsNumber(1) || ((slotId > EQEmu::legacy::EQUIPMENT_END || slotId < EQEmu::legacy::EQUIPMENT_BEGIN) && slotId != EQEmu::inventory::slotPowerSource)) {
 		c->Message(m_fail, "Valid slots are 0-21 or 9999");
 		return;
 	}
 
-	const EQEmu::ItemBase* itm = nullptr;
+	const EQEmu::ItemData* itm = nullptr;
-	const ItemInst* itminst = my_bot->GetBotItem(slotId);
+	const EQEmu::ItemInstance* itminst = my_bot->GetBotItem(slotId);
 	if (itminst)
 		itm = itminst->GetItem();
 
@@ -7142,11 +7147,11 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
 		return;
 	}
 
-	for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) {
+	for (int m = EQEmu::inventory::socketBegin; m < EQEmu::inventory::SocketCount; ++m) {
 		if (!itminst)
 			break;
 
-		ItemInst *itma = itminst->GetAugment(m);
+		EQEmu::ItemInstance *itma = itminst->GetAugment(m);
 		if (!itma)
 			continue;
 		if (!c->CheckLoreConflict(itma->GetItem()))
@@ -7159,7 +7164,7 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
 	std::string error_message;
 	if (itm) {
 		c->PushItemOnCursor(*itminst, true);
-		if ((slotId == EQEmu::legacy::SlotRange) || (slotId == EQEmu::legacy::SlotAmmo) || (slotId == EQEmu::legacy::SlotPrimary) || (slotId == EQEmu::legacy::SlotSecondary))
+		if ((slotId == EQEmu::inventory::slotRange) || (slotId == EQEmu::inventory::slotAmmo) || (slotId == EQEmu::inventory::slotPrimary) || (slotId == EQEmu::inventory::slotSecondary))
 			my_bot->SetBotArcher(false);
 
 		my_bot->RemoveBotItemBySlot(slotId, &error_message);
@@ -7173,31 +7178,31 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
 	}
 
 	switch (slotId) {
-	case EQEmu::legacy::SlotCharm:
+	case EQEmu::inventory::slotCharm:
-	case EQEmu::legacy::SlotEar1:
+	case EQEmu::inventory::slotEar1:
-	case EQEmu::legacy::SlotHead:
+	case EQEmu::inventory::slotHead:
-	case EQEmu::legacy::SlotFace:
+	case EQEmu::inventory::slotFace:
-	case EQEmu::legacy::SlotEar2:
+	case EQEmu::inventory::slotEar2:
-	case EQEmu::legacy::SlotNeck:
+	case EQEmu::inventory::slotNeck:
-	case EQEmu::legacy::SlotBack:
+	case EQEmu::inventory::slotBack:
-	case EQEmu::legacy::SlotWrist1:
+	case EQEmu::inventory::slotWrist1:
-	case EQEmu::legacy::SlotWrist2:
+	case EQEmu::inventory::slotWrist2:
-	case EQEmu::legacy::SlotRange:
+	case EQEmu::inventory::slotRange:
-	case EQEmu::legacy::SlotPrimary:
+	case EQEmu::inventory::slotPrimary:
-	case EQEmu::legacy::SlotSecondary:
+	case EQEmu::inventory::slotSecondary:
-	case EQEmu::legacy::SlotFinger1:
+	case EQEmu::inventory::slotFinger1:
-	case EQEmu::legacy::SlotFinger2:
+	case EQEmu::inventory::slotFinger2:
-	case EQEmu::legacy::SlotChest:
+	case EQEmu::inventory::slotChest:
-	case EQEmu::legacy::SlotWaist:
+	case EQEmu::inventory::slotWaist:
-	case EQEmu::legacy::SlotPowerSource:
+	case EQEmu::inventory::slotPowerSource:
-	case EQEmu::legacy::SlotAmmo:
+	case EQEmu::inventory::slotAmmo:
 		c->Message(m_message, "My %s is %s unequipped", GetBotEquipSlotName(slotId), ((itm) ? ("now") : ("already")));
 		break;
-	case EQEmu::legacy::SlotShoulders:
+	case EQEmu::inventory::slotShoulders:
-	case EQEmu::legacy::SlotArms:
+	case EQEmu::inventory::slotArms:
-	case EQEmu::legacy::SlotHands:
+	case EQEmu::inventory::slotHands:
-	case EQEmu::legacy::SlotLegs:
+	case EQEmu::inventory::slotLegs:
-	case EQEmu::legacy::SlotFeet:
+	case EQEmu::inventory::slotFeet:
 		c->Message(m_message, "My %s are %s unequipped", GetBotEquipSlotName(slotId), ((itm) ? ("now") : ("already")));
 		break;
 	default:
@@ -7235,13 +7240,13 @@ void bot_subcommand_inventory_window(Client *c, const Seperator *sep)
 	//linker.SetLinkType(linker.linkItemInst);
 
 	for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
-		const ItemInst* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i);
+		const EQEmu::ItemInstance* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::inventory::slotPowerSource : i);
 		if (inst)
 			item = inst->GetItem();
 
 		window_text.append("<c \"#FFFFFF\">");
-		window_text.append(GetBotEquipSlotName(i == 22 ? EQEmu::legacy::SlotPowerSource : i));
+		window_text.append(GetBotEquipSlotName(i == 22 ? EQEmu::inventory::slotPowerSource : i));
 		window_text.append(": ");
 		if (item) {
 			//window_text.append("</c>");

zone/bot_database.cpp

@@ -1023,7 +1023,7 @@ bool BotDatabase::QueryInventoryCount(const uint32 bot_id, uint32& item_count)
 	return true;
 }
 
-bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
+bool BotDatabase::LoadItems(const uint32 bot_id, EQEmu::InventoryProfile& inventory_inst)
 {
 	if (!bot_id)
 		return false;
@@ -1058,13 +1058,13 @@ bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
 	
 	for (auto row = results.begin(); row != results.end(); ++row) {
 		int16 slot_id = atoi(row[0]);
-		if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::legacy::SlotPowerSource)
+		if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::inventory::slotPowerSource)
 			continue;
 
 		uint32 item_id = atoi(row[1]);
 		uint16 item_charges = (uint16)atoi(row[2]);
 
-		ItemInst* item_inst = database.CreateItem(
+		EQEmu::ItemInstance* item_inst = database.CreateItem(
 			item_id,
 			item_charges,
 			(uint32)atoul(row[9]),
@@ -1093,7 +1093,7 @@ bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
 		if (item_inst->GetItem()->Attuneable) {
 			if (atoi(row[4]))
 				item_inst->SetAttuned(true);
-			else if (((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || slot_id == EQEmu::legacy::SlotPowerSource))
+			else if (((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || slot_id == EQEmu::inventory::slotPowerSource))
 				item_inst->SetAttuned(true);
 		}
 
@@ -1161,7 +1161,7 @@ bool BotDatabase::LoadItemBySlot(Bot* bot_inst)
 
 bool BotDatabase::LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint32& item_id)
 {
-	if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
+	if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
 		return false;
 	
 	query = StringFormat("SELECT `item_id` FROM `bot_inventories` WHERE `bot_id` = '%i' AND `slot_id` = '%i' LIMIT 1", bot_id, slot_id);
@@ -1177,9 +1177,9 @@ bool BotDatabase::LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint
 	return true;
 }
 
-bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const ItemInst* item_inst)
+bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::ItemInstance* item_inst)
 {
-	if (!bot_inst || !bot_inst->GetBotID() || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
+	if (!bot_inst || !bot_inst->GetBotID() || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
 		return false;
 
 	if (!DeleteItemBySlot(bot_inst->GetBotID(), slot_id))
@@ -1188,8 +1188,8 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const Item
 	if (!item_inst || !item_inst->GetID())
 		return true;
 	
-	uint32 augment_id[] = { 0, 0, 0, 0, 0, 0 };
+	uint32 augment_id[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
-	for (int augment_iter = 0; augment_iter < EQEmu::legacy::ITEM_COMMON_SIZE; ++augment_iter)
+	for (int augment_iter = EQEmu::inventory::socketBegin; augment_iter < EQEmu::inventory::SocketCount; ++augment_iter)
 		augment_id[augment_iter] = item_inst->GetAugmentItemID(augment_iter);
 	
 	uint16 item_charges = 0;
@@ -1263,7 +1263,7 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const Item
 
 bool BotDatabase::DeleteItemBySlot(const uint32 bot_id, const uint32 slot_id)
 {
-	if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
+	if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
 		return false;
 
 	query = StringFormat("DELETE FROM `bot_inventories` WHERE `bot_id` = '%u' AND `slot_id` = '%u'", bot_id, slot_id);
@@ -1279,7 +1279,7 @@ bool BotDatabase::LoadEquipmentColor(const uint32 bot_id, const uint8 material_s
 	if (!bot_id)
 		return false;
 
-	int16 slot_id = Inventory::CalcSlotFromMaterial(material_slot_id);
+	int16 slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot_id);
 	if (slot_id == INVALID_INDEX)
 		return false;
 	
@@ -1302,12 +1302,12 @@ bool BotDatabase::SaveEquipmentColor(const uint32 bot_id, const int16 slot_id, c
 		return false;
 
 	bool all_flag = (slot_id == -2);
-	if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::legacy::SlotPowerSource && !all_flag)
+	if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::inventory::slotPowerSource && !all_flag)
 		return false;
 
 	std::string where_clause;
 	if (all_flag)
-		where_clause = StringFormat(" AND `slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u')", EQEmu::legacy::SlotHead, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet);
+		where_clause = StringFormat(" AND `slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u')", EQEmu::inventory::slotHead, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotHands, EQEmu::inventory::slotChest, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet);
 	else
 		where_clause = StringFormat(" AND `slot_id` = '%u'", slot_id);
 
@@ -1752,7 +1752,7 @@ bool BotDatabase::SaveAllArmorColorBySlot(const uint32 owner_id, const int16 slo
 		" AND bi.`slot_id` = '%i'",
 		owner_id,
 		rgb_value,
-		EQEmu::legacy::SlotHead, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotWrist2, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet,
+		EQEmu::inventory::slotHead, EQEmu::inventory::slotChest, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotWrist2, EQEmu::inventory::slotHands, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet,
 		slot_id
 	);
 	auto results = QueryDatabase(query);
@@ -1776,7 +1776,7 @@ bool BotDatabase::SaveAllArmorColors(const uint32 owner_id, const uint32 rgb_val
 		" AND bi.`slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u', '%u')",
 		owner_id,
 		rgb_value,
-		EQEmu::legacy::SlotHead, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotWrist2, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet
+		EQEmu::inventory::slotHead, EQEmu::inventory::slotChest, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotWrist2, EQEmu::inventory::slotHands, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet
 	);
 	auto results = QueryDatabase(query);
 	if (!results.Success())

zone/bot_database.h

@@ -31,10 +31,14 @@
 
 
 class Bot;
-class ItemInst;
-class Inventory;
 struct BotsAvailableList;
 
+namespace EQEmu
+{
+	class ItemInstance;
+	class InventoryProfile;
+}
+
 
 class BotDatabase : public DBcore
 {
@@ -85,13 +89,13 @@ public:
 	/* Bot inventory functions   */
 	bool QueryInventoryCount(const uint32 bot_id, uint32& item_count);
 
-	bool LoadItems(const uint32 bot_id, Inventory &inventory_inst);
+	bool LoadItems(const uint32 bot_id, EQEmu::InventoryProfile &inventory_inst);
 	bool SaveItems(Bot* bot_inst);
 	bool DeleteItems(const uint32 bot_id);
 
 	bool LoadItemBySlot(Bot* bot_inst);
 	bool LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint32& item_id);
-	bool SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const ItemInst* item_inst);
+	bool SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::ItemInstance* item_inst);
 	bool DeleteItemBySlot(const uint32 bot_id, const uint32 slot_id);
 
 	bool LoadEquipmentColor(const uint32 bot_id, const uint8 material_slot_id, uint32& rgb);

zone/client.cpp

@@ -2017,7 +2017,7 @@ void Client::ReadBook(BookRequest_Struct *book) {
 		out->window = book->window;
 		if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
 		{
-			const ItemInst *inst = m_inv[book->invslot];
+			const EQEmu::ItemInstance *inst = m_inv[book->invslot];
 			if(inst)
 				out->type = inst->GetItem()->Book;
 			else
@@ -2549,7 +2549,7 @@ void Client::SetFeigned(bool in_feigned) {
 	feigned=in_feigned;
  }
 
-void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying)
+void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemData* item, bool buying)
 {
 	if(!player || !merchant || !item)
 		return;
@@ -2796,11 +2796,11 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
 }
 
 void Client::SetMaterial(int16 in_slot, uint32 item_id) {
-	const EQEmu::ItemBase* item = database.GetItem(item_id);
+	const EQEmu::ItemData* item = database.GetItem(item_id);
 	if (item && item->IsClassCommon())
 	{
-		uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot);
+		uint8 matslot = EQEmu::InventoryProfile::CalcMaterialFromSlot(in_slot);
-		if (matslot != EQEmu::textures::TextureInvalid)
+		if (matslot != EQEmu::textures::materialInvalid)
 		{
 			m_pp.item_material.Slot[matslot].Material = GetEquipmentMaterial(matslot);
 		}
@@ -3132,17 +3132,17 @@ void Client::Tell_StringID(uint32 string_id, const char *who, const char *messag
 }
 
 void Client::SetTint(int16 in_slot, uint32 color) {
-	EQEmu::Tint_Struct new_color;
+	EQEmu::textures::Tint_Struct new_color;
 	new_color.Color = color;
 	SetTint(in_slot, new_color);
 	database.SaveCharacterMaterialColor(this->CharacterID(), in_slot, color);
 }
 
 // Still need to reconcile bracer01 versus bracer02
-void Client::SetTint(int16 in_slot, EQEmu::Tint_Struct& color) {
+void Client::SetTint(int16 in_slot, EQEmu::textures::Tint_Struct& color) {
 
-	uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot);
+	uint8 matslot = EQEmu::InventoryProfile::CalcMaterialFromSlot(in_slot);
-	if (matslot != EQEmu::textures::TextureInvalid)
+	if (matslot != EQEmu::textures::materialInvalid)
 	{
 		m_pp.item_tint.Slot[matslot].Color = color.Color;
 		database.SaveCharacterMaterialColor(this->CharacterID(), in_slot, color.Color);
@@ -3219,28 +3219,28 @@ void Client::LinkDead()
 uint8 Client::SlotConvert(uint8 slot,bool bracer){
 	uint8 slot2 = 0; // why are we returning MainCharm instead of INVALID_INDEX? (must be a pre-charm segment...)
 	if(bracer)
-		return EQEmu::legacy::SlotWrist2;
+		return EQEmu::inventory::slotWrist2;
 	switch(slot) {
-	case EQEmu::textures::TextureHead:
+	case EQEmu::textures::armorHead:
-		slot2 = EQEmu::legacy::SlotHead;
+		slot2 = EQEmu::inventory::slotHead;
 		break;
-	case EQEmu::textures::TextureChest:
+	case EQEmu::textures::armorChest:
-		slot2 = EQEmu::legacy::SlotChest;
+		slot2 = EQEmu::inventory::slotChest;
 		break;
-	case EQEmu::textures::TextureArms:
+	case EQEmu::textures::armorArms:
-		slot2 = EQEmu::legacy::SlotArms;
+		slot2 = EQEmu::inventory::slotArms;
 		break;
-	case EQEmu::textures::TextureWrist:
+	case EQEmu::textures::armorWrist:
-		slot2 = EQEmu::legacy::SlotWrist1;
+		slot2 = EQEmu::inventory::slotWrist1;
 		break;
-	case EQEmu::textures::TextureHands:
+	case EQEmu::textures::armorHands:
-		slot2 = EQEmu::legacy::SlotHands;
+		slot2 = EQEmu::inventory::slotHands;
 		break;
-	case EQEmu::textures::TextureLegs:
+	case EQEmu::textures::armorLegs:
-		slot2 = EQEmu::legacy::SlotLegs;
+		slot2 = EQEmu::inventory::slotLegs;
 		break;
-	case EQEmu::textures::TextureFeet:
+	case EQEmu::textures::armorFeet:
-		slot2 = EQEmu::legacy::SlotFeet;
+		slot2 = EQEmu::inventory::slotFeet;
 		break;
 	}
 	return slot2;
@@ -3249,26 +3249,26 @@ uint8 Client::SlotConvert(uint8 slot,bool bracer){
 uint8 Client::SlotConvert2(uint8 slot){
 	uint8 slot2 = 0; // same as above...
 	switch(slot){
-	case EQEmu::legacy::SlotHead:
+	case EQEmu::inventory::slotHead:
-		slot2 = EQEmu::textures::TextureHead;
+		slot2 = EQEmu::textures::armorHead;
 		break;
-	case EQEmu::legacy::SlotChest:
+	case EQEmu::inventory::slotChest:
-		slot2 = EQEmu::textures::TextureChest;
+		slot2 = EQEmu::textures::armorChest;
 		break;
-	case EQEmu::legacy::SlotArms:
+	case EQEmu::inventory::slotArms:
-		slot2 = EQEmu::textures::TextureArms;
+		slot2 = EQEmu::textures::armorArms;
 		break;
-	case EQEmu::legacy::SlotWrist1:
+	case EQEmu::inventory::slotWrist1:
-		slot2 = EQEmu::textures::TextureWrist;
+		slot2 = EQEmu::textures::armorWrist;
 		break;
-	case EQEmu::legacy::SlotHands:
+	case EQEmu::inventory::slotHands:
-		slot2 = EQEmu::textures::TextureHands;
+		slot2 = EQEmu::textures::armorHands;
 		break;
-	case EQEmu::legacy::SlotLegs:
+	case EQEmu::inventory::slotLegs:
-		slot2 = EQEmu::textures::TextureLegs;
+		slot2 = EQEmu::textures::armorLegs;
 		break;
-	case EQEmu::legacy::SlotFeet:
+	case EQEmu::inventory::slotFeet:
-		slot2 = EQEmu::textures::TextureFeet;
+		slot2 = EQEmu::textures::armorFeet;
 		break;
 	}
 	return slot2;
@@ -3839,7 +3839,7 @@ void Client::SendOPTranslocateConfirm(Mob *Caster, uint16 SpellID) {
 
 	return;
 }
-void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item){
+void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemData* item){
 	auto outapp = new EQApplicationPacket(OP_PickPocket, sizeof(sPickPocket_Struct));
 	sPickPocket_Struct *pick_out = (sPickPocket_Struct *)outapp->pBuffer;
 	pick_out->coin = amt;
@@ -4013,7 +4013,7 @@ bool Client::KeyRingCheck(uint32 item_id)
 void Client::KeyRingList()
 {
 	Message(4,"Keys on Keyring:");
-	const EQEmu::ItemBase *item = 0;
+	const EQEmu::ItemData *item = 0;
 	for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) {
 		if ((item = database.GetItem(*iter))!=nullptr) {
 			Message(4,item->Name);
@@ -4268,14 +4268,14 @@ bool Client::GroupFollow(Client* inviter) {
 uint16 Client::GetPrimarySkillValue()
 {
 	EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
-	bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
+	bool equiped = m_inv.GetItem(EQEmu::inventory::slotPrimary);
 
 	if (!equiped)
 		skill = EQEmu::skills::SkillHandtoHand;
 
 	else {
 
-		uint8 type = m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->ItemType; //is this the best way to do this?
+		uint8 type = m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->ItemType; //is this the best way to do this?
 
 		switch (type) {
 		case EQEmu::item::ItemType1HSlash: // 1H Slashing
@@ -5440,7 +5440,7 @@ bool Client::TryReward(uint32 claim_id)
 	uint32 free_slot = 0xFFFFFFFF;
 
 	for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; ++i) {
-		ItemInst *item = GetInv().GetItem(i);
+		EQEmu::ItemInstance *item = GetInv().GetItem(i);
 		if (!item) {
 			free_slot = i;
 			break;
@@ -5486,7 +5486,7 @@ bool Client::TryReward(uint32 claim_id)
 	}
 
 	auto &ivr = (*iter);
-	ItemInst *claim = database.CreateItem(ivr.items[0].item_id, ivr.items[0].charges);
+	EQEmu::ItemInstance *claim = database.CreateItem(ivr.items[0].item_id, ivr.items[0].charges);
 	if (!claim) {
 		Save();
 		return true;
@@ -5496,7 +5496,7 @@ bool Client::TryReward(uint32 claim_id)
 
 	for (int y = 1; y < 8; y++)
 		if (ivr.items[y].item_id && claim->GetItem()->ItemClass == 1) {
-			ItemInst *item_temp = database.CreateItem(ivr.items[y].item_id, ivr.items[y].charges);
+			EQEmu::ItemInstance *item_temp = database.CreateItem(ivr.items[y].item_id, ivr.items[y].charges);
 			if (item_temp) {
 				if (CheckLoreConflict(item_temp->GetItem())) {
 					lore_conflict = true;
@@ -5756,8 +5756,8 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
 		insr->TargetID = requester->GetID();
 		insr->playerid = requestee->GetID();
 
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
-		const ItemInst* inst = nullptr;
+		const EQEmu::ItemInstance* inst = nullptr;
 		int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
 		for(int16 L = 0; L <= 20; L++) {
 			inst = requestee->GetInv().GetItem(L);
@@ -5768,7 +5768,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
 					strcpy(insr->itemnames[L], item->Name);
 					if (inst && inst->GetOrnamentationAug(ornamentationAugtype))
 					{
-						const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
+						const EQEmu::ItemData *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
 						insr->itemicons[L] = aug_item->Icon;
 					}
 					else if (inst && inst->GetOrnamentationIcon())
@@ -5785,7 +5785,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
 			}
 		}
 
-		inst = requestee->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
+		inst = requestee->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
 
 		if(inst) {
 			item = inst->GetItem();
@@ -5799,7 +5799,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
 				insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
 		}
 
-		inst = requestee->GetInv().GetItem(EQEmu::legacy::SlotAmmo);
+		inst = requestee->GetInv().GetItem(EQEmu::inventory::slotAmmo);
 
 		if(inst) {
 			item = inst->GetItem();
@@ -6341,8 +6341,8 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
 	made_npc->Corrup = GetCorrup();
 	made_npc->PhR = GetPhR();
 	// looks
-	made_npc->texture = GetEquipmentMaterial(EQEmu::textures::TextureChest);
+	made_npc->texture = GetEquipmentMaterial(EQEmu::textures::armorChest);
-	made_npc->helmtexture = GetEquipmentMaterial(EQEmu::textures::TextureHead);
+	made_npc->helmtexture = GetEquipmentMaterial(EQEmu::textures::armorHead);
 	made_npc->haircolor = GetHairColor();
 	made_npc->beardcolor = GetBeardColor();
 	made_npc->eyecolor1 = GetEyeColor1();
@@ -6353,9 +6353,9 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
 	made_npc->drakkin_heritage = GetDrakkinHeritage();
 	made_npc->drakkin_tattoo = GetDrakkinTattoo();
 	made_npc->drakkin_details = GetDrakkinDetails();
-	made_npc->d_melee_texture1 = GetEquipmentMaterial(EQEmu::textures::TexturePrimary);
+	made_npc->d_melee_texture1 = GetEquipmentMaterial(EQEmu::textures::weaponPrimary);
-	made_npc->d_melee_texture2 = GetEquipmentMaterial(EQEmu::textures::TextureSecondary);
+	made_npc->d_melee_texture2 = GetEquipmentMaterial(EQEmu::textures::weaponSecondary);
-	for (int i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTexture; i++)	{
+	for (int i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTexture; i++)	{
 		made_npc->armor_tint.Slot[i].Color = GetEquipmentColor(i);
 	}
 	made_npc->loottable_id = 0;
@@ -6949,7 +6949,7 @@ void Client::SendAltCurrencies() {
 		uint32 i = 0;
 		auto iter = zone->AlternateCurrencies.begin();
 		while(iter != zone->AlternateCurrencies.end()) {
-			const EQEmu::ItemBase* item = database.GetItem((*iter).item_id);
+			const EQEmu::ItemData* item = database.GetItem((*iter).item_id);
 			altc->entries[i].currency_number = (*iter).id;
 			altc->entries[i].unknown00 = 1;
 			altc->entries[i].currency_number2 = (*iter).id;
@@ -7272,7 +7272,8 @@ void Client::SendXTargetUpdates()
 	for (int i = 0; i < GetMaxXTargets(); ++i) {
 		if (XTargets[i].dirty) {
 			outapp->WriteUInt32(i);
-			outapp->WriteUInt8(0); // no idea what this is
+			// MQ2 checks this for valid mobs, so 0 is bad here at least ...
+			outapp->WriteUInt8(XTargets[i].ID ? 1 : 0);
 			outapp->WriteUInt32(XTargets[i].ID);
 			outapp->WriteString(XTargets[i].Name);
 			count++;
@@ -7604,7 +7605,7 @@ void Client::DuplicateLoreMessage(uint32 ItemID)
 		return;
 	}
 
-	const EQEmu::ItemBase *item = database.GetItem(ItemID);
+	const EQEmu::ItemData *item = database.GetItem(ItemID);
 
 	if(!item)
 		return;
@@ -8061,7 +8062,7 @@ void Client::TickItemCheck()
 		TryItemTick(i);
 	}
 	//Scan main inventory + cursor
-	for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::SlotCursor; i++)
+	for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::inventory::slotCursor; i++)
 	{
 		TryItemTick(i);
 	}
@@ -8075,7 +8076,7 @@ void Client::TickItemCheck()
 void Client::TryItemTick(int slot)
 {
 	int iid = 0;
-	const ItemInst* inst = m_inv[slot];
+	const EQEmu::ItemInstance* inst = m_inv[slot];
 	if(inst == 0) { return; }
 
 	iid = inst->GetID();
@@ -8084,7 +8085,7 @@ void Client::TryItemTick(int slot)
 	{
 		if (GetLevel() >= zone->tick_items[iid].level && zone->random.Int(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot <= EQEmu::legacy::EQUIPMENT_END))
 		{
-			ItemInst* e_inst = (ItemInst*)inst;
+			EQEmu::ItemInstance* e_inst = (EQEmu::ItemInstance*)inst;
 			parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
 		}
 	}
@@ -8092,9 +8093,9 @@ void Client::TryItemTick(int slot)
 	//Only look at augs in main inventory
 	if (slot > EQEmu::legacy::EQUIPMENT_END) { return; }
 
-	for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
+	for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
 	{
-		ItemInst * a_inst = inst->GetAugment(x);
+		EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
 		if(!a_inst) { continue; }
 
 		iid = a_inst->GetID();
@@ -8103,7 +8104,7 @@ void Client::TryItemTick(int slot)
 		{
 			if( GetLevel() >= zone->tick_items[iid].level && zone->random.Int(0, 100) >= (100 - zone->tick_items[iid].chance) )
 			{
-				ItemInst* e_inst = (ItemInst*)a_inst;
+				EQEmu::ItemInstance* e_inst = (EQEmu::ItemInstance*)a_inst;
 				parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
 			}
 		}
@@ -8118,7 +8119,7 @@ void Client::ItemTimerCheck()
 		TryItemTimer(i);
 	}
 
-	for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::SlotCursor; i++)
+	for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::inventory::slotCursor; i++)
 	{
 		TryItemTimer(i);
 	}
@@ -8131,7 +8132,7 @@ void Client::ItemTimerCheck()
 
 void Client::TryItemTimer(int slot)
 {
-	ItemInst* inst = m_inv.GetItem(slot);
+	EQEmu::ItemInstance* inst = m_inv.GetItem(slot);
 	if(!inst) {
 		return;
 	}
@@ -8149,9 +8150,9 @@ void Client::TryItemTimer(int slot)
 		return;
 	}
 
-	for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
+	for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
 	{
-		ItemInst * a_inst = inst->GetAugment(x);
+		EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
 		if(!a_inst) {
 			continue;
 		}
@@ -8167,7 +8168,7 @@ void Client::TryItemTimer(int slot)
 	}
 }
 
-void Client::SendItemScale(ItemInst *inst) {
+void Client::SendItemScale(EQEmu::ItemInstance *inst) {
 	int slot = m_inv.GetSlotByItemInst(inst);
 	if(slot != -1) {
 		inst->ScaleItem();
@@ -8321,7 +8322,7 @@ void Client::SetConsumption(int32 in_hunger, int32 in_thirst)
 	safe_delete(outapp);
 }
 
-void Client::Consume(const EQEmu::ItemBase *item, uint8 type, int16 slot, bool auto_consume)
+void Client::Consume(const EQEmu::ItemData *item, uint8 type, int16 slot, bool auto_consume)
 {
    if(!item) { return; }
 
@@ -8436,7 +8437,7 @@ void Client::ShowNumHits()
 
 int Client::GetQuiverHaste(int delay)
 {
-	const ItemInst *pi = nullptr;
+	const EQEmu::ItemInstance *pi = nullptr;
 	for (int r = EQEmu::legacy::GENERAL_BEGIN; r <= EQEmu::legacy::GENERAL_END; r++) {
 		pi = GetInv().GetItem(r);
 		if (pi && pi->IsClassBag() && pi->GetItem()->BagType == EQEmu::item::BagTypeQuiver &&
@@ -8482,7 +8483,7 @@ void Client::QuestReward(Mob* target, uint32 copper, uint32 silver, uint32 gold,
 		AddMoneyToPP(copper, silver, gold, platinum, false);
 
 	if (itemid > 0)
-		SummonItem(itemid, 0, 0, 0, 0, 0, 0, false, EQEmu::legacy::SlotPowerSource);
+		SummonItem(itemid, 0, 0, 0, 0, 0, 0, false, EQEmu::inventory::slotPowerSource);
 
 	if (faction)
 	{

zone/client.h

@@ -31,7 +31,7 @@ enum WaterRegionType : int;
 
 namespace EQEmu
 {
-	struct ItemBase;
+	struct ItemData;
 }
 
 #include "../common/timer.h"
@@ -45,9 +45,9 @@ namespace EQEmu
 #include "../common/extprofile.h"
 #include "../common/races.h"
 #include "../common/seperator.h"
-#include "../common/item.h"
+#include "../common/inventory_profile.h"
 #include "../common/guilds.h"
-#include "../common/item_base.h"
+//#include "../common/item_data.h"
 
 #include "common.h"
 #include "merc.h"
@@ -222,7 +222,7 @@ public:
 	//abstract virtual function implementations required by base abstract class
 	virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
 	virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
-	virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
+	virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
 			ExtraAttackOptions *opts = nullptr, int special = 0);
 	virtual bool HasRaid() { return (GetRaid() ? true : false); }
 	virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -250,7 +250,7 @@ public:
 	void KeyRingList();
 	virtual bool IsClient() const { return true; }
 	void CompleteConnect();
-	bool TryStacking(ItemInst* item, uint8 type = ItemPacketTrade, bool try_worn = true, bool try_cursor = true);
+	bool TryStacking(EQEmu::ItemInstance* item, uint8 type = ItemPacketTrade, bool try_worn = true, bool try_cursor = true);
 	void SendTraderPacket(Client* trader, uint32 Unknown72 = 51);
 	void SendBuyerPacket(Client* Buyer);
 	GetItems_Struct* GetTraderItems();
@@ -273,7 +273,7 @@ public:
 	void SendTraderItem(uint32 item_id,uint16 quantity);
 	uint16 FindTraderItem(int32 SerialNumber,uint16 Quantity);
 	uint32 FindTraderItemSerialNumber(int32 ItemID);
-	ItemInst* FindTraderItemBySerialNumber(int32 SerialNumber);
+	EQEmu::ItemInstance* FindTraderItemBySerialNumber(int32 SerialNumber);
 	void FindAndNukeTraderItem(int32 item_id,uint16 quantity,Client* customer,uint16 traderslot);
 	void NukeTraderItem(uint16 slot, int16 charges, uint16 quantity, Client* customer, uint16 traderslot, int32 uniqueid, int32 itemid = 0);
 	void ReturnTraderReq(const EQApplicationPacket* app,int16 traderitemcharges, uint32 itemid = 0);
@@ -294,7 +294,7 @@ public:
 
 	void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
 	virtual bool Process();
-	void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying);
+	void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemData* item, bool buying);
 	void SendPacketQueue(bool Block = true);
 	void QueuePacket(const EQApplicationPacket* app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL, eqFilterType filter=FilterNone);
 	void FastQueuePacket(EQApplicationPacket** app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL);
@@ -308,7 +308,7 @@ public:
 	void LearnRecipe(uint32 recipeID);
 	bool CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill);
 
-	EQApplicationPacket* ReturnItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type);
+	EQApplicationPacket* ReturnItemPacket(int16 slot_id, const EQEmu::ItemInstance* inst, ItemPacketType packet_type);
 
 	bool GetRevoked() const { return revoked; }
 	void SetRevoked(bool rev) { revoked = rev; }
@@ -340,8 +340,8 @@ public:
 	inline uint8 GetAnon() const { return m_pp.anon; }
 	inline PlayerProfile_Struct& GetPP() { return m_pp; }
 	inline ExtendedProfile_Struct& GetEPP() { return m_epp; }
-	inline Inventory& GetInv() { return m_inv; }
+	inline EQEmu::InventoryProfile& GetInv() { return m_inv; }
-	inline const Inventory& GetInv() const { return m_inv; }
+	inline const EQEmu::InventoryProfile& GetInv() const { return m_inv; }
 	inline PetInfo* GetPetInfo(uint16 pet) { return (pet==1)?&m_suspendedminion:&m_petinfo; }
 	inline InspectMessage_Struct& GetInspectMessage() { return m_inspect_message; }
 	inline const InspectMessage_Struct& GetInspectMessage() const { return m_inspect_message; }
@@ -403,7 +403,7 @@ public:
 
 	inline uint8 GetLanguageSkill(uint16 n) const { return m_pp.languages[n]; }
 
-	void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item = nullptr);
+	void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemData* item = nullptr);
 
 	inline const char* GetLastName() const { return lastname; }
 
@@ -509,10 +509,10 @@ public:
 	virtual int GetCurrentBuffSlots() const;
 	virtual int GetCurrentSongSlots() const;
 	virtual int GetCurrentDiscSlots() const { return 1; }
-	virtual int GetMaxBuffSlots() const { return 25; }
+	virtual int GetMaxBuffSlots() const { return EQEmu::constants::LongBuffs; }
-	virtual int GetMaxSongSlots() const { return 12; }
+	virtual int GetMaxSongSlots() const { return EQEmu::constants::ShortBuffs; }
-	virtual int GetMaxDiscSlots() const { return 1; }
+	virtual int GetMaxDiscSlots() const { return EQEmu::constants::DiscBuffs; }
-	virtual int GetMaxTotalSlots() const { return 38; }
+	virtual int GetMaxTotalSlots() const { return EQEmu::constants::TotalBuffs; }
 	virtual uint32 GetFirstBuffSlot(bool disc, bool song);
 	virtual uint32 GetLastBuffSlot(bool disc, bool song);
 	virtual void InitializeBuffSlots();
@@ -601,7 +601,7 @@ public:
 	void AssignToInstance(uint16 instance_id);
 	void RemoveFromInstance(uint16 instance_id);
 	void WhoAll();
-	bool CheckLoreConflict(const EQEmu::ItemBase* item);
+	bool CheckLoreConflict(const EQEmu::ItemData* item);
 	void ChangeLastName(const char* in_lastname);
 	void GetGroupAAs(GroupLeadershipAA_Struct *into) const;
 	void GetRaidAAs(RaidLeadershipAA_Struct *into) const;
@@ -808,30 +808,30 @@ public:
 	uint32 NukeItem(uint32 itemnum, uint8 where_to_check =
 			(invWhereWorn | invWherePersonal | invWhereBank | invWhereSharedBank | invWhereTrading | invWhereCursor));
 	void SetTint(int16 slot_id, uint32 color);
-	void SetTint(int16 slot_id, EQEmu::Tint_Struct& color);
+	void SetTint(int16 slot_id, EQEmu::textures::Tint_Struct& color);
 	void SetMaterial(int16 slot_id, uint32 item_id);
 	void Undye();
 	int32 GetItemIDAt(int16 slot_id);
 	int32 GetAugmentIDAt(int16 slot_id, uint8 augslot);
-	bool PutItemInInventory(int16 slot_id, const ItemInst& inst, bool client_update = false);
+	bool PutItemInInventory(int16 slot_id, const EQEmu::ItemInstance& inst, bool client_update = false);
-	bool PushItemOnCursor(const ItemInst& inst, bool client_update = false);
+	bool PushItemOnCursor(const EQEmu::ItemInstance& inst, bool client_update = false);
 	void SendCursorBuffer();
 	void DeleteItemInInventory(int16 slot_id, int8 quantity = 0, bool client_update = false, bool update_db = true);
 	bool SwapItem(MoveItem_Struct* move_in);
 	void SwapItemResync(MoveItem_Struct* move_slots);
 	void QSSwapItemAuditor(MoveItem_Struct* move_in, bool postaction_call = false);
-	void PutLootInInventory(int16 slot_id, const ItemInst &inst, ServerLootItem_Struct** bag_item_data = 0);
+	void PutLootInInventory(int16 slot_id, const EQEmu::ItemInstance &inst, ServerLootItem_Struct** bag_item_data = 0);
-	bool AutoPutLootInInventory(ItemInst& inst, bool try_worn = false, bool try_cursor = true, ServerLootItem_Struct** bag_item_data = 0);
+	bool AutoPutLootInInventory(EQEmu::ItemInstance& inst, bool try_worn = false, bool try_cursor = true, ServerLootItem_Struct** bag_item_data = 0);
-	bool SummonItem(uint32 item_id, int16 charges = -1, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, bool attuned = false, uint16 to_slot = EQEmu::legacy::SlotCursor, uint32 ornament_icon = 0, uint32 ornament_idfile = 0, uint32 ornament_hero_model = 0);
+	bool SummonItem(uint32 item_id, int16 charges = -1, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, bool attuned = false, uint16 to_slot = EQEmu::inventory::slotCursor, uint32 ornament_icon = 0, uint32 ornament_idfile = 0, uint32 ornament_hero_model = 0);
 	void SetStats(uint8 type,int16 set_val);
 	void IncStats(uint8 type,int16 increase_val);
 	void DropItem(int16 slot_id);
 
-	int GetItemLinkHash(const ItemInst* inst); // move to ItemBase..or make use of the pre-calculated database field
+	int GetItemLinkHash(const EQEmu::ItemInstance* inst); // move to ItemData..or make use of the pre-calculated database field
 
-	void SendItemLink(const ItemInst* inst, bool sendtoall=false);
+	void SendItemLink(const EQEmu::ItemInstance* inst, bool sendtoall=false);
-	void SendLootItemInPacket(const ItemInst* inst, int16 slot_id);
+	void SendLootItemInPacket(const EQEmu::ItemInstance* inst, int16 slot_id);
-	void SendItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type);
+	void SendItemPacket(int16 slot_id, const EQEmu::ItemInstance* inst, ItemPacketType packet_type);
 	bool IsValidSlot(uint32 slot);
 	bool IsBankSlot(uint32 slot);
 
@@ -887,7 +887,7 @@ public:
 	//Calculate vendor price modifier based on CHA: (reverse==selling)
 	float CalcPriceMod(Mob* other = 0, bool reverse = false);
 	void ResetTrade();
-	void DropInst(const ItemInst* inst);
+	void DropInst(const EQEmu::ItemInstance* inst);
 	bool TrainDiscipline(uint32 itemid);
 	void TrainDiscBySpellID(int32 spell_id);
 	int GetDiscSlotBySpellID(int32 spellid);
@@ -965,7 +965,7 @@ public:
 	inline void UpdateTasksForItem(ActivityType Type, int ItemID, int Count=1) { if(taskstate) taskstate->UpdateTasksForItem(this, Type, ItemID, Count); }
 	inline void UpdateTasksOnExplore(int ExploreID) { if(taskstate) taskstate->UpdateTasksOnExplore(this, ExploreID); }
 	inline bool UpdateTasksOnSpeakWith(int NPCTypeID) { if(taskstate) return taskstate->UpdateTasksOnSpeakWith(this, NPCTypeID); else return false; }
-	inline bool UpdateTasksOnDeliver(std::list<ItemInst*>& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, NPCTypeID); else return false; }
+	inline bool UpdateTasksOnDeliver(std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, NPCTypeID); else return false; }
 	inline void TaskSetSelector(Mob *mob, int TaskSetID) { if(taskmanager) taskmanager->TaskSetSelector(this, taskstate, mob, TaskSetID); }
 	inline void EnableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->EnableTask(CharacterID(), TaskCount, TaskList); }
 	inline void DisableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->DisableTask(CharacterID(), TaskCount, TaskList); }
@@ -1080,7 +1080,7 @@ public:
 	inline bool GetPendingGuildInvitation() { return PendingGuildInvitation; }
 	void LocateCorpse();
 	void SendTargetCommand(uint32 EntityID);
-	bool MoveItemToInventory(ItemInst *BInst, bool UpdateClient = false);
+	bool MoveItemToInventory(EQEmu::ItemInstance *BInst, bool UpdateClient = false);
 	void HandleRespawnFromHover(uint32 Option);
 	bool IsHoveringForRespawn() { return RespawnFromHoverTimer.Enabled(); }
 	std::list<RespawnOption> respawn_options;
@@ -1173,7 +1173,7 @@ public:
 	void TryItemTick(int slot);
 	void ItemTimerCheck();
 	void TryItemTimer(int slot);
-	void SendItemScale(ItemInst *inst);
+	void SendItemScale(EQEmu::ItemInstance *inst);
 
 	int32 GetActSTR() { return( std::min(GetMaxSTR(), GetSTR()) ); }
 	int32 GetActSTA() { return( std::min(GetMaxSTA(), GetSTA()) ); }
@@ -1186,10 +1186,10 @@ public:
 	void SetAccountFlag(std::string flag, std::string val);
 	std::string GetAccountFlag(std::string flag);
 	float GetDamageMultiplier(EQEmu::skills::SkillType how_long_has_this_been_missing);
-	void Consume(const EQEmu::ItemBase *item, uint8 type, int16 slot, bool auto_consume);
+	void Consume(const EQEmu::ItemData *item, uint8 type, int16 slot, bool auto_consume);
 	void PlayMP3(const char* fname);
 	void ExpeditionSay(const char *str, int ExpID);
-	int mod_client_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other);
+	int mod_client_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemInstance* weapon, Mob* other);
 	bool mod_client_message(char* message, uint8 chan_num);
 	bool mod_can_increase_skill(EQEmu::skills::SkillType skillid, Mob* against_who);
 	int16 mod_increase_skill_chance(int16 chance, Mob* against_who);
@@ -1201,16 +1201,16 @@ public:
 	int16 mod_pet_power(int16 act_power, uint16 spell_id);
 	float mod_tradeskill_chance(float chance, DBTradeskillRecipe_Struct *spec);
 	float mod_tradeskill_skillup(float chance_stage2);
-	int32 mod_tribute_item_value(int32 pts, const ItemInst* item);
+	int32 mod_tribute_item_value(int32 pts, const EQEmu::ItemInstance* item);
 	void mod_client_death_npc(Mob* killerMob);
 	void mod_client_death_duel(Mob* killerMob);
 	void mod_client_death_env();
 	int32 mod_client_xp(int32 in_exp, NPC *npc);
 	uint32 mod_client_xp_for_level(uint32 xp, uint16 check_level);
 	int mod_client_haste_cap(int cap);
-	int mod_consume(EQEmu::ItemBase *item, EQEmu::item::ItemType type, int change);
+	int mod_consume(EQEmu::ItemData *item, EQEmu::item::ItemType type, int change);
-	int mod_food_value(const EQEmu::ItemBase *item, int change);
+	int mod_food_value(const EQEmu::ItemData *item, int change);
-	int mod_drink_value(const EQEmu::ItemBase *item, int change);
+	int mod_drink_value(const EQEmu::ItemData *item, int change);
 
 	void SetEngagedRaidTarget(bool value) { EngagedRaidTarget = value; }
 	bool GetEngagedRaidTarget() const { return EngagedRaidTarget; }
@@ -1244,8 +1244,8 @@ public:
 protected:
 	friend class Mob;
 	void CalcItemBonuses(StatBonuses* newbon);
-	void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0, bool ammo_slot_item = false);
+	void AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0, bool ammo_slot_item = false);
-	void AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false);
+	void AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false);
 	int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
 	void CalcEdibleBonuses(StatBonuses* newbon);
 	void ProcessItemCaps();
@@ -1286,7 +1286,7 @@ private:
 	void OPRezzAnswer(uint32 Action, uint32 SpellID, uint16 ZoneID, uint16 InstanceID, float x, float y, float z);
 	void OPMemorizeSpell(const EQApplicationPacket *app);
 	void OPMoveCoin(const EQApplicationPacket* app);
-	void MoveItemCharges(ItemInst &from, int16 to_slot, uint8 type);
+	void MoveItemCharges(EQEmu::ItemInstance &from, int16 to_slot, uint8 type);
 	void OPGMTraining(const EQApplicationPacket *app);
 	void OPGMEndTraining(const EQApplicationPacket *app);
 	void OPGMTrainSkill(const EQApplicationPacket *app);
@@ -1395,7 +1395,7 @@ private:
 
 	PlayerProfile_Struct m_pp;
 	ExtendedProfile_Struct m_epp;
-	Inventory m_inv;
+	EQEmu::InventoryProfile m_inv;
 	Object* m_tradeskill_object;
 	PetInfo m_petinfo; // current pet data, used while loading from and saving to DB
 	PetInfo m_suspendedminion; // pet data for our suspended minion.
@@ -1561,8 +1561,8 @@ private:
 
 	bool interrogateinv_flag; // used to minimize log spamming by players
 
-	void InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const ItemInst* inst, const ItemInst* parent, bool log, bool silent, bool &error, int depth);
+	void InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* parent, bool log, bool silent, bool &error, int depth);
-	bool InterrogateInventory_error(int16 head, int16 index, const ItemInst* inst, const ItemInst* parent, int depth);
+	bool InterrogateInventory_error(int16 head, int16 index, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* parent, int depth);
 };
 
 #endif

zone/client_mods.cpp

@@ -486,7 +486,7 @@ int32 Client::GetRawItemAC()
 	int32 Total = 0;
 	// this skips MainAmmo..add an '=' conditional if that slot is required (original behavior)
 	for (int16 slot_id = EQEmu::legacy::EQUIPMENT_BEGIN; slot_id < EQEmu::legacy::EQUIPMENT_END; slot_id++) {
-		const ItemInst* inst = m_inv[slot_id];
+		const EQEmu::ItemInstance* inst = m_inv[slot_id];
 		if (inst && inst->IsClassCommon()) {
 			Total += inst->GetItem()->AC;
 		}
@@ -1074,9 +1074,9 @@ int32 Client::CalcAC()
 	}
 	// Shield AC bonus for HeroicSTR
 	if (itembonuses.HeroicSTR) {
-		bool equiped = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary);
+		bool equiped = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary);
 		if (equiped) {
-			uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType;
+			uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType;
 			if (shield == EQEmu::item::ItemTypeShield) {
 				displayed += itembonuses.HeroicSTR / 2;
 			}
@@ -1103,9 +1103,9 @@ int32 Client::GetACMit()
 	}
 	// Shield AC bonus for HeroicSTR
 	if (itembonuses.HeroicSTR) {
-		bool equiped = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary);
+		bool equiped = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary);
 		if (equiped) {
-			uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType;
+			uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType;
 			if (shield == EQEmu::item::ItemTypeShield) {
 				mitigation += itembonuses.HeroicSTR / 2;
 			}
@@ -1316,11 +1316,11 @@ int32 Client::CalcManaRegenCap()
 
 uint32 Client::CalcCurrentWeight()
 {
-	const EQEmu::ItemBase* TempItem = 0;
+	const EQEmu::ItemData* TempItem = 0;
-	ItemInst* ins;
+	EQEmu::ItemInstance* ins;
 	uint32 Total = 0;
 	int x;
-	for (x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::SlotCursor; x++) { // include cursor or not?
+	for (x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::inventory::slotCursor; x++) { // include cursor or not?
 		TempItem = 0;
 		ins = GetInv().GetItem(x);
 		if (ins) {
@@ -1343,14 +1343,14 @@ uint32 Client::CalcCurrentWeight()
 		if (TmpWeight > 0) {
 			// this code indicates that weight redux bags can only be in the first general inventory slot to be effective...
 			// is this correct? or can we scan for the highest weight redux and use that? (need client verifications)
-			int bagslot = EQEmu::legacy::SlotGeneral1;
+			int bagslot = EQEmu::inventory::slotGeneral1;
 			int reduction = 0;
 			for (int m = EQEmu::legacy::GENERAL_BAGS_BEGIN + 10; m <= EQEmu::legacy::GENERAL_BAGS_END; m += 10) { // include cursor bags or not?
 				if (x >= m) {
 					bagslot += 1;
 				}
 			}
-			ItemInst* baginst = GetInv().GetItem(bagslot);
+			EQEmu::ItemInstance* baginst = GetInv().GetItem(bagslot);
 			if (baginst && baginst->GetItem() && baginst->IsClassBag()) {
 				reduction = baginst->GetItem()->BagWR;
 			}
@@ -1369,7 +1369,7 @@ uint32 Client::CalcCurrentWeight()
 	    This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd.
 	*/
 	// SoD+ client has no weight for coin
-	if (EQEmu::behavior::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))->CoinHasWeight) {
+	if (EQEmu::behavior::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion()))->CoinHasWeight) {
 		Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4;
 	}
 	float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat;
@@ -2219,12 +2219,12 @@ int Client::GetRawACNoShield(int &shield_ac) const
 {
 	int ac = itembonuses.AC + spellbonuses.AC + aabonuses.AC;
 	shield_ac = 0;
-	const ItemInst *inst = m_inv.GetItem(EQEmu::legacy::SlotSecondary);
+	const EQEmu::ItemInstance *inst = m_inv.GetItem(EQEmu::inventory::slotSecondary);
 	if (inst) {
 		if (inst->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
 			ac -= inst->GetItem()->AC;
 			shield_ac = inst->GetItem()->AC;
-			for (uint8 i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (uint8 i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
 				if (inst->GetAugment(i)) {
 					ac -= inst->GetAugment(i)->GetItem()->AC;
 					shield_ac += inst->GetAugment(i)->GetItem()->AC;

zone/client_packet.cpp

@@ -1334,7 +1334,7 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 	}
 
 	/* Set item material tint */
-	for (int i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTexture; i++)
+	for (int i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTexture; i++)
 	{
 		if (m_pp.item_tint.Slot[i].UseTint == 1 || m_pp.item_tint.Slot[i].UseTint == 255)
 		{
@@ -1690,8 +1690,8 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
 			/* First item cursor is sent in bulk inventory packet */
 			if (iter == m_inv.cursor_cbegin())
 				continue;
-			const ItemInst *inst = *iter;
+			const EQEmu::ItemInstance *inst = *iter;
-			SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
+			SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
 		}
 	}
 
@@ -1883,7 +1883,7 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
 
 	merchantid = tmp->CastToNPC()->MerchantType;
 
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
 	bool found = false;
 	std::list<MerchantList> merlist = zone->merchanttable[merchantid];
 	std::list<MerchantList>::const_iterator itr;
@@ -2026,10 +2026,10 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
 	if (item->MaxCharges != 0)
 		charges = item->MaxCharges;
 
-	ItemInst *inst = database.CreateItem(item, charges);
+	EQEmu::ItemInstance *inst = database.CreateItem(item, charges);
 	if (!AutoPutLootInInventory(*inst, true, true))
 	{
-		PutLootInInventory(EQEmu::legacy::SlotCursor, *inst);
+		PutLootInInventory(EQEmu::inventory::slotCursor, *inst);
 	}
 	Save(1);
 }
@@ -2059,7 +2059,7 @@ void Client::Handle_OP_AdventureMerchantRequest(const EQApplicationPacket *app)
 	merchantid = tmp->CastToNPC()->MerchantType;
 	tmp->CastToNPC()->FaceTarget(this->CastToMob());
 
-	const EQEmu::ItemBase *item = 0;
+	const EQEmu::ItemData *item = 0;
 	std::list<MerchantList> merlist = zone->merchanttable[merchantid];
 	std::list<MerchantList>::const_iterator itr;
 	for (itr = merlist.begin(); itr != merlist.end() && count<255; ++itr){
@@ -2158,8 +2158,8 @@ void Client::Handle_OP_AdventureMerchantSell(const EQApplicationPacket *app)
 		return;
 	}
 
-	const EQEmu::ItemBase* item = database.GetItem(itemid);
+	const EQEmu::ItemData* item = database.GetItem(itemid);
-	ItemInst* inst = GetInv().GetItem(ams_in->slot);
+	EQEmu::ItemInstance* inst = GetInv().GetItem(ams_in->slot);
 	if (!item || !inst){
 		Message(13, "You seemed to have misplaced that item...");
 		return;
@@ -2435,7 +2435,7 @@ void Client::Handle_OP_AltCurrencyMerchantRequest(const EQApplicationPacket *app
 		ss << alt_cur_id << "|1|" << alt_cur_id;
 		uint32 count = 0;
 		uint32 merchant_id = tar->MerchantType;
-		const EQEmu::ItemBase *item = nullptr;
+		const EQEmu::ItemData *item = nullptr;
 
 		std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
 		std::list<MerchantList>::const_iterator itr;
@@ -2495,7 +2495,7 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
 			return;
 		}
 
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
 		uint32 cost = 0;
 		uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
 		uint32 merchant_id = tar->MerchantType;
@@ -2551,10 +2551,10 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
 		if (item->MaxCharges != 0)
 			charges = item->MaxCharges;
 
-		ItemInst *inst = database.CreateItem(item, charges);
+		EQEmu::ItemInstance *inst = database.CreateItem(item, charges);
 		if (!AutoPutLootInInventory(*inst, true, true))
 		{
-			PutLootInInventory(EQEmu::legacy::SlotCursor, *inst);
+			PutLootInInventory(EQEmu::inventory::slotCursor, *inst);
 		}
 
 		Save(1);
@@ -2604,7 +2604,7 @@ void Client::Handle_OP_AltCurrencyReclaim(const EQApplicationPacket *app)
 			SetAlternateCurrencyValue(reclaim->currency_id, 0);
 		}
 		else {
-			SummonItem(item_id, reclaim->count, 0, 0, 0, 0, 0, 0, false, EQEmu::legacy::SlotCursor);
+			SummonItem(item_id, reclaim->count, 0, 0, 0, 0, 0, 0, false, EQEmu::inventory::slotCursor);
 			AddAlternateCurrencyValue(reclaim->currency_id, -((int32)reclaim->count));
 		}
 		/* QS: PlayerLogAlternateCurrencyTransactions :: Cursor to Item Storage */
@@ -2635,7 +2635,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
 			return;
 		}
 
-		ItemInst* inst = GetInv().GetItem(sell->slot_id);
+		EQEmu::ItemInstance* inst = GetInv().GetItem(sell->slot_id);
 		if (!inst) {
 			return;
 		}
@@ -2644,7 +2644,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
 			return;
 		}
 
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
 		uint32 cost = 0;
 		uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
 		uint32 merchant_id = tar->MerchantType;
@@ -2732,12 +2732,12 @@ void Client::Handle_OP_AltCurrencySellSelection(const EQApplicationPacket *app)
 			return;
 		}
 
-		ItemInst *inst = m_inv.GetItem(select->slot_id);
+		EQEmu::ItemInstance *inst = m_inv.GetItem(select->slot_id);
 		if (!inst) {
 			return;
 		}
 
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
 		uint32 cost = 0;
 		uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
 		uint32 merchant_id = tar->MerchantType;
@@ -2816,9 +2816,9 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app)
 	}
 	uint32 ApplyPoisonSuccessResult = 0;
 	ApplyPoison_Struct* ApplyPoisonData = (ApplyPoison_Struct*)app->pBuffer;
-	const ItemInst* PrimaryWeapon = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
+	const EQEmu::ItemInstance* PrimaryWeapon = GetInv().GetItem(EQEmu::inventory::slotPrimary);
-	const ItemInst* SecondaryWeapon = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
+	const EQEmu::ItemInstance* SecondaryWeapon = GetInv().GetItem(EQEmu::inventory::slotSecondary);
-	const ItemInst* PoisonItemInstance = GetInv()[ApplyPoisonData->inventorySlot];
+	const EQEmu::ItemInstance* PoisonItemInstance = GetInv()[ApplyPoisonData->inventorySlot];
 
 	bool IsPoison = PoisonItemInstance && (PoisonItemInstance->GetItem()->ItemType == EQEmu::item::ItemTypePoison);
 
@@ -2912,7 +2912,7 @@ void Client::Handle_OP_AugmentInfo(const EQApplicationPacket *app)
 	}
 
 	AugmentInfo_Struct* AugInfo = (AugmentInfo_Struct*)app->pBuffer;
-	const EQEmu::ItemBase * item = database.GetItem(AugInfo->itemid);
+	const EQEmu::ItemData * item = database.GetItem(AugInfo->itemid);
 
 	if (item) {
 		strn0cpy(AugInfo->augment_info, item->Name, 64);
@@ -2933,13 +2933,17 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 	bool deleteItems = false;
 	if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
 	{
-		ItemInst *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
+		EQEmu::ItemInstance *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
-		ItemInst *tobe_auged = nullptr, *old_aug = nullptr, *new_aug = nullptr, *aug = nullptr, *solvent = nullptr;
+
-		Inventory& user_inv = GetInv();
+		//Log.Out(Logs::DebugLevel::Moderate, Logs::Debug, "cslot: %i aslot: %i cidx: %i aidx: %i act: %i dest: %i",
+		//	in_augment->container_slot, in_augment->augment_slot, in_augment->container_index, in_augment->augment_index, in_augment->augment_action, in_augment->dest_inst_id);
+
+		EQEmu::ItemInstance *tobe_auged = nullptr, *old_aug = nullptr, *new_aug = nullptr, *aug = nullptr, *solvent = nullptr;
+		EQEmu::InventoryProfile& user_inv = GetInv();
 
 		uint16 item_slot = in_augment->container_slot;
 		uint16 solvent_slot = in_augment->augment_slot;
-		uint8 mat = Inventory::CalcMaterialFromSlot(item_slot); // for when player is augging a piece of equipment while they're wearing it
+		uint8 mat = EQEmu::InventoryProfile::CalcMaterialFromSlot(item_slot); // for when player is augging a piece of equipment while they're wearing it
 
 		if (item_slot == INVALID_INDEX || solvent_slot == INVALID_INDEX)
 		{
@@ -2995,7 +2999,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 		{
 			case 0: // Adding an augment
 			case 2: // Swapping augment
-				new_aug = user_inv.GetItem(EQEmu::legacy::SlotCursor);
+				new_aug = user_inv.GetItem(EQEmu::inventory::slotCursor);
 
 				if (!new_aug) // Shouldn't get the OP code without the augment on the user's cursor, but maybe it's h4x.
 				{
@@ -3053,7 +3057,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 						if (itemOneToPush)
 						{
 							DeleteItemInInventory(item_slot, 0, true);
-							DeleteItemInInventory(EQEmu::legacy::SlotCursor, new_aug->IsStackable() ? 1 : 0, true);
+							DeleteItemInInventory(EQEmu::inventory::slotCursor, new_aug->IsStackable() ? 1 : 0, true);
 
 							if (solvent)
 							{
@@ -3064,7 +3068,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 							if (itemTwoToPush)
 							{
 								// This is a swap. Return the old aug to the player's cursor.
-								if (!PutItemInInventory(EQEmu::legacy::SlotCursor, *itemTwoToPush, true))
+								if (!PutItemInInventory(EQEmu::inventory::slotCursor, *itemTwoToPush, true))
 								{
 									Log.Out(Logs::General, Logs::Error, "Problem returning old augment to player's cursor after augmentation swap.");
 									Message(15, "Error: Failed to retrieve old augment after augmentation swap!");
@@ -3077,7 +3081,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 
 								CalcBonuses();
 
-								if (mat != EQEmu::textures::TextureInvalid)
+								if (mat != EQEmu::textures::materialInvalid)
 								{
 									SendWearChange(mat); // Visible item augged while equipped. Send WC in case ornamentation changed.
 								}
@@ -3142,13 +3146,13 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 
 					CalcBonuses();
 					
-					if (mat != EQEmu::textures::TextureInvalid)
+					if (mat != EQEmu::textures::materialInvalid)
 					{
 						SendWearChange(mat); // Visible item augged while equipped. Send WC in case ornamentation changed.
 					}
 
 					// Drop the removed augment on the player's cursor
-					if (!PutItemInInventory(EQEmu::legacy::SlotCursor, *itemTwoToPush, true))
+					if (!PutItemInInventory(EQEmu::inventory::slotCursor, *itemTwoToPush, true))
 					{
 						Log.Out(Logs::General, Logs::Error, "Problem returning augment to player's cursor after safe removal.");
 						Message(15, "Error: Failed to return augment after removal from item!");
@@ -3197,7 +3201,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
 
 				CalcBonuses();
 
-				if (mat != EQEmu::textures::TextureInvalid)
+				if (mat != EQEmu::textures::materialInvalid)
 				{
 					SendWearChange(mat);
 				}
@@ -3490,13 +3494,13 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
 	{
 		BarterItemSearchLinkRequest_Struct* bislr = (BarterItemSearchLinkRequest_Struct*)app->pBuffer;
 
-		const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
+		const EQEmu::ItemData* item = database.GetItem(bislr->ItemID);
 
 		if (!item)
 			Message(13, "Error: This item does not exist!");
 		else
 		{
-			ItemInst* inst = database.CreateItem(item);
+			EQEmu::ItemInstance* inst = database.CreateItem(item);
 			if (inst)
 			{
 				SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3523,13 +3527,13 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
 	{
 		BuyerItemSearchLinkRequest_Struct* bislr = (BuyerItemSearchLinkRequest_Struct*)app->pBuffer;
 
-		const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
+		const EQEmu::ItemData* item = database.GetItem(bislr->ItemID);
 
 		if (!item)
 			Message(13, "Error: This item does not exist!");
 		else
 		{
-			ItemInst* inst = database.CreateItem(item);
+			EQEmu::ItemInstance* inst = database.CreateItem(item);
 			if (inst)
 			{
 				SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3562,14 +3566,14 @@ void Client::Handle_OP_BazaarInspect(const EQApplicationPacket *app)
 
 	BazaarInspect_Struct* bis = (BazaarInspect_Struct*)app->pBuffer;
 
-	const EQEmu::ItemBase* item = database.GetItem(bis->ItemID);
+	const EQEmu::ItemData* item = database.GetItem(bis->ItemID);
 
 	if (!item) {
 		Message(13, "Error: This item does not exist!");
 		return;
 	}
 
-	ItemInst* inst = database.CreateItem(item);
+	EQEmu::ItemInstance* inst = database.CreateItem(item);
 
 	if (inst) {
 		SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3602,7 +3606,7 @@ void Client::Handle_OP_BazaarSearch(const EQApplicationPacket *app)
 
 		Client *c = entity_list.GetClientByName(nbis->Name);
 		if (c) {
-			ItemInst* inst = c->FindTraderItemBySerialNumber(nbis->SerialNumber);
+			EQEmu::ItemInstance* inst = c->FindTraderItemBySerialNumber(nbis->SerialNumber);
 			if (inst)
 				SendItemPacket(0, inst, ItemPacketViewLink);
 		}
@@ -4003,11 +4007,11 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 		if (m_inv.SupportsClickCasting(castspell->inventoryslot) || slot == CastingSlot::PotionBelt)	// sanity check
 		{
 			// packet field types will be reviewed as packet transistions occur
-			const ItemInst* inst = m_inv[castspell->inventoryslot]; //slot values are int16, need to check packet on this field
+			const EQEmu::ItemInstance* inst = m_inv[castspell->inventoryslot]; //slot values are int16, need to check packet on this field
 			//bool cancast = true;
 			if (inst && inst->IsClassCommon())
 			{
-				const EQEmu::ItemBase* item = inst->GetItem();
+				const EQEmu::ItemData* item = inst->GetItem();
 				if (item->Click.Effect != (uint32)castspell->spell_id)
 				{
 					database.SetMQDetectionFlag(account_name, name, "OP_CastSpell with item, tried to cast a different spell.", zone->GetShortName());
@@ -4021,7 +4025,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 					{
 						if (GetLevel() >= item->Click.Level2)
 						{
-							ItemInst* p_inst = (ItemInst*)inst;
+							EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
 							int i = parse->EventItem(EVENT_ITEM_CLICK_CAST, this, p_inst, nullptr, "", castspell->inventoryslot);
 
 							if (i == 0) {
@@ -4041,7 +4045,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 					}
 					else
 					{
-						ItemInst* p_inst = (ItemInst*)inst;
+						EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
 						int i = parse->EventItem(EVENT_ITEM_CLICK_CAST, this, p_inst, nullptr, "", castspell->inventoryslot);
 
 						if (i == 0) {
@@ -4066,7 +4070,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
 		}
 		else
 		{
-			Message(0, "Error: castspell->inventoryslot >= %i (0x%04x)", EQEmu::legacy::SlotCursor, castspell->inventoryslot);
+			Message(0, "Error: castspell->inventoryslot >= %i (0x%04x)", EQEmu::inventory::slotCursor, castspell->inventoryslot);
 			InterruptSpell(castspell->spell_id);
 		}
 	}
@@ -4853,13 +4857,13 @@ void Client::Handle_OP_Consume(const EQApplicationPacket *app)
 		}
 	}
 
-	ItemInst *myitem = GetInv().GetItem(pcs->slot);
+	EQEmu::ItemInstance *myitem = GetInv().GetItem(pcs->slot);
 	if (myitem == nullptr) {
 		Log.Out(Logs::General, Logs::Error, "Consuming from empty slot %d", pcs->slot);
 		return;
 	}
 
-	const EQEmu::ItemBase* eat_item = myitem->GetItem();
+	const EQEmu::ItemData* eat_item = myitem->GetItem();
 	if (pcs->type == 0x01) {
 		Consume(eat_item, EQEmu::item::ItemTypeFood, pcs->slot, (pcs->auto_consumed == 0xffffffff));
 	}
@@ -4989,7 +4993,7 @@ void Client::Handle_OP_CrashDump(const EQApplicationPacket *app)
 
 void Client::Handle_OP_CreateObject(const EQApplicationPacket *app)
 {
-	DropItem(EQEmu::legacy::SlotCursor);
+	DropItem(EQEmu::inventory::slotCursor);
 	return;
 }
 
@@ -5142,7 +5146,7 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app)
 	}
 
 	DeleteItem_Struct* alc = (DeleteItem_Struct*)app->pBuffer;
-	const ItemInst *inst = GetInv().GetItem(alc->from_slot);
+	const EQEmu::ItemInstance *inst = GetInv().GetItem(alc->from_slot);
 	if (inst && inst->GetItem()->ItemType == EQEmu::item::ItemTypeAlcohol) {
 		entity_list.MessageClose_StringID(this, true, 50, 0, DRINKING_MESSAGE, GetName(), inst->GetItem()->Name);
 		CheckIncreaseSkill(EQEmu::skills::SkillAlcoholTolerance, nullptr, 25);
@@ -6872,7 +6876,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 
 		if (Slot >= 0)
 		{
-			ItemInst* inst = GuildBanks->GetItem(GuildID(), GuildBankMainArea, Slot, 1);
+			EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), GuildBankMainArea, Slot, 1);
 
 			if (inst)
 			{
@@ -6892,7 +6896,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 	{
 		GuildBankViewItem_Struct *gbvis = (GuildBankViewItem_Struct*)app->pBuffer;
 
-		ItemInst* inst = GuildBanks->GetItem(GuildID(), gbvis->Area, gbvis->SlotID, 1);
+		EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), gbvis->Area, gbvis->SlotID, 1);
 
 		if (!inst)
 			break;
@@ -6915,7 +6919,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 			return;
 		}
 
-		ItemInst *CursorItemInst = GetInv().GetItem(EQEmu::legacy::SlotCursor);
+		EQEmu::ItemInstance *CursorItemInst = GetInv().GetItem(EQEmu::inventory::slotCursor);
 
 		bool Allowed = true;
 
@@ -6928,7 +6932,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 			return;
 		}
 
-		const EQEmu::ItemBase* CursorItem = CursorItemInst->GetItem();
+		const EQEmu::ItemData* CursorItem = CursorItemInst->GetItem();
 
 		if (!CursorItem->NoDrop || CursorItemInst->IsAttuned())
 		{
@@ -6963,7 +6967,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 		{
 			GuildBankDepositAck(false, sentAction);
 
-			DeleteItemInInventory(EQEmu::legacy::SlotCursor, 0, false);
+			DeleteItemInInventory(EQEmu::inventory::slotCursor, 0, false);
 		}
 
 		break;
@@ -6984,7 +6988,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 
 	case GuildBankWithdraw:
 	{
-		if (GetInv()[EQEmu::legacy::SlotCursor])
+		if (GetInv()[EQEmu::inventory::slotCursor])
 		{
 			Message_StringID(13, GUILD_BANK_EMPTY_HANDS);
 
@@ -6995,7 +6999,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 
 		GuildBankWithdrawItem_Struct *gbwis = (GuildBankWithdrawItem_Struct*)app->pBuffer;
 
-		ItemInst* inst = GuildBanks->GetItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
+		EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
 
 		if (!inst)
 		{
@@ -7030,7 +7034,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
 		{
 			PushItemOnCursor(*inst);
 
-			SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
+			SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
 
 			GuildBanks->DeleteItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
 		}
@@ -7907,6 +7911,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app)
 		}
 		else
 			hidden = true;
+		tmHidden = Timer::GetCurrentTime();
 	}
 	if (GetClass() == ROGUE){
 		auto outapp = new EQApplicationPacket(OP_SimpleMessage, sizeof(SimpleMessage_Struct));
@@ -8009,17 +8014,17 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
 	EQApplicationPacket* outapp = app->Copy();
 	InspectResponse_Struct* insr = (InspectResponse_Struct*)outapp->pBuffer;
 	Mob* tmp = entity_list.GetMob(insr->TargetID);
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
 
 	int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
-	for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::legacy::SlotWaist; L++) {
+	for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::inventory::slotWaist; L++) {
-		const ItemInst* inst = GetInv().GetItem(L);
+		const EQEmu::ItemInstance* inst = GetInv().GetItem(L);
 		item = inst ? inst->GetItem() : nullptr;
 
 		if (item) {
 			strcpy(insr->itemnames[L], item->Name);
 			if (inst && inst->GetOrnamentationAug(ornamentationAugtype)) {
-				const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
+				const EQEmu::ItemData *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
 				insr->itemicons[L] = aug_item->Icon;
 			}
 			else if (inst->GetOrnamentationIcon()) {
@@ -8032,7 +8037,7 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
 		else { insr->itemicons[L] = 0xFFFFFFFF; }
 	}
 
-	const ItemInst* inst = GetInv().GetItem(EQEmu::legacy::SlotAmmo);
+	const EQEmu::ItemInstance* inst = GetInv().GetItem(EQEmu::inventory::slotAmmo);
 	item = inst ? inst->GetItem() : nullptr;
 
 	if (item) {
@@ -8119,7 +8124,7 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
 	// todo: verify ivrs->link_hash based on a rule, in case we don't care about people being able to sniff data
 	// from the item DB
 
-	const EQEmu::ItemBase *item = database.GetItem(ivrs->item_id);
+	const EQEmu::ItemData *item = database.GetItem(ivrs->item_id);
 	if (!item) {
 		if (ivrs->item_id != SAYLINK_ITEM_ID) {
 			Message(13, "Error: The item for the link you have clicked on does not exist!");
@@ -8177,7 +8182,7 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
 		}
 	}
 
-	ItemInst *inst =
+	EQEmu::ItemInstance *inst =
 	    database.CreateItem(item, item->MaxCharges, ivrs->augments[0], ivrs->augments[1], ivrs->augments[2],
 				ivrs->augments[3], ivrs->augments[4], ivrs->augments[5]);
 	if (inst) {
@@ -8194,7 +8199,7 @@ void Client::Handle_OP_ItemLinkResponse(const EQApplicationPacket *app)
 		return;
 	}
 	LDONItemViewRequest_Struct* item = (LDONItemViewRequest_Struct*)app->pBuffer;
-	ItemInst* inst = database.CreateItem(item->item_id);
+	EQEmu::ItemInstance* inst = database.CreateItem(item->item_id);
 	if (inst) {
 		SendItemPacket(0, inst, ItemPacketViewLink);
 		safe_delete(inst);
@@ -8210,7 +8215,7 @@ void Client::Handle_OP_ItemName(const EQApplicationPacket *app)
 		return;
 	}
 	ItemNamePacket_Struct *p = (ItemNamePacket_Struct*)app->pBuffer;
-	const EQEmu::ItemBase *item = 0;
+	const EQEmu::ItemData *item = 0;
 	if ((item = database.GetItem(p->item_id)) != nullptr) {
 		auto outapp = new EQApplicationPacket(OP_ItemName, sizeof(ItemNamePacket_Struct));
 		p = (ItemNamePacket_Struct*)outapp->pBuffer;
@@ -8226,7 +8231,7 @@ void Client::Handle_OP_ItemPreview(const EQApplicationPacket *app)
 	VERIFY_PACKET_LENGTH(OP_ItemPreview, app, ItemPreview_Struct);
 	ItemPreview_Struct *ips = (ItemPreview_Struct *)app->pBuffer;
 
-	const EQEmu::ItemBase* item = database.GetItem(ips->itemid);
+	const EQEmu::ItemData* item = database.GetItem(ips->itemid);
 
 	if (item) {
 		auto outapp = new EQApplicationPacket(OP_ItemPreview, strlen(item->Name) + strlen(item->Lore) +
@@ -8437,14 +8442,14 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 		return;
 	}
 
-	const ItemInst* inst = m_inv[slot_id];
+	const EQEmu::ItemInstance* inst = m_inv[slot_id];
 	if (!inst) {
 		Message(0, "Error: item not found in inventory slot #%i", slot_id);
 		DeleteItemInInventory(slot_id, 0, true);
 		return;
 	}
 
-	const EQEmu::ItemBase* item = inst->GetItem();
+	const EQEmu::ItemData* item = inst->GetItem();
 	if (!item) {
 		Message(0, "Error: item not found in inventory slot #%i", slot_id);
 		DeleteItemInInventory(slot_id, 0, true);
@@ -8480,7 +8485,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 
 	if (m_inv.SupportsClickCasting(slot_id) || ((item->ItemType == EQEmu::item::ItemTypePotion || item->PotionBelt) && m_inv.SupportsPotionBeltCasting(slot_id))) // sanity check
 	{
-		ItemInst* p_inst = (ItemInst*)inst;
+		EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
 
 		parse->EventItem(EVENT_ITEM_CLICK, this, p_inst, nullptr, "", slot_id);
 		inst = m_inv[slot_id];
@@ -8491,22 +8496,22 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
 
 		int r;
 		bool tryaug = false;
-		ItemInst* clickaug = 0;
+		EQEmu::ItemInstance* clickaug = 0;
-		EQEmu::ItemBase* augitem = 0;
+		EQEmu::ItemData* augitem = 0;
 
-		for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
+		for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
-			const ItemInst* aug_i = inst->GetAugment(r);
+			const EQEmu::ItemInstance* aug_i = inst->GetAugment(r);
 			if (!aug_i)
 				continue;
-			const EQEmu::ItemBase* aug = aug_i->GetItem();
+			const EQEmu::ItemData* aug = aug_i->GetItem();
 			if (!aug)
 				continue;
 
 			if ((aug->Click.Type == EQEmu::item::ItemEffectClick) || (aug->Click.Type == EQEmu::item::ItemEffectExpendable) || (aug->Click.Type == EQEmu::item::ItemEffectEquipClick) || (aug->Click.Type == EQEmu::item::ItemEffectClick2))
 			{
 				tryaug = true;
-				clickaug = (ItemInst*)aug_i;
+				clickaug = (EQEmu::ItemInstance*)aug_i;
-				augitem = (EQEmu::ItemBase*)aug;
+				augitem = (EQEmu::ItemData*)aug;
 				spell_id = aug->Click.Effect;
 				break;
 			}
@@ -9674,8 +9679,8 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
 		if (mi->from_slot != mi->to_slot && (mi->from_slot <= EQEmu::legacy::GENERAL_END || mi->from_slot > 39) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot))
 		{
 			char *detect = nullptr;
-			const ItemInst *itm_from = GetInv().GetItem(mi->from_slot);
+			const EQEmu::ItemInstance *itm_from = GetInv().GetItem(mi->from_slot);
-			const ItemInst *itm_to = GetInv().GetItem(mi->to_slot);
+			const EQEmu::ItemInstance *itm_to = GetInv().GetItem(mi->to_slot);
 			MakeAnyLenString(&detect, "Player issued a move item from %u(item id %u) to %u(item id %u) while casting %u.",
 				mi->from_slot,
 				itm_from ? itm_from->GetID() : 0,
@@ -10541,7 +10546,7 @@ void Client::Handle_OP_PotionBelt(const EQApplicationPacket *app)
 	}
 
 	if (mptbs->Action == 0) {
-		const EQEmu::ItemBase *BaseItem = database.GetItem(mptbs->ItemID);
+		const EQEmu::ItemData *BaseItem = database.GetItem(mptbs->ItemID);
 		if (BaseItem) {
 			m_pp.potionbelt.Items[mptbs->SlotNumber].ID = BaseItem->ID;
 			m_pp.potionbelt.Items[mptbs->SlotNumber].Icon = BaseItem->Icon;
@@ -12027,12 +12032,12 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
 	Shielding_Struct* shield = (Shielding_Struct*)app->pBuffer;
 	shield_target = entity_list.GetMob(shield->target_id);
 	bool ack = false;
-	ItemInst* inst = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
+	EQEmu::ItemInstance* inst = GetInv().GetItem(EQEmu::inventory::slotSecondary);
 	if (!shield_target)
 		return;
 	if (inst)
 	{
-		const EQEmu::ItemBase* shield = inst->GetItem();
+		const EQEmu::ItemData* shield = inst->GetItem();
 		if (shield && shield->ItemType == EQEmu::item::ItemTypeShield)
 		{
 			for (int x = 0; x < 2; x++)
@@ -12130,17 +12135,12 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 			continue;
 		}
 
-		int32 fac = tmp->GetPrimaryFaction();
-		if (fac != 0 && GetModCharacterFactionLevel(fac) < ml.faction_required) {
-			continue;
-		}
-
 		if (mp->itemslot == ml.slot){
 			item_id = ml.item;
 			break;
 		}
 	}
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
 	uint32 prevcharges = 0;
 	if (item_id == 0) { //check to see if its on the temporary table
 		std::list<TempMerchantList> tmp_merlist = zone->tmpmerchanttable[tmp->GetNPCTypeID()];
@@ -12201,7 +12201,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 	else
 		charges = item->MaxCharges;
 
-	ItemInst* inst = database.CreateItem(item, charges);
+	EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
 
 	int SinglePrice = 0;
 	if (RuleB(Merchant, UsePriceMod))
@@ -12244,8 +12244,8 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 	// shouldn't we be reimbursing if these two fail?
 
 	//make sure we are not completely full...
-	if (freeslotid == EQEmu::legacy::SlotCursor) {
+	if (freeslotid == EQEmu::inventory::slotCursor) {
-		if (m_inv.GetItem(EQEmu::legacy::SlotCursor) != nullptr) {
+		if (m_inv.GetItem(EQEmu::inventory::slotCursor) != nullptr) {
 			Message(13, "You do not have room for any more items.");
 			safe_delete(outapp);
 			safe_delete(inst);
@@ -12322,7 +12322,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 		qsaudit->items[0].item_id = item->ID;
 		qsaudit->items[0].charges = mpo->quantity;
 
-		const ItemInst* audit_inst = m_inv[freeslotid];
+		const EQEmu::ItemInstance* audit_inst = m_inv[freeslotid];
 
 		if (audit_inst) {
 			qsaudit->items[0].aug_1 = audit_inst->GetAugmentItemID(0);
@@ -12388,8 +12388,8 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
 	uint32 itemid = GetItemIDAt(mp->itemslot);
 	if (itemid == 0)
 		return;
-	const EQEmu::ItemBase* item = database.GetItem(itemid);
+	const EQEmu::ItemData* item = database.GetItem(itemid);
-	ItemInst* inst = GetInv().GetItem(mp->itemslot);
+	EQEmu::ItemInstance* inst = GetInv().GetItem(mp->itemslot);
 	if (!item || !inst){
 		Message(13, "You seemed to have misplaced that item..");
 		return;
@@ -12434,7 +12434,7 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
 
 	int freeslot = 0;
 	if (charges > 0 && (freeslot = zone->SaveTempItem(vendor->CastToNPC()->MerchantType, vendor->GetNPCTypeID(), itemid, charges, true)) > 0){
-		ItemInst* inst2 = inst->Clone();
+		EQEmu::ItemInstance* inst2 = inst->Clone();
 
 		while (true) {
 			if (inst2 == nullptr)
@@ -13499,7 +13499,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
 					TradeItemsValid = false;
 					break;
 				}
-				const EQEmu::ItemBase *Item = database.GetItem(gis->Items[i]);
+				const EQEmu::ItemData *Item = database.GetItem(gis->Items[i]);
 
 				if (!Item) {
 					Message(13, "Unexpected error. Unable to start trader mode");

zone/client_process.cpp

@@ -296,7 +296,7 @@ bool Client::Process() {
 		}
 
 		if(AutoFireEnabled()){
-			ItemInst *ranged = GetInv().GetItem(EQEmu::legacy::SlotRange);
+			EQEmu::ItemInstance *ranged = GetInv().GetItem(EQEmu::inventory::slotRange);
 			if(ranged)
 			{
 				if (ranged->GetItem() && ranged->GetItem()->ItemType == EQEmu::item::ItemTypeBow){
@@ -391,10 +391,10 @@ bool Client::Process() {
 			}
 			else if (auto_attack_target->GetHP() > -10) // -10 so we can watch people bleed in PvP
 			{
-				ItemInst *wpn = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
+				EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::inventory::slotPrimary);
-				TryWeaponProc(wpn, auto_attack_target, EQEmu::legacy::SlotPrimary);
+				TryWeaponProc(wpn, auto_attack_target, EQEmu::inventory::slotPrimary);
 
-				DoAttackRounds(auto_attack_target, EQEmu::legacy::SlotPrimary);
+				DoAttackRounds(auto_attack_target, EQEmu::inventory::slotPrimary);
 				if (CheckAATimer(aaTimerRampage))
 					entity_list.AEAttack(this, 30);
 			}
@@ -430,10 +430,10 @@ bool Client::Process() {
 			else if(auto_attack_target->GetHP() > -10) {
 				CheckIncreaseSkill(EQEmu::skills::SkillDualWield, auto_attack_target, -10);
 				if (CheckDualWield()) {
-					ItemInst *wpn = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
+					EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::inventory::slotSecondary);
-					TryWeaponProc(wpn, auto_attack_target, EQEmu::legacy::SlotSecondary);
+					TryWeaponProc(wpn, auto_attack_target, EQEmu::inventory::slotSecondary);
 
-					DoAttackRounds(auto_attack_target, EQEmu::legacy::SlotSecondary);
+					DoAttackRounds(auto_attack_target, EQEmu::inventory::slotSecondary);
 				}
 			}
 		}
@@ -738,7 +738,7 @@ void Client::BulkSendInventoryItems()
 	// LINKDEAD TRADE ITEMS
 	// Move trade slot items back into normal inventory..need them there now for the proceeding validity checks
 	for (int16 slot_id = EQEmu::legacy::TRADE_BEGIN; slot_id <= EQEmu::legacy::TRADE_END; slot_id++) {
-		ItemInst* inst = m_inv.PopItem(slot_id);
+		EQEmu::ItemInstance* inst = m_inv.PopItem(slot_id);
 		if(inst) {
 			bool is_arrow = (inst->GetItem()->ItemType == EQEmu::item::ItemTypeArrow) ? true : false;
 			int16 free_slot_id = m_inv.FindFreeSlot(inst->IsClassBag(), true, inst->GetItem()->Size, is_arrow);
@@ -763,8 +763,8 @@ void Client::BulkSendInventoryItems()
 	EQEmu::OutBuffer::pos_type last_pos = ob.tellp();
 
 	// Possessions items
-	for (int16 slot_id = SLOT_BEGIN; slot_id < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; slot_id++) {
+	for (int16 slot_id = EQEmu::inventory::slotBegin; slot_id < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; slot_id++) {
-		const ItemInst* inst = m_inv[slot_id];
+		const EQEmu::ItemInstance* inst = m_inv[slot_id];
 		if (!inst)
 			continue;
 
@@ -778,12 +778,12 @@ void Client::BulkSendInventoryItems()
 
 	// PowerSource item
 	if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
-		const ItemInst* inst = m_inv[EQEmu::legacy::SlotPowerSource];
+		const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotPowerSource];
 		if (inst) {
-			inst->Serialize(ob, EQEmu::legacy::SlotPowerSource);
+			inst->Serialize(ob, EQEmu::inventory::slotPowerSource);
 
 			if (ob.tellp() == last_pos)
-				Log.Out(Logs::General, Logs::Inventory, "Serialization failed on item slot %d during BulkSendInventoryItems.  Item skipped.", EQEmu::legacy::SlotPowerSource);
+				Log.Out(Logs::General, Logs::Inventory, "Serialization failed on item slot %d during BulkSendInventoryItems.  Item skipped.", EQEmu::inventory::slotPowerSource);
 
 			last_pos = ob.tellp();
 		}
@@ -791,7 +791,7 @@ void Client::BulkSendInventoryItems()
 
 	// Bank items
 	for (int16 slot_id = EQEmu::legacy::BANK_BEGIN; slot_id <= EQEmu::legacy::BANK_END; slot_id++) {
-		const ItemInst* inst = m_inv[slot_id];
+		const EQEmu::ItemInstance* inst = m_inv[slot_id];
 		if (!inst)
 			continue;
 
@@ -805,7 +805,7 @@ void Client::BulkSendInventoryItems()
 
 	// SharedBank items
 	for (int16 slot_id = EQEmu::legacy::SHARED_BANK_BEGIN; slot_id <= EQEmu::legacy::SHARED_BANK_END; slot_id++) {
-		const ItemInst* inst = m_inv[slot_id];
+		const EQEmu::ItemInstance* inst = m_inv[slot_id];
 		if (!inst)
 			continue;
 
@@ -825,12 +825,12 @@ void Client::BulkSendInventoryItems()
 }
 
 void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
-	const EQEmu::ItemBase* handyitem = nullptr;
+	const EQEmu::ItemData* handyitem = nullptr;
 	uint32 numItemSlots = 80; //The max number of items passed in the transaction.
 	if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) { // RoF+ can send 200 items
 		numItemSlots = 200;
 	}
-	const EQEmu::ItemBase *item;
+	const EQEmu::ItemData *item;
 	std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
 	std::list<MerchantList>::const_iterator itr;
 	Mob* merch = entity_list.GetMobByNpcTypeID(npcid);
@@ -857,7 +857,15 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 			continue;
 
 		int32 fac = merch ? merch->GetPrimaryFaction() : 0;
-		if (fac != 0 && GetModCharacterFactionLevel(fac) < ml.faction_required)
+		int32 cur_fac_level;
+		if (fac == 0 || sneaking) {
+			cur_fac_level = 0;
+		}
+		else {
+			cur_fac_level = GetModCharacterFactionLevel(fac);
+		}
+			
+		if (cur_fac_level < ml.faction_required)
 			continue;
 
 		handychance = zone->random.Int(0, merlist.size() + tmp_merlist.size() - 1);
@@ -871,7 +879,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 			int charges = 1;
 			if (item->IsClassCommon())
 				charges = item->MaxCharges;
-			ItemInst* inst = database.CreateItem(item, charges);
+			EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
 			if (inst) {
 				if (RuleB(Merchant, UsePriceMod)) {
 					inst->SetPrice((item->Price * (RuleR(Merchant, SellCostMod)) * item->SellRate * Client::CalcPriceMod(merch, false)));
@@ -912,7 +920,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
 			//	charges=ml.charges;
 			//else
 			charges = item->MaxCharges;
-			ItemInst* inst = database.CreateItem(item, charges);
+			EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
 			if (inst) {
 				if (RuleB(Merchant, UsePriceMod)) {
 					inst->SetPrice((item->Price * (RuleR(Merchant, SellCostMod)) * item->SellRate * Client::CalcPriceMod(merch, false)));
@@ -1087,11 +1095,11 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
 	switch(memspell->scribing)
 	{
 		case memSpellScribing:	{	// scribing spell to book
-			const ItemInst* inst = m_inv[EQEmu::legacy::SlotCursor];
+			const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotCursor];
 
 			if (inst && inst->IsClassCommon())
 			{
-				const EQEmu::ItemBase* item = inst->GetItem();
+				const EQEmu::ItemData* item = inst->GetItem();
 
 				if (RuleB(Character, RestrictSpellScribing) && !item->IsEquipable(GetRace(), GetClass())) {
 					Message_StringID(13, CANNOT_USE_ITEM);
@@ -1101,7 +1109,7 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
 				if(item && item->Scroll.Effect == (int32)(memspell->spell_id))
 				{
 					ScribeSpell(memspell->spell_id, memspell->slot);
-					DeleteItemInInventory(EQEmu::legacy::SlotCursor, 1, true);
+					DeleteItemInInventory(EQEmu::inventory::slotCursor, 1, true);
 				}
 				else
 					Message(0,"Scribing spell: inst exists but item does not or spell ids do not match.");
@@ -1186,6 +1194,12 @@ void Client::OPMoveCoin(const EQApplicationPacket* app)
 	int32 *from_bucket = 0, *to_bucket = 0;
 	Mob* trader = trade->With();
 
+	// if amount < 0, client is sending a malicious packet
+	if (mc->amount < 0)
+	{
+		return;
+	}
+	
 	// could just do a range, but this is clearer and explicit
 	if
 	(

zone/command.cpp

@@ -1471,16 +1471,29 @@ void command_npcstats(Client *c, const Seperator *sep)
 	else if (!c->GetTarget()->IsNPC())
 		c->Message(0, "ERROR: Target is not a NPC!");
 	else {
+		auto target_npc = c->GetTarget()->CastToNPC();
 		c->Message(0, "NPC Stats:");
-		c->Message(0, "Name: %s   NpcID: %u",  c->GetTarget()->GetName(), c->GetTarget()->GetNPCTypeID());
+		c->Message(0, "Name: %s   NpcID: %u", target_npc->GetName(), target_npc->GetNPCTypeID());
-		c->Message(0, "Race: %i  Level: %i  Class: %i  Material: %i",  c->GetTarget()->GetRace(), c->GetTarget()->GetLevel(), c->GetTarget()->GetClass(), c->GetTarget()->GetTexture());
+		c->Message(0, "Race: %i  Level: %i  Class: %i  Material: %i", target_npc->GetRace(), target_npc->GetLevel(), target_npc->GetClass(), target_npc->GetTexture());
-		c->Message(0, "Current HP: %i  Max HP: %i",  c->GetTarget()->GetHP(), c->GetTarget()->GetMaxHP());
+		c->Message(0, "Current HP: %i  Max HP: %i", target_npc->GetHP(), target_npc->GetMaxHP());
-		//c->Message(0, "Weapon Item Number: %s", c->GetTarget()->GetWeapNo());
+		//c->Message(0, "Weapon Item Number: %s", target_npc->GetWeapNo());
-		c->Message(0, "Gender: %i  Size: %f  Bodytype: %d",  c->GetTarget()->GetGender(), c->GetTarget()->GetSize(), c->GetTarget()->GetBodyType());
+		c->Message(0, "Gender: %i  Size: %f  Bodytype: %d", target_npc->GetGender(), target_npc->GetSize(), target_npc->GetBodyType());
-		c->Message(0, "Runspeed: %.3f  Walkspeed: %.3f",  static_cast<float>(0.025f * c->GetTarget()->GetRunspeed()), static_cast<float>(0.025f * c->GetTarget()->GetWalkspeed()));
+		c->Message(0, "Runspeed: %.3f  Walkspeed: %.3f", static_cast<float>(0.025f * target_npc->GetRunspeed()), static_cast<float>(0.025f * target_npc->GetWalkspeed()));
-		c->Message(0, "Spawn Group: %i  Grid: %i",  c->GetTarget()->CastToNPC()->GetSp2(), c->GetTarget()->CastToNPC()->GetGrid());
+		c->Message(0, "Spawn Group: %i  Grid: %i", target_npc->GetSp2(), target_npc->GetGrid());
-		c->Message(0, "EmoteID: %i",  c->GetTarget()->CastToNPC()->GetEmoteID());
+		if (target_npc->proximity) {
-		c->GetTarget()->CastToNPC()->QueryLoot(c);
+			c->Message(0, "Proximity: Enabled");
+			c->Message(0, "Cur_X: %1.3f, Cur_Y: %1.3f, Cur_Z: %1.3f", target_npc->GetX(), target_npc->GetY(), target_npc->GetZ());
+			c->Message(0, "Min_X: %1.3f(%1.3f), Max_X: %1.3f(%1.3f), X_Range: %1.3f", target_npc->proximity->min_x, (target_npc->proximity->min_x - target_npc->GetX()), target_npc->proximity->max_x, (target_npc->proximity->max_x - target_npc->GetX()), (target_npc->proximity->max_x - target_npc->proximity->min_x));
+			c->Message(0, "Min_Y: %1.3f(%1.3f), Max_Y: %1.3f(%1.3f), Y_Range: %1.3f", target_npc->proximity->min_y, (target_npc->proximity->min_y - target_npc->GetY()), target_npc->proximity->max_y, (target_npc->proximity->max_y - target_npc->GetY()), (target_npc->proximity->max_y - target_npc->proximity->min_y));
+			c->Message(0, "Min_Z: %1.3f(%1.3f), Max_Z: %1.3f(%1.3f), Z_Range: %1.3f", target_npc->proximity->min_z, (target_npc->proximity->min_z - target_npc->GetZ()), target_npc->proximity->max_z, (target_npc->proximity->max_z - target_npc->GetZ()), (target_npc->proximity->max_z - target_npc->proximity->min_z));
+			c->Message(0, "Say: %s", (target_npc->proximity->say ? "Enabled" : "Disabled"));
+		}
+		else {
+			c->Message(0, "Proximity: Disabled");
+		}
+		c->Message(0, "");
+		c->Message(0, "EmoteID: %i", target_npc->GetEmoteID());
+		target_npc->QueryLoot(c);
 	}
 }
 
@@ -2417,14 +2430,14 @@ void command_texture(Client *c, const Seperator *sep)
 		// Player Races Wear Armor, so Wearchange is sent instead
 		int i;
 		if (!c->GetTarget())
-			for (i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
+			for (i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
 			{
 				c->SendTextureWC(i, texture);
 			}
 		else if ((c->GetTarget()->GetRace() > 0 && c->GetTarget()->GetRace() <= 12) ||
 			c->GetTarget()->GetRace() == 128 || c->GetTarget()->GetRace() == 130 ||
 			c->GetTarget()->GetRace() == 330 || c->GetTarget()->GetRace() == 522) {
-			for (i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
+			for (i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
 			{
 				c->GetTarget()->SendTextureWC(i, texture);
 			}
@@ -2545,9 +2558,9 @@ void command_peekinv(Client *c, const Seperator *sep)
 	}
 
 	Client* targetClient = c->GetTarget()->CastToClient();
-	const ItemInst* inst_main = nullptr;
+	const EQEmu::ItemInstance* inst_main = nullptr;
-	const ItemInst* inst_sub = nullptr;
+	const EQEmu::ItemInstance* inst_sub = nullptr;
-	const EQEmu::ItemBase* item_data = nullptr;
+	const EQEmu::ItemData* item_data = nullptr;
 	std::string item_link;
 	EQEmu::SayLinkEngine linker;
 	linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
@@ -2567,14 +2580,14 @@ void command_peekinv(Client *c, const Seperator *sep)
 	}
 
 	if ((scopeWhere & peekWorn) && (targetClient->ClientVersion() >= EQEmu::versions::ClientVersion::SoF)) {
-		inst_main = targetClient->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
+		inst_main = targetClient->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
 		item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem();
 		linker.SetItemInst(inst_main);
 
 		item_link = linker.GenerateLink();
 
 		c->Message((item_data == nullptr), "WornSlot: %i, Item: %i (%s), Charges: %i",
-			EQEmu::legacy::SlotPowerSource, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
+			EQEmu::inventory::slotPowerSource, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 	}
 
 	// inv
@@ -2588,7 +2601,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 		c->Message((item_data == nullptr), "InvSlot: %i, Item: %i (%s), Charges: %i",
 			indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-		for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+		for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 			inst_sub = inst_main->GetItem(indexSub);
 			item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 			linker.SetItemInst(inst_sub);
@@ -2596,7 +2609,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 			item_link = linker.GenerateLink();
 
 			c->Message((item_data == nullptr), "  InvBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
-				Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
+				EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
 		}
 	}
 
@@ -2608,7 +2621,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 			item_link = linker.GenerateLink();
 
 			c->Message(1, "CursorSlot: %i, Item: %i (%s), Charges: %i",
-				EQEmu::legacy::SlotCursor, 0, item_link.c_str(), 0);
+				EQEmu::inventory::slotCursor, 0, item_link.c_str(), 0);
 		}
 		else {
 			int cursorDepth = 0;
@@ -2620,9 +2633,9 @@ void command_peekinv(Client *c, const Seperator *sep)
 				item_link = linker.GenerateLink();
 
 				c->Message((item_data == nullptr), "CursorSlot: %i, Depth: %i, Item: %i (%s), Charges: %i",
-					EQEmu::legacy::SlotCursor, cursorDepth, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
+					EQEmu::inventory::slotCursor, cursorDepth, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-				for (uint8 indexSub = SUB_INDEX_BEGIN; (cursorDepth == 0) && inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+				for (uint8 indexSub = EQEmu::inventory::containerBegin; (cursorDepth == 0) && inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 					inst_sub = inst_main->GetItem(indexSub);
 					item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 					linker.SetItemInst(inst_sub);
@@ -2630,7 +2643,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 					item_link = linker.GenerateLink();
 
 					c->Message((item_data == nullptr), "  CursorBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
-						Inventory::CalcSlotId(EQEmu::legacy::SlotCursor, indexSub), EQEmu::legacy::SlotCursor, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
+						EQEmu::InventoryProfile::CalcSlotId(EQEmu::inventory::slotCursor, indexSub), EQEmu::inventory::slotCursor, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
 				}
 			}
 		}
@@ -2659,7 +2672,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 		c->Message((item_data == nullptr), "BankSlot: %i, Item: %i (%s), Charges: %i",
 			indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-		for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+		for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 			inst_sub = inst_main->GetItem(indexSub);
 			item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 			linker.SetItemInst(inst_sub);
@@ -2667,7 +2680,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 			item_link = linker.GenerateLink();
 
 			c->Message((item_data == nullptr), "  BankBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
-				Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
+				EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
 		}
 	}
 
@@ -2681,7 +2694,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 		c->Message((item_data == nullptr), "SharedBankSlot: %i, Item: %i (%s), Charges: %i",
 			indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-		for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+		for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 			inst_sub = inst_main->GetItem(indexSub);
 			item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 			linker.SetItemInst(inst_sub);
@@ -2689,7 +2702,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 			item_link = linker.GenerateLink();
 
 			c->Message((item_data == nullptr), "  SharedBankBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
-				Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
+				EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
 		}
 	}
 
@@ -2704,7 +2717,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 		c->Message((item_data == nullptr), "TradeSlot: %i, Item: %i (%s), Charges: %i",
 			indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-		for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+		for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 			inst_sub = inst_main->GetItem(indexSub);
 			item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 			linker.SetItemInst(inst_sub);
@@ -2712,7 +2725,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 			item_link = linker.GenerateLink();
 
 			c->Message((item_data == nullptr), "  TradeBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
-				Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
+				EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
 		}
 	}
 
@@ -2726,7 +2739,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 		else {
 			c->Message(0, "[WorldObject DBID: %i (entityid: %i)]",  objectTradeskill->GetDBID(), objectTradeskill->GetID());
 
-			for (int16 indexMain = SLOT_BEGIN; indexMain < EQEmu::legacy::TYPE_WORLD_SIZE; ++indexMain) {
+			for (int16 indexMain = EQEmu::inventory::slotBegin; indexMain < EQEmu::legacy::TYPE_WORLD_SIZE; ++indexMain) {
 				inst_main = objectTradeskill->GetItem(indexMain);
 				item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem();
 				linker.SetItemInst(inst_main);
@@ -2736,7 +2749,7 @@ void command_peekinv(Client *c, const Seperator *sep)
 				c->Message((item_data == nullptr), "WorldSlot: %i, Item: %i (%s), Charges: %i",
 					(EQEmu::legacy::WORLD_BEGIN + indexMain), ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
 
-				for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsType(EQEmu::item::ItemClassBag) && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
+				for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsType(EQEmu::item::ItemClassBag) && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
 					inst_sub = inst_main->GetItem(indexSub);
 					item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
 					linker.SetItemInst(inst_sub);
@@ -2780,7 +2793,7 @@ void command_interrogateinv(Client *c, const Seperator *sep)
 	}
 
 	Client* target = nullptr;
-	std::map<int16, const ItemInst*> instmap;
+	std::map<int16, const EQEmu::ItemInstance*> instmap;
 	bool log = false;
 	bool silent = false;
 	bool error = false;
@@ -3145,16 +3158,16 @@ void command_listpetition(Client *c, const Seperator *sep)
 void command_equipitem(Client *c, const Seperator *sep)
 {
 	uint32 slot_id = atoi(sep->arg[1]);
-	if (sep->IsNumber(1) && ((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || (slot_id == EQEmu::legacy::SlotPowerSource))) {
+	if (sep->IsNumber(1) && ((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || (slot_id == EQEmu::inventory::slotPowerSource))) {
-		const ItemInst* from_inst = c->GetInv().GetItem(EQEmu::legacy::SlotCursor);
+		const EQEmu::ItemInstance* from_inst = c->GetInv().GetItem(EQEmu::inventory::slotCursor);
-		const ItemInst* to_inst = c->GetInv().GetItem(slot_id); // added (desync issue when forcing stack to stack)
+		const EQEmu::ItemInstance* to_inst = c->GetInv().GetItem(slot_id); // added (desync issue when forcing stack to stack)
 		bool partialmove = false;
 		int16 movecount;
 
 		if (from_inst && from_inst->IsClassCommon()) {
 			auto outapp = new EQApplicationPacket(OP_MoveItem, sizeof(MoveItem_Struct));
 			MoveItem_Struct* mi	= (MoveItem_Struct*)outapp->pBuffer;
-			mi->from_slot = EQEmu::legacy::SlotCursor;
+			mi->from_slot = EQEmu::inventory::slotCursor;
 			mi->to_slot			= slot_id;
 			// mi->number_in_stack	= from_inst->GetCharges(); // replaced with con check for stacking
 
@@ -4339,7 +4352,7 @@ void command_goto(Client *c, const Seperator *sep)
 
 void command_iteminfo(Client *c, const Seperator *sep)
 {
-	auto inst = c->GetInv()[EQEmu::legacy::SlotCursor];
+	auto inst = c->GetInv()[EQEmu::inventory::slotCursor];
 	if (!inst) {
 		c->Message(13, "Error: You need an item on your cursor for this command");
 		return;
@@ -5519,7 +5532,7 @@ void command_summonitem(Client *c, const Seperator *sep)
 	}
 
 	int16 item_status = 0;
-	const EQEmu::ItemBase* item = database.GetItem(itemid);
+	const EQEmu::ItemData* item = database.GetItem(itemid);
 	if (item) {
 		item_status = static_cast<int16>(item->MinStatus);
 	}
@@ -5558,7 +5571,7 @@ void command_giveitem(Client *c, const Seperator *sep)
 		Client *t = c->GetTarget()->CastToClient();
 		uint32 itemid = atoi(sep->arg[1]);
 		int16 item_status = 0;
-		const EQEmu::ItemBase* item = database.GetItem(itemid);
+		const EQEmu::ItemData* item = database.GetItem(itemid);
 		if(item) {
 			item_status = static_cast<int16>(item->MinStatus);
 		}
@@ -5611,7 +5624,7 @@ void command_itemsearch(Client *c, const Seperator *sep)
 	{
 		const char *search_criteria=sep->argplus[1];
 
-		const EQEmu::ItemBase* item = nullptr;
+		const EQEmu::ItemData* item = nullptr;
 		std::string item_link;
 		EQEmu::SayLinkEngine linker;
 		linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
@@ -7124,9 +7137,9 @@ void command_path(Client *c, const Seperator *sep)
 }
 
 void Client::Undye() {
-	for (int cur_slot = EQEmu::textures::TextureBegin; cur_slot <= EQEmu::textures::LastTexture; cur_slot++) {
+	for (int cur_slot = EQEmu::textures::textureBegin; cur_slot <= EQEmu::textures::LastTexture; cur_slot++) {
 		uint8 slot2=SlotConvert(cur_slot);
-		ItemInst* inst = m_inv.GetItem(slot2);
+		EQEmu::ItemInstance* inst = m_inv.GetItem(slot2);
 
 		if(inst != nullptr) {
 			inst->SetColor(inst->GetItem()->Color);
@@ -10235,7 +10248,7 @@ void command_zopp(Client *c, const Seperator *sep)
 		uint32 itemid = atoi(sep->arg[3]);
 		int16 charges = sep->argnum == 4 ? atoi(sep->arg[4]) : 1; // defaults to 1 charge if not specified
 
-		const EQEmu::ItemBase* FakeItem = database.GetItem(itemid);
+		const EQEmu::ItemData* FakeItem = database.GetItem(itemid);
 
 		if (!FakeItem) {
 			c->Message(13, "Error: Item [%u] is not a valid item id.",  itemid);
@@ -10243,7 +10256,7 @@ void command_zopp(Client *c, const Seperator *sep)
 		}
 
 		int16 item_status = 0;
-		const EQEmu::ItemBase* item = database.GetItem(itemid);
+		const EQEmu::ItemData* item = database.GetItem(itemid);
 		if(item) {
 			item_status = static_cast<int16>(item->MinStatus);
 		}
@@ -10257,7 +10270,7 @@ void command_zopp(Client *c, const Seperator *sep)
 			c->Message(0, "Processing request..results may cause unpredictable behavior.");
 		}
 
-		ItemInst* FakeItemInst = database.CreateItem(FakeItem, charges);
+		EQEmu::ItemInstance* FakeItemInst = database.CreateItem(FakeItem, charges);
 		c->SendItemPacket(slotid, FakeItemInst, packettype);
 		c->Message(0, "Sending zephyr op packet to client - [%s] %s (%u) with %i %s to slot %i.",
 			   packettype == ItemPacketTrade ? "Trade" : "Summon",  FakeItem->Name, itemid, charges,

zone/common.h

@@ -568,7 +568,11 @@ struct MercData {
 	uint32	NPCID;
 };
 
-class ItemInst;
+namespace EQEmu
+{
+	class ItemInstance;
+}
+
 class Mob;
 // All data associated with a single trade
 class Trade
@@ -606,7 +610,7 @@ public:
 
 private:
 	// Send item data for trade item to other person involved in trade
-	void SendItemData(const ItemInst* inst, int16 dest_slot_id);
+	void SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id);
 
 	uint32 with_id;
 	Mob* owner;

zone/corpse.cpp

@@ -268,7 +268,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
 	int i;
 
 	PlayerProfile_Struct *pp = &client->GetPP();
-	ItemInst *item;
+	EQEmu::ItemInstance *item;
 
 	/* Check if Zone has Graveyard First */
 	if(!zone->HasGraveyard()) {
@@ -323,12 +323,12 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
 		// to go into the regular slots on the player, out of bags
 		std::list<uint32> removed_list;
 		
-		for (i = SLOT_BEGIN; i < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; ++i) {
+		for (i = EQEmu::inventory::slotBegin; i < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; ++i) {
-			if (i == EQEmu::legacy::SlotAmmo && client->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
+			if (i == EQEmu::inventory::slotAmmo && client->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
-				item = client->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
+				item = client->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
 				if (item != nullptr) {
 					if (!client->IsBecomeNPC() || (client->IsBecomeNPC() && !item->GetItem()->NoRent))
-						MoveItemToCorpse(client, item, EQEmu::legacy::SlotPowerSource, removed_list);
+						MoveItemToCorpse(client, item, EQEmu::inventory::slotPowerSource, removed_list);
 				}
 			}
 
@@ -387,7 +387,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
 	Save();
 }
 
-void Corpse::MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, std::list<uint32> &removedList)
+void Corpse::MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList)
 {
 	AddItem(
 		inst->GetItem()->ID,
@@ -405,10 +405,10 @@ void Corpse::MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, s
 
 	while (true) {
 		if (!inst->IsClassBag()) { break; }
-		if (equipSlot < EQEmu::legacy::GENERAL_BEGIN || equipSlot > EQEmu::legacy::SlotCursor) { break; }
+		if (equipSlot < EQEmu::legacy::GENERAL_BEGIN || equipSlot > EQEmu::inventory::slotCursor) { break; }
 
-		for (auto sub_index = SUB_INDEX_BEGIN; sub_index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++sub_index) {
+		for (int16 sub_index = EQEmu::inventory::containerBegin; sub_index < EQEmu::inventory::ContainerCount; ++sub_index) {
-			int16 real_bag_slot = Inventory::CalcSlotId(equipSlot, sub_index);
+			int16 real_bag_slot = EQEmu::InventoryProfile::CalcSlotId(equipSlot, sub_index);
 			auto bag_inst = client->GetInv().GetItem(real_bag_slot);
 			if (bag_inst == nullptr) { continue; }
 
@@ -684,8 +684,8 @@ ServerLootItem_Struct* Corpse::GetItem(uint16 lootslot, ServerLootItem_Struct**
 		}
 	}
 
-	if (sitem && bag_item_data && Inventory::SupportsContainers(sitem->equip_slot)) {
+	if (sitem && bag_item_data && EQEmu::InventoryProfile::SupportsContainers(sitem->equip_slot)) {
-		int16 bagstart = Inventory::CalcSlotId(sitem->equip_slot, SUB_INDEX_BEGIN);
+		int16 bagstart = EQEmu::InventoryProfile::CalcSlotId(sitem->equip_slot, EQEmu::inventory::containerBegin);
 
 		cur = itemlist.begin();
 		end = itemlist.end();
@@ -739,8 +739,8 @@ void Corpse::RemoveItem(ServerLootItem_Struct* item_data)
 		is_corpse_changed = true;
 		itemlist.erase(iter);
 
-		uint8 material = Inventory::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
+		uint8 material = EQEmu::InventoryProfile::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
-		if (material != EQEmu::textures::TextureInvalid)
+		if (material != EQEmu::textures::materialInvalid)
 			SendWearChange(material);
 
 		UpdateEquipmentLight();
@@ -979,8 +979,8 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
 		safe_delete(outapp);
 		if(Loot_Request_Type == 5) {
 			int pkitem = GetPlayerKillItem();
-			const EQEmu::ItemBase* item = database.GetItem(pkitem);
+			const EQEmu::ItemData* item = database.GetItem(pkitem);
-			ItemInst* inst = database.CreateItem(item, item->MaxCharges);
+			EQEmu::ItemInstance* inst = database.CreateItem(item, item->MaxCharges);
 			if(inst) {
 				if (item->RecastDelay)
 					inst->SetRecastTimestamp(timestamps.count(item->RecastType) ? timestamps.at(item->RecastType) : 0);
@@ -994,12 +994,12 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
 		}
 
 		int i = 0;
-		const EQEmu::ItemBase* item = 0;
+		const EQEmu::ItemData* item = 0;
 		ItemList::iterator cur,end;
 		cur = itemlist.begin();
 		end = itemlist.end();
 
-		int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::legacy::TypeCorpse];
+		int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
 
 		for(; cur != end; ++cur) {
 			ServerLootItem_Struct* item_data = *cur;
@@ -1008,12 +1008,12 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
 			// Dont display the item if it's in a bag
 
 			// Added cursor queue slots to corpse item visibility list. Nothing else should be making it to corpse.
-			if (!IsPlayerCorpse() || item_data->equip_slot <= EQEmu::legacy::SlotCursor || item_data->equip_slot == EQEmu::legacy::SlotPowerSource || Loot_Request_Type >= 3 ||
+			if (!IsPlayerCorpse() || item_data->equip_slot <= EQEmu::inventory::slotCursor || item_data->equip_slot == EQEmu::inventory::slotPowerSource || Loot_Request_Type >= 3 ||
 				(item_data->equip_slot >= 8000 && item_data->equip_slot <= 8999)) {
 				if(i < corpselootlimit) {
 					item = database.GetItem(item_data->item_id);
 					if(client && item) {
-						ItemInst* inst = database.CreateItem(item, item_data->charges, item_data->aug_1, item_data->aug_2, item_data->aug_3, item_data->aug_4, item_data->aug_5, item_data->aug_6, item_data->attuned);
+						EQEmu::ItemInstance* inst = database.CreateItem(item, item_data->charges, item_data->aug_1, item_data->aug_2, item_data->aug_3, item_data->aug_4, item_data->aug_5, item_data->aug_6, item_data->attuned);
 						if(inst) {
 							if (item->RecastDelay)
 								inst->SetRecastTimestamp(timestamps.count(item->RecastType) ? timestamps.at(item->RecastType) : 0);
@@ -1110,8 +1110,8 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
 		being_looted_by = 0xFFFFFFFF;
 		return;
 	}
-	const EQEmu::ItemBase* item = 0;
+	const EQEmu::ItemData* item = 0;
-	ItemInst *inst = 0;
+	EQEmu::ItemInstance *inst = 0;
 	ServerLootItem_Struct* item_data = nullptr, *bag_item_data[10];
 
 	memset(bag_item_data, 0, sizeof(bag_item_data));
@@ -1148,8 +1148,8 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
 		}
 
 		if (inst->IsAugmented()) {
-			for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
+			for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
-				ItemInst *itm = inst->GetAugment(i);
+				EQEmu::ItemInstance *itm = inst->GetAugment(i);
 				if (itm) {
 					if (client->CheckLoreConflict(itm->GetItem())) {
 						client->Message_StringID(0, LOOT_LORE_ERROR);
@@ -1190,10 +1190,10 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
 		/* First add it to the looter - this will do the bag contents too */
 		if (lootitem->auto_loot) {
 			if (!client->AutoPutLootInInventory(*inst, true, true, bag_item_data))
-				client->PutLootInInventory(EQEmu::legacy::SlotCursor, *inst, bag_item_data);
+				client->PutLootInInventory(EQEmu::inventory::slotCursor, *inst, bag_item_data);
 		}
 		else {
-			client->PutLootInInventory(EQEmu::legacy::SlotCursor, *inst, bag_item_data);
+			client->PutLootInInventory(EQEmu::inventory::slotCursor, *inst, bag_item_data);
 		}
 
 		/* Update any tasks that have an activity to loot this item */
@@ -1210,7 +1210,7 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
 
 		/* Remove Bag Contents */
 		if (item->IsClassBag() && (GetPlayerKillItem() != -1 || GetPlayerKillItem() != 1)) {
-			for (int i = SUB_INDEX_BEGIN; i < EQEmu::legacy::ITEM_CONTAINER_SIZE; i++) {
+			for (int i = EQEmu::inventory::containerBegin; i < EQEmu::inventory::ContainerCount; i++) {
 				if (bag_item_data[i]) {
 					/* Delete needs to be before RemoveItem because its deletes the pointer for item_data/bag_item_data */
 					database.DeleteItemOffCharacterCorpse(this->corpse_db_id, bag_item_data[i]->equip_slot, bag_item_data[i]->item_id);
@@ -1294,7 +1294,7 @@ void Corpse::QueryLoot(Client* to) {
 	cur = itemlist.begin();
 	end = itemlist.end();
 
-	int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::legacy::TypeCorpse];
+	int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
 
 	for(; cur != end; ++cur) {
 		ServerLootItem_Struct* sitem = *cur;
@@ -1305,7 +1305,7 @@ void Corpse::QueryLoot(Client* to) {
 			else
 				x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF;
 
-			const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
+			const EQEmu::ItemData* item = database.GetItem(sitem->item_id);
 
 			if (item)
 				to->Message((sitem->lootslot == 0xFFFF), "LootSlot: %i (EquipSlot: %i) Item: %s (%d), Count: %i", static_cast<int16>(sitem->lootslot), sitem->equip_slot, item->Name, item->ID, sitem->charges);
@@ -1319,7 +1319,7 @@ void Corpse::QueryLoot(Client* to) {
 		}
 		else {
 			sitem->lootslot=y;
-			const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
+			const EQEmu::ItemData* item = database.GetItem(sitem->item_id);
 
 			if (item)
 				to->Message(0, "LootSlot: %i Item: %s (%d), Count: %i", sitem->lootslot, item->Name, item->ID, sitem->charges);
@@ -1403,25 +1403,25 @@ uint32 Corpse::GetEquipment(uint8 material_slot) const {
 	int16 invslot;
 
 	if (material_slot > EQEmu::textures::LastTexture) {
-		return NO_ITEM;
+		return 0;
 	}
 
-	invslot = Inventory::CalcSlotFromMaterial(material_slot);
+	invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
-	if(invslot == INVALID_INDEX) // GetWornItem() should be returning a NO_ITEM for any invalid index...
+	if(invslot == INVALID_INDEX) // GetWornItem() should be returning a 0 for any invalid index...
-		return NO_ITEM;
+		return 0;
 
 	return GetWornItem(invslot);
 }
 
 uint32 Corpse::GetEquipmentColor(uint8 material_slot) const {
-	const EQEmu::ItemBase *item;
+	const EQEmu::ItemData *item;
 
 	if (material_slot > EQEmu::textures::LastTexture) {
 		return 0;
 	}
 
 	item = database.GetItem(GetEquipment(material_slot));
-	if(item != NO_ITEM) {
+	if(item != 0) {
 		return (item_tint.Slot[material_slot].UseTint ? item_tint.Slot[material_slot].Color : item->Color);
 	}
 
@@ -1434,8 +1434,8 @@ void Corpse::UpdateEquipmentLight()
 	m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
 
 	for (auto iter = itemlist.begin(); iter != itemlist.end(); ++iter) {
-		if (((*iter)->equip_slot < EQEmu::legacy::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQEmu::legacy::EQUIPMENT_END) && (*iter)->equip_slot != EQEmu::legacy::SlotPowerSource) { continue; }
+		if (((*iter)->equip_slot < EQEmu::legacy::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQEmu::legacy::EQUIPMENT_END) && (*iter)->equip_slot != EQEmu::inventory::slotPowerSource) { continue; }
-		if ((*iter)->equip_slot == EQEmu::legacy::SlotAmmo) { continue; }
+		if ((*iter)->equip_slot == EQEmu::inventory::slotAmmo) { continue; }
 		
 		auto item = database.GetItem((*iter)->item_id);
 		if (item == nullptr) { continue; }

zone/corpse.h

@@ -24,13 +24,17 @@
 class Client;
 class EQApplicationPacket;
 class Group;
-class ItemInst;
 class NPC;
 class Raid;
 
 struct ExtraAttackOptions;
 struct NPCType;
 
+namespace EQEmu
+{
+	class ItemInstance;
+}
+
 #define MAX_LOOTERS 72
 
 class Corpse : public Mob {
@@ -49,7 +53,7 @@ class Corpse : public Mob {
 	/* Corpse: General */
 	virtual bool	Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
 	virtual void	Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
-	virtual bool	Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
+	virtual bool	Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
 	virtual bool	HasRaid()			{ return false; }
 	virtual bool	HasGroup()			{ return false; }
 	virtual Raid*	GetRaid()			{ return 0; }
@@ -128,7 +132,7 @@ class Corpse : public Mob {
 	virtual void UpdateEquipmentLight();
 
 protected:
-	void MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, std::list<uint32> &removedList);
+	void MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList);
 
 private:
 	bool		is_player_corpse; /* Determines if Player Corpse or not */

zone/doors.cpp

@@ -188,7 +188,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger)
 	uint8 keepoffkeyring = GetNoKeyring();
 	uint32 haskey = 0;
 	uint32 playerkey = 0;
-	const ItemInst *lockpicks = sender->GetInv().GetItem(EQEmu::legacy::SlotCursor);
+	const EQEmu::ItemInstance *lockpicks = sender->GetInv().GetItem(EQEmu::inventory::slotCursor);
 
 	haskey = sender->GetInv().HasItem(keyneeded, 1);
 

zone/effects.cpp

@@ -481,7 +481,7 @@ int32 Client::GetActSpellCasttime(uint16 spell_id, int32 casttime)
 bool Client::TrainDiscipline(uint32 itemid) {
 
 	//get the item info
-	const EQEmu::ItemBase *item = database.GetItem(itemid);
+	const EQEmu::ItemData *item = database.GetItem(itemid);
 	if(item == nullptr) {
 		Message(13, "Unable to find the tome you turned in!");
 		Log.Out(Logs::General, Logs::Error, "Unable to find turned in tome id %lu\n", (unsigned long)itemid);
@@ -630,17 +630,6 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
 	if(r == MAX_PP_DISCIPLINES)
 		return(false);	//not found.
 
-	//Check the disc timer
-	pTimerType DiscTimer = pTimerDisciplineReuseStart + spells[spell_id].EndurTimerIndex;
-	if(!p_timers.Expired(&database, DiscTimer)) {
-		/*char val1[20]={0};*/	//unused
-		/*char val2[20]={0};*/	//unused
-		uint32 remain = p_timers.GetRemainingTime(DiscTimer);
-		//Message_StringID(0, DISCIPLINE_CANUSEIN, ConvertArray((remain)/60,val1), ConvertArray(remain%60,val2));
-		Message(0, "You can use this discipline in %d minutes %d seconds.", ((remain)/60), (remain%60));
-		return(false);
-	}
-
 	//make sure we can use it..
 	if(!IsValidSpell(spell_id)) {
 		Message(13, "This tome contains invalid knowledge.");
@@ -667,6 +656,23 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
 		return(false);
 	}
 
+	// sneak attack discs require you to be hidden for 4 seconds before use
+	if (spell.sneak && (!hidden || (hidden && (Timer::GetCurrentTime() - tmHidden) < 4000))) {
+		Message_StringID(MT_SpellFailure, SNEAK_RESTRICT);
+		return false;
+	}
+
+	//Check the disc timer
+	pTimerType DiscTimer = pTimerDisciplineReuseStart + spell.EndurTimerIndex;
+	if(!p_timers.Expired(&database, DiscTimer)) {
+		/*char val1[20]={0};*/	//unused
+		/*char val2[20]={0};*/	//unused
+		uint32 remain = p_timers.GetRemainingTime(DiscTimer);
+		//Message_StringID(0, DISCIPLINE_CANUSEIN, ConvertArray((remain)/60,val1), ConvertArray(remain%60,val2));
+		Message(0, "You can use this discipline in %d minutes %d seconds.", ((remain)/60), (remain%60));
+		return(false);
+	}
+
 	if(spell.recast_time > 0)
 	{
 		uint32 reduced_recast = spell.recast_time / 1000;

zone/embparser.cpp

@@ -157,7 +157,7 @@ void PerlembParser::ReloadQuests() {
 	spell_quest_status_.clear();
 }
 
-int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
+int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob,
 	uint32 extradata, bool global, std::vector<EQEmu::Any> *extra_pointers)
 {
 	if(!perl)
@@ -174,9 +174,9 @@ int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * da
 	std::string package_name;
 
 	GetQuestTypes(isPlayerQuest, isGlobalPlayerQuest, isGlobalNPC, isItemQuest, isSpellQuest,
-		event, npcmob, iteminst, mob, global);
+		event, npcmob, item_inst, mob, global);
 	GetQuestPackageName(isPlayerQuest, isGlobalPlayerQuest, isGlobalNPC, isItemQuest, isSpellQuest,
-		package_name, event, objid, data, npcmob, iteminst, global);
+		package_name, event, objid, data, npcmob, item_inst, global);
 
 	const char *sub_name = QuestEventSubroutines[event];
 	if(!perl->SubExists(package_name.c_str(), sub_name)) {
@@ -208,14 +208,14 @@ int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * da
 
 	/* Check for Event export event enable */
 	if (parse->perl_event_export_settings[event].event_variables){
-		ExportEventVariables(package_name, event, objid, data, npcmob, iteminst, mob, extradata, extra_pointers);
+		ExportEventVariables(package_name, event, objid, data, npcmob, item_inst, mob, extradata, extra_pointers);
 	}
 
 	if(isPlayerQuest || isGlobalPlayerQuest){
 		return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, nullptr);
 	}
 	else if(isItemQuest) {
-		return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, iteminst);
+		return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, item_inst);
 	}
 	else if(isSpellQuest){
 		if(mob) {
@@ -249,7 +249,7 @@ int PerlembParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::stri
 	return EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, true, extra_pointers);
 }
 
-int PerlembParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
+int PerlembParser::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
 							std::vector<EQEmu::Any> *extra_pointers) {
 	// needs pointer validation on 'item' argument
 	return EventCommon(evt, item->GetID(), nullptr, nullptr, item, client, extra_data, false, extra_pointers);
@@ -348,7 +348,7 @@ bool PerlembParser::SpellHasQuestSub(uint32 spell_id, QuestEventID evt) {
 	return(perl->SubExists(package_name.str().c_str(), subname));
 }
 
-bool PerlembParser::ItemHasQuestSub(ItemInst *itm, QuestEventID evt) {
+bool PerlembParser::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
 	std::stringstream package_name;
 	package_name << "qst_item_" << itm->GetID();
 
@@ -471,7 +471,7 @@ void PerlembParser::LoadGlobalPlayerScript(std::string filename) {
 	global_player_quest_status_ = questLoaded;
 }
 
-void PerlembParser::LoadItemScript(std::string filename, ItemInst *item) {
+void PerlembParser::LoadItemScript(std::string filename, EQEmu::ItemInstance *item) {
 	if (item == nullptr)
 		return;
 
@@ -642,13 +642,13 @@ void PerlembParser::ExportVar(const char *pkgprefix, const char *varname, const
 	}
 }
 
-int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, ItemInst* iteminst) {
+int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQEmu::ItemInstance* item_inst) {
 	if(!perl)
 		return 0;
 
 	int ret_value = 0;
 	if(mob && mob->IsClient())
-		quest_manager.StartQuest(other, mob->CastToClient(), iteminst);
+		quest_manager.StartQuest(other, mob->CastToClient(), item_inst);
 	else
 		quest_manager.StartQuest(other, nullptr, nullptr);
 
@@ -711,8 +711,8 @@ int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32
 		}
 
 		//only export QuestItem if it's an item quest
-		if(iteminst) {
+		if(item_inst) {
-			ItemInst* curi = quest_manager.GetQuestItem();
+			EQEmu::ItemInstance* curi = quest_manager.GetQuestItem();
 			snprintf(namebuf, 64, "%s::questitem", pkgprefix);
 			SV *questitem = get_sv(namebuf, true);
 			sv_setref_pv(questitem, "QuestItem", curi);
@@ -840,7 +840,7 @@ void PerlembParser::MapFunctions() {
 }
 
 void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
-		bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global)
+		bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, bool global)
 {
 	if(event == EVENT_SPELL_EFFECT_CLIENT ||
 		event == EVENT_SPELL_EFFECT_NPC ||
@@ -854,7 +854,7 @@ void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest
 	else
 	{
 		if(!npcmob && mob) {
-			if(!iteminst) {
+			if(!item_inst) {
 				if(global) {
 					isGlobalPlayerQuest = true;
 				} else {
@@ -869,7 +869,7 @@ void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest
 
 void PerlembParser::GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
 		bool &isSpellQuest, std::string &package_name, QuestEventID event, uint32 objid, const char * data,
-		NPC* npcmob, ItemInst* iteminst, bool global)
+		NPC* npcmob, EQEmu::ItemInstance* item_inst, bool global)
 {
 	if(!isPlayerQuest && !isGlobalPlayerQuest && !isItemQuest && !isSpellQuest) {
 		if(global) {
@@ -881,8 +881,8 @@ void PerlembParser::GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlaye
 		}
 	}
 	else if(isItemQuest) {
-		// need a valid ItemInst pointer check here..unsure how to cancel this process
+		// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
-		const EQEmu::ItemBase* item = iteminst->GetItem();
+		const EQEmu::ItemData* item = item_inst->GetItem();
 		package_name = "qst_item_";
 		package_name += itoa(item->ID);
 	}
@@ -1141,7 +1141,7 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob) {
 #undef HASITEM_ISNULLITEM
 
 void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data,
-	NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers)
+	NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers)
 {
 	switch (event) {
 		case EVENT_SAY: {
@@ -1159,7 +1159,7 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
 			if(extra_pointers) {
 				size_t sz = extra_pointers->size();
 				for(size_t i = 0; i < sz; ++i) {
-					ItemInst *inst = EQEmu::any_cast<ItemInst*>(extra_pointers->at(i));
+					EQEmu::ItemInstance *inst = EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(i));
 
 					std::string var_name = "item";
 					var_name += std::to_string(i + 1);
@@ -1327,19 +1327,19 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
 
 		case EVENT_SCALE_CALC:
 		case EVENT_ITEM_ENTER_ZONE: {
-			// need a valid ItemInst pointer check here..unsure how to cancel this process
+			// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
 			ExportVar(package_name.c_str(), "itemid", objid);
-			ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
+			ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
 			break;
 		}
 
 		case EVENT_ITEM_CLICK_CAST:
 		case EVENT_ITEM_CLICK: {
-			// need a valid ItemInst pointer check here..unsure how to cancel this process
+			// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
 			ExportVar(package_name.c_str(), "itemid", objid);
-			ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
+			ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
 			ExportVar(package_name.c_str(), "slotid", extradata);
-			ExportVar(package_name.c_str(), "spell_id", iteminst->GetItem()->Click.Effect);
+			ExportVar(package_name.c_str(), "spell_id", item_inst->GetItem()->Click.Effect);
 			break;
 		}
 
@@ -1419,10 +1419,10 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
 			break;
 		}
 		case EVENT_DROP_ITEM: {
-			ExportVar(package_name.c_str(), "quantity", iteminst->IsStackable() ? iteminst->GetCharges() : 1);
+			ExportVar(package_name.c_str(), "quantity", item_inst->IsStackable() ? item_inst->GetCharges() : 1);
-			ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
+			ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
-			ExportVar(package_name.c_str(), "itemid", iteminst->GetItem()->ID);
+			ExportVar(package_name.c_str(), "itemid", item_inst->GetItem()->ID);
-			ExportVar(package_name.c_str(), "spell_id", iteminst->GetItem()->Click.Effect);
+			ExportVar(package_name.c_str(), "spell_id", item_inst->GetItem()->Click.Effect);
 			ExportVar(package_name.c_str(), "slotid", extradata);
 			break;
 		}

zone/embparser.h

@@ -17,7 +17,7 @@
 */
 
 #ifndef EQEMU_EMBPARSER_H
-#define EQMEU_EMBPARSER_H
+#define EQEMU_EMBPARSER_H
 #ifdef EMBPERL
 
 #include "quest_parser_collection.h"
@@ -27,11 +27,15 @@
 #include <map>
 #include "embperl.h"
 
-class ItemInst;
 class Mob;
 class Client;
 class NPC;
 
+namespace EQEmu
+{
+	class ItemInstance;
+}
+
 typedef enum 
 {
 	questUnloaded,
@@ -52,7 +56,7 @@ public:
 		std::vector<EQEmu::Any> *extra_pointers);
 	virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
 		std::vector<EQEmu::Any> *extra_pointers);
-	virtual int EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
+	virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
 		std::vector<EQEmu::Any> *extra_pointers);
 	virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
 		std::vector<EQEmu::Any> *extra_pointers);
@@ -62,13 +66,13 @@ public:
 	virtual bool PlayerHasQuestSub(QuestEventID evt);
 	virtual bool GlobalPlayerHasQuestSub(QuestEventID evt);
 	virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
-	virtual bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt);
+	virtual bool ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt);
 
 	virtual void LoadNPCScript(std::string filename, int npc_id);
 	virtual void LoadGlobalNPCScript(std::string filename);
 	virtual void LoadPlayerScript(std::string filename);
 	virtual void LoadGlobalPlayerScript(std::string filename);
-	virtual void LoadItemScript(std::string filename, ItemInst *item);
+	virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item);
 	virtual void LoadSpellScript(std::string filename, uint32 spell_id);
 
 	virtual void AddVar(std::string name, std::string val);
@@ -86,16 +90,16 @@ private:
 	void ExportVar(const char *pkgprefix, const char *varname, float value);
 	void ExportVarComplex(const char *pkgprefix, const char *varname, const char *value);
 
-	int EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob, 
+	int EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, 
 		uint32 extradata, bool global, std::vector<EQEmu::Any> *extra_pointers);
-	int SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, ItemInst *iteminst);
+	int SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQEmu::ItemInstance *item_inst);
 	void MapFunctions();
 
 	void GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest, 
-		bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global);
+		bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, bool global);
 	void GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest, 
 		bool &isSpellQuest, std::string &package_name, QuestEventID event, uint32 objid, const char * data, 
-		NPC* npcmob, ItemInst* iteminst, bool global);
+		NPC* npcmob, EQEmu::ItemInstance* item_inst, bool global);
 	void ExportCharID(const std::string &package_name, int &char_id, NPC *npcmob, Mob *mob);
 	void ExportQGlobals(bool isPlayerQuest, bool isGlobalPlayerQuest, bool isGlobalNPC, bool isItemQuest, 
 		bool isSpellQuest, std::string &package_name, NPC *npcmob, Mob *mob, int char_id);
@@ -104,7 +108,7 @@ private:
 	void ExportZoneVariables(std::string &package_name);
 	void ExportItemVariables(std::string &package_name, Mob *mob);
 	void ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data, 
-		NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers);
+		NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers);
 	
 	std::map<uint32, PerlQuestStatus> npc_quest_status_;
 	PerlQuestStatus global_npc_quest_status_;

zone/embparser_api.cpp

@@ -110,7 +110,7 @@ XS(XS_QuestItem_new)
 	if (items != 1)
 		Perl_croak(aTHX_ "Usage: QuestItem::new()");
 
-	ItemInst* RETVAL;
+	EQEmu::ItemInstance* RETVAL;
 
 	RETVAL = quest_manager.GetQuestItem();
 	ST(0) = sv_newmortal();

zone/embxs.cpp

@@ -33,7 +33,7 @@
 
 const char *getItemName(unsigned itemid) 
 { 
-	const EQEmu::ItemBase* item = nullptr;
+	const EQEmu::ItemData* item = nullptr;
   item = database.GetItem(itemid); 
 
   if (item) 

zone/encounter.h

@@ -36,7 +36,7 @@ public:
 	//abstract virtual function implementations required by base abstract class
 	virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
 	virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
-	virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
+	virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
 		ExtraAttackOptions *opts = nullptr, int special = 0) {
 		return false;
 	}

zone/entity.cpp

@@ -2009,7 +2009,7 @@ void EntityList::QueueClientsGuildBankItemUpdate(const GuildBankItemUpdate_Struc
 
 	memcpy(outgbius, gbius, sizeof(GuildBankItemUpdate_Struct));
 
-	const EQEmu::ItemBase *Item = database.GetItem(gbius->ItemID);
+	const EQEmu::ItemData *Item = database.GetItem(gbius->ItemID);
 
 	auto it = client_list.begin();
 	while (it != client_list.end()) {
@@ -3878,11 +3878,11 @@ void EntityList::GroupMessage(uint32 gid, const char *from, const char *message)
 
 uint16 EntityList::CreateGroundObject(uint32 itemid, const glm::vec4& position, uint32 decay_time)
 {
-	const EQEmu::ItemBase *is = database.GetItem(itemid);
+	const EQEmu::ItemData *is = database.GetItem(itemid);
 	if (!is)
 		return 0;
 
-	auto i = new ItemInst(is, is->MaxCharges);
+	auto i = new EQEmu::ItemInstance(is, is->MaxCharges);
 	if (!i)
 		return 0;
 

zone/entity.h

@@ -352,7 +352,7 @@ public:
 	void	QueueToGroupsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app);
 	void	QueueManaged(Mob* sender, const EQApplicationPacket* app, bool ignore_sender=false, bool ackreq = true);
 
-	void	AEAttack(Mob *attacker, float dist, int Hand = EQEmu::legacy::SlotPrimary, int count = 0, bool IsFromSpell = false);
+	void	AEAttack(Mob *attacker, float dist, int Hand = EQEmu::inventory::slotPrimary, int count = 0, bool IsFromSpell = false);
 	void	AETaunt(Client *caster, float range=0, int32 bonus_hate=0);
 	void	AESpell(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true, int16 resist_adjust = 0);
 	void	MassGroupBuff(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true);

zone/exp.cpp

@@ -350,19 +350,50 @@ void Client::SetEXP(uint32 set_exp, uint32 set_aaxp, bool isrezzexp) {
 	}
 
 	if ((set_exp + set_aaxp) > (m_pp.exp+m_pp.expAA)) {
-		if (isrezzexp)
+
-			this->Message_StringID(MT_Experience, REZ_REGAIN);
+		uint32 exp_gained = set_exp - m_pp.exp;
+		uint32 aaxp_gained = set_aaxp - m_pp.expAA;
+		float exp_percent = (float)((float)exp_gained / (float)(GetEXPForLevel(GetLevel() + 1) - GetEXPForLevel(GetLevel())))*(float)100; //EXP needed for level
+		float aaxp_percent = (float)((float)aaxp_gained / (float)(RuleI(AA, ExpPerPoint)))*(float)100; //AAEXP needed for level
+		std::string exp_amount_message = "";
+		if (RuleI(Character, ShowExpValues) >= 1) {
+			if (exp_gained > 0 && aaxp_gained > 0) exp_amount_message = StringFormat("%u, %u AA", exp_gained, aaxp_gained);
+			else if (exp_gained > 0) exp_amount_message = StringFormat("%u", exp_gained);
+			else exp_amount_message = StringFormat("%u AA", aaxp_gained);
+		}
+
+		std::string exp_percent_message = "";
+		if (RuleI(Character, ShowExpValues) >= 2) {
+			if (exp_gained > 0 && aaxp_gained > 0) exp_percent_message = StringFormat("(%.3f%%, %.3f%%AA)", exp_percent, aaxp_percent);
+			else if (exp_gained > 0) exp_percent_message = StringFormat("(%.3f%%)", exp_percent);
+			else exp_percent_message = StringFormat("(%.3f%%AA)", aaxp_percent);
+		}
+
+		if (isrezzexp) {
+			if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You regain %s experience from resurrection. %s", exp_amount_message.c_str(), exp_percent_message.c_str());
+			else Message_StringID(MT_Experience, REZ_REGAIN);
+		} else {
+			if (membercount > 1) {
+				if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s party experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
+				else Message_StringID(MT_Experience, GAIN_GROUPXP);
+			}
+			else if (IsRaidGrouped()) {
+				if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s raid experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
+				else Message_StringID(MT_Experience, GAIN_RAIDEXP);
+			} 
 			else {
-			if(membercount > 1)
+				if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
-				this->Message_StringID(MT_Experience, GAIN_GROUPXP);
+				else Message_StringID(MT_Experience, GAIN_XP);				
-			else if(IsRaidGrouped())
+			}
-				Message_StringID(MT_Experience, GAIN_RAIDEXP);
-			else
-				this->Message_StringID(MT_Experience, GAIN_XP);
 		}
 	}
 	else if((set_exp + set_aaxp) < (m_pp.exp+m_pp.expAA)){ //only loss message if you lose exp, no message if you gained/lost nothing.
-		Message(15, "You have lost experience.");
+		uint32 exp_lost = m_pp.exp - set_exp;
+		float exp_percent = (float)((float)exp_lost / (float)(GetEXPForLevel(GetLevel() + 1) - GetEXPForLevel(GetLevel())))*(float)100;
+
+		if (RuleI(Character, ShowExpValues) == 1 && exp_lost > 0) Message(15, "You have lost %i experience.", exp_lost);
+		else if (RuleI(Character, ShowExpValues) == 2 && exp_lost > 0) Message(15, "You have lost %i experience. (%.3f%%)", exp_lost, exp_percent);
+		else Message(15, "You have lost experience.");		
 	}
 
 	//check_level represents the level we should be when we have

zone/forage.cpp

@@ -153,9 +153,9 @@ uint32 ZoneDatabase::GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id,
 //we need this function to immediately determine, after we receive OP_Fishing, if we can even try to fish, otherwise we have to wait a while to get the failure
 bool Client::CanFish() {
 	//make sure we still have a fishing pole on:
-	const ItemInst* Pole = m_inv[EQEmu::legacy::SlotPrimary];
+	const EQEmu::ItemInstance* Pole = m_inv[EQEmu::inventory::slotPrimary];
 	int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
-	const ItemInst* Bait = nullptr;
+	const EQEmu::ItemInstance* Bait = nullptr;
 	if (bslot != INVALID_INDEX)
 		Bait = m_inv.GetItem(bslot);
 
@@ -253,7 +253,7 @@ void Client::GoFish()
 
 	//make sure we still have a fishing pole on:
 	int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
-	const ItemInst* Bait = nullptr;
+	const EQEmu::ItemInstance* Bait = nullptr;
 	if (bslot != INVALID_INDEX)
 		Bait = m_inv.GetItem(bslot);
 
@@ -304,10 +304,10 @@ void Client::GoFish()
 			food_id = common_fish_ids[index];
 		}
 
-		const EQEmu::ItemBase* food_item = database.GetItem(food_id);
+		const EQEmu::ItemData* food_item = database.GetItem(food_id);
 
 		Message_StringID(MT_Skills, FISHING_SUCCESS);
-		ItemInst* inst = database.CreateItem(food_item, 1);
+		EQEmu::ItemInstance* inst = database.CreateItem(food_item, 1);
 		if(inst != nullptr) {
 			if(CheckLoreConflict(inst->GetItem()))
 			{
@@ -317,12 +317,12 @@ void Client::GoFish()
 			else
 			{
 				PushItemOnCursor(*inst);
-				SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
+				SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
 				if(RuleB(TaskSystem, EnableTaskSystem))
 					UpdateTasksForItem(ActivityFish, food_id);
 
 				safe_delete(inst);
-				inst = m_inv.GetItem(EQEmu::legacy::SlotCursor);
+				inst = m_inv.GetItem(EQEmu::inventory::slotCursor);
 			}
 
 			if(inst) {
@@ -354,7 +354,7 @@ void Client::GoFish()
 	//and then swap out items in primary slot... too lazy to fix right now
 	if (zone->random.Int(0, 49) == 1) {
 		Message_StringID(MT_Skills, FISHING_POLE_BROKE);	//Your fishing pole broke!
-		DeleteItemInInventory(EQEmu::legacy::SlotPrimary, 0, true);
+		DeleteItemInInventory(EQEmu::inventory::slotPrimary, 0, true);
 	}
 
 	if (CheckIncreaseSkill(EQEmu::skills::SkillFishing, nullptr, 5))
@@ -396,7 +396,7 @@ void Client::ForageItem(bool guarantee) {
 			foragedfood = common_food_ids[index];
 		}
 
-		const EQEmu::ItemBase* food_item = database.GetItem(foragedfood);
+		const EQEmu::ItemData* food_item = database.GetItem(foragedfood);
 
 		if(!food_item) {
 			Log.Out(Logs::General, Logs::Error, "nullptr returned from database.GetItem in ClientForageItem");
@@ -421,7 +421,7 @@ void Client::ForageItem(bool guarantee) {
 			}
 
 		Message_StringID(MT_Skills, stringid);
-		ItemInst* inst = database.CreateItem(food_item, 1);
+		EQEmu::ItemInstance* inst = database.CreateItem(food_item, 1);
 		if(inst != nullptr) {
 			// check to make sure it isn't a foraged lore item
 			if(CheckLoreConflict(inst->GetItem()))
@@ -431,12 +431,12 @@ void Client::ForageItem(bool guarantee) {
 			}
 			else {
 				PushItemOnCursor(*inst);
-				SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
+				SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
 				if(RuleB(TaskSystem, EnableTaskSystem))
 					UpdateTasksForItem(ActivityForage, foragedfood);
 
 				safe_delete(inst);
-				inst = m_inv.GetItem(EQEmu::legacy::SlotCursor);
+				inst = m_inv.GetItem(EQEmu::inventory::slotCursor);
 			}
 
 			if(inst) {

zone/guild_mgr.cpp

@@ -694,7 +694,7 @@ void GuildBankManager::SendGuildBank(Client *c)
 	if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater) {
 		auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240);
 		for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) {
-			const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
+			const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
 			if (Item) {
 				outapp->WriteUInt8(1);
 				outapp->WriteUInt32(guild_bank->Items.DepositArea[i].Permissions);
@@ -718,7 +718,7 @@ void GuildBankManager::SendGuildBank(Client *c)
 		outapp->SetWritePosition(outapp->GetWritePosition() + 20); // newer clients have 40 deposit slots, keep them 0 for now
 
 		for (int i = 0; i < GUILD_BANK_MAIN_AREA_SIZE; ++i) {
-			const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
+			const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
 			if (Item) {
 				outapp->WriteUInt8(1);
 				outapp->WriteUInt32(guild_bank->Items.MainArea[i].Permissions);
@@ -749,7 +749,7 @@ void GuildBankManager::SendGuildBank(Client *c)
 	{
 		if(guild_bank->Items.DepositArea[i].ItemID > 0)
 		{
-			const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
+			const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
 
 			if(!Item)
 				continue;
@@ -785,7 +785,7 @@ void GuildBankManager::SendGuildBank(Client *c)
 	{
 		if(guild_bank->Items.MainArea[i].ItemID > 0)
 		{
-			const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
+			const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
 
 			if(!Item)
 				continue;
@@ -916,7 +916,7 @@ bool GuildBankManager::AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32
 		return false;
 	}
 
-	const EQEmu::ItemBase *Item = database.GetItem(ItemID);
+	const EQEmu::ItemData *Item = database.GetItem(ItemID);
 
 	GuildBankItemUpdate_Struct gbius;
 
@@ -982,7 +982,7 @@ int GuildBankManager::Promote(uint32 guildID, int slotID)
 
 	(*iter)->Items.DepositArea[slotID].ItemID = 0;
 
-	const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
+	const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
 
 	GuildBankItemUpdate_Struct gbius;
 
@@ -1038,7 +1038,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
 	else
 		(*iter)->Items.MainArea[slotID].WhoFor[0] = '\0';
 
-	const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
+	const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
 
 	GuildBankItemUpdate_Struct gbius;
 
@@ -1062,7 +1062,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
 	entity_list.QueueClientsGuildBankItemUpdate(&gbius, guildID);
 }
 
-ItemInst* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
+EQEmu::ItemInstance* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
 {
 	auto Iterator = GetGuildBank(GuildID);
 
@@ -1071,7 +1071,7 @@ ItemInst* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID,
 
 	GuildBankItem* BankArea = nullptr;
 
-	ItemInst* inst = nullptr;
+	EQEmu::ItemInstance* inst = nullptr;
 
 	if(Area == GuildBankDepositArea)
 	{
@@ -1169,7 +1169,7 @@ bool GuildBankManager::DeleteItem(uint32 guildID, uint16 area, uint16 slotID, ui
 
 	bool deleted = true;
 
-	const EQEmu::ItemBase *Item = database.GetItem(BankArea[slotID].ItemID);
+	const EQEmu::ItemData *Item = database.GetItem(BankArea[slotID].ItemID);
 
 	if(!Item->Stackable || (quantity >= BankArea[slotID].Quantity)) {
         std::string query = StringFormat("DELETE FROM `guild_bank` WHERE `guildid` = %i "
@@ -1230,7 +1230,7 @@ bool GuildBankManager::MergeStacks(uint32 GuildID, uint16 SlotID)
 	if(BankArea[SlotID].ItemID == 0)
 		return false;
 
-	const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
+	const EQEmu::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
 
 	if(!Item->Stackable)
 		return false;
@@ -1328,7 +1328,7 @@ bool GuildBankManager::SplitStack(uint32 GuildID, uint16 SlotID, uint32 Quantity
 	if(BankArea[SlotID].Quantity <= Quantity || Quantity == 0)
 		return false;
 
-	const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
+	const EQEmu::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
 
 	if(!Item->Stackable)
 		return false;

zone/guild_mgr.h

@@ -117,7 +117,7 @@ public:
 	bool AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32 QtyOrCharges, const char *Donator, uint8 Permissions, const char *WhoFor);
 	int Promote(uint32 GuildID, int SlotID);
 	void SetPermissions(uint32 GuildID, uint16 SlotID, uint32 Permissions, const char *MemberName);
-	ItemInst* GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
+	EQEmu::ItemInstance* GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
 	bool DeleteItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
 	bool HasItem(uint32 GuildID, uint32 ItemID);
 	bool IsAreaFull(uint32 GuildID, uint16 Area);

zone/loottables.cpp

@@ -119,7 +119,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
 			int charges = lds->Entries[i].multiplier;
 			for(int j = 0; j < charges; ++j) {
 				if(zone->random.Real(0.0, 100.0) <= lds->Entries[i].chance) {
-					const EQEmu::ItemBase* dbitem = GetItem(lds->Entries[i].item_id);
+					const EQEmu::ItemData* dbitem = GetItem(lds->Entries[i].item_id);
 					npc->AddLootDrop(dbitem, itemlist, lds->Entries[i].item_charges, lds->Entries[i].minlevel,
 									lds->Entries[i].maxlevel, lds->Entries[i].equip_item > 0 ? true : false, false);
 				}
@@ -140,7 +140,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
 	float roll_t_min = 0.0f;
 	bool active_item_list = false;
 	for(uint32 i = 0; i < lds->NumEntries; ++i) {
-		const EQEmu::ItemBase* db_item = GetItem(lds->Entries[i].item_id);
+		const EQEmu::ItemData* db_item = GetItem(lds->Entries[i].item_id);
 		if(db_item) {
 			roll_t += lds->Entries[i].chance;
 			active_item_list = true;
@@ -157,7 +157,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
 	for(int i = 0; i < mindrop; ++i) {
 		float roll = (float)zone->random.Real(0.0, roll_t_min);
 		for(uint32 j = 0; j < lds->NumEntries; ++j) {
-			const EQEmu::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
+			const EQEmu::ItemData* db_item = GetItem(lds->Entries[j].item_id);
 			if(db_item) {
 				if(roll < lds->Entries[j].chance) {
 					npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel,
@@ -187,7 +187,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
 	for(int i = mindrop; i < droplimit; ++i) {
 		float roll = (float)zone->random.Real(0.0, roll_t);
 		for(uint32 j = 0; j < lds->NumEntries; ++j) {
-			const EQEmu::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
+			const EQEmu::ItemData* db_item = GetItem(lds->Entries[j].item_id);
 			if(db_item) {
 				if(roll < lds->Entries[j].chance) {
 					npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel,
@@ -221,7 +221,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
 }
 
 //if itemlist is null, just send wear changes
-void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange) {
+void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6) {
 	if(item2 == nullptr)
 		return;
 
@@ -245,12 +245,12 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
 
 	item->item_id = item2->ID;
 	item->charges = charges;
-	item->aug_1 = 0;
+	item->aug_1 = aug1;
-	item->aug_2 = 0;
+	item->aug_2 = aug2;
-	item->aug_3 = 0;
+	item->aug_3 = aug3;
-	item->aug_4 = 0;
+	item->aug_4 = aug4;
-	item->aug_5 = 0;
+	item->aug_5 = aug5;
-	item->aug_6 = 0;
+	item->aug_6 = aug6;
 	item->attuned = 0;
 	item->min_level = minlevel;
 	item->max_level = maxlevel;
@@ -258,7 +258,7 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
 	if (equipit) {
 		uint8 eslot = 0xFF;
 		char newid[20];
-		const EQEmu::ItemBase* compitem = nullptr;
+		const EQEmu::ItemData* compitem = nullptr;
 		bool found = false; // track if we found an empty slot we fit into
 		int32 foundslot = -1; // for multi-slot items
 
@@ -313,7 +313,7 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
 		// @merth: IDFile size has been increased, this needs to change
 		uint16 emat;
 		if(item2->Material <= 0
-			|| item2->Slots & (1 << EQEmu::legacy::SlotPrimary | 1 << EQEmu::legacy::SlotSecondary)) {
+			|| item2->Slots & (1 << EQEmu::inventory::slotPrimary | 1 << EQEmu::inventory::slotSecondary)) {
 			memset(newid, 0, sizeof(newid));
 			for(int i=0;i<7;i++){
 				if (!isalpha(item2->IDFile[i])){
@@ -327,47 +327,47 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
 			emat = item2->Material;
 		}
 
-		if (foundslot == EQEmu::legacy::SlotPrimary) {
+		if (foundslot == EQEmu::inventory::slotPrimary) {
 			if (item2->Proc.Effect != 0)
 				CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
 
-			eslot = EQEmu::textures::TexturePrimary;
+			eslot = EQEmu::textures::weaponPrimary;
 			if (item2->Damage > 0)
 				SendAddPlayerState(PlayerState::PrimaryWeaponEquipped);
 			if (item2->IsType2HWeapon())
 				SetTwoHanderEquipped(true);
 		}
-		else if (foundslot == EQEmu::legacy::SlotSecondary
+		else if (foundslot == EQEmu::inventory::slotSecondary
 			&& (GetOwner() != nullptr || (CanThisClassDualWield() && zone->random.Roll(NPC_DW_CHANCE)) || (item2->Damage==0)) &&
 			(item2->IsType1HWeapon() || item2->ItemType == EQEmu::item::ItemTypeShield))
 		{
 			if (item2->Proc.Effect!=0)
 				CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
 
-			eslot = EQEmu::textures::TextureSecondary;
+			eslot = EQEmu::textures::weaponSecondary;
 			if (item2->Damage > 0)
 				SendAddPlayerState(PlayerState::SecondaryWeaponEquipped);
 		}
-		else if (foundslot == EQEmu::legacy::SlotHead) {
+		else if (foundslot == EQEmu::inventory::slotHead) {
-			eslot = EQEmu::textures::TextureHead;
+			eslot = EQEmu::textures::armorHead;
 		}
-		else if (foundslot == EQEmu::legacy::SlotChest) {
+		else if (foundslot == EQEmu::inventory::slotChest) {
-			eslot = EQEmu::textures::TextureChest;
+			eslot = EQEmu::textures::armorChest;
 		}
-		else if (foundslot == EQEmu::legacy::SlotArms) {
+		else if (foundslot == EQEmu::inventory::slotArms) {
-			eslot = EQEmu::textures::TextureArms;
+			eslot = EQEmu::textures::armorArms;
 		}
-		else if (foundslot == EQEmu::legacy::SlotWrist1 || foundslot == EQEmu::legacy::SlotWrist2) {
+		else if (foundslot == EQEmu::inventory::slotWrist1 || foundslot == EQEmu::inventory::slotWrist2) {
-			eslot = EQEmu::textures::TextureWrist;
+			eslot = EQEmu::textures::armorWrist;
 		}
-		else if (foundslot == EQEmu::legacy::SlotHands) {
+		else if (foundslot == EQEmu::inventory::slotHands) {
-			eslot = EQEmu::textures::TextureHands;
+			eslot = EQEmu::textures::armorHands;
 		}
-		else if (foundslot == EQEmu::legacy::SlotLegs) {
+		else if (foundslot == EQEmu::inventory::slotLegs) {
-			eslot = EQEmu::textures::TextureLegs;
+			eslot = EQEmu::textures::armorLegs;
 		}
-		else if (foundslot == EQEmu::legacy::SlotFeet) {
+		else if (foundslot == EQEmu::inventory::slotFeet) {
-			eslot = EQEmu::textures::TextureFeet;
+			eslot = EQEmu::textures::armorFeet;
 		}
 
 		/*
@@ -415,17 +415,17 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
 		SendAppearancePacket(AT_Light, GetActiveLightType());
 }
 
-void NPC::AddItem(const EQEmu::ItemBase* item, uint16 charges, bool equipitem) {
+void NPC::AddItem(const EQEmu::ItemData* item, uint16 charges, bool equipitem) {
 	//slot isnt needed, its determined from the item.
 	AddLootDrop(item, &itemlist, charges, 1, 255, equipitem, equipitem);
 }
 
-void NPC::AddItem(uint32 itemid, uint16 charges, bool equipitem) {
+void NPC::AddItem(uint32 itemid, uint16 charges, bool equipitem, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6) {
 	//slot isnt needed, its determined from the item.
-	const EQEmu::ItemBase * i = database.GetItem(itemid);
+	const EQEmu::ItemData * i = database.GetItem(itemid);
 	if(i == nullptr)
 		return;
-	AddLootDrop(i, &itemlist, charges, 1, 255, equipitem, equipitem);
+	AddLootDrop(i, &itemlist, charges, 1, 255, equipitem, equipitem, aug1, aug2, aug3, aug4, aug5, aug6);
 }
 
 void NPC::AddLootTable() {

zone/lua_client.cpp

@@ -1219,13 +1219,13 @@ Lua_Raid Lua_Client::GetRaid() {
 
 bool Lua_Client::PutItemInInventory(int slot_id, Lua_ItemInst inst) {
 	Lua_Safe_Call_Bool();
-	ItemInst *rinst = inst;
+	EQEmu::ItemInstance *rinst = inst;
 	return self->PutItemInInventory(slot_id, *rinst, true);
 }
 
 bool Lua_Client::PushItemOnCursor(Lua_ItemInst inst) {
 	Lua_Safe_Call_Bool();
-	ItemInst *rinst = inst;
+	EQEmu::ItemInstance *rinst = inst;
 	return self->PushItemOnCursor(*rinst, true);
 }
 

zone/lua_general.cpp

@@ -1762,43 +1762,43 @@ luabind::scope lua_register_slot() {
 	return luabind::class_<Slots>("Slot")
 		.enum_("constants")
 		[
-			luabind::value("Charm", static_cast<int>(EQEmu::legacy::SlotCharm)),
+			luabind::value("Charm", static_cast<int>(EQEmu::inventory::slotCharm)),
-			luabind::value("Ear1", static_cast<int>(EQEmu::legacy::SlotEar1)),
+			luabind::value("Ear1", static_cast<int>(EQEmu::inventory::slotEar1)),
-			luabind::value("Head", static_cast<int>(EQEmu::legacy::SlotHead)),
+			luabind::value("Head", static_cast<int>(EQEmu::inventory::slotHead)),
-			luabind::value("Face", static_cast<int>(EQEmu::legacy::SlotFace)),
+			luabind::value("Face", static_cast<int>(EQEmu::inventory::slotFace)),
-			luabind::value("Ear2", static_cast<int>(EQEmu::legacy::SlotEar2)),
+			luabind::value("Ear2", static_cast<int>(EQEmu::inventory::slotEar2)),
-			luabind::value("Neck", static_cast<int>(EQEmu::legacy::SlotNeck)),
+			luabind::value("Neck", static_cast<int>(EQEmu::inventory::slotNeck)),
-			luabind::value("Shoulder", static_cast<int>(EQEmu::legacy::SlotShoulders)), // deprecated
+			luabind::value("Shoulder", static_cast<int>(EQEmu::inventory::slotShoulders)), // deprecated
-			luabind::value("Shoulders", static_cast<int>(EQEmu::legacy::SlotShoulders)),
+			luabind::value("Shoulders", static_cast<int>(EQEmu::inventory::slotShoulders)),
-			luabind::value("Arms", static_cast<int>(EQEmu::legacy::SlotArms)),
+			luabind::value("Arms", static_cast<int>(EQEmu::inventory::slotArms)),
-			luabind::value("Back", static_cast<int>(EQEmu::legacy::SlotBack)),
+			luabind::value("Back", static_cast<int>(EQEmu::inventory::slotBack)),
-			luabind::value("Bracer1", static_cast<int>(EQEmu::legacy::SlotWrist1)), // deprecated
+			luabind::value("Bracer1", static_cast<int>(EQEmu::inventory::slotWrist1)), // deprecated
-			luabind::value("Wrist1", static_cast<int>(EQEmu::legacy::SlotWrist1)),
+			luabind::value("Wrist1", static_cast<int>(EQEmu::inventory::slotWrist1)),
-			luabind::value("Bracer2", static_cast<int>(EQEmu::legacy::SlotWrist2)), // deprecated
+			luabind::value("Bracer2", static_cast<int>(EQEmu::inventory::slotWrist2)), // deprecated
-			luabind::value("Wrist2", static_cast<int>(EQEmu::legacy::SlotWrist2)),
+			luabind::value("Wrist2", static_cast<int>(EQEmu::inventory::slotWrist2)),
-			luabind::value("Range", static_cast<int>(EQEmu::legacy::SlotRange)),
+			luabind::value("Range", static_cast<int>(EQEmu::inventory::slotRange)),
-			luabind::value("Hands", static_cast<int>(EQEmu::legacy::SlotHands)),
+			luabind::value("Hands", static_cast<int>(EQEmu::inventory::slotHands)),
-			luabind::value("Primary", static_cast<int>(EQEmu::legacy::SlotPrimary)),
+			luabind::value("Primary", static_cast<int>(EQEmu::inventory::slotPrimary)),
-			luabind::value("Secondary", static_cast<int>(EQEmu::legacy::SlotSecondary)),
+			luabind::value("Secondary", static_cast<int>(EQEmu::inventory::slotSecondary)),
-			luabind::value("Ring1", static_cast<int>(EQEmu::legacy::SlotFinger1)), // deprecated
+			luabind::value("Ring1", static_cast<int>(EQEmu::inventory::slotFinger1)), // deprecated
-			luabind::value("Finger1", static_cast<int>(EQEmu::legacy::SlotFinger1)),
+			luabind::value("Finger1", static_cast<int>(EQEmu::inventory::slotFinger1)),
-			luabind::value("Ring2", static_cast<int>(EQEmu::legacy::SlotFinger2)), // deprecated
+			luabind::value("Ring2", static_cast<int>(EQEmu::inventory::slotFinger2)), // deprecated
-			luabind::value("Finger2", static_cast<int>(EQEmu::legacy::SlotFinger2)),
+			luabind::value("Finger2", static_cast<int>(EQEmu::inventory::slotFinger2)),
-			luabind::value("Chest", static_cast<int>(EQEmu::legacy::SlotChest)),
+			luabind::value("Chest", static_cast<int>(EQEmu::inventory::slotChest)),
-			luabind::value("Legs", static_cast<int>(EQEmu::legacy::SlotLegs)),
+			luabind::value("Legs", static_cast<int>(EQEmu::inventory::slotLegs)),
-			luabind::value("Feet", static_cast<int>(EQEmu::legacy::SlotFeet)),
+			luabind::value("Feet", static_cast<int>(EQEmu::inventory::slotFeet)),
-			luabind::value("Waist", static_cast<int>(EQEmu::legacy::SlotWaist)),
+			luabind::value("Waist", static_cast<int>(EQEmu::inventory::slotWaist)),
-			luabind::value("PowerSource", static_cast<int>(EQEmu::legacy::SlotPowerSource)),
+			luabind::value("PowerSource", static_cast<int>(EQEmu::inventory::slotPowerSource)),
-			luabind::value("Ammo", static_cast<int>(EQEmu::legacy::SlotAmmo)),
+			luabind::value("Ammo", static_cast<int>(EQEmu::inventory::slotAmmo)),
-			luabind::value("General1", static_cast<int>(EQEmu::legacy::SlotGeneral1)),
+			luabind::value("General1", static_cast<int>(EQEmu::inventory::slotGeneral1)),
-			luabind::value("General2", static_cast<int>(EQEmu::legacy::SlotGeneral2)),
+			luabind::value("General2", static_cast<int>(EQEmu::inventory::slotGeneral2)),
-			luabind::value("General3", static_cast<int>(EQEmu::legacy::SlotGeneral3)),
+			luabind::value("General3", static_cast<int>(EQEmu::inventory::slotGeneral3)),
-			luabind::value("General4", static_cast<int>(EQEmu::legacy::SlotGeneral4)),
+			luabind::value("General4", static_cast<int>(EQEmu::inventory::slotGeneral4)),
-			luabind::value("General5", static_cast<int>(EQEmu::legacy::SlotGeneral5)),
+			luabind::value("General5", static_cast<int>(EQEmu::inventory::slotGeneral5)),
-			luabind::value("General6", static_cast<int>(EQEmu::legacy::SlotGeneral6)),
+			luabind::value("General6", static_cast<int>(EQEmu::inventory::slotGeneral6)),
-			luabind::value("General7", static_cast<int>(EQEmu::legacy::SlotGeneral7)),
+			luabind::value("General7", static_cast<int>(EQEmu::inventory::slotGeneral7)),
-			luabind::value("General8", static_cast<int>(EQEmu::legacy::SlotGeneral8)),
+			luabind::value("General8", static_cast<int>(EQEmu::inventory::slotGeneral8)),
-			luabind::value("Cursor", static_cast<int>(EQEmu::legacy::SlotCursor)),
+			luabind::value("Cursor", static_cast<int>(EQEmu::inventory::slotCursor)),
 			luabind::value("PersonalBegin", static_cast<int>(EQEmu::legacy::GENERAL_BEGIN)), // deprecated
 			luabind::value("GeneralBegin", static_cast<int>(EQEmu::legacy::GENERAL_BEGIN)),
 			luabind::value("PersonalEnd", static_cast<int>(EQEmu::legacy::GENERAL_END)), // deprecated
@@ -1814,19 +1814,19 @@ luabind::scope lua_register_material() {
 	return luabind::class_<Materials>("Material")
 		.enum_("constants")
 		[
-			luabind::value("Head", static_cast<int>(EQEmu::textures::TextureHead)),
+			luabind::value("Head", static_cast<int>(EQEmu::textures::armorHead)),
-			luabind::value("Chest", static_cast<int>(EQEmu::textures::TextureChest)),
+			luabind::value("Chest", static_cast<int>(EQEmu::textures::armorChest)),
-			luabind::value("Arms", static_cast<int>(EQEmu::textures::TextureArms)),
+			luabind::value("Arms", static_cast<int>(EQEmu::textures::armorArms)),
-			luabind::value("Bracer", static_cast<int>(EQEmu::textures::TextureWrist)), // deprecated
+			luabind::value("Bracer", static_cast<int>(EQEmu::textures::armorWrist)), // deprecated
-			luabind::value("Wrist", static_cast<int>(EQEmu::textures::TextureWrist)),
+			luabind::value("Wrist", static_cast<int>(EQEmu::textures::armorWrist)),
-			luabind::value("Hands", static_cast<int>(EQEmu::textures::TextureHands)),
+			luabind::value("Hands", static_cast<int>(EQEmu::textures::armorHands)),
-			luabind::value("Legs", static_cast<int>(EQEmu::textures::TextureLegs)),
+			luabind::value("Legs", static_cast<int>(EQEmu::textures::armorLegs)),
-			luabind::value("Feet", static_cast<int>(EQEmu::textures::TextureFeet)),
+			luabind::value("Feet", static_cast<int>(EQEmu::textures::armorFeet)),
-			luabind::value("Primary", static_cast<int>(EQEmu::textures::TexturePrimary)),
+			luabind::value("Primary", static_cast<int>(EQEmu::textures::weaponPrimary)),
-			luabind::value("Secondary", static_cast<int>(EQEmu::textures::TextureSecondary)),
+			luabind::value("Secondary", static_cast<int>(EQEmu::textures::weaponSecondary)),
-			luabind::value("Max", static_cast<int>(EQEmu::textures::TextureCount)), // deprecated
+			luabind::value("Max", static_cast<int>(EQEmu::textures::materialCount)), // deprecated
-			luabind::value("Count", static_cast<int>(EQEmu::textures::TextureCount)),
+			luabind::value("Count", static_cast<int>(EQEmu::textures::materialCount)),
-			luabind::value("Invalid", static_cast<int>(EQEmu::textures::TextureInvalid))
+			luabind::value("Invalid", static_cast<int>(EQEmu::textures::materialInvalid))
 		];
 }
 

zone/lua_group.cpp

@@ -82,6 +82,11 @@ int Lua_Group::GetHighestLevel() {
 	return self->GetHighestLevel();
 }
 
+int Lua_Group::GetLowestLevel() {
+	Lua_Safe_Call_Int();
+	return self->GetLowestLevel();
+}
+
 void Lua_Group::TeleportGroup(Lua_Mob sender, uint32 zone_id, uint32 instance_id, float x, float y, float z, float h) {
 	Lua_Safe_Call_Void();
 	self->TeleportGroup(sender, zone_id, instance_id, x, y, z, h);
@@ -121,6 +126,7 @@ luabind::scope lua_register_group() {
 		.def("IsLeader", (bool(Lua_Group::*)(Lua_Mob))&Lua_Group::IsLeader)
 		.def("GroupCount", (int(Lua_Group::*)(void))&Lua_Group::GroupCount)
 		.def("GetHighestLevel", (int(Lua_Group::*)(void))&Lua_Group::GetHighestLevel)
+		.def("GetLowestLevel", (int(Lua_Group::*)(void))&Lua_Group::GetLowestLevel)
 		.def("TeleportGroup", (void(Lua_Group::*)(Lua_Mob,uint32,uint32,float,float,float,float))&Lua_Group::TeleportGroup)
 		.def("GetID", (int(Lua_Group::*)(void))&Lua_Group::GetID)
 		.def("GetMember", (Lua_Mob(Lua_Group::*)(int))&Lua_Group::GetMember);

zone/lua_group.h

@@ -40,6 +40,7 @@ public:
 	bool IsLeader(Lua_Mob leader);
 	int GroupCount();
 	int GetHighestLevel();
+	int GetLowestLevel();
 	void TeleportGroup(Lua_Mob sender, uint32 zone_id, uint32 instance_id, float x, float y, float z, float h);
 	int GetID();
 	Lua_Mob GetMember(int index);

zone/lua_inventory.cpp

@@ -20,7 +20,7 @@ Lua_ItemInst Lua_Inventory::GetItem(int slot_id, int bag_slot) {
 
 int Lua_Inventory::PutItem(int slot_id, Lua_ItemInst item) {
 	Lua_Safe_Call_Int();
-	ItemInst *inst = item;
+	EQEmu::ItemInstance *inst = item;
 	if(!inst) {
 		return 0;
 	}
@@ -30,7 +30,7 @@ int Lua_Inventory::PutItem(int slot_id, Lua_ItemInst item) {
 
 int Lua_Inventory::PushCursor(Lua_ItemInst item) {
 	Lua_Safe_Call_Int();
-	ItemInst *inst = item;
+	EQEmu::ItemInstance *inst = item;
 	if(!inst) {
 		return 0;
 	}

zone/lua_inventory.h

@@ -4,26 +4,30 @@
 
 #include "lua_ptr.h"
 
-class Inventory;
 class Lua_ItemInst;
 class Lua_Item;
 
+namespace EQEmu
+{
+	class InventoryProfile;
+}
+
 namespace luabind {
 	struct scope;
 }
 
 luabind::scope lua_register_inventory();
 
-class Lua_Inventory : public Lua_Ptr<Inventory>
+class Lua_Inventory : public Lua_Ptr<EQEmu::InventoryProfile>
 {
-	typedef Inventory NativeType;
+	typedef EQEmu::InventoryProfile NativeType;
 public:
 	Lua_Inventory() : Lua_Ptr(nullptr) { }
-	Lua_Inventory(Inventory *d) : Lua_Ptr(d) { }
+	Lua_Inventory(EQEmu::InventoryProfile *d) : Lua_Ptr(d) { }
 	virtual ~Lua_Inventory() { }
 
-	operator Inventory*() {
+	operator EQEmu::InventoryProfile*() {
-		return reinterpret_cast<Inventory*>(GetLuaPtrData());
+		return reinterpret_cast<EQEmu::InventoryProfile*>(GetLuaPtrData());
 	}
 
 	Lua_ItemInst GetItem(int slot_id);

zone/lua_item.cpp

@@ -7,7 +7,7 @@
 #include "lua_item.h"
 
 Lua_Item::Lua_Item(uint32 item_id) {
-	const EQEmu::ItemBase *t = database.GetItem(item_id);
+	const EQEmu::ItemData *t = database.GetItem(item_id);
 	SetLuaPtrData(t);
 }
 

zone/lua_item.h

@@ -6,7 +6,7 @@
 
 namespace EQEmu
 {
-	struct ItemBase;
+	struct ItemData;
 }
 
 namespace luabind {
@@ -15,17 +15,17 @@ namespace luabind {
 
 luabind::scope lua_register_item();
 
-class Lua_Item : public Lua_Ptr<const EQEmu::ItemBase>
+class Lua_Item : public Lua_Ptr<const EQEmu::ItemData>
 {
-	typedef const EQEmu::ItemBase NativeType;
+	typedef const EQEmu::ItemData NativeType;
 public:
 	Lua_Item(uint32 item_id);
 	Lua_Item() : Lua_Ptr(nullptr) { }
-	Lua_Item(const EQEmu::ItemBase *d) : Lua_Ptr(d) { }
+	Lua_Item(const EQEmu::ItemData *d) : Lua_Ptr(d) { }
 	virtual ~Lua_Item() { }
 
-	operator const EQEmu::ItemBase*() {
+	operator const EQEmu::ItemData*() {
-		return reinterpret_cast<const EQEmu::ItemBase*>(GetLuaPtrData());
+		return reinterpret_cast<const EQEmu::ItemData*>(GetLuaPtrData());
 	}
 
 	int GetMinStatus();