pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-13 18:51:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Renamed EQEmu::Item_Struct to EQEmu::ItemBase to coincide with new inventory naming conventions (re-run shared_memory.exe)

Browse Source
This commit is contained in:
Uleat 2016-05-27 22:22:19 -04:00
parent a37a811014
commit 579efe83af
67 changed files with 391 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
changelog.txt
View File

@ -1,5 +1,8 @@
EQEMu Changelog (Started on Sept 24, 2003 15:50) EQEMu Changelog (Started on Sept 24, 2003 15:50)
------------------------------------------------------- -------------------------------------------------------
== 05/27/2016 ==
Uleat: Renamed EQEmu::Item_Struct to EQEmu::ItemBase (and appropriate files) to coincide with new inventory naming conventions
== 05/25/2016 == == 05/25/2016 ==
Uleat: Renamed and moved enumeration SkillUseTypes to EQEmu::skill::SkillType - added class EQEmu::SkillProfile, though not implemented at this time Uleat: Renamed and moved enumeration SkillUseTypes to EQEmu::skill::SkillType - added class EQEmu::SkillProfile, though not implemented at this time
Uleat: Some more work on eq_dictionary Uleat: Some more work on eq_dictionary

4
common/CMakeLists.txt
View File

@ -38,7 +38,7 @@ SET(common_sources
inventory_version.cpp inventory_version.cpp
ipc_mutex.cpp ipc_mutex.cpp
item.cpp item.cpp
item_struct.cpp item_base.cpp
light_source.cpp light_source.cpp
md5.cpp md5.cpp
memory_buffer.cpp memory_buffer.cpp
@ -158,8 +158,8 @@ SET(common_headers
inventory_version.h inventory_version.h
ipc_mutex.h ipc_mutex.h
item.h item.h
item_base.h
item_fieldlist.h item_fieldlist.h
item_struct.h
languages.h languages.h
light_source.h light_source.h
linked_list.h linked_list.h

6
common/eq_packet_structs.h
View File

@ -25,7 +25,8 @@
#include <list> #include <list>
#include <time.h> #include <time.h>
#include "../common/version.h" #include "../common/version.h"
//#include "../common/item_struct.h" #include "emu_constants.h"
static const uint32 BUFF_COUNT = 25; static const uint32 BUFF_COUNT = 25;
static const uint32 MAX_MERC = 100; static const uint32 MAX_MERC = 100;
@ -33,7 +34,6 @@ static const uint32 MAX_MERC_GRADES = 10;
static const uint32 MAX_MERC_STANCES = 10; static const uint32 MAX_MERC_STANCES = 10;
static const uint32 BLOCKED_BUFF_COUNT = 20; static const uint32 BLOCKED_BUFF_COUNT = 20;
#include "emu_constants.h"
/* /*
** Compiler override to ensure ** Compiler override to ensure
@ -2119,7 +2119,7 @@ struct AdventureLeaderboard_Struct
/*struct Item_Shop_Struct { /*struct Item_Shop_Struct {
uint16 merchantid; uint16 merchantid;
uint8 itemtype; uint8 itemtype;
EQEmu::Item_Struct item; EQEmu::ItemBase item;
uint8 iss_unknown001[6]; uint8 iss_unknown001[6];
};*/ };*/

28
common/item.cpp
View File

@ -370,7 +370,7 @@ ItemInst* Inventory::PopItem(int16 slot_id)
return p; return p;
} }
bool Inventory::HasSpaceForItem(const EQEmu::Item_Struct *ItemToTry, int16 Quantity) { bool Inventory::HasSpaceForItem(const EQEmu::ItemBase *ItemToTry, int16 Quantity) {
if (ItemToTry->Stackable) { if (ItemToTry->Stackable) {
@ -903,7 +903,7 @@ uint8 Inventory::CalcMaterialFromSlot(int16 equipslot)
} }
} }
bool Inventory::CanItemFitInContainer(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container) { bool Inventory::CanItemFitInContainer(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container) {
if (!ItemToTry || !Container) if (!ItemToTry || !Container)
return false; return false;
@ -1440,10 +1440,10 @@ int16 Inventory::_HasItemByLoreGroup(ItemInstQueue& iqueue, uint32 loregroup)
// //
// class ItemInst // class ItemInst
// //
ItemInst::ItemInst(const EQEmu::Item_Struct* item, int16 charges) { ItemInst::ItemInst(const EQEmu::ItemBase* item, int16 charges) {
m_use_type = ItemInstNormal; m_use_type = ItemInstNormal;
if(item) { if(item) {
m_item = new EQEmu::Item_Struct(*item); m_item = new EQEmu::ItemBase(*item);
} else { } else {
m_item = nullptr; m_item = nullptr;
} }
@ -1474,7 +1474,7 @@ ItemInst::ItemInst(SharedDatabase *db, uint32 item_id, int16 charges) {
m_use_type = ItemInstNormal; m_use_type = ItemInstNormal;
m_item = db->GetItem(item_id); m_item = db->GetItem(item_id);
if(m_item) { if(m_item) {
m_item = new EQEmu::Item_Struct(*m_item); m_item = new EQEmu::ItemBase(*m_item);
} }
else { else {
m_item = nullptr; m_item = nullptr;
@ -1529,7 +1529,7 @@ ItemInst::ItemInst(const ItemInst& copy)
{ {
m_use_type=copy.m_use_type; m_use_type=copy.m_use_type;
if(copy.m_item) if(copy.m_item)
m_item = new EQEmu::Item_Struct(*copy.m_item); m_item = new EQEmu::ItemBase(*copy.m_item);
else else
m_item = nullptr; m_item = nullptr;
@ -1565,7 +1565,7 @@ ItemInst::ItemInst(const ItemInst& copy)
m_evolveLvl = copy.m_evolveLvl; m_evolveLvl = copy.m_evolveLvl;
m_activated = copy.m_activated; m_activated = copy.m_activated;
if (copy.m_scaledItem) if (copy.m_scaledItem)
m_scaledItem = new EQEmu::Item_Struct(*copy.m_scaledItem); m_scaledItem = new EQEmu::ItemBase(*copy.m_scaledItem);
else else
m_scaledItem = nullptr; m_scaledItem = nullptr;
@ -1800,7 +1800,7 @@ void ItemInst::ClearByFlags(byFlagSetting is_nodrop, byFlagSetting is_norent)
continue; continue;
} }
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item == nullptr) { if (item == nullptr) {
cur = m_contents.erase(cur); cur = m_contents.erase(cur);
continue; continue;
@ -1941,7 +1941,7 @@ bool ItemInst::UpdateOrnamentationInfo() {
int32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); int32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
if (GetOrnamentationAug(ornamentationAugtype)) if (GetOrnamentationAug(ornamentationAugtype))
{ {
const EQEmu::Item_Struct* ornamentItem; const EQEmu::ItemBase* ornamentItem;
ornamentItem = GetOrnamentationAug(ornamentationAugtype)->GetItem(); ornamentItem = GetOrnamentationAug(ornamentationAugtype)->GetItem();
if (ornamentItem != nullptr) if (ornamentItem != nullptr)
{ {
@ -1968,7 +1968,7 @@ bool ItemInst::UpdateOrnamentationInfo() {
return ornamentSet; return ornamentSet;
} }
bool ItemInst::CanTransform(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container, bool AllowAll) { bool ItemInst::CanTransform(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container, bool AllowAll) {
if (!ItemToTry || !Container) return false; if (!ItemToTry || !Container) return false;
if (ItemToTry->ItemType == EQEmu::item::ItemTypeArrow || strnlen(Container->CharmFile, 30) == 0) if (ItemToTry->ItemType == EQEmu::item::ItemTypeArrow || strnlen(Container->CharmFile, 30) == 0)
@ -2102,7 +2102,7 @@ bool ItemInst::IsAmmo() const
} }
const EQEmu::Item_Struct* ItemInst::GetItem() const const EQEmu::ItemBase* ItemInst::GetItem() const
{ {
if (!m_item) if (!m_item)
return nullptr; return nullptr;
@ -2113,7 +2113,7 @@ const EQEmu::Item_Struct* ItemInst::GetItem() const
return m_item; return m_item;
} }
const EQEmu::Item_Struct* ItemInst::GetUnscaledItem() const const EQEmu::ItemBase* ItemInst::GetUnscaledItem() const
{ {
// No operator calls and defaults to nullptr // No operator calls and defaults to nullptr
return m_item; return m_item;
@ -2221,10 +2221,10 @@ void ItemInst::ScaleItem() {
return; return;
if (m_scaledItem) { if (m_scaledItem) {
memcpy(m_scaledItem, m_item, sizeof(EQEmu::Item_Struct)); memcpy(m_scaledItem, m_item, sizeof(EQEmu::ItemBase));
} }
else { else {
m_scaledItem = new EQEmu::Item_Struct(*m_item); m_scaledItem = new EQEmu::ItemBase(*m_item);
} }
float Mult = (float)(GetExp()) / 10000; // scaling is determined by exp, with 10,000 being full stats float Mult = (float)(GetExp()) / 10000; // scaling is determined by exp, with 10,000 being full stats

18
common/item.h
View File

@ -29,7 +29,7 @@ class ItemParse; // Parses item packets
class EvolveInfo; // Stores information about an evolving item family class EvolveInfo; // Stores information about an evolving item family
#include "../common/eq_constants.h" #include "../common/eq_constants.h"
#include "../common/item_struct.h" #include "../common/item_base.h"
#include "../common/timer.h" #include "../common/timer.h"
#include "../common/bodytypes.h" #include "../common/bodytypes.h"
#include "../common/deity.h" #include "../common/deity.h"
@ -175,7 +175,7 @@ public:
ItemInst* PopItem(int16 slot_id); ItemInst* PopItem(int16 slot_id);
// Check whether there is space for the specified number of the specified item. // Check whether there is space for the specified number of the specified item.
bool HasSpaceForItem(const EQEmu::Item_Struct *ItemToTry, int16 Quantity); bool HasSpaceForItem(const EQEmu::ItemBase *ItemToTry, int16 Quantity);
// Check whether item exists in inventory // Check whether item exists in inventory
// where argument specifies OR'd list of invWhere constants to look // where argument specifies OR'd list of invWhere constants to look
@ -200,7 +200,7 @@ public:
static int16 CalcSlotFromMaterial(uint8 material); static int16 CalcSlotFromMaterial(uint8 material);
static uint8 CalcMaterialFromSlot(int16 equipslot); static uint8 CalcMaterialFromSlot(int16 equipslot);
static bool CanItemFitInContainer(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container); static bool CanItemFitInContainer(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container);
// Test for valid inventory casting slot // Test for valid inventory casting slot
bool SupportsClickCasting(int16 slot_id); bool SupportsClickCasting(int16 slot_id);
@ -277,7 +277,7 @@ public:
///////////////////////// /////////////////////////
// Constructors/Destructor // Constructors/Destructor
ItemInst(const EQEmu::Item_Struct* item = nullptr, int16 charges = 0); ItemInst(const EQEmu::ItemBase* item = nullptr, int16 charges = 0);
ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0); ItemInst(SharedDatabase *db, uint32 item_id, int16 charges = 0);
@ -346,7 +346,7 @@ public:
bool IsAugmented(); bool IsAugmented();
ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const; ItemInst* GetOrnamentationAug(int32 ornamentationAugtype) const;
bool UpdateOrnamentationInfo(); bool UpdateOrnamentationInfo();
static bool CanTransform(const EQEmu::Item_Struct *ItemToTry, const EQEmu::Item_Struct *Container, bool AllowAll = false); static bool CanTransform(const EQEmu::ItemBase *ItemToTry, const EQEmu::ItemBase *Container, bool AllowAll = false);
// Has attack/delay? // Has attack/delay?
bool IsWeapon() const; bool IsWeapon() const;
@ -355,8 +355,8 @@ public:
// Accessors // Accessors
const uint32 GetID() const { return ((m_item) ? m_item->ID : NO_ITEM); } 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 uint32 GetItemScriptID() const { return ((m_item) ? m_item->ScriptFileID : NO_ITEM); }
const EQEmu::Item_Struct* GetItem() const; const EQEmu::ItemBase* GetItem() const;
const EQEmu::Item_Struct* GetUnscaledItem() const; const EQEmu::ItemBase* GetUnscaledItem() const;
int16 GetCharges() const { return m_charges; } int16 GetCharges() const { return m_charges; }
void SetCharges(int16 charges) { m_charges = charges; } void SetCharges(int16 charges) { m_charges = charges; }
@ -500,7 +500,7 @@ protected:
void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; } void _PutItem(uint8 index, ItemInst* inst) { m_contents[index] = inst; }
ItemInstTypes m_use_type; // Usage type for item ItemInstTypes m_use_type; // Usage type for item
const EQEmu::Item_Struct* m_item; // Ptr to item data const EQEmu::ItemBase* m_item; // Ptr to item data
int16 m_charges; // # of charges for chargeable items int16 m_charges; // # of charges for chargeable items
uint32 m_price; // Bazaar /trader price uint32 m_price; // Bazaar /trader price
uint32 m_color; uint32 m_color;
@ -512,7 +512,7 @@ protected:
uint32 m_exp; uint32 m_exp;
int8 m_evolveLvl; int8 m_evolveLvl;
bool m_activated; bool m_activated;
EQEmu::Item_Struct* m_scaledItem; EQEmu::ItemBase* m_scaledItem;
EvolveInfo* m_evolveInfo; EvolveInfo* m_evolveInfo;
bool m_scaling; bool m_scaling;
uint32 m_ornamenticon; uint32 m_ornamenticon;

16
common/item_struct.cpp → common/item_base.cpp
View File

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

32
common/item_struct.h → common/item_base.h
View File

@ -17,8 +17,8 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
*/ */
#ifndef COMMON_ITEM_STRUCT_H #ifndef COMMON_ITEM_BASE_H
#define COMMON_ITEM_STRUCT_H #define COMMON_ITEM_BASE_H
/* /*
@ -336,10 +336,10 @@ namespace EQEmu
}; };
enum ItemDataType : uint8 { enum ItemDataType : uint8 {
ItemDataTypeBase = 0, ItemDataBase = 0,
ItemDataTypeScaling, ItemDataScaling,
ItemDataTypeEvolving, ItemDataEvolving,
ItemDataTypeCount ItemDataCount
}; };
struct ItemEffect_Struct { struct ItemEffect_Struct {
@ -364,10 +364,10 @@ namespace EQEmu
const void * inst; const void * inst;
}; };
struct Item_Struct { struct ItemBase {
// Non packet based fields // Non packet based fields
uint8 MinStatus; uint8 MinStatus;
//uint8 ItemDataType; uint8 ItemDataType; // memset to item::ItemDataBase ('0') during mmf load
// Packet based fields // Packet based fields
uint8 ItemClass; // Item Type: 0=common, 1=container, 2=book uint8 ItemClass; // Item Type: 0=common, 1=container, 2=book
@ -551,15 +551,15 @@ namespace EQEmu
bool IsType2HWeapon(); bool IsType2HWeapon();
bool IsTypeShield(); bool IsTypeShield();
bool IsEquipable(uint16 Race, uint16 Class) const { return const_cast<Item_Struct*>(this)->IsEquipable(Race, Class); } bool IsEquipable(uint16 Race, uint16 Class) const { return const_cast<ItemBase*>(this)->IsEquipable(Race, Class); }
bool IsClassCommon() const { return const_cast<Item_Struct*>(this)->IsClassCommon(); } bool IsClassCommon() const { return const_cast<ItemBase*>(this)->IsClassCommon(); }
bool IsClassBag() const { return const_cast<Item_Struct*>(this)->IsClassBag(); } bool IsClassBag() const { return const_cast<ItemBase*>(this)->IsClassBag(); }
bool IsClassBook() const { return const_cast<Item_Struct*>(this)->IsClassBook(); } bool IsClassBook() const { return const_cast<ItemBase*>(this)->IsClassBook(); }
bool IsType1HWeapon() const { return const_cast<Item_Struct*>(this)->IsType1HWeapon(); } bool IsType1HWeapon() const { return const_cast<ItemBase*>(this)->IsType1HWeapon(); }
bool IsType2HWeapon() const { return const_cast<Item_Struct*>(this)->IsType2HWeapon(); } bool IsType2HWeapon() const { return const_cast<ItemBase*>(this)->IsType2HWeapon(); }
bool IsTypeShield() const { return const_cast<Item_Struct*>(this)->IsTypeShield(); } bool IsTypeShield() const { return const_cast<ItemBase*>(this)->IsTypeShield(); }
}; };
} /*EQEmu*/ } /*EQEmu*/
#endif /*COMMON_ITEM_STRUCT_H*/ #endif /*COMMON_ITEM_BASE_H*/

2
common/patches/rof.cpp
View File

@ -5201,7 +5201,7 @@ namespace RoF
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
{ {
const EQEmu::Item_Struct *item = inst->GetUnscaledItem(); const EQEmu::ItemBase *item = inst->GetUnscaledItem();
RoF::structs::ItemSerializationHeader hdr; RoF::structs::ItemSerializationHeader hdr;

2
common/patches/rof2.cpp
View File

@ -5476,7 +5476,7 @@ namespace RoF2
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth, ItemPacketType packet_type) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth, ItemPacketType packet_type)
{ {
const EQEmu::Item_Struct *item = inst->GetUnscaledItem(); const EQEmu::ItemBase *item = inst->GetUnscaledItem();
RoF2::structs::ItemSerializationHeader hdr; RoF2::structs::ItemSerializationHeader hdr;

2
common/patches/rof2_structs.h
View File

@ -2446,7 +2446,7 @@ struct AdventureLeaderboard_Struct
/*struct Item_Shop_Struct { /*struct Item_Shop_Struct {
uint16 merchantid; uint16 merchantid;
uint8 itemtype; uint8 itemtype;
Item_Struct item; ItemBase item;
uint8 iss_unknown001[6]; uint8 iss_unknown001[6];
};*/ };*/

2
common/patches/rof_structs.h
View File

@ -2473,7 +2473,7 @@ struct AdventureLeaderboard_Struct
/*struct Item_Shop_Struct { /*struct Item_Shop_Struct {
uint16 merchantid; uint16 merchantid;
uint8 itemtype; uint8 itemtype;
Item_Struct item; ItemBase item;
uint8 iss_unknown001[6]; uint8 iss_unknown001[6];
};*/ };*/

2
common/patches/sod.cpp
View File

@ -3546,7 +3546,7 @@ namespace SoD
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
{ {
const EQEmu::Item_Struct *item = inst->GetUnscaledItem(); const EQEmu::ItemBase *item = inst->GetUnscaledItem();
SoD::structs::ItemSerializationHeader hdr; SoD::structs::ItemSerializationHeader hdr;

2
common/patches/sod_structs.h
View File

@ -1995,7 +1995,7 @@ struct AdventureLeaderboard_Struct
/*struct Item_Shop_Struct { /*struct Item_Shop_Struct {
uint16 merchantid; uint16 merchantid;
uint8 itemtype; uint8 itemtype;
Item_Struct item; ItemBase item;
uint8 iss_unknown001[6]; uint8 iss_unknown001[6];
};*/ };*/

2
common/patches/sof.cpp
View File

@ -2887,7 +2887,7 @@ namespace SoF
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
{ {
const EQEmu::Item_Struct *item = inst->GetUnscaledItem(); const EQEmu::ItemBase *item = inst->GetUnscaledItem();
SoF::structs::ItemSerializationHeader hdr; SoF::structs::ItemSerializationHeader hdr;

2
common/patches/titanium.cpp
View File

@ -2107,7 +2107,7 @@ namespace Titanium
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
{ {
const char* protection = "\\\\\\\\\\"; const char* protection = "\\\\\\\\\\";
const EQEmu::Item_Struct* item = inst->GetUnscaledItem(); const EQEmu::ItemBase* item = inst->GetUnscaledItem();
ob << StringFormat("%.*s%s", (depth ? (depth - 1) : 0), protection, (depth ? "\"" : "")); // For leading quotes (and protection) if a subitem; ob << StringFormat("%.*s%s", (depth ? (depth - 1) : 0), protection, (depth ? "\"" : "")); // For leading quotes (and protection) if a subitem;

4
common/patches/uf.cpp
View File

@ -3841,7 +3841,7 @@ namespace UF
void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth) void SerializeItem(EQEmu::OutBuffer& ob, const ItemInst *inst, int16 slot_id_in, uint8 depth)
{ {
const EQEmu::Item_Struct *item = inst->GetUnscaledItem(); const EQEmu::ItemBase *item = inst->GetUnscaledItem();
UF::structs::ItemSerializationHeader hdr; UF::structs::ItemSerializationHeader hdr;
@ -3885,7 +3885,7 @@ namespace UF
int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
uint16 ornaIcon = 0; uint16 ornaIcon = 0;
if (inst->GetOrnamentationAug(ornamentationAugtype)) { if (inst->GetOrnamentationAug(ornamentationAugtype)) {
const EQEmu::Item_Struct *aug_weap = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem(); const EQEmu::ItemBase *aug_weap = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
ornaIcon = aug_weap->Icon; ornaIcon = aug_weap->Icon;
ob.write(aug_weap->IDFile, strlen(aug_weap->IDFile)); ob.write(aug_weap->IDFile, strlen(aug_weap->IDFile));

2
common/patches/uf_structs.h
View File

@ -2054,7 +2054,7 @@ struct AdventureLeaderboard_Struct
/*struct Item_Shop_Struct { /*struct Item_Shop_Struct {
uint16 merchantid; uint16 merchantid;
uint8 itemtype; uint8 itemtype;
Item_Struct item; ItemBase item;
uint8 iss_unknown001[6]; uint8 iss_unknown001[6];
};*/ };*/

6
common/say_link.cpp
View File

@ -22,7 +22,7 @@
#include "string_util.h" #include "string_util.h"
#include "item.h" #include "item.h"
#include "item_struct.h" #include "item_base.h"
#include "../zone/zonedb.h" #include "../zone/zonedb.h"
@ -99,7 +99,7 @@ void EQEmu::saylink::SayLinkEngine::generate_body()
memset(&m_LinkBodyStruct, 0, sizeof(SayLinkBody_Struct)); memset(&m_LinkBodyStruct, 0, sizeof(SayLinkBody_Struct));
const EQEmu::Item_Struct* item_data = nullptr; const EQEmu::ItemBase* item_data = nullptr;
switch (m_LinkType) { switch (m_LinkType) {
case SayLinkBlank: case SayLinkBlank:
@ -202,7 +202,7 @@ void EQEmu::saylink::SayLinkEngine::generate_text()
return; return;
} }
const EQEmu::Item_Struct* item_data = nullptr; const EQEmu::ItemBase* item_data = nullptr;
switch (m_LinkType) { switch (m_LinkType) {
case SayLinkBlank: case SayLinkBlank:

6
common/say_link.h
View File

@ -31,7 +31,7 @@ class ItemInst;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
namespace saylink { namespace saylink {
struct SayLinkBody_Struct; // Current server mask: EQClientRoF2 struct SayLinkBody_Struct; // Current server mask: EQClientRoF2
@ -74,7 +74,7 @@ public:
SayLinkEngine(); SayLinkEngine();
void SetLinkType(SayLinkType link_type) { m_LinkType = link_type; } void SetLinkType(SayLinkType link_type) { m_LinkType = link_type; }
void SetItemData(const EQEmu::Item_Struct* item_data) { m_ItemData = item_data; } void SetItemData(const EQEmu::ItemBase* item_data) { m_ItemData = item_data; }
void SetLootData(const ServerLootItem_Struct* loot_data) { m_LootData = loot_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 ItemInst* item_inst) { m_ItemInst = item_inst; }
@ -110,7 +110,7 @@ private:
void generate_text(); void generate_text();
int m_LinkType; int m_LinkType;
const EQEmu::Item_Struct* m_ItemData; const EQEmu::ItemBase* m_ItemData;
const ServerLootItem_Struct* m_LootData; const ServerLootItem_Struct* m_LootData;
const ItemInst* m_ItemInst; const ItemInst* m_ItemInst;

26
common/shareddb.cpp
View File

@ -364,7 +364,7 @@ bool SharedDatabase::SetSharedPlatinum(uint32 account_id, int32 amount_to_add) {
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, Inventory* inv, uint32 si_race, uint32 si_class, uint32 si_deity, uint32 si_current_zone, char* si_name, int admin_level) {
const EQEmu::Item_Struct* myitem; const EQEmu::ItemBase* myitem;
std::string query = StringFormat("SELECT itemid, item_charges, slot FROM starting_items " 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 " "WHERE (race = %i or race = 0) AND (class = %i or class = 0) AND "
@ -436,7 +436,7 @@ bool SharedDatabase::GetSharedBank(uint32 id, Inventory *inv, bool is_charid)
aug[4] = (uint32)atoi(row[7]); aug[4] = (uint32)atoi(row[7]);
aug[5] = (uint32)atoi(row[8]); aug[5] = (uint32)atoi(row[8]);
const EQEmu::Item_Struct *item = GetItem(item_id); const EQEmu::ItemBase *item = GetItem(item_id);
if (!item) { if (!item) {
Log.Out(Logs::General, Logs::Error, Log.Out(Logs::General, Logs::Error,
@ -538,7 +538,7 @@ bool SharedDatabase::GetInventory(uint32 char_id, Inventory *inv)
uint32 ornament_idfile = (uint32)atoul(row[13]); uint32 ornament_idfile = (uint32)atoul(row[13]);
uint32 ornament_hero_model = (uint32)atoul(row[14]); uint32 ornament_hero_model = (uint32)atoul(row[14]);
const EQEmu::Item_Struct *item = GetItem(item_id); const EQEmu::ItemBase *item = GetItem(item_id);
if (!item) { if (!item) {
Log.Out(Logs::General, Logs::Error, Log.Out(Logs::General, Logs::Error,
@ -679,7 +679,7 @@ bool SharedDatabase::GetInventory(uint32 account_id, char *name, Inventory *inv)
uint32 ornament_idfile = (uint32)atoul(row[13]); uint32 ornament_idfile = (uint32)atoul(row[13]);
uint32 ornament_hero_model = (uint32)atoul(row[14]); uint32 ornament_hero_model = (uint32)atoul(row[14]);
const EQEmu::Item_Struct *item = GetItem(item_id); const EQEmu::ItemBase *item = GetItem(item_id);
int16 put_slot_id = INVALID_INDEX; int16 put_slot_id = INVALID_INDEX;
if (!item) if (!item)
continue; continue;
@ -816,7 +816,7 @@ bool SharedDatabase::LoadItems(const std::string &prefix) {
mutex.Lock(); mutex.Lock();
std::string file_name = Config->SharedMemDir + prefix + std::string("items"); std::string file_name = Config->SharedMemDir + prefix + std::string("items");
items_mmf = std::unique_ptr<EQEmu::MemoryMappedFile>(new EQEmu::MemoryMappedFile(file_name)); items_mmf = std::unique_ptr<EQEmu::MemoryMappedFile>(new EQEmu::MemoryMappedFile(file_name));
items_hash = std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::Item_Struct>>(new EQEmu::FixedMemoryHashSet<EQEmu::Item_Struct>(reinterpret_cast<uint8*>(items_mmf->Get()), items_mmf->Size())); items_hash = std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>>(new EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>(reinterpret_cast<uint8*>(items_mmf->Get()), items_mmf->Size()));
mutex.Unlock(); mutex.Unlock();
} catch(std::exception& ex) { } catch(std::exception& ex) {
Log.Out(Logs::General, Logs::Error, "Error Loading Items: %s", ex.what()); Log.Out(Logs::General, Logs::Error, "Error Loading Items: %s", ex.what());
@ -828,7 +828,7 @@ bool SharedDatabase::LoadItems(const std::string &prefix) {
void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id) void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id)
{ {
EQEmu::FixedMemoryHashSet<EQEmu::Item_Struct> hash(reinterpret_cast<uint8 *>(data), size, items, max_item_id); EQEmu::FixedMemoryHashSet<EQEmu::ItemBase> hash(reinterpret_cast<uint8 *>(data), size, items, max_item_id);
std::string ndbuffer; std::string ndbuffer;
bool disableNoRent = false; bool disableNoRent = false;
@ -856,7 +856,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
} }
} }
EQEmu::Item_Struct item; EQEmu::ItemBase item;
const std::string query = "SELECT source," const std::string query = "SELECT source,"
#define F(x) "`"#x"`," #define F(x) "`"#x"`,"
@ -869,7 +869,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
} }
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
memset(&item, 0, sizeof(EQEmu::Item_Struct)); memset(&item, 0, sizeof(EQEmu::ItemBase));
item.ItemClass = (uint8)atoi(row[ItemField::itemclass]); item.ItemClass = (uint8)atoi(row[ItemField::itemclass]);
strcpy(item.Name, row[ItemField::name]); strcpy(item.Name, row[ItemField::name]);
@ -1086,7 +1086,7 @@ void SharedDatabase::LoadItems(void *data, uint32 size, int32 items, uint32 max_
} }
} }
const EQEmu::Item_Struct* SharedDatabase::GetItem(uint32 id) { const EQEmu::ItemBase* SharedDatabase::GetItem(uint32 id) {
if (id == 0) if (id == 0)
{ {
return nullptr; return nullptr;
@ -1105,7 +1105,7 @@ const EQEmu::Item_Struct* SharedDatabase::GetItem(uint32 id) {
return nullptr; return nullptr;
} }
const EQEmu::Item_Struct* SharedDatabase::IterateItems(uint32* id) { const EQEmu::ItemBase* SharedDatabase::IterateItems(uint32* id) {
if(!items_hash || !id) { if(!items_hash || !id) {
return nullptr; return nullptr;
} }
@ -1253,7 +1253,7 @@ bool SharedDatabase::LoadNPCFactionLists(const std::string &prefix) {
// Create appropriate ItemInst class // Create appropriate ItemInst class
ItemInst* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned) ItemInst* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
{ {
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
ItemInst* inst = nullptr; ItemInst* inst = nullptr;
item = GetItem(item_id); item = GetItem(item_id);
@ -1280,7 +1280,7 @@ ItemInst* SharedDatabase::CreateItem(uint32 item_id, int16 charges, uint32 aug1,
// Create appropriate ItemInst class // Create appropriate ItemInst class
ItemInst* SharedDatabase::CreateItem(const EQEmu::Item_Struct* item, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned) ItemInst* SharedDatabase::CreateItem(const EQEmu::ItemBase* item, int16 charges, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6, uint8 attuned)
{ {
ItemInst* inst = nullptr; ItemInst* inst = nullptr;
if (item) { if (item) {
@ -1304,7 +1304,7 @@ ItemInst* SharedDatabase::CreateItem(const EQEmu::Item_Struct* item, int16 charg
return inst; return inst;
} }
ItemInst* SharedDatabase::CreateBaseItem(const EQEmu::Item_Struct* item, int16 charges) { ItemInst* SharedDatabase::CreateBaseItem(const EQEmu::ItemBase* item, int16 charges) {
ItemInst* inst = nullptr; ItemInst* inst = nullptr;
if (item) { if (item) {
// if maxcharges is -1 that means it is an unlimited use item. // if maxcharges is -1 that means it is an unlimited use item.

13
common/shareddb.h
View File

@ -42,9 +42,10 @@ struct SPDat_Spell_Struct;
struct NPCFactionList; struct NPCFactionList;
struct LootTable_Struct; struct LootTable_Struct;
struct LootDrop_Struct; struct LootDrop_Struct;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
class MemoryMappedFile; class MemoryMappedFile;
} }
@ -99,8 +100,8 @@ class SharedDatabase : public Database
Item Methods 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); 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);
ItemInst* CreateItem(const EQEmu::Item_Struct* 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* 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);
ItemInst* CreateBaseItem(const EQEmu::Item_Struct* item, int16 charges = 0); ItemInst* CreateBaseItem(const EQEmu::ItemBase* item, int16 charges = 0);
/* /*
Shared Memory crap Shared Memory crap
@ -110,8 +111,8 @@ class SharedDatabase : public Database
void GetItemsCount(int32 &item_count, uint32 &max_id); void GetItemsCount(int32 &item_count, uint32 &max_id);
void LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id); void LoadItems(void *data, uint32 size, int32 items, uint32 max_item_id);
bool LoadItems(const std::string &prefix); bool LoadItems(const std::string &prefix);
const EQEmu::Item_Struct* IterateItems(uint32* id); const EQEmu::ItemBase* IterateItems(uint32* id);
const EQEmu::Item_Struct* GetItem(uint32 id); const EQEmu::ItemBase* GetItem(uint32 id);
const EvolveInfo* GetEvolveInfo(uint32 loregroup); const EvolveInfo* GetEvolveInfo(uint32 loregroup);
//faction lists //faction lists
@ -148,7 +149,7 @@ class SharedDatabase : public Database
std::unique_ptr<EQEmu::MemoryMappedFile> skill_caps_mmf; std::unique_ptr<EQEmu::MemoryMappedFile> skill_caps_mmf;
std::unique_ptr<EQEmu::MemoryMappedFile> items_mmf; std::unique_ptr<EQEmu::MemoryMappedFile> items_mmf;
std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::Item_Struct>> items_hash; std::unique_ptr<EQEmu::FixedMemoryHashSet<EQEmu::ItemBase>> items_hash;
std::unique_ptr<EQEmu::MemoryMappedFile> faction_mmf; std::unique_ptr<EQEmu::MemoryMappedFile> faction_mmf;
std::unique_ptr<EQEmu::FixedMemoryHashSet<NPCFactionList>> faction_hash; std::unique_ptr<EQEmu::FixedMemoryHashSet<NPCFactionList>> faction_hash;
std::unique_ptr<EQEmu::MemoryMappedFile> loot_table_mmf; std::unique_ptr<EQEmu::MemoryMappedFile> loot_table_mmf;

4
shared_memory/items.cpp
View File

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

46
tests/fixed_memory_test.h
View File

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

2
world/worlddb.cpp
View File

@ -245,7 +245,7 @@ void WorldDatabase::GetCharSelectInfo(uint32 accountID, EQApplicationPacket **ou
/* Load Inventory */ /* Load Inventory */
// If we ensure that the material data is updated appropriately, we can do away with inventory loads // If we ensure that the material data is updated appropriately, we can do away with inventory loads
if (GetInventory(accountID, cse->Name, &inv)) { if (GetInventory(accountID, cse->Name, &inv)) {
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
const ItemInst* inst = nullptr; const ItemInst* inst = nullptr;
int16 invslot = 0; int16 invslot = 0;

2
zone/aa.cpp
View File

@ -423,7 +423,7 @@ void Mob::WakeTheDead(uint16 spell_id, Mob *target, uint32 duration)
uint32 sitem = 0; uint32 sitem = 0;
sitem = CorpseToUse->GetWornItem(x); sitem = CorpseToUse->GetWornItem(x);
if(sitem){ if(sitem){
const EQEmu::Item_Struct * itm = database.GetItem(sitem); const EQEmu::ItemBase * itm = database.GetItem(sitem);
npca->AddLootDrop(itm, &npca->itemlist, 1, 1, 127, true, true); npca->AddLootDrop(itm, &npca->itemlist, 1, 1, 127, true, true);
} }
} }

26
zone/attack.cpp
View File

@ -55,7 +55,7 @@ bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const
// Determine animation // Determine animation
int type = 0; int type = 0;
if (weapon && weapon->IsClassCommon()) { if (weapon && weapon->IsClassCommon()) {
const EQEmu::Item_Struct* item = weapon->GetItem(); const EQEmu::ItemBase* item = weapon->GetItem();
Log.Out(Logs::Detail, Logs::Attack, "Weapon skill : %i", item->ItemType); Log.Out(Logs::Detail, Logs::Attack, "Weapon skill : %i", item->ItemType);
@ -788,9 +788,9 @@ int32 Client::GetMeleeMitDmg(Mob *attacker, int32 damage, int32 minhit,
//Returns the weapon damage against the input mob //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 //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. //Else we know we can hit.
//GetWeaponDamage(mob*, const Item_Struct*) is intended to be used for mobs or any other situation where we do not have a client inventory item //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 ItemInst*) is intended to be used for situations where we have a client inventory item //GetWeaponDamage(mob*, const ItemInst*) is intended to be used for situations where we have a client inventory item
int Mob::GetWeaponDamage(Mob *against, const EQEmu::Item_Struct *weapon_item) { int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
int dmg = 0; int dmg = 0;
int banedmg = 0; int banedmg = 0;
@ -1116,7 +1116,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above // 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. // who belong to a melee class. If we're here, then all of these conditions apply.
ucDamageBonus = GetWeaponDamageBonus( weapon ? weapon->GetItem() : (const EQEmu::Item_Struct*) nullptr ); ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
@ -1127,7 +1127,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
if (Hand == EQEmu::legacy::SlotSecondary) { if (Hand == EQEmu::legacy::SlotSecondary) {
if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){ if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::Item_Struct*) nullptr, true ); ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr, true);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
@ -1595,7 +1595,7 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
} }
//figure out what weapon they are using, if any //figure out what weapon they are using, if any
const EQEmu::Item_Struct* weapon = nullptr; const EQEmu::ItemBase* weapon = nullptr;
if (Hand == EQEmu::legacy::SlotPrimary && equipment[EQEmu::legacy::SlotPrimary] > 0) if (Hand == EQEmu::legacy::SlotPrimary && equipment[EQEmu::legacy::SlotPrimary] > 0)
weapon = database.GetItem(equipment[EQEmu::legacy::SlotPrimary]); weapon = database.GetItem(equipment[EQEmu::legacy::SlotPrimary]);
else if (equipment[EQEmu::legacy::SlotSecondary]) else if (equipment[EQEmu::legacy::SlotSecondary])
@ -2517,7 +2517,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) {
} }
} }
uint8 Mob::GetWeaponDamageBonus(const EQEmu::Item_Struct *weapon, bool offhand) uint8 Mob::GetWeaponDamageBonus(const EQEmu::ItemBase *weapon, bool offhand)
{ {
// dev quote with old and new formulas // 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 // https://forums.daybreakgames.com/eq/index.php?threads/test-update-09-17-15.226618/page-5#post-3326194
@ -3548,12 +3548,12 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
} }
if(!weapon_g) { if(!weapon_g) {
TrySpellProc(nullptr, (const EQEmu::Item_Struct*)nullptr, on); TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
return; return;
} }
if (!weapon_g->IsClassCommon()) { if (!weapon_g->IsClassCommon()) {
TrySpellProc(nullptr, (const EQEmu::Item_Struct*)nullptr, on); TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
return; return;
} }
@ -3566,7 +3566,7 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
return; return;
} }
void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::Item_Struct *weapon, Mob *on, uint16 hand) void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
{ {
if (!weapon) if (!weapon)
@ -3619,7 +3619,7 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::Item_Struct *weapon,
const ItemInst *aug_i = inst->GetAugment(r); const ItemInst *aug_i = inst->GetAugment(r);
if (!aug_i) // no aug, try next slot! if (!aug_i) // no aug, try next slot!
continue; continue;
const EQEmu::Item_Struct *aug = aug_i->GetItem(); const EQEmu::ItemBase *aug = aug_i->GetItem();
if (!aug) if (!aug)
continue; continue;
@ -3649,7 +3649,7 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::Item_Struct *weapon,
return; return;
} }
void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::Item_Struct *weapon, Mob *on, uint16 hand) void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
{ {
float ProcBonus = static_cast<float>(spellbonuses.SpellProcChance + float ProcBonus = static_cast<float>(spellbonuses.SpellProcChance +
itembonuses.SpellProcChance + aabonuses.SpellProcChance); itembonuses.SpellProcChance + aabonuses.SpellProcChance);
@ -4506,7 +4506,7 @@ void Client::SetAttackTimer()
else //invalid slot (hands will always hit this) else //invalid slot (hands will always hit this)
continue; continue;
const EQEmu::Item_Struct *ItemToUse = nullptr; const EQEmu::ItemBase *ItemToUse = nullptr;
//find our item //find our item
ItemInst *ci = GetInv().GetItem(i); ItemInst *ci = GetInv().GetItem(i);

12
zone/bonuses.cpp
View File

@ -152,7 +152,7 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::legacy::SlotAmmo)); AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::legacy::SlotAmmo));
//These are given special flags due to how often they are checked for various spell effects. //These are given special flags due to how often they are checked for various spell effects.
const EQEmu::Item_Struct *item = inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if (i == EQEmu::legacy::SlotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield)) if (i == EQEmu::legacy::SlotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
SetShieldEquiped(true); SetShieldEquiped(true);
else if (i == EQEmu::legacy::SlotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) { else if (i == EQEmu::legacy::SlotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
@ -218,7 +218,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
return; return;
} }
const EQEmu::Item_Struct *item = inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) { if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
if (item->ItemType != EQEmu::item::ItemTypeFood && item->ItemType != EQEmu::item::ItemTypeDrink) if (item->ItemType != EQEmu::item::ItemTypeFood && item->ItemType != EQEmu::item::ItemTypeDrink)
@ -550,7 +550,7 @@ void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool
if(inst->GetAugmentType()==0 && isAug == true) if(inst->GetAugmentType()==0 && isAug == true)
return; return;
const EQEmu::Item_Struct *item = inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if(!inst->IsEquipable(GetBaseRace(),GetClass())) if(!inst->IsEquipable(GetBaseRace(),GetClass()))
return; return;
@ -582,7 +582,7 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
break; break;
const ItemInst* inst = GetInv().GetItem(i); const ItemInst* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) { if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::Item_Struct *item=inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if (item->ItemType == EQEmu::item::ItemTypeFood && !food) if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
food = true; food = true;
else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink) else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@ -598,7 +598,7 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
break; break;
const ItemInst* inst = GetInv().GetItem(i); const ItemInst* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) { if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::Item_Struct *item=inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if (item->ItemType == EQEmu::item::ItemTypeFood && !food) if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
food = true; food = true;
else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink) else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@ -3203,7 +3203,7 @@ void NPC::CalcItemBonuses(StatBonuses *newbon)
if(newbon){ if(newbon){
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){ for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){
const EQEmu::Item_Struct *cur = database.GetItem(equipment[i]); const EQEmu::ItemBase *cur = database.GetItem(equipment[i]);
if(cur){ if(cur){
//basic stats //basic stats
newbon->AC += cur->AC; newbon->AC += cur->AC;

52
zone/bot.cpp
View File

@ -234,8 +234,8 @@ uint32 Bot::GetBotArcheryRange() {
if (!range_inst || !ammo_inst) if (!range_inst || !ammo_inst)
return 0; return 0;
const EQEmu::Item_Struct *range_item = range_inst->GetItem(); const EQEmu::ItemBase *range_item = range_inst->GetItem();
const EQEmu::Item_Struct *ammo_item = ammo_inst->GetItem(); const EQEmu::ItemBase *ammo_item = ammo_inst->GetItem();
if (!range_item || !ammo_item || range_item->ItemType != EQEmu::item::ItemTypeBow || ammo_item->ItemType != EQEmu::item::ItemTypeArrow) if (!range_item || !ammo_item || range_item->ItemType != EQEmu::item::ItemTypeBow || ammo_item->ItemType != EQEmu::item::ItemTypeArrow)
return 0; return 0;
@ -1899,12 +1899,12 @@ void Bot::BotRangedAttack(Mob* other) {
} }
ItemInst* rangedItem = GetBotItem(EQEmu::legacy::SlotRange); ItemInst* rangedItem = GetBotItem(EQEmu::legacy::SlotRange);
const EQEmu::Item_Struct* RangeWeapon = 0; const EQEmu::ItemBase* RangeWeapon = 0;
if(rangedItem) if(rangedItem)
RangeWeapon = rangedItem->GetItem(); RangeWeapon = rangedItem->GetItem();
ItemInst* ammoItem = GetBotItem(EQEmu::legacy::SlotAmmo); ItemInst* ammoItem = GetBotItem(EQEmu::legacy::SlotAmmo);
const EQEmu::Item_Struct* Ammo = 0; const EQEmu::ItemBase* Ammo = 0;
if(ammoItem) if(ammoItem)
Ammo = ammoItem->GetItem(); Ammo = ammoItem->GetItem();
@ -2013,7 +2013,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int32 min_hit = 1; int32 min_hit = 1;
int32 max_hit = ((2 * weapon_damage * GetDamageTable(skillinuse)) / 100); int32 max_hit = ((2 * weapon_damage * GetDamageTable(skillinuse)) / 100);
if(GetLevel() >= 28 && IsWarriorClass()) { if(GetLevel() >= 28 && IsWarriorClass()) {
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::Item_Struct*) nullptr); int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
hate += ucDamageBonus; hate += ucDamageBonus;
@ -2055,7 +2055,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
if (skillinuse == EQEmu::skills::SkillBash){ if (skillinuse == EQEmu::skills::SkillBash){
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary); const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::Item_Struct* botweapon = 0; const EQEmu::ItemBase* botweapon = 0;
if(inst) if(inst)
botweapon = inst->GetItem(); botweapon = inst->GetItem();
@ -2115,7 +2115,7 @@ void Bot::ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int3
if (item_slot >= EQEmu::legacy::EQUIPMENT_BEGIN){ if (item_slot >= EQEmu::legacy::EQUIPMENT_BEGIN){
const ItemInst* inst = GetBotItem(item_slot); const ItemInst* inst = GetBotItem(item_slot);
const EQEmu::Item_Struct* botweapon = 0; const EQEmu::ItemBase* botweapon = 0;
if(inst) if(inst)
botweapon = inst->GetItem(); botweapon = inst->GetItem();
@ -2503,7 +2503,7 @@ void Bot::AI_Process() {
//now off hand //now off hand
if(GetTarget() && attack_dw_timer.Check() && CanThisClassDualWield()) { if(GetTarget() && attack_dw_timer.Check() && CanThisClassDualWield()) {
const ItemInst* instweapon = GetBotItem(EQEmu::legacy::SlotSecondary); const ItemInst* instweapon = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::Item_Struct* weapon = 0; const EQEmu::ItemBase* weapon = 0;
//can only dual wield without a weapon if you're a monk //can only dual wield without a weapon if you're a monk
if(instweapon || (botClass == MONK)) { if(instweapon || (botClass == MONK)) {
if(instweapon) if(instweapon)
@ -2950,7 +2950,7 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive]; ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
ns->spawn.helm = helmtexture; //(GetShowHelm() ? helmtexture : 0); //0xFF; ns->spawn.helm = helmtexture; //(GetShowHelm() ? helmtexture : 0); //0xFF;
ns->spawn.equip_chest2 = texture; //0xFF; ns->spawn.equip_chest2 = texture; //0xFF;
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
const ItemInst* inst = 0; const ItemInst* inst = 0;
uint32 spawnedbotid = 0; uint32 spawnedbotid = 0;
spawnedbotid = this->GetBotID(); spawnedbotid = this->GetBotID();
@ -3393,7 +3393,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
//EQoffline: will give the items to the bots and change the bot stats //EQoffline: will give the items to the bots and change the bot stats
if(inst && (GetBotOwner() == client->CastToMob()) && !IsEngaged()) { if(inst && (GetBotOwner() == client->CastToMob()) && !IsEngaged()) {
std::string TempErrorMessage; std::string TempErrorMessage;
const EQEmu::Item_Struct* mWeaponItem = inst->GetItem(); const EQEmu::ItemBase* mWeaponItem = inst->GetItem();
bool failedLoreCheck = false; bool failedLoreCheck = false;
for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) { for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) {
ItemInst *itm = inst->GetAugment(m); ItemInst *itm = inst->GetAugment(m);
@ -3572,7 +3572,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
} }
} }
const EQEmu::Item_Struct* item2 = 0; const EQEmu::ItemBase* item2 = 0;
for(int y = beginSlotID; y <= endSlotID; ++y) { for(int y = beginSlotID; y <= endSlotID; ++y) {
item2 = database.GetItem(items[y]); item2 = database.GetItem(items[y]);
if(item2) { if(item2) {
@ -3811,7 +3811,7 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass()) { if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass()) {
// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above // 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. // who belong to a melee class. If we're here, then all of these conditions apply.
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::Item_Struct*) nullptr); ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
hate += ucDamageBonus; hate += ucDamageBonus;
@ -3820,7 +3820,7 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
//Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon. //Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon.
if (Hand == EQEmu::legacy::SlotSecondary) { if (Hand == EQEmu::legacy::SlotSecondary) {
if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){ if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::Item_Struct*) nullptr); ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
hate += ucDamageBonus; hate += ucDamageBonus;
@ -4278,8 +4278,8 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
//Check if item focus effect exists for the client. //Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[bottype]) { if (itembonuses.FocusEffects[bottype]) {
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
const EQEmu::Item_Struct* UsedItem = 0; const EQEmu::ItemBase* UsedItem = 0;
const ItemInst* TempInst = 0; const ItemInst* TempInst = 0;
uint16 UsedFocusID = 0; uint16 UsedFocusID = 0;
int32 Total = 0; int32 Total = 0;
@ -4315,7 +4315,7 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
ItemInst *aug = nullptr; ItemInst *aug = nullptr;
aug = ins->GetAugment(y); aug = ins->GetAugment(y);
if(aug) { if(aug) {
const EQEmu::Item_Struct* TempItemAug = aug->GetItem(); const EQEmu::ItemBase* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) { if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) {
if(rand_effectiveness) { if(rand_effectiveness) {
focus_max = CalcBotFocusEffect(bottype, TempItemAug->Focus.Effect, spell_id, true); focus_max = CalcBotFocusEffect(bottype, TempItemAug->Focus.Effect, spell_id, true);
@ -4863,7 +4863,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
if (skill == EQEmu::skills::SkillBash) { if (skill == EQEmu::skills::SkillBash) {
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary); const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::Item_Struct* botweapon = 0; const EQEmu::ItemBase* botweapon = 0;
if(inst) if(inst)
botweapon = inst->GetItem(); botweapon = inst->GetItem();
@ -4928,7 +4928,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
bool bIsBehind = false; bool bIsBehind = false;
bool bCanFrontalBS = false; bool bCanFrontalBS = false;
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotPrimary); const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotPrimary);
const EQEmu::Item_Struct* botpiercer = nullptr; const EQEmu::ItemBase* botpiercer = nullptr;
if(inst) if(inst)
botpiercer = inst->GetItem(); botpiercer = inst->GetItem();
@ -5365,7 +5365,7 @@ bool Bot::IsBotAttackAllowed(Mob* attacker, Mob* target, bool& hasRuleDefined) {
void Bot::EquipBot(std::string* errorMessage) { void Bot::EquipBot(std::string* errorMessage) {
GetBotItems(m_inv, errorMessage); GetBotItems(m_inv, errorMessage);
const ItemInst* inst = 0; const ItemInst* inst = 0;
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) { for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
inst = GetBotItem(i); inst = GetBotItem(i);
if(inst) { if(inst) {
@ -5492,7 +5492,7 @@ void Bot::SetAttackTimer() {
float haste_mod = (GetHaste() * 0.01f); float haste_mod = (GetHaste() * 0.01f);
attack_timer.SetAtTrigger(4000, true); attack_timer.SetAtTrigger(4000, true);
Timer* TimerToUse = nullptr; Timer* TimerToUse = nullptr;
const EQEmu::Item_Struct* PrimaryWeapon = nullptr; const EQEmu::ItemBase* PrimaryWeapon = nullptr;
for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) { for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
if (i == EQEmu::legacy::SlotPrimary) if (i == EQEmu::legacy::SlotPrimary)
TimerToUse = &attack_timer; TimerToUse = &attack_timer;
@ -5503,7 +5503,7 @@ void Bot::SetAttackTimer() {
else else
continue; continue;
const EQEmu::Item_Struct* ItemToUse = nullptr; const EQEmu::ItemBase* ItemToUse = nullptr;
ItemInst* ci = GetBotItem(i); ItemInst* ci = GetBotItem(i);
if (ci) if (ci)
ItemToUse = ci->GetItem(); ItemToUse = ci->GetItem();
@ -7178,7 +7178,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
insr->TargetID = inspectedBot->GetNPCTypeID(); insr->TargetID = inspectedBot->GetNPCTypeID();
insr->playerid = inspectedBot->GetID(); insr->playerid = inspectedBot->GetID();
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
const ItemInst* inst = 0; const ItemInst* inst = 0;
// Modded to display power source items (will only show up on SoF+ client inspect windows though.) // Modded to display power source items (will only show up on SoF+ client inspect windows though.)
@ -7230,7 +7230,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
void Bot::CalcItemBonuses(StatBonuses* newbon) void Bot::CalcItemBonuses(StatBonuses* newbon)
{ {
const EQEmu::Item_Struct* itemtmp = 0; const EQEmu::ItemBase* itemtmp = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) { for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
const ItemInst* item = GetBotItem((i == 22 ? 9999 : i)); const ItemInst* item = GetBotItem((i == 22 ? 9999 : i));
@ -7261,7 +7261,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
return; return;
} }
const EQEmu::Item_Struct *item = inst->GetItem(); const EQEmu::ItemBase *item = inst->GetItem();
if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass())) if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass()))
{ {
@ -7628,7 +7628,7 @@ void Bot::CalcBotStats(bool showtext) {
} }
} }
bool Bot::CheckLoreConflict(const EQEmu::Item_Struct* item) { bool Bot::CheckLoreConflict(const EQEmu::ItemBase* item) {
if (!item || !(item->LoreFlag)) if (!item || !(item->LoreFlag))
return false; return false;
@ -8051,7 +8051,7 @@ int Bot::GetRawACNoShield(int &shield_ac) {
} }
uint32 Bot::CalcCurrentWeight() { uint32 Bot::CalcCurrentWeight() {
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
ItemInst* inst; ItemInst* inst;
uint32 Total = 0; uint32 Total = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) { for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {

2
zone/bot.h
View File

@ -385,7 +385,7 @@ public:
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 ItemInst* inst, const ItemInst* 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 ItemInst* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
void EquipBot(std::string* errorMessage); void EquipBot(std::string* errorMessage);
bool CheckLoreConflict(const EQEmu::Item_Struct* item); bool CheckLoreConflict(const EQEmu::ItemBase* 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]); } 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 // Static Class Methods

6
zone/bot_command.cpp
View File

@ -7063,7 +7063,7 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
} }
const ItemInst* inst = nullptr; const ItemInst* inst = nullptr;
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
bool is2Hweapon = false; bool is2Hweapon = false;
std::string item_link; std::string item_link;
@ -7132,7 +7132,7 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
return; return;
} }
const EQEmu::Item_Struct* itm = nullptr; const EQEmu::ItemBase* itm = nullptr;
const ItemInst* itminst = my_bot->GetBotItem(slotId); const ItemInst* itminst = my_bot->GetBotItem(slotId);
if (itminst) if (itminst)
itm = itminst->GetItem(); itm = itminst->GetItem();
@ -7235,7 +7235,7 @@ void bot_subcommand_inventory_window(Client *c, const Seperator *sep)
//linker.SetLinkType(linker.linkItemInst); //linker.SetLinkType(linker.linkItemInst);
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) { for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
const ItemInst* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i); const ItemInst* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i);
if (inst) if (inst)
item = inst->GetItem(); item = inst->GetItem();

18
zone/client.cpp
View File

@ -2539,7 +2539,7 @@ void Client::SetFeigned(bool in_feigned) {
feigned=in_feigned; feigned=in_feigned;
} }
void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::Item_Struct* item, bool buying) void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying)
{ {
if(!player || !merchant || !item) if(!player || !merchant || !item)
return; return;
@ -2726,7 +2726,7 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
} }
void Client::SetMaterial(int16 in_slot, uint32 item_id) { void Client::SetMaterial(int16 in_slot, uint32 item_id) {
const EQEmu::Item_Struct* item = database.GetItem(item_id); const EQEmu::ItemBase* item = database.GetItem(item_id);
if (item && item->IsClassCommon()) if (item && item->IsClassCommon())
{ {
uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot); uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot);
@ -3769,7 +3769,7 @@ void Client::SendOPTranslocateConfirm(Mob *Caster, uint16 SpellID) {
return; return;
} }
void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::Item_Struct* item){ void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item){
auto outapp = new EQApplicationPacket(OP_PickPocket, sizeof(sPickPocket_Struct)); auto outapp = new EQApplicationPacket(OP_PickPocket, sizeof(sPickPocket_Struct));
sPickPocket_Struct *pick_out = (sPickPocket_Struct *)outapp->pBuffer; sPickPocket_Struct *pick_out = (sPickPocket_Struct *)outapp->pBuffer;
pick_out->coin = amt; pick_out->coin = amt;
@ -3943,7 +3943,7 @@ bool Client::KeyRingCheck(uint32 item_id)
void Client::KeyRingList() void Client::KeyRingList()
{ {
Message(4,"Keys on Keyring:"); Message(4,"Keys on Keyring:");
const EQEmu::Item_Struct *item = 0; const EQEmu::ItemBase *item = 0;
for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) { for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) {
if ((item = database.GetItem(*iter))!=nullptr) { if ((item = database.GetItem(*iter))!=nullptr) {
Message(4,item->Name); Message(4,item->Name);
@ -5686,7 +5686,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
insr->TargetID = requester->GetID(); insr->TargetID = requester->GetID();
insr->playerid = requestee->GetID(); insr->playerid = requestee->GetID();
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
const ItemInst* inst = nullptr; const ItemInst* inst = nullptr;
int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
for(int16 L = 0; L <= 20; L++) { for(int16 L = 0; L <= 20; L++) {
@ -5698,7 +5698,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
strcpy(insr->itemnames[L], item->Name); strcpy(insr->itemnames[L], item->Name);
if (inst && inst->GetOrnamentationAug(ornamentationAugtype)) if (inst && inst->GetOrnamentationAug(ornamentationAugtype))
{ {
const EQEmu::Item_Struct *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem(); const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
insr->itemicons[L] = aug_item->Icon; insr->itemicons[L] = aug_item->Icon;
} }
else if (inst && inst->GetOrnamentationIcon()) else if (inst && inst->GetOrnamentationIcon())
@ -6879,7 +6879,7 @@ void Client::SendAltCurrencies() {
uint32 i = 0; uint32 i = 0;
auto iter = zone->AlternateCurrencies.begin(); auto iter = zone->AlternateCurrencies.begin();
while(iter != zone->AlternateCurrencies.end()) { while(iter != zone->AlternateCurrencies.end()) {
const EQEmu::Item_Struct* item = database.GetItem((*iter).item_id); const EQEmu::ItemBase* item = database.GetItem((*iter).item_id);
altc->entries[i].currency_number = (*iter).id; altc->entries[i].currency_number = (*iter).id;
altc->entries[i].unknown00 = 1; altc->entries[i].unknown00 = 1;
altc->entries[i].currency_number2 = (*iter).id; altc->entries[i].currency_number2 = (*iter).id;
@ -7534,7 +7534,7 @@ void Client::DuplicateLoreMessage(uint32 ItemID)
return; return;
} }
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) if(!item)
return; return;
@ -8251,7 +8251,7 @@ void Client::SetConsumption(int32 in_hunger, int32 in_thirst)
safe_delete(outapp); safe_delete(outapp);
} }
void Client::Consume(const EQEmu::Item_Struct *item, uint8 type, int16 slot, bool auto_consume) void Client::Consume(const EQEmu::ItemBase *item, uint8 type, int16 slot, bool auto_consume)
{ {
if(!item) { return; } if(!item) { return; }

24
zone/client.h
View File

@ -30,15 +30,14 @@ class ServerPacket;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
} }
#include "../common/timer.h" #include "../common/timer.h"
#include "../common/ptimer.h" #include "../common/ptimer.h"
#include "../common/emu_opcodes.h" #include "../common/emu_opcodes.h"
#include "../common/eq_packet_structs.h" #include "../common/eq_packet_structs.h"
//#include "../common/eq_constants.h" #include "../common/emu_constants.h"
#include "../common/emu_constants.h" // inv2 watch
#include "../common/eq_stream_intf.h" #include "../common/eq_stream_intf.h"
#include "../common/eq_packet.h" #include "../common/eq_packet.h"
#include "../common/linked_list.h" #include "../common/linked_list.h"
@ -47,8 +46,7 @@ namespace EQEmu
#include "../common/seperator.h" #include "../common/seperator.h"
#include "../common/item.h" #include "../common/item.h"
#include "../common/guilds.h" #include "../common/guilds.h"
#include "../common/item_struct.h" #include "../common/item_base.h"
//#include "../common/clientversions.h"
#include "common.h" #include "common.h"
#include "merc.h" #include "merc.h"
@ -294,7 +292,7 @@ public:
void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho); void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
virtual bool Process(); virtual bool Process();
void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::Item_Struct* item, bool buying); void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying);
void SendPacketQueue(bool Block = true); void SendPacketQueue(bool Block = true);
void QueuePacket(const EQApplicationPacket* app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL, eqFilterType filter=FilterNone); 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); void FastQueuePacket(EQApplicationPacket** app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL);
@ -402,7 +400,7 @@ public:
inline uint8 GetLanguageSkill(uint16 n) const { return m_pp.languages[n]; } inline uint8 GetLanguageSkill(uint16 n) const { return m_pp.languages[n]; }
void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::Item_Struct* item = nullptr); void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item = nullptr);
inline const char* GetLastName() const { return lastname; } inline const char* GetLastName() const { return lastname; }
@ -598,7 +596,7 @@ public:
void AssignToInstance(uint16 instance_id); void AssignToInstance(uint16 instance_id);
void RemoveFromInstance(uint16 instance_id); void RemoveFromInstance(uint16 instance_id);
void WhoAll(); void WhoAll();
bool CheckLoreConflict(const EQEmu::Item_Struct* item); bool CheckLoreConflict(const EQEmu::ItemBase* item);
void ChangeLastName(const char* in_lastname); void ChangeLastName(const char* in_lastname);
void GetGroupAAs(GroupLeadershipAA_Struct *into) const; void GetGroupAAs(GroupLeadershipAA_Struct *into) const;
void GetRaidAAs(RaidLeadershipAA_Struct *into) const; void GetRaidAAs(RaidLeadershipAA_Struct *into) const;
@ -823,7 +821,7 @@ public:
void IncStats(uint8 type,int16 increase_val); void IncStats(uint8 type,int16 increase_val);
void DropItem(int16 slot_id); void DropItem(int16 slot_id);
int GetItemLinkHash(const ItemInst* inst); // move to Item_Struct..or make use of the pre-calculated database field int GetItemLinkHash(const ItemInst* inst); // move to ItemBase..or make use of the pre-calculated database field
void SendItemLink(const ItemInst* inst, bool sendtoall=false); void SendItemLink(const ItemInst* inst, bool sendtoall=false);
void SendLootItemInPacket(const ItemInst* inst, int16 slot_id); void SendLootItemInPacket(const ItemInst* inst, int16 slot_id);
@ -1178,7 +1176,7 @@ public:
void SetAccountFlag(std::string flag, std::string val); void SetAccountFlag(std::string flag, std::string val);
std::string GetAccountFlag(std::string flag); std::string GetAccountFlag(std::string flag);
float GetDamageMultiplier(EQEmu::skills::SkillType how_long_has_this_been_missing); float GetDamageMultiplier(EQEmu::skills::SkillType how_long_has_this_been_missing);
void Consume(const EQEmu::Item_Struct *item, uint8 type, int16 slot, bool auto_consume); void Consume(const EQEmu::ItemBase *item, uint8 type, int16 slot, bool auto_consume);
void PlayMP3(const char* fname); void PlayMP3(const char* fname);
void ExpeditionSay(const char *str, int ExpID); 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 ItemInst* weapon, Mob* other);
@ -1200,9 +1198,9 @@ public:
int32 mod_client_xp(int32 in_exp, NPC *npc); int32 mod_client_xp(int32 in_exp, NPC *npc);
uint32 mod_client_xp_for_level(uint32 xp, uint16 check_level); uint32 mod_client_xp_for_level(uint32 xp, uint16 check_level);
int mod_client_haste_cap(int cap); int mod_client_haste_cap(int cap);
int mod_consume(EQEmu::Item_Struct *item, EQEmu::item::ItemType type, int change); int mod_consume(EQEmu::ItemBase *item, EQEmu::item::ItemType type, int change);
int mod_food_value(const EQEmu::Item_Struct *item, int change); int mod_food_value(const EQEmu::ItemBase *item, int change);
int mod_drink_value(const EQEmu::Item_Struct *item, int change); int mod_drink_value(const EQEmu::ItemBase *item, int change);
void SetEngagedRaidTarget(bool value) { EngagedRaidTarget = value; } void SetEngagedRaidTarget(bool value) { EngagedRaidTarget = value; }
bool GetEngagedRaidTarget() const { return EngagedRaidTarget; } bool GetEngagedRaidTarget() const { return EngagedRaidTarget; }

2
zone/client_mods.cpp
View File

@ -1302,7 +1302,7 @@ int32 Client::CalcManaRegenCap()
uint32 Client::CalcCurrentWeight() uint32 Client::CalcCurrentWeight()
{ {
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
ItemInst* ins; ItemInst* ins;
uint32 Total = 0; uint32 Total = 0;
int x; int x;

56
zone/client_packet.cpp
View File

@ -1881,7 +1881,7 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
merchantid = tmp->CastToNPC()->MerchantType; merchantid = tmp->CastToNPC()->MerchantType;
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
bool found = false; bool found = false;
std::list<MerchantList> merlist = zone->merchanttable[merchantid]; std::list<MerchantList> merlist = zone->merchanttable[merchantid];
std::list<MerchantList>::const_iterator itr; std::list<MerchantList>::const_iterator itr;
@ -2057,7 +2057,7 @@ void Client::Handle_OP_AdventureMerchantRequest(const EQApplicationPacket *app)
merchantid = tmp->CastToNPC()->MerchantType; merchantid = tmp->CastToNPC()->MerchantType;
tmp->CastToNPC()->FaceTarget(this->CastToMob()); tmp->CastToNPC()->FaceTarget(this->CastToMob());
const EQEmu::Item_Struct *item = 0; const EQEmu::ItemBase *item = 0;
std::list<MerchantList> merlist = zone->merchanttable[merchantid]; std::list<MerchantList> merlist = zone->merchanttable[merchantid];
std::list<MerchantList>::const_iterator itr; std::list<MerchantList>::const_iterator itr;
for (itr = merlist.begin(); itr != merlist.end() && count<255; ++itr){ for (itr = merlist.begin(); itr != merlist.end() && count<255; ++itr){
@ -2156,7 +2156,7 @@ void Client::Handle_OP_AdventureMerchantSell(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* item = database.GetItem(itemid); const EQEmu::ItemBase* item = database.GetItem(itemid);
ItemInst* inst = GetInv().GetItem(ams_in->slot); ItemInst* inst = GetInv().GetItem(ams_in->slot);
if (!item || !inst){ if (!item || !inst){
Message(13, "You seemed to have misplaced that item..."); Message(13, "You seemed to have misplaced that item...");
@ -2432,7 +2432,7 @@ void Client::Handle_OP_AltCurrencyMerchantRequest(const EQApplicationPacket *app
ss << alt_cur_id << "|1|" << alt_cur_id; ss << alt_cur_id << "|1|" << alt_cur_id;
uint32 count = 0; uint32 count = 0;
uint32 merchant_id = tar->MerchantType; uint32 merchant_id = tar->MerchantType;
const EQEmu::Item_Struct *item = nullptr; const EQEmu::ItemBase *item = nullptr;
std::list<MerchantList> merlist = zone->merchanttable[merchant_id]; std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
std::list<MerchantList>::const_iterator itr; std::list<MerchantList>::const_iterator itr;
@ -2492,7 +2492,7 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
uint32 cost = 0; uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id); uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType; uint32 merchant_id = tar->MerchantType;
@ -2641,7 +2641,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
uint32 cost = 0; uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id); uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType; uint32 merchant_id = tar->MerchantType;
@ -2734,7 +2734,7 @@ void Client::Handle_OP_AltCurrencySellSelection(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
uint32 cost = 0; uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id); uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType; uint32 merchant_id = tar->MerchantType;
@ -2909,7 +2909,7 @@ void Client::Handle_OP_AugmentInfo(const EQApplicationPacket *app)
} }
AugmentInfo_Struct* AugInfo = (AugmentInfo_Struct*)app->pBuffer; AugmentInfo_Struct* AugInfo = (AugmentInfo_Struct*)app->pBuffer;
const EQEmu::Item_Struct * item = database.GetItem(AugInfo->itemid); const EQEmu::ItemBase * item = database.GetItem(AugInfo->itemid);
if (item) { if (item) {
strn0cpy(AugInfo->augment_info, item->Name, 64); strn0cpy(AugInfo->augment_info, item->Name, 64);
@ -3491,7 +3491,7 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
{ {
BarterItemSearchLinkRequest_Struct* bislr = (BarterItemSearchLinkRequest_Struct*)app->pBuffer; BarterItemSearchLinkRequest_Struct* bislr = (BarterItemSearchLinkRequest_Struct*)app->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(bislr->ItemID); const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
if (!item) if (!item)
Message(13, "Error: This item does not exist!"); Message(13, "Error: This item does not exist!");
@ -3524,7 +3524,7 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
{ {
BuyerItemSearchLinkRequest_Struct* bislr = (BuyerItemSearchLinkRequest_Struct*)app->pBuffer; BuyerItemSearchLinkRequest_Struct* bislr = (BuyerItemSearchLinkRequest_Struct*)app->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(bislr->ItemID); const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
if (!item) if (!item)
Message(13, "Error: This item does not exist!"); Message(13, "Error: This item does not exist!");
@ -3563,7 +3563,7 @@ void Client::Handle_OP_BazaarInspect(const EQApplicationPacket *app)
BazaarInspect_Struct* bis = (BazaarInspect_Struct*)app->pBuffer; BazaarInspect_Struct* bis = (BazaarInspect_Struct*)app->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(bis->ItemID); const EQEmu::ItemBase* item = database.GetItem(bis->ItemID);
if (!item) { if (!item) {
Message(13, "Error: This item does not exist!"); Message(13, "Error: This item does not exist!");
@ -4015,7 +4015,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
//bool cancast = true; //bool cancast = true;
if (inst && inst->IsClassCommon()) if (inst && inst->IsClassCommon())
{ {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item->Click.Effect != (uint32)castspell->spell_id) 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()); database.SetMQDetectionFlag(account_name, name, "OP_CastSpell with item, tried to cast a different spell.", zone->GetShortName());
@ -4864,7 +4864,7 @@ void Client::Handle_OP_Consume(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* eat_item = myitem->GetItem(); const EQEmu::ItemBase* eat_item = myitem->GetItem();
if (pcs->type == 0x01) { if (pcs->type == 0x01) {
Consume(eat_item, EQEmu::item::ItemTypeFood, pcs->slot, (pcs->auto_consumed == 0xffffffff)); Consume(eat_item, EQEmu::item::ItemTypeFood, pcs->slot, (pcs->auto_consumed == 0xffffffff));
} }
@ -6922,7 +6922,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* CursorItem = CursorItemInst->GetItem(); const EQEmu::ItemBase* CursorItem = CursorItemInst->GetItem();
if (!CursorItem->NoDrop || CursorItemInst->IsAttuned()) if (!CursorItem->NoDrop || CursorItemInst->IsAttuned())
{ {
@ -7995,7 +7995,7 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
EQApplicationPacket* outapp = app->Copy(); EQApplicationPacket* outapp = app->Copy();
InspectResponse_Struct* insr = (InspectResponse_Struct*)outapp->pBuffer; InspectResponse_Struct* insr = (InspectResponse_Struct*)outapp->pBuffer;
Mob* tmp = entity_list.GetMob(insr->TargetID); Mob* tmp = entity_list.GetMob(insr->TargetID);
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); 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::legacy::SlotWaist; L++) {
@ -8005,7 +8005,7 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
if (item) { if (item) {
strcpy(insr->itemnames[L], item->Name); strcpy(insr->itemnames[L], item->Name);
if (inst && inst->GetOrnamentationAug(ornamentationAugtype)) { if (inst && inst->GetOrnamentationAug(ornamentationAugtype)) {
const EQEmu::Item_Struct *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem(); const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
insr->itemicons[L] = aug_item->Icon; insr->itemicons[L] = aug_item->Icon;
} }
else if (inst->GetOrnamentationIcon()) { else if (inst->GetOrnamentationIcon()) {
@ -8105,7 +8105,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 // 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 // from the item DB
const EQEmu::Item_Struct *item = database.GetItem(ivrs->item_id); const EQEmu::ItemBase *item = database.GetItem(ivrs->item_id);
if (!item) { if (!item) {
if (ivrs->item_id != SAYLINK_ITEM_ID) { if (ivrs->item_id != SAYLINK_ITEM_ID) {
Message(13, "Error: The item for the link you have clicked on does not exist!"); Message(13, "Error: The item for the link you have clicked on does not exist!");
@ -8196,7 +8196,7 @@ void Client::Handle_OP_ItemName(const EQApplicationPacket *app)
return; return;
} }
ItemNamePacket_Struct *p = (ItemNamePacket_Struct*)app->pBuffer; ItemNamePacket_Struct *p = (ItemNamePacket_Struct*)app->pBuffer;
const EQEmu::Item_Struct *item = 0; const EQEmu::ItemBase *item = 0;
if ((item = database.GetItem(p->item_id)) != nullptr) { if ((item = database.GetItem(p->item_id)) != nullptr) {
auto outapp = new EQApplicationPacket(OP_ItemName, sizeof(ItemNamePacket_Struct)); auto outapp = new EQApplicationPacket(OP_ItemName, sizeof(ItemNamePacket_Struct));
p = (ItemNamePacket_Struct*)outapp->pBuffer; p = (ItemNamePacket_Struct*)outapp->pBuffer;
@ -8212,7 +8212,7 @@ void Client::Handle_OP_ItemPreview(const EQApplicationPacket *app)
VERIFY_PACKET_LENGTH(OP_ItemPreview, app, ItemPreview_Struct); VERIFY_PACKET_LENGTH(OP_ItemPreview, app, ItemPreview_Struct);
ItemPreview_Struct *ips = (ItemPreview_Struct *)app->pBuffer; ItemPreview_Struct *ips = (ItemPreview_Struct *)app->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(ips->itemid); const EQEmu::ItemBase* item = database.GetItem(ips->itemid);
if (item) { if (item) {
auto outapp = new EQApplicationPacket(OP_ItemPreview, strlen(item->Name) + strlen(item->Lore) + auto outapp = new EQApplicationPacket(OP_ItemPreview, strlen(item->Name) + strlen(item->Lore) +
@ -8429,7 +8429,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
return; return;
} }
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (!item) { if (!item) {
Message(0, "Error: item not found in inventory slot #%i", slot_id); Message(0, "Error: item not found in inventory slot #%i", slot_id);
DeleteItemInInventory(slot_id, 0, true); DeleteItemInInventory(slot_id, 0, true);
@ -8477,13 +8477,13 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
int r; int r;
bool tryaug = false; bool tryaug = false;
ItemInst* clickaug = 0; ItemInst* clickaug = 0;
EQEmu::Item_Struct* augitem = 0; EQEmu::ItemBase* augitem = 0;
for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) { for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
const ItemInst* aug_i = inst->GetAugment(r); const ItemInst* aug_i = inst->GetAugment(r);
if (!aug_i) if (!aug_i)
continue; continue;
const EQEmu::Item_Struct* aug = aug_i->GetItem(); const EQEmu::ItemBase* aug = aug_i->GetItem();
if (!aug) if (!aug)
continue; continue;
@ -8491,7 +8491,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
{ {
tryaug = true; tryaug = true;
clickaug = (ItemInst*)aug_i; clickaug = (ItemInst*)aug_i;
augitem = (EQEmu::Item_Struct*)aug; augitem = (EQEmu::ItemBase*)aug;
spell_id = aug->Click.Effect; spell_id = aug->Click.Effect;
break; break;
} }
@ -10554,7 +10554,7 @@ void Client::Handle_OP_PotionBelt(const EQApplicationPacket *app)
} }
if (mptbs->Action == 0) { if (mptbs->Action == 0) {
const EQEmu::Item_Struct *BaseItem = database.GetItem(mptbs->ItemID); const EQEmu::ItemBase *BaseItem = database.GetItem(mptbs->ItemID);
if (BaseItem) { if (BaseItem) {
m_pp.potionbelt.Items[mptbs->SlotNumber].ID = BaseItem->ID; m_pp.potionbelt.Items[mptbs->SlotNumber].ID = BaseItem->ID;
m_pp.potionbelt.Items[mptbs->SlotNumber].Icon = BaseItem->Icon; m_pp.potionbelt.Items[mptbs->SlotNumber].Icon = BaseItem->Icon;
@ -12045,7 +12045,7 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
return; return;
if (inst) if (inst)
{ {
const EQEmu::Item_Struct* shield = inst->GetItem(); const EQEmu::ItemBase* shield = inst->GetItem();
if (shield && shield->ItemType == EQEmu::item::ItemTypeShield) if (shield && shield->ItemType == EQEmu::item::ItemTypeShield)
{ {
for (int x = 0; x < 2; x++) for (int x = 0; x < 2; x++)
@ -12153,7 +12153,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
break; break;
} }
} }
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
uint32 prevcharges = 0; uint32 prevcharges = 0;
if (item_id == 0) { //check to see if its on the temporary table if (item_id == 0) { //check to see if its on the temporary table
std::list<TempMerchantList> tmp_merlist = zone->tmpmerchanttable[tmp->GetNPCTypeID()]; std::list<TempMerchantList> tmp_merlist = zone->tmpmerchanttable[tmp->GetNPCTypeID()];
@ -12401,7 +12401,7 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
uint32 itemid = GetItemIDAt(mp->itemslot); uint32 itemid = GetItemIDAt(mp->itemslot);
if (itemid == 0) if (itemid == 0)
return; return;
const EQEmu::Item_Struct* item = database.GetItem(itemid); const EQEmu::ItemBase* item = database.GetItem(itemid);
ItemInst* inst = GetInv().GetItem(mp->itemslot); ItemInst* inst = GetInv().GetItem(mp->itemslot);
if (!item || !inst){ if (!item || !inst){
Message(13, "You seemed to have misplaced that item.."); Message(13, "You seemed to have misplaced that item..");
@ -13507,7 +13507,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
TradeItemsValid = false; TradeItemsValid = false;
break; break;
} }
const EQEmu::Item_Struct *Item = database.GetItem(gis->Items[i]); const EQEmu::ItemBase *Item = database.GetItem(gis->Items[i]);
if (!Item) { if (!Item) {
Message(13, "Unexpected error. Unable to start trader mode"); Message(13, "Unexpected error. Unable to start trader mode");

6
zone/client_process.cpp
View File

@ -825,12 +825,12 @@ void Client::BulkSendInventoryItems()
} }
void Client::BulkSendMerchantInventory(int merchant_id, int npcid) { void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
const EQEmu::Item_Struct* handyitem = nullptr; const EQEmu::ItemBase* handyitem = nullptr;
uint32 numItemSlots = 80; //The max number of items passed in the transaction. uint32 numItemSlots = 80; //The max number of items passed in the transaction.
if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) { // RoF+ can send 200 items if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) { // RoF+ can send 200 items
numItemSlots = 200; numItemSlots = 200;
} }
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
std::list<MerchantList> merlist = zone->merchanttable[merchant_id]; std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
std::list<MerchantList>::const_iterator itr; std::list<MerchantList>::const_iterator itr;
Mob* merch = entity_list.GetMobByNpcTypeID(npcid); Mob* merch = entity_list.GetMobByNpcTypeID(npcid);
@ -1088,7 +1088,7 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
if (inst && inst->IsClassCommon()) if (inst && inst->IsClassCommon())
{ {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (RuleB(Character, RestrictSpellScribing) && !item->IsEquipable(GetRace(), GetClass())) { if (RuleB(Character, RestrictSpellScribing) && !item->IsEquipable(GetRace(), GetClass())) {
Message_StringID(13, CANNOT_USE_ITEM); Message_StringID(13, CANNOT_USE_ITEM);

12
zone/command.cpp
View File

@ -2546,7 +2546,7 @@ void command_peekinv(Client *c, const Seperator *sep)
Client* targetClient = c->GetTarget()->CastToClient(); Client* targetClient = c->GetTarget()->CastToClient();
const ItemInst* inst_main = nullptr; const ItemInst* inst_main = nullptr;
const ItemInst* inst_sub = nullptr; const ItemInst* inst_sub = nullptr;
const EQEmu::Item_Struct* item_data = nullptr; const EQEmu::ItemBase* item_data = nullptr;
std::string item_link; std::string item_link;
EQEmu::saylink::SayLinkEngine linker; EQEmu::saylink::SayLinkEngine linker;
linker.SetLinkType(linker.SayLinkItemInst); linker.SetLinkType(linker.SayLinkItemInst);
@ -5514,7 +5514,7 @@ void command_summonitem(Client *c, const Seperator *sep)
} }
int16 item_status = 0; int16 item_status = 0;
const EQEmu::Item_Struct* item = database.GetItem(itemid); const EQEmu::ItemBase* item = database.GetItem(itemid);
if (item) { if (item) {
item_status = static_cast<int16>(item->MinStatus); item_status = static_cast<int16>(item->MinStatus);
} }
@ -5553,7 +5553,7 @@ void command_giveitem(Client *c, const Seperator *sep)
Client *t = c->GetTarget()->CastToClient(); Client *t = c->GetTarget()->CastToClient();
uint32 itemid = atoi(sep->arg[1]); uint32 itemid = atoi(sep->arg[1]);
int16 item_status = 0; int16 item_status = 0;
const EQEmu::Item_Struct* item = database.GetItem(itemid); const EQEmu::ItemBase* item = database.GetItem(itemid);
if(item) { if(item) {
item_status = static_cast<int16>(item->MinStatus); item_status = static_cast<int16>(item->MinStatus);
} }
@ -5606,7 +5606,7 @@ void command_itemsearch(Client *c, const Seperator *sep)
{ {
const char *search_criteria=sep->argplus[1]; const char *search_criteria=sep->argplus[1];
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
std::string item_link; std::string item_link;
EQEmu::saylink::SayLinkEngine linker; EQEmu::saylink::SayLinkEngine linker;
linker.SetLinkType(linker.SayLinkItemData); linker.SetLinkType(linker.SayLinkItemData);
@ -10230,7 +10230,7 @@ void command_zopp(Client *c, const Seperator *sep)
uint32 itemid = atoi(sep->arg[3]); uint32 itemid = atoi(sep->arg[3]);
int16 charges = sep->argnum == 4 ? atoi(sep->arg[4]) : 1; // defaults to 1 charge if not specified int16 charges = sep->argnum == 4 ? atoi(sep->arg[4]) : 1; // defaults to 1 charge if not specified
const EQEmu::Item_Struct* FakeItem = database.GetItem(itemid); const EQEmu::ItemBase* FakeItem = database.GetItem(itemid);
if (!FakeItem) { if (!FakeItem) {
c->Message(13, "Error: Item [%u] is not a valid item id.", itemid); c->Message(13, "Error: Item [%u] is not a valid item id.", itemid);
@ -10238,7 +10238,7 @@ void command_zopp(Client *c, const Seperator *sep)
} }
int16 item_status = 0; int16 item_status = 0;
const EQEmu::Item_Struct* item = database.GetItem(itemid); const EQEmu::ItemBase* item = database.GetItem(itemid);
if(item) { if(item) {
item_status = static_cast<int16>(item->MinStatus); item_status = static_cast<int16>(item->MinStatus);
} }

12
zone/corpse.cpp
View File

@ -978,7 +978,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
safe_delete(outapp); safe_delete(outapp);
if(Loot_Request_Type == 5) { if(Loot_Request_Type == 5) {
int pkitem = GetPlayerKillItem(); int pkitem = GetPlayerKillItem();
const EQEmu::Item_Struct* item = database.GetItem(pkitem); const EQEmu::ItemBase* item = database.GetItem(pkitem);
ItemInst* inst = database.CreateItem(item, item->MaxCharges); ItemInst* inst = database.CreateItem(item, item->MaxCharges);
if(inst) { if(inst) {
if (item->RecastDelay) if (item->RecastDelay)
@ -993,7 +993,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
} }
int i = 0; int i = 0;
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
ItemList::iterator cur,end; ItemList::iterator cur,end;
cur = itemlist.begin(); cur = itemlist.begin();
end = itemlist.end(); end = itemlist.end();
@ -1108,7 +1108,7 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
being_looted_by = 0xFFFFFFFF; being_looted_by = 0xFFFFFFFF;
return; return;
} }
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
ItemInst *inst = 0; ItemInst *inst = 0;
ServerLootItem_Struct* item_data = nullptr, *bag_item_data[10]; ServerLootItem_Struct* item_data = nullptr, *bag_item_data[10];
@ -1303,7 +1303,7 @@ void Corpse::QueryLoot(Client* to) {
else else
x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF; x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF;
const EQEmu::Item_Struct* item = database.GetItem(sitem->item_id); const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
if (item) 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); 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);
@ -1317,7 +1317,7 @@ void Corpse::QueryLoot(Client* to) {
} }
else { else {
sitem->lootslot=y; sitem->lootslot=y;
const EQEmu::Item_Struct* item = database.GetItem(sitem->item_id); const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
if (item) if (item)
to->Message(0, "LootSlot: %i Item: %s (%d), Count: %i", sitem->lootslot, item->Name, item->ID, sitem->charges); to->Message(0, "LootSlot: %i Item: %s (%d), Count: %i", sitem->lootslot, item->Name, item->ID, sitem->charges);
@ -1412,7 +1412,7 @@ uint32 Corpse::GetEquipment(uint8 material_slot) const {
} }
uint32 Corpse::GetEquipmentColor(uint8 material_slot) const { uint32 Corpse::GetEquipmentColor(uint8 material_slot) const {
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
if (material_slot > EQEmu::legacy::MATERIAL_END) { if (material_slot > EQEmu::legacy::MATERIAL_END) {
return 0; return 0;

2
zone/effects.cpp
View File

@ -481,7 +481,7 @@ int32 Client::GetActSpellCasttime(uint16 spell_id, int32 casttime)
bool Client::TrainDiscipline(uint32 itemid) { bool Client::TrainDiscipline(uint32 itemid) {
//get the item info //get the item info
const EQEmu::Item_Struct *item = database.GetItem(itemid); const EQEmu::ItemBase *item = database.GetItem(itemid);
if(item == nullptr) { if(item == nullptr) {
Message(13, "Unable to find the tome you turned in!"); 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); Log.Out(Logs::General, Logs::Error, "Unable to find turned in tome id %lu\n", (unsigned long)itemid);

2
zone/embparser.cpp
View File

@ -882,7 +882,7 @@ void PerlembParser::GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlaye
} }
else if(isItemQuest) { else if(isItemQuest) {
// need a valid ItemInst pointer check here..unsure how to cancel this process // need a valid ItemInst pointer check here..unsure how to cancel this process
const EQEmu::Item_Struct* item = iteminst->GetItem(); const EQEmu::ItemBase* item = iteminst->GetItem();
package_name = "qst_item_"; package_name = "qst_item_";
package_name += itoa(item->ID); package_name += itoa(item->ID);
} }

2
zone/embxs.cpp
View File

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

4
zone/entity.cpp
View File

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

4
zone/forage.cpp
View File

@ -304,7 +304,7 @@ void Client::GoFish()
food_id = common_fish_ids[index]; food_id = common_fish_ids[index];
} }
const EQEmu::Item_Struct* food_item = database.GetItem(food_id); const EQEmu::ItemBase* food_item = database.GetItem(food_id);
Message_StringID(MT_Skills, FISHING_SUCCESS); Message_StringID(MT_Skills, FISHING_SUCCESS);
ItemInst* inst = database.CreateItem(food_item, 1); ItemInst* inst = database.CreateItem(food_item, 1);
@ -396,7 +396,7 @@ void Client::ForageItem(bool guarantee) {
foragedfood = common_food_ids[index]; foragedfood = common_food_ids[index];
} }
const EQEmu::Item_Struct* food_item = database.GetItem(foragedfood); const EQEmu::ItemBase* food_item = database.GetItem(foragedfood);
if(!food_item) { if(!food_item) {
Log.Out(Logs::General, Logs::Error, "nullptr returned from database.GetItem in ClientForageItem"); Log.Out(Logs::General, Logs::Error, "nullptr returned from database.GetItem in ClientForageItem");

20
zone/guild_mgr.cpp
View File

@ -694,7 +694,7 @@ void GuildBankManager::SendGuildBank(Client *c)
if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater) { if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater) {
auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240); auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240);
for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) { for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) {
const EQEmu::Item_Struct *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID); const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if (Item) { if (Item) {
outapp->WriteUInt8(1); outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.DepositArea[i].Permissions); 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 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) { for (int i = 0; i < GUILD_BANK_MAIN_AREA_SIZE; ++i) {
const EQEmu::Item_Struct *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID); const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if (Item) { if (Item) {
outapp->WriteUInt8(1); outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.MainArea[i].Permissions); 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) if(guild_bank->Items.DepositArea[i].ItemID > 0)
{ {
const EQEmu::Item_Struct *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID); const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if(!Item) if(!Item)
continue; continue;
@ -785,7 +785,7 @@ void GuildBankManager::SendGuildBank(Client *c)
{ {
if(guild_bank->Items.MainArea[i].ItemID > 0) if(guild_bank->Items.MainArea[i].ItemID > 0)
{ {
const EQEmu::Item_Struct *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID); const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if(!Item) if(!Item)
continue; continue;
@ -916,7 +916,7 @@ bool GuildBankManager::AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32
return false; return false;
} }
const EQEmu::Item_Struct *Item = database.GetItem(ItemID); const EQEmu::ItemBase *Item = database.GetItem(ItemID);
GuildBankItemUpdate_Struct gbius; GuildBankItemUpdate_Struct gbius;
@ -982,7 +982,7 @@ int GuildBankManager::Promote(uint32 guildID, int slotID)
(*iter)->Items.DepositArea[slotID].ItemID = 0; (*iter)->Items.DepositArea[slotID].ItemID = 0;
const EQEmu::Item_Struct *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID); const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
GuildBankItemUpdate_Struct gbius; GuildBankItemUpdate_Struct gbius;
@ -1038,7 +1038,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
else else
(*iter)->Items.MainArea[slotID].WhoFor[0] = '\0'; (*iter)->Items.MainArea[slotID].WhoFor[0] = '\0';
const EQEmu::Item_Struct *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID); const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
GuildBankItemUpdate_Struct gbius; GuildBankItemUpdate_Struct gbius;
@ -1169,7 +1169,7 @@ bool GuildBankManager::DeleteItem(uint32 guildID, uint16 area, uint16 slotID, ui
bool deleted = true; bool deleted = true;
const EQEmu::Item_Struct *Item = database.GetItem(BankArea[slotID].ItemID); const EQEmu::ItemBase *Item = database.GetItem(BankArea[slotID].ItemID);
if(!Item->Stackable || (quantity >= BankArea[slotID].Quantity)) { if(!Item->Stackable || (quantity >= BankArea[slotID].Quantity)) {
std::string query = StringFormat("DELETE FROM `guild_bank` WHERE `guildid` = %i " 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) if(BankArea[SlotID].ItemID == 0)
return false; return false;
const EQEmu::Item_Struct *Item = database.GetItem(BankArea[SlotID].ItemID); const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
if(!Item->Stackable) if(!Item->Stackable)
return false; return false;
@ -1328,7 +1328,7 @@ bool GuildBankManager::SplitStack(uint32 GuildID, uint16 SlotID, uint32 Quantity
if(BankArea[SlotID].Quantity <= Quantity || Quantity == 0) if(BankArea[SlotID].Quantity <= Quantity || Quantity == 0)
return false; return false;
const EQEmu::Item_Struct *Item = database.GetItem(BankArea[SlotID].ItemID); const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
if(!Item->Stackable) if(!Item->Stackable)
return false; return false;

36
zone/inventory.cpp
View File

@ -177,7 +177,7 @@ uint32 Client::NukeItem(uint32 itemnum, uint8 where_to_check) {
} }
bool Client::CheckLoreConflict(const EQEmu::Item_Struct* item) bool Client::CheckLoreConflict(const EQEmu::ItemBase* item)
{ {
if (!item) { return false; } if (!item) { return false; }
if (!item->LoreFlag) { return false; } if (!item->LoreFlag) { return false; }
@ -195,7 +195,7 @@ bool Client::SummonItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2,
// TODO: update calling methods and script apis to handle a failure return // TODO: update calling methods and script apis to handle a failure return
const EQEmu::Item_Struct* item = database.GetItem(item_id); const EQEmu::ItemBase* item = database.GetItem(item_id);
// make sure the item exists // make sure the item exists
if(item == nullptr) { if(item == nullptr) {
@ -247,7 +247,7 @@ bool Client::SummonItem(uint32 item_id, int16 charges, uint32 aug1, uint32 aug2,
bool enforceusable = RuleB(Inventory, EnforceAugmentUsability); bool enforceusable = RuleB(Inventory, EnforceAugmentUsability);
for (int iter = AUG_INDEX_BEGIN; iter < EQEmu::legacy::ITEM_COMMON_SIZE; ++iter) { for (int iter = AUG_INDEX_BEGIN; iter < EQEmu::legacy::ITEM_COMMON_SIZE; ++iter) {
const EQEmu::Item_Struct* augtest = database.GetItem(augments[iter]); const EQEmu::ItemBase* augtest = database.GetItem(augments[iter]);
if(augtest == nullptr) { if(augtest == nullptr) {
if(augments[iter]) { if(augments[iter]) {
@ -1074,7 +1074,7 @@ void Client::MoveItemCharges(ItemInst &from, int16 to_slot, uint8 type)
#if 0 #if 0
// TODO: needs clean-up to save references // TODO: needs clean-up to save references
bool MakeItemLink(char* &ret_link, const Item_Struct *item, uint32 aug0, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint8 evolving, uint8 evolvedlevel) { bool MakeItemLink(char* &ret_link, const ItemBase *item, uint32 aug0, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint8 evolving, uint8 evolvedlevel) {
//we're sending back the entire "link", minus the null characters & item name //we're sending back the entire "link", minus the null characters & item name
//that way, we can use it for regular links & Task links //that way, we can use it for regular links & Task links
//note: initiator needs to pass us ret_link //note: initiator needs to pass us ret_link
@ -1189,7 +1189,7 @@ int Client::GetItemLinkHash(const ItemInst* inst) {
if (!inst) //have to have an item to make the hash if (!inst) //have to have an item to make the hash
return 0; return 0;
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
char* hash_str = 0; char* hash_str = 0;
/*register */int hash = 0; /*register */int hash = 0;
@ -1283,7 +1283,7 @@ packet with the item number in it, but I cant seem to find it right now
if (!inst) if (!inst)
return; return;
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
const char* name2 = &item->Name[0]; const char* name2 = &item->Name[0];
auto outapp = new EQApplicationPacket(OP_ItemLinkText, strlen(name2) + 68); auto outapp = new EQApplicationPacket(OP_ItemLinkText, strlen(name2) + 68);
char buffer2[135] = {0}; char buffer2[135] = {0};
@ -1555,7 +1555,7 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
else { else {
auto ndh_item = ndh_inst->GetItem(); auto ndh_item = ndh_inst->GetItem();
if (ndh_item == nullptr) { if (ndh_item == nullptr) {
ndh_item_data.append("[nullptr on Item_Struct*]"); ndh_item_data.append("[nullptr on ItemBase*]");
} }
else { else {
ndh_item_data.append(StringFormat("name=%s", ndh_item->Name)); ndh_item_data.append(StringFormat("name=%s", ndh_item->Name));
@ -1597,8 +1597,8 @@ bool Client::SwapItem(MoveItem_Struct* move_in) {
m_inv.DeleteItem(src_slot_id); m_inv.DeleteItem(src_slot_id);
} }
else { else {
const EQEmu::Item_Struct* world_item = world_inst->GetItem(); const EQEmu::ItemBase* world_item = world_inst->GetItem();
const EQEmu::Item_Struct* src_item = src_inst->GetItem(); const EQEmu::ItemBase* src_item = src_inst->GetItem();
if (world_item && src_item) { if (world_item && src_item) {
// Case 2: Same item on cursor, stacks, transfer of charges needed // Case 2: Same item on cursor, stacks, transfer of charges needed
if ((world_item->ID == src_item->ID) && src_inst->IsStackable()) { if ((world_item->ID == src_item->ID) && src_inst->IsStackable()) {
@ -1838,7 +1838,7 @@ void Client::SwapItemResync(MoveItem_Struct* move_slots) {
int16 resync_slot = (Inventory::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : Inventory::CalcSlotId(move_slots->from_slot); int16 resync_slot = (Inventory::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : Inventory::CalcSlotId(move_slots->from_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) { if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
// This prevents the client from crashing when closing any 'phantom' bags // This prevents the client from crashing when closing any 'phantom' bags
const EQEmu::Item_Struct* token_struct = database.GetItem(22292); // 'Copper Coin' const EQEmu::ItemBase* token_struct = database.GetItem(22292); // 'Copper Coin'
ItemInst* token_inst = database.CreateItem(token_struct, 1); ItemInst* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade); SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
@ -1863,7 +1863,7 @@ void Client::SwapItemResync(MoveItem_Struct* move_slots) {
int16 resync_slot = (Inventory::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : Inventory::CalcSlotId(move_slots->from_slot); int16 resync_slot = (Inventory::CalcSlotId(move_slots->from_slot) == INVALID_INDEX) ? move_slots->from_slot : Inventory::CalcSlotId(move_slots->from_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) { if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
if(m_inv[resync_slot]) { if(m_inv[resync_slot]) {
const EQEmu::Item_Struct* token_struct = database.GetItem(22292); // 'Copper Coin' const EQEmu::ItemBase* token_struct = database.GetItem(22292); // 'Copper Coin'
ItemInst* token_inst = database.CreateItem(token_struct, 1); ItemInst* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade); SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
@ -1880,7 +1880,7 @@ void Client::SwapItemResync(MoveItem_Struct* move_slots) {
if ((move_slots->to_slot >= EQEmu::legacy::EQUIPMENT_BEGIN && move_slots->to_slot <= EQEmu::legacy::CURSOR_BAG_END) || move_slots->to_slot == EQEmu::legacy::SlotPowerSource) { if ((move_slots->to_slot >= EQEmu::legacy::EQUIPMENT_BEGIN && move_slots->to_slot <= EQEmu::legacy::CURSOR_BAG_END) || move_slots->to_slot == EQEmu::legacy::SlotPowerSource) {
int16 resync_slot = (Inventory::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : Inventory::CalcSlotId(move_slots->to_slot); int16 resync_slot = (Inventory::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : Inventory::CalcSlotId(move_slots->to_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) { if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
const EQEmu::Item_Struct* token_struct = database.GetItem(22292); // 'Copper Coin' const EQEmu::ItemBase* token_struct = database.GetItem(22292); // 'Copper Coin'
ItemInst* token_inst = database.CreateItem(token_struct, 1); ItemInst* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade); SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
@ -1905,7 +1905,7 @@ void Client::SwapItemResync(MoveItem_Struct* move_slots) {
int16 resync_slot = (Inventory::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : Inventory::CalcSlotId(move_slots->to_slot); int16 resync_slot = (Inventory::CalcSlotId(move_slots->to_slot) == INVALID_INDEX) ? move_slots->to_slot : Inventory::CalcSlotId(move_slots->to_slot);
if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) { if (IsValidSlot(resync_slot) && resync_slot != INVALID_INDEX) {
if(m_inv[resync_slot]) { if(m_inv[resync_slot]) {
const EQEmu::Item_Struct* token_struct = database.GetItem(22292); // 'Copper Coin' const EQEmu::ItemBase* token_struct = database.GetItem(22292); // 'Copper Coin'
ItemInst* token_inst = database.CreateItem(token_struct, 1); ItemInst* token_inst = database.CreateItem(token_struct, 1);
SendItemPacket(resync_slot, token_inst, ItemPacketTrade); SendItemPacket(resync_slot, token_inst, ItemPacketTrade);
@ -2057,7 +2057,7 @@ void Client::DyeArmor(DyeStruct* dye){
#if 0 #if 0
bool Client::DecreaseByItemType(uint32 type, uint8 amt) { bool Client::DecreaseByItemType(uint32 type, uint8 amt) {
const Item_Struct* TempItem = 0; const ItemBase* TempItem = 0;
ItemInst* ins; ItemInst* ins;
int x; int x;
for(x=EQEmu::legacy::POSSESSIONS_BEGIN; x <= EQEmu::legacy::POSSESSIONS_END; x++) for(x=EQEmu::legacy::POSSESSIONS_BEGIN; x <= EQEmu::legacy::POSSESSIONS_END; x++)
@ -2109,7 +2109,7 @@ bool Client::DecreaseByItemType(uint32 type, uint8 amt) {
#endif #endif
bool Client::DecreaseByID(uint32 type, uint8 amt) { bool Client::DecreaseByID(uint32 type, uint8 amt) {
const EQEmu::Item_Struct* TempItem = nullptr; const EQEmu::ItemBase* TempItem = nullptr;
ItemInst* ins = nullptr; ItemInst* ins = nullptr;
int x; int x;
int num = 0; int num = 0;
@ -2617,7 +2617,7 @@ uint32 Client::GetEquipment(uint8 material_slot) const
#if 0 #if 0
int32 Client::GetEquipmentMaterial(uint8 material_slot) int32 Client::GetEquipmentMaterial(uint8 material_slot)
{ {
const Item_Struct *item; const ItemBase *item;
item = database.GetItem(GetEquipment(material_slot)); item = database.GetItem(GetEquipment(material_slot));
if(item != 0) if(item != 0)
@ -2634,7 +2634,7 @@ uint32 Client::GetEquipmentColor(uint8 material_slot) const
if (material_slot > EQEmu::legacy::MATERIAL_END) if (material_slot > EQEmu::legacy::MATERIAL_END)
return 0; return 0;
const EQEmu::Item_Struct *item = database.GetItem(GetEquipment(material_slot)); const EQEmu::ItemBase *item = database.GetItem(GetEquipment(material_slot));
if(item != nullptr) if(item != nullptr)
return ((m_pp.item_tint[material_slot].RGB.UseTint) ? m_pp.item_tint[material_slot].Color : item->Color); return ((m_pp.item_tint[material_slot].RGB.UseTint) ? m_pp.item_tint[material_slot].Color : item->Color);
@ -2718,7 +2718,7 @@ void Client::CreateBandolier(const EQApplicationPacket *app)
strcpy(m_pp.bandoliers[bs->Number].Name, bs->Name); strcpy(m_pp.bandoliers[bs->Number].Name, bs->Name);
const ItemInst* InvItem = nullptr; const ItemInst* InvItem = nullptr;
const EQEmu::Item_Struct *BaseItem = nullptr; const EQEmu::ItemBase *BaseItem = nullptr;
int16 WeaponSlot = 0; int16 WeaponSlot = 0;
for(int BandolierSlot = bandolierPrimary; BandolierSlot <= bandolierAmmo; BandolierSlot++) { for(int BandolierSlot = bandolierPrimary; BandolierSlot <= bandolierAmmo; BandolierSlot++) {

16
zone/loottables.cpp
View File

@ -119,7 +119,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
int charges = lds->Entries[i].multiplier; int charges = lds->Entries[i].multiplier;
for(int j = 0; j < charges; ++j) { for(int j = 0; j < charges; ++j) {
if(zone->random.Real(0.0, 100.0) <= lds->Entries[i].chance) { if(zone->random.Real(0.0, 100.0) <= lds->Entries[i].chance) {
const EQEmu::Item_Struct* dbitem = GetItem(lds->Entries[i].item_id); const EQEmu::ItemBase* dbitem = GetItem(lds->Entries[i].item_id);
npc->AddLootDrop(dbitem, itemlist, lds->Entries[i].item_charges, lds->Entries[i].minlevel, 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); 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; float roll_t_min = 0.0f;
bool active_item_list = false; bool active_item_list = false;
for(uint32 i = 0; i < lds->NumEntries; ++i) { for(uint32 i = 0; i < lds->NumEntries; ++i) {
const EQEmu::Item_Struct* db_item = GetItem(lds->Entries[i].item_id); const EQEmu::ItemBase* db_item = GetItem(lds->Entries[i].item_id);
if(db_item) { if(db_item) {
roll_t += lds->Entries[i].chance; roll_t += lds->Entries[i].chance;
active_item_list = true; 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) { for(int i = 0; i < mindrop; ++i) {
float roll = (float)zone->random.Real(0.0, roll_t_min); float roll = (float)zone->random.Real(0.0, roll_t_min);
for(uint32 j = 0; j < lds->NumEntries; ++j) { for(uint32 j = 0; j < lds->NumEntries; ++j) {
const EQEmu::Item_Struct* db_item = GetItem(lds->Entries[j].item_id); const EQEmu::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
if(db_item) { if(db_item) {
if(roll < lds->Entries[j].chance) { if(roll < lds->Entries[j].chance) {
npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel, 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) { for(int i = mindrop; i < droplimit; ++i) {
float roll = (float)zone->random.Real(0.0, roll_t); float roll = (float)zone->random.Real(0.0, roll_t);
for(uint32 j = 0; j < lds->NumEntries; ++j) { for(uint32 j = 0; j < lds->NumEntries; ++j) {
const EQEmu::Item_Struct* db_item = GetItem(lds->Entries[j].item_id); const EQEmu::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
if(db_item) { if(db_item) {
if(roll < lds->Entries[j].chance) { if(roll < lds->Entries[j].chance) {
npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel, 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 //if itemlist is null, just send wear changes
void NPC::AddLootDrop(const EQEmu::Item_Struct *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange) { void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange) {
if(item2 == nullptr) if(item2 == nullptr)
return; return;
@ -258,7 +258,7 @@ void NPC::AddLootDrop(const EQEmu::Item_Struct *item2, ItemList* itemlist, int16
if (equipit) { if (equipit) {
uint8 eslot = 0xFF; uint8 eslot = 0xFF;
char newid[20]; char newid[20];
const EQEmu::Item_Struct* compitem = nullptr; const EQEmu::ItemBase* compitem = nullptr;
bool found = false; // track if we found an empty slot we fit into bool found = false; // track if we found an empty slot we fit into
int32 foundslot = -1; // for multi-slot items int32 foundslot = -1; // for multi-slot items
@ -415,14 +415,14 @@ void NPC::AddLootDrop(const EQEmu::Item_Struct *item2, ItemList* itemlist, int16
SendAppearancePacket(AT_Light, GetActiveLightType()); SendAppearancePacket(AT_Light, GetActiveLightType());
} }
void NPC::AddItem(const EQEmu::Item_Struct* item, uint16 charges, bool equipitem) { void NPC::AddItem(const EQEmu::ItemBase* item, uint16 charges, bool equipitem) {
//slot isnt needed, its determined from the item. //slot isnt needed, its determined from the item.
AddLootDrop(item, &itemlist, charges, 1, 127, equipitem, equipitem); AddLootDrop(item, &itemlist, charges, 1, 127, equipitem, equipitem);
} }
void NPC::AddItem(uint32 itemid, uint16 charges, bool equipitem) { void NPC::AddItem(uint32 itemid, uint16 charges, bool equipitem) {
//slot isnt needed, its determined from the item. //slot isnt needed, its determined from the item.
const EQEmu::Item_Struct * i = database.GetItem(itemid); const EQEmu::ItemBase * i = database.GetItem(itemid);
if(i == nullptr) if(i == nullptr)
return; return;
AddLootDrop(i, &itemlist, charges, 1, 127, equipitem, equipitem); AddLootDrop(i, &itemlist, charges, 1, 127, equipitem, equipitem);

2
zone/lua_item.cpp
View File

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

12
zone/lua_item.h
View File

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

2
zone/lua_parser_events.cpp
View File

@ -298,7 +298,7 @@ void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, st
void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data, void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { std::vector<EQEmu::Any> *extra_pointers) {
const EQEmu::Item_Struct *item = database.GetItem(extra_data); const EQEmu::ItemBase *item = database.GetItem(extra_data);
if(item) { if(item) {
Lua_Item l_item(item); Lua_Item l_item(item);
luabind::adl::object l_item_o = luabind::adl::object(L, l_item); luabind::adl::object l_item_o = luabind::adl::object(L, l_item);

14
zone/merc.cpp
View File

@ -217,7 +217,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
for (i = 0; i < EQEmu::legacy::SlotAmmo; i++) { for (i = 0; i < EQEmu::legacy::SlotAmmo; i++) {
if(equipment[i] == 0) if(equipment[i] == 0)
continue; continue;
const EQEmu::Item_Struct * itm = database.GetItem(equipment[i]); const EQEmu::ItemBase * itm = database.GetItem(equipment[i]);
if(itm) if(itm)
AddItemBonuses(itm, newbon); AddItemBonuses(itm, newbon);
} }
@ -243,7 +243,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
SetAttackTimer(); SetAttackTimer();
} }
void Merc::AddItemBonuses(const EQEmu::Item_Struct *item, StatBonuses* newbon) { void Merc::AddItemBonuses(const EQEmu::ItemBase *item, StatBonuses* newbon) {
if(GetLevel() < item->ReqLevel) if(GetLevel() < item->ReqLevel)
{ {
@ -1221,7 +1221,7 @@ void Merc::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
{ {
continue; continue;
} }
const Item_Struct* item = database.GetItem(equipment[i]); const ItemBase* item = database.GetItem(equipment[i]);
if(item) if(item)
{ {
ns->spawn.equipment[i].material = item->Material; ns->spawn.equipment[i].material = item->Material;
@ -2547,8 +2547,8 @@ int16 Merc::GetFocusEffect(focusType type, uint16 spell_id) {
//Check if item focus effect exists for the client. //Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){ if (itembonuses.FocusEffects[type]){
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
const EQEmu::Item_Struct* UsedItem = 0; const EQEmu::ItemBase* UsedItem = 0;
uint16 UsedFocusID = 0; uint16 UsedFocusID = 0;
int16 Total = 0; int16 Total = 0;
int16 focus_max = 0; int16 focus_max = 0;
@ -4428,7 +4428,7 @@ void Merc::DoClassAttacks(Mob *target) {
DoAnim(animKick); DoAnim(animKick);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{
@ -4450,7 +4450,7 @@ void Merc::DoClassAttacks(Mob *target) {
DoAnim(animTailRake); DoAnim(animTailRake);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{

4
zone/merc.h
View File

@ -14,7 +14,7 @@ struct NewSpawn_Struct;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
} }
#define MAXMERCS 1 #define MAXMERCS 1
@ -283,7 +283,7 @@ public:
protected: protected:
void CalcItemBonuses(StatBonuses* newbon); void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const EQEmu::Item_Struct *item, StatBonuses* newbon); void AddItemBonuses(const EQEmu::ItemBase *item, StatBonuses* newbon);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat); int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
int16 GetFocusEffect(focusType type, uint16 spell_id); int16 GetFocusEffect(focusType type, uint16 spell_id);

16
zone/mob.cpp
View File

@ -2382,7 +2382,7 @@ bool Mob::CanThisClassDualWield(void) const {
// 2HS, 2HB, or 2HP // 2HS, 2HB, or 2HP
if(pinst && pinst->IsWeapon()) { if(pinst && pinst->IsWeapon()) {
const EQEmu::Item_Struct* item = pinst->GetItem(); const EQEmu::ItemBase* item = pinst->GetItem();
if (item->IsType2HWeapon()) if (item->IsType2HWeapon())
return false; return false;
@ -2754,7 +2754,7 @@ void Mob::SendArmorAppearance(Client *one_client)
{ {
if (!IsClient()) if (!IsClient())
{ {
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
for (int i = 0; i < 7; ++i) for (int i = 0; i < 7; ++i)
{ {
item = database.GetItem(GetEquipment(i)); item = database.GetItem(GetEquipment(i));
@ -2857,7 +2857,7 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const
{ {
uint32 equipmaterial = 0; uint32 equipmaterial = 0;
int32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); int32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
item = database.GetItem(GetEquipment(material_slot)); item = database.GetItem(GetEquipment(material_slot));
if (item != 0) if (item != 0)
@ -2910,7 +2910,7 @@ int32 Mob::GetHerosForgeModel(uint8 material_slot) const
if (material_slot >= 0 && material_slot < EQEmu::legacy::MaterialPrimary) if (material_slot >= 0 && material_slot < EQEmu::legacy::MaterialPrimary)
{ {
uint32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType); uint32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
item = database.GetItem(GetEquipment(material_slot)); item = database.GetItem(GetEquipment(material_slot));
int16 invslot = Inventory::CalcSlotFromMaterial(material_slot); int16 invslot = Inventory::CalcSlotFromMaterial(material_slot);
@ -2964,7 +2964,7 @@ int32 Mob::GetHerosForgeModel(uint8 material_slot) const
uint32 Mob::GetEquipmentColor(uint8 material_slot) const uint32 Mob::GetEquipmentColor(uint8 material_slot) const
{ {
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
if (armor_tint[material_slot]) if (armor_tint[material_slot])
{ {
@ -2980,7 +2980,7 @@ uint32 Mob::GetEquipmentColor(uint8 material_slot) const
uint32 Mob::IsEliteMaterialItem(uint8 material_slot) const uint32 Mob::IsEliteMaterialItem(uint8 material_slot) const
{ {
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
item = database.GetItem(GetEquipment(material_slot)); item = database.GetItem(GetEquipment(material_slot));
if(item != 0) if(item != 0)
@ -3896,7 +3896,7 @@ int32 Mob::GetItemStat(uint32 itemid, const char *identifier)
if (!inst) if (!inst)
return 0; return 0;
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (!item) if (!item)
return 0; return 0;
@ -5627,7 +5627,7 @@ int32 Mob::GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot)
bool Mob::CanClassEquipItem(uint32 item_id) bool Mob::CanClassEquipItem(uint32 item_id)
{ {
const EQEmu::Item_Struct* itm = nullptr; const EQEmu::ItemBase* itm = nullptr;
itm = database.GetItem(item_id); itm = database.GetItem(item_id);
if (!itm) if (!itm)

18
zone/mob.h
View File

@ -50,7 +50,7 @@ struct PlayerPositionUpdateServer_Struct;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
} }
class Mob : public Entity { class Mob : public Entity {
@ -768,7 +768,7 @@ public:
virtual int GetHaste(); virtual int GetHaste();
int32 GetMeleeMitigation(); int32 GetMeleeMitigation();
uint8 GetWeaponDamageBonus(const EQEmu::Item_Struct* weapon, bool offhand = false); uint8 GetWeaponDamageBonus(const EQEmu::ItemBase* weapon, bool offhand = false);
uint16 GetDamageTable(EQEmu::skills::SkillType skillinuse); uint16 GetDamageTable(EQEmu::skills::SkillType skillinuse);
virtual int GetHandToHandDamage(void); virtual int GetHandToHandDamage(void);
@ -793,10 +793,10 @@ public:
int32 ReduceAllDamage(int32 damage); int32 ReduceAllDamage(int32 damage);
virtual void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool CheckHitChance = false, bool CanAvoid = true); virtual void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool CheckHitChance = false, bool CanAvoid = true);
virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const EQEmu::Item_Struct* AmmoItem=nullptr, uint16 weapon_damage=0, int16 chance_mod=0,int16 focus=0, int ReuseTime=0, uint32 range_id=0, int AmmoSlot=0, float speed = 4.0f); virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon = nullptr, const EQEmu::ItemBase* AmmoItem = nullptr, uint16 weapon_damage = 0, int16 chance_mod = 0, int16 focus = 0, int ReuseTime = 0, uint32 range_id = 0, int AmmoSlot = 0, float speed = 4.0f);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0); virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0);
virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const ItemInst* Ammo=nullptr, uint16 weapon_damage=0, int16 chance_mod=0, int16 focus=0, int ReuseTime=0, uint32 range_id=0, uint32 ammo_id=0, const EQEmu::Item_Struct *AmmoItem=nullptr, int AmmoSlot=0, float speed= 4.0f); virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon = nullptr, const ItemInst* Ammo = nullptr, uint16 weapon_damage = 0, int16 chance_mod = 0, int16 focus = 0, int ReuseTime = 0, uint32 range_id = 0, uint32 ammo_id = 0, const EQEmu::ItemBase *AmmoItem = nullptr, int AmmoSlot = 0, float speed = 4.0f);
bool TryProjectileAttack(Mob* other, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed); bool TryProjectileAttack(Mob* other, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed);
void ProjectileAttack(); void ProjectileAttack();
inline bool HasProjectileAttack() const { return ActiveProjectileATK; } inline bool HasProjectileAttack() const { return ActiveProjectileATK; }
inline void SetProjectileAttack(bool value) { ActiveProjectileATK = value; } inline void SetProjectileAttack(bool value) { ActiveProjectileATK = value; }
@ -914,7 +914,7 @@ public:
// HP Event // HP Event
inline int GetNextHPEvent() const { return nexthpevent; } inline int GetNextHPEvent() const { return nexthpevent; }
void SetNextHPEvent( int hpevent ); void SetNextHPEvent( int hpevent );
void SendItemAnimation(Mob *to, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0); void SendItemAnimation(Mob *to, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0);
inline int& GetNextIncHPEvent() { return nextinchpevent; } inline int& GetNextIncHPEvent() { return nextinchpevent; }
void SetNextIncHPEvent( int inchpevent ); void SetNextIncHPEvent( int inchpevent );
@ -1152,8 +1152,8 @@ protected:
bool PassLimitToSkill(uint16 spell_id, uint16 skill); bool PassLimitToSkill(uint16 spell_id, uint16 skill);
bool PassLimitClass(uint32 Classes_, uint16 Class_); bool PassLimitClass(uint32 Classes_, uint16 Class_);
void TryDefensiveProc(Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary); void TryDefensiveProc(Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void TryWeaponProc(const ItemInst* inst, const EQEmu::Item_Struct* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary); void TryWeaponProc(const ItemInst* inst, const EQEmu::ItemBase* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void TrySpellProc(const ItemInst* inst, const EQEmu::Item_Struct* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary); void TrySpellProc(const ItemInst* inst, const EQEmu::ItemBase* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void TryWeaponProc(const ItemInst* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary); void TryWeaponProc(const ItemInst* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void ExecWeaponProc(const ItemInst* weapon, uint16 spell_id, Mob *on, int level_override = -1); void ExecWeaponProc(const ItemInst* weapon, uint16 spell_id, Mob *on, int level_override = -1);
virtual float GetProcChances(float ProcBonus, uint16 hand = EQEmu::legacy::SlotPrimary); virtual float GetProcChances(float ProcBonus, uint16 hand = EQEmu::legacy::SlotPrimary);
@ -1162,7 +1162,7 @@ protected:
virtual float GetAssassinateProcChances(uint16 ReuseTime); virtual float GetAssassinateProcChances(uint16 ReuseTime);
virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); // hand = MainCharm? virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); // hand = MainCharm?
uint16 GetWeaponSpeedbyHand(uint16 hand); uint16 GetWeaponSpeedbyHand(uint16 hand);
int GetWeaponDamage(Mob *against, const EQEmu::Item_Struct *weapon_item); int GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item);
int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr); int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr);
int GetKickDamage(); int GetKickDamage();
int GetBashDamage(); int GetBashDamage();

10
zone/mod_functions.cpp
View File

@ -10,10 +10,6 @@ class Spawn2;
struct Consider_Struct; struct Consider_Struct;
struct DBTradeskillRecipe_Struct; struct DBTradeskillRecipe_Struct;
namespace {
struct Item_Struct;
}
extern EntityList entity_list; extern EntityList entity_list;
extern Zone* zone; extern Zone* zone;
@ -29,7 +25,7 @@ void Zone::mod_repop() { return; }
void NPC::mod_prespawn(Spawn2 *sp) { return; } void NPC::mod_prespawn(Spawn2 *sp) { return; }
//Base damage from NPC::Attack //Base damage from NPC::Attack
int NPC::mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::Item_Struct* weapon, Mob* other) { return(damage); } int NPC::mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemBase* weapon, Mob* other) { return(damage); }
//Mob c has been given credit for a kill. This is called after the regular EVENT_KILLED_MERIT event. //Mob c has been given credit for a kill. This is called after the regular EVENT_KILLED_MERIT event.
void NPC::mod_npc_killed_merit(Mob* c) { return; } void NPC::mod_npc_killed_merit(Mob* c) { return; }
@ -107,8 +103,8 @@ int32 Client::mod_client_xp(int32 in_xp, NPC *npc) { return(in_xp); }
uint32 Client::mod_client_xp_for_level(uint32 xp, uint16 check_level) { return(xp); } uint32 Client::mod_client_xp_for_level(uint32 xp, uint16 check_level) { return(xp); }
//Food and drink values as computed by consume requests. Return < 0 to abort the request. //Food and drink values as computed by consume requests. Return < 0 to abort the request.
int Client::mod_food_value(const EQEmu::Item_Struct *item, int change) { return(change); } int Client::mod_food_value(const EQEmu::ItemBase *item, int change) { return(change); }
int Client::mod_drink_value(const EQEmu::Item_Struct *item, int change) { return(change); } int Client::mod_drink_value(const EQEmu::ItemBase *item, int change) { return(change); }
//effect_vallue - Spell effect value as calculated by default formulas. You will want to ignore effects that don't lend themselves to scaling - pet ID's, gate coords, etc. //effect_vallue - Spell effect value as calculated by default formulas. You will want to ignore effects that don't lend themselves to scaling - pet ID's, gate coords, etc.
int Mob::mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster, uint16 caster_id) { return(effect_value); } int Mob::mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster, uint16 caster_id) { return(effect_value); }

6
zone/npc.cpp
View File

@ -27,7 +27,7 @@
#include "../common/client_version.h" // inv2 watch #include "../common/client_version.h" // inv2 watch
#include "../common/features.h" #include "../common/features.h"
#include "../common/item.h" #include "../common/item.h"
#include "../common/item_struct.h" #include "../common/item_base.h"
#include "../common/linked_list.h" #include "../common/linked_list.h"
#include "../common/servertalk.h" #include "../common/servertalk.h"
#include "../common/say_link.h" #include "../common/say_link.h"
@ -524,7 +524,7 @@ void NPC::QueryLoot(Client* to)
int x = 0; int x = 0;
for (auto cur = itemlist.begin(); cur != itemlist.end(); ++cur, ++x) { for (auto cur = itemlist.begin(); cur != itemlist.end(); ++cur, ++x) {
const EQEmu::Item_Struct* item = database.GetItem((*cur)->item_id); const EQEmu::ItemBase* item = database.GetItem((*cur)->item_id);
if (item == nullptr) { if (item == nullptr) {
Log.Out(Logs::General, Logs::Error, "Database error, invalid item"); Log.Out(Logs::General, Logs::Error, "Database error, invalid item");
continue; continue;
@ -1457,7 +1457,7 @@ void NPC::PickPocket(Client* thief)
// still needs to have FindFreeSlot vs PutItemInInventory issue worked out // still needs to have FindFreeSlot vs PutItemInInventory issue worked out
while (steal_item) { while (steal_item) {
std::vector<std::pair<const EQEmu::Item_Struct*, uint16>> loot_selection; // <const Item_Struct*, charges> std::vector<std::pair<const EQEmu::ItemBase*, uint16>> loot_selection; // <const ItemBase*, charges>
for (auto item_iter : itemlist) { for (auto item_iter : itemlist) {
if (!item_iter || !item_iter->item_id) if (!item_iter || !item_iter->item_id)
continue; continue;

8
zone/npc.h
View File

@ -93,7 +93,7 @@ class Spawn2;
namespace EQEmu namespace EQEmu
{ {
struct Item_Struct; struct ItemBase;
} }
class NPC : public Mob class NPC : public Mob
@ -178,7 +178,7 @@ public:
virtual void SpellProcess(); virtual void SpellProcess();
virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho); virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
void AddItem(const EQEmu::Item_Struct* item, uint16 charges, bool equipitem = true); void AddItem(const EQEmu::ItemBase* item, uint16 charges, bool equipitem = true);
void AddItem(uint32 itemid, uint16 charges, bool equipitem = true); void AddItem(uint32 itemid, uint16 charges, bool equipitem = true);
void AddLootTable(); void AddLootTable();
void AddLootTable(uint32 ldid); void AddLootTable(uint32 ldid);
@ -270,7 +270,7 @@ public:
bool IsTaunting() const { return taunting; } bool IsTaunting() const { return taunting; }
void PickPocket(Client* thief); void PickPocket(Client* thief);
void StartSwarmTimer(uint32 duration) { swarm_timer.Start(duration); } void StartSwarmTimer(uint32 duration) { swarm_timer.Start(duration); }
void AddLootDrop(const EQEmu::Item_Struct*dbitem, ItemList* itemlistconst, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange = false); void AddLootDrop(const EQEmu::ItemBase*dbitem, ItemList* itemlistconst, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange = false);
virtual void DoClassAttacks(Mob *target); virtual void DoClassAttacks(Mob *target);
void CheckSignal(); void CheckSignal();
inline bool IsNotTargetableWithHotkey() const { return no_target_hotkey; } inline bool IsNotTargetableWithHotkey() const { return no_target_hotkey; }
@ -403,7 +403,7 @@ public:
void SetMerchantProbability(uint8 amt) { probability = amt; } void SetMerchantProbability(uint8 amt) { probability = amt; }
uint8 GetMerchantProbability() { return probability; } uint8 GetMerchantProbability() { return probability; }
void mod_prespawn(Spawn2 *sp); void mod_prespawn(Spawn2 *sp);
int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::Item_Struct* weapon, Mob* other); int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemBase* weapon, Mob* other);
void mod_npc_killed_merit(Mob* c); void mod_npc_killed_merit(Mob* c);
void mod_npc_killed(Mob* oos); void mod_npc_killed(Mob* oos);
void AISpellsList(Client *c); void AISpellsList(Client *c);

6
zone/object.cpp
View File

@ -138,7 +138,7 @@ Object::Object(Client* client, const ItemInst* inst)
// Set object name // Set object name
if (inst) { if (inst) {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item && item->IDFile) { if (item && item->IDFile) {
if (strlen(item->IDFile) == 0) { if (strlen(item->IDFile) == 0) {
strcpy(m_data.object_name, DEFAULT_OBJECT_NAME); strcpy(m_data.object_name, DEFAULT_OBJECT_NAME);
@ -194,7 +194,7 @@ Object::Object(const ItemInst *inst, float x, float y, float z, float heading, u
// Set object name // Set object name
if (inst) { if (inst) {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item && item->IDFile) { if (item && item->IDFile) {
if (strlen(item->IDFile) == 0) { if (strlen(item->IDFile) == 0) {
strcpy(m_data.object_name, DEFAULT_OBJECT_NAME); strcpy(m_data.object_name, DEFAULT_OBJECT_NAME);
@ -881,7 +881,7 @@ uint32 Object::GetItemID()
return 0; return 0;
} }
const EQEmu::Item_Struct* item = this->m_inst->GetItem(); const EQEmu::ItemBase* item = this->m_inst->GetItem();
if (item == 0) if (item == 0)
{ {

2
zone/perl_mob.cpp
View File

@ -8131,7 +8131,7 @@ XS(XS_Mob_DoThrowingAttackDmg)
Mob * THIS; Mob * THIS;
Mob* target; Mob* target;
ItemInst* RangeWeapon = nullptr; ItemInst* RangeWeapon = nullptr;
EQEmu::Item_Struct* item = nullptr; EQEmu::ItemBase* item = nullptr;
uint16 weapon_damage = (uint16)SvIV(ST(4)); uint16 weapon_damage = (uint16)SvIV(ST(4));
int16 chance_mod = (int16)SvIV(ST(5)); int16 chance_mod = (int16)SvIV(ST(5));
int16 focus = (int16)SvIV(ST(6)); int16 focus = (int16)SvIV(ST(6));

4
zone/pets.cpp
View File

@ -420,7 +420,7 @@ void Mob::MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower,
// like the special back items some focused pets may receive. // like the special back items some focused pets may receive.
uint32 petinv[EQEmu::legacy::EQUIPMENT_SIZE]; uint32 petinv[EQEmu::legacy::EQUIPMENT_SIZE];
memset(petinv, 0, sizeof(petinv)); memset(petinv, 0, sizeof(petinv));
const EQEmu::Item_Struct *item = 0; const EQEmu::ItemBase *item = 0;
if (database.GetBasePetItems(record.equipmentset, petinv)) { if (database.GetBasePetItems(record.equipmentset, petinv)) {
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++) for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++)
@ -665,7 +665,7 @@ void NPC::SetPetState(SpellBuff_Struct *pet_buffs, uint32 *items) {
if(items[i] == 0) if(items[i] == 0)
continue; continue;
const EQEmu::Item_Struct* item2 = database.GetItem(items[i]); const EQEmu::ItemBase* item2 = database.GetItem(items[i]);
if (item2 && item2->NoDrop != 0) { if (item2 && item2->NoDrop != 0) {
//dont bother saving item charges for now, NPCs never use them //dont bother saving item charges for now, NPCs never use them
//and nobody should be able to get them off the corpse..? //and nobody should be able to get them off the corpse..?

10
zone/questmgr.cpp
View File

@ -814,7 +814,7 @@ void QuestManager::traindisc(int discipline_tome_item_id) {
} }
bool QuestManager::isdisctome(int item_id) { bool QuestManager::isdisctome(int item_id) {
const EQEmu::Item_Struct *item = database.GetItem(item_id); const EQEmu::ItemBase *item = database.GetItem(item_id);
if(item == nullptr) { if(item == nullptr) {
return(false); return(false);
} }
@ -1305,7 +1305,7 @@ void QuestManager::settime(uint8 new_hour, uint8 new_min, bool update_world /*=
void QuestManager::itemlink(int item_id) { void QuestManager::itemlink(int item_id) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
if (initiator) { if (initiator) {
const EQEmu::Item_Struct* item = database.GetItem(item_id); const EQEmu::ItemBase* item = database.GetItem(item_id);
if (item == nullptr) if (item == nullptr)
return; return;
@ -2497,7 +2497,7 @@ void QuestManager::MerchantSetItem(uint32 NPCid, uint32 itemid, uint32 quantity)
if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT)) if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
return; // don't do anything if NPCid isn't a merchant return; // don't do anything if NPCid isn't a merchant
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
item = database.GetItem(itemid); item = database.GetItem(itemid);
if (!item) return; // if the item id doesn't correspond to a real item, do nothing if (!item) return; // if the item id doesn't correspond to a real item, do nothing
@ -2510,7 +2510,7 @@ uint32 QuestManager::MerchantCountItem(uint32 NPCid, uint32 itemid) {
if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT)) if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
return 0; // if it isn't a merchant, it doesn't have any items return 0; // if it isn't a merchant, it doesn't have any items
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
item = database.GetItem(itemid); item = database.GetItem(itemid);
if (!item) if (!item)
return 0; // if it isn't a valid item, the merchant doesn't have any return 0; // if it isn't a valid item, the merchant doesn't have any
@ -2533,7 +2533,7 @@ uint32 QuestManager::MerchantCountItem(uint32 NPCid, uint32 itemid) {
// Item Link for use in Variables - "my $example_link = quest::varlink(item_id);" // Item Link for use in Variables - "my $example_link = quest::varlink(item_id);"
const char* QuestManager::varlink(char* perltext, int item_id) { const char* QuestManager::varlink(char* perltext, int item_id) {
QuestManagerCurrentQuestVars(); QuestManagerCurrentQuestVars();
const EQEmu::Item_Struct* item = database.GetItem(item_id); const EQEmu::ItemBase* item = database.GetItem(item_id);
if (!item) if (!item)
return "INVALID ITEM ID IN VARLINK"; return "INVALID ITEM ID IN VARLINK";

40
zone/special_attacks.cpp
View File

@ -118,7 +118,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
{ {
hate += item->GetItem()->AC; hate += item->GetItem()->AC;
} }
const EQEmu::Item_Struct *itm = item->GetItem(); const EQEmu::ItemBase *itm = item->GetItem();
auto fbash = GetFuriousBash(itm->Focus.Effect); auto fbash = GetFuriousBash(itm->Focus.Effect);
hate = hate * (100 + fbash) / 100; hate = hate * (100 + fbash) / 100;
if (fbash) if (fbash)
@ -463,7 +463,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
} }
} }
else{ else{
if(GetWeaponDamage(other, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(other, (const EQEmu::ItemBase*)nullptr) <= 0){
ndamage = -5; ndamage = -5;
} }
} }
@ -694,8 +694,8 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
return; return;
} }
const EQEmu::Item_Struct* RangeItem = RangeWeapon->GetItem(); const EQEmu::ItemBase* RangeItem = RangeWeapon->GetItem();
const EQEmu::Item_Struct* AmmoItem = Ammo->GetItem(); const EQEmu::ItemBase* AmmoItem = Ammo->GetItem();
if (RangeItem->ItemType != EQEmu::item::ItemTypeBow) { if (RangeItem->ItemType != EQEmu::item::ItemTypeBow) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item is not a bow. type %d.", RangeItem->ItemType); Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item is not a bow. type %d.", RangeItem->ItemType);
@ -719,7 +719,7 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
const ItemInst *pi = m_inv[r]; const ItemInst *pi = m_inv[r];
if (pi == nullptr || !pi->IsClassBag()) if (pi == nullptr || !pi->IsClassBag())
continue; continue;
const EQEmu::Item_Struct* bagitem = pi->GetItem(); const EQEmu::ItemBase* bagitem = pi->GetItem();
if (!bagitem || bagitem->BagType != EQEmu::item::BagTypeQuiver) if (!bagitem || bagitem->BagType != EQEmu::item::BagTypeQuiver)
continue; continue;
@ -798,7 +798,7 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
} }
void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const ItemInst* Ammo, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime, void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const ItemInst* Ammo, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime,
uint32 range_id, uint32 ammo_id, const EQEmu::Item_Struct *AmmoItem, int AmmoSlot, float speed) { uint32 range_id, uint32 ammo_id, const EQEmu::ItemBase *AmmoItem, int AmmoSlot, float speed) {
if ((other == nullptr || if ((other == nullptr ||
((IsClient() && CastToClient()->dead) || ((IsClient() && CastToClient()->dead) ||
@ -813,7 +813,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
const ItemInst* _RangeWeapon = nullptr; const ItemInst* _RangeWeapon = nullptr;
const ItemInst* _Ammo = nullptr; const ItemInst* _Ammo = nullptr;
const EQEmu::Item_Struct* ammo_lost = nullptr; const EQEmu::ItemBase* ammo_lost = nullptr;
/* /*
If LaunchProjectile is false this function will do archery damage on target, If LaunchProjectile is false this function will do archery damage on target,
@ -1009,7 +1009,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
} }
} }
bool Mob::TryProjectileAttack(Mob* other, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed){ bool Mob::TryProjectileAttack(Mob* other, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed){
if (!other) if (!other)
return false; return false;
@ -1313,7 +1313,7 @@ void NPC::DoRangedAttackDmg(Mob* other, bool Launch, int16 damage_mod, int16 cha
//try proc on hits and misses //try proc on hits and misses
if(other && !other->HasDied()) if(other && !other->HasDied())
TrySpellProc(nullptr, (const EQEmu::Item_Struct*)nullptr, other, EQEmu::legacy::SlotRange); TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, other, EQEmu::legacy::SlotRange);
if (HasSkillProcs() && other && !other->HasDied()) if (HasSkillProcs() && other && !other->HasDied())
TrySkillProc(other, skillInUse, 0, false, EQEmu::legacy::SlotRange); TrySkillProc(other, skillInUse, 0, false, EQEmu::legacy::SlotRange);
@ -1367,7 +1367,7 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
return; return;
} }
const EQEmu::Item_Struct* item = RangeWeapon->GetItem(); const EQEmu::ItemBase* item = RangeWeapon->GetItem();
if (item->ItemType != EQEmu::item::ItemTypeLargeThrowing && item->ItemType != EQEmu::item::ItemTypeSmallThrowing) { if (item->ItemType != EQEmu::item::ItemTypeLargeThrowing && item->ItemType != EQEmu::item::ItemTypeSmallThrowing) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item %d is not a throwing weapon. type %d.", item->ItemType); Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item %d is not a throwing weapon. type %d.", item->ItemType);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing useful to throw!", GetItemIDAt(EQEmu::legacy::SlotRange)); Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing useful to throw!", GetItemIDAt(EQEmu::legacy::SlotRange));
@ -1428,7 +1428,7 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
CommonBreakInvisibleFromCombat(); CommonBreakInvisibleFromCombat();
} }
void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQEmu::Item_Struct* AmmoItem, uint16 weapon_damage, int16 chance_mod,int16 focus, int ReuseTime, uint32 range_id, int AmmoSlot, float speed) void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQEmu::ItemBase* AmmoItem, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime, uint32 range_id, int AmmoSlot, float speed)
{ {
if ((other == nullptr || if ((other == nullptr ||
((IsClient() && CastToClient()->dead) || ((IsClient() && CastToClient()->dead) ||
@ -1442,7 +1442,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
} }
const ItemInst* _RangeWeapon = nullptr; const ItemInst* _RangeWeapon = nullptr;
const EQEmu::Item_Struct* ammo_lost = nullptr; const EQEmu::ItemBase* ammo_lost = nullptr;
/* /*
If LaunchProjectile is false this function will do archery damage on target, If LaunchProjectile is false this function will do archery damage on target,
@ -1566,7 +1566,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
} }
} }
void Mob::SendItemAnimation(Mob *to, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, float velocity) { void Mob::SendItemAnimation(Mob *to, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, float velocity) {
auto outapp = new EQApplicationPacket(OP_SomeItemPacketMaybe, sizeof(Arrow_Struct)); auto outapp = new EQApplicationPacket(OP_SomeItemPacketMaybe, sizeof(Arrow_Struct));
Arrow_Struct *as = (Arrow_Struct *) outapp->pBuffer; Arrow_Struct *as = (Arrow_Struct *) outapp->pBuffer;
as->type = 1; as->type = 1;
@ -1616,7 +1616,7 @@ void Mob::ProjectileAnimation(Mob* to, int item_id, bool IsArrow, float speed, f
if (!to) if (!to)
return; return;
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
uint8 item_type = 0; uint8 item_type = 0;
if(!item_id) { if(!item_id) {
@ -1757,7 +1757,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animKick); DoAnim(animKick);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{
@ -1778,7 +1778,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animTailRake); DoAnim(animTailRake);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{
@ -1831,7 +1831,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animKick); DoAnim(animKick);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{
@ -1856,7 +1856,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animTailRake); DoAnim(animTailRake);
int32 dmg = 0; int32 dmg = 0;
if(GetWeaponDamage(target, (const EQEmu::Item_Struct*)nullptr) <= 0){ if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
dmg = -5; dmg = -5;
} }
else{ else{
@ -2368,7 +2368,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int32 max_hit = (2 * weapon_damage*GetDamageTable(skillinuse)) / 100; int32 max_hit = (2 * weapon_damage*GetDamageTable(skillinuse)) / 100;
if(GetLevel() >= 28 && IsWarriorClass() ) { if(GetLevel() >= 28 && IsWarriorClass() ) {
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::Item_Struct*) nullptr ); int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;
hate += ucDamageBonus; hate += ucDamageBonus;
@ -2381,7 +2381,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
if (item->GetItem()->ItemType == EQEmu::item::ItemTypeShield) { if (item->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
hate += item->GetItem()->AC; hate += item->GetItem()->AC;
} }
const EQEmu::Item_Struct *itm = item->GetItem(); const EQEmu::ItemBase *itm = item->GetItem();
hate = hate * (100 + GetFuriousBash(itm->Focus.Effect)) / 100; hate = hate * (100 + GetFuriousBash(itm->Focus.Effect)) / 100;
} }
} }

20
zone/spell_effects.cpp
View File

@ -1138,7 +1138,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
case SE_SummonItem: case SE_SummonItem:
{ {
const EQEmu::Item_Struct *item = database.GetItem(spell.base[i]); const EQEmu::ItemBase *item = database.GetItem(spell.base[i]);
#ifdef SPELL_EFFECT_SPAM #ifdef SPELL_EFFECT_SPAM
const char *itemname = item ? item->Name : "*Unknown Item*"; const char *itemname = item ? item->Name : "*Unknown Item*";
snprintf(effect_desc, _EDLEN, "Summon Item: %s (id %d)", itemname, spell.base[i]); snprintf(effect_desc, _EDLEN, "Summon Item: %s (id %d)", itemname, spell.base[i]);
@ -1174,7 +1174,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
} }
case SE_SummonItemIntoBag: case SE_SummonItemIntoBag:
{ {
const EQEmu::Item_Struct *item = database.GetItem(spell.base[i]); const EQEmu::ItemBase *item = database.GetItem(spell.base[i]);
#ifdef SPELL_EFFECT_SPAM #ifdef SPELL_EFFECT_SPAM
const char *itemname = item ? item->Name : "*Unknown Item*"; const char *itemname = item ? item->Name : "*Unknown Item*";
snprintf(effect_desc, _EDLEN, "Summon Item In Bag: %s (id %d)", itemname, spell.base[i]); snprintf(effect_desc, _EDLEN, "Summon Item In Bag: %s (id %d)", itemname, spell.base[i]);
@ -5128,7 +5128,7 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
//item focus //item focus
if (itembonuses.FocusEffects[type]){ if (itembonuses.FocusEffects[type]){
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++) for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++)
{ {
@ -5159,7 +5159,7 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
aug = ins->GetAugment(y); aug = ins->GetAugment(y);
if(aug) if(aug)
{ {
const EQEmu::Item_Struct* TempItemAug = aug->GetItem(); const EQEmu::ItemBase* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && IsValidSpell(TempItemAug->Focus.Effect)) { if (TempItemAug && TempItemAug->Focus.Effect > 0 && IsValidSpell(TempItemAug->Focus.Effect)) {
proc_spellid = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id); proc_spellid = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id);
if (IsValidSpell(proc_spellid)){ if (IsValidSpell(proc_spellid)){
@ -5257,8 +5257,8 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
//Check if item focus effect exists for the client. //Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){ if (itembonuses.FocusEffects[type]){
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
const EQEmu::Item_Struct* UsedItem = 0; const EQEmu::ItemBase* UsedItem = 0;
uint16 UsedFocusID = 0; uint16 UsedFocusID = 0;
int16 Total = 0; int16 Total = 0;
int16 focus_max = 0; int16 focus_max = 0;
@ -5305,7 +5305,7 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
aug = ins->GetAugment(y); aug = ins->GetAugment(y);
if(aug) if(aug)
{ {
const EQEmu::Item_Struct* TempItemAug = aug->GetItem(); const EQEmu::ItemBase* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) { if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) {
if(rand_effectiveness) { if(rand_effectiveness) {
focus_max = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id, true); focus_max = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id, true);
@ -5529,8 +5529,8 @@ int16 NPC::GetFocusEffect(focusType type, uint16 spell_id) {
if (RuleB(Spells, NPC_UseFocusFromItems) && itembonuses.FocusEffects[type]){ if (RuleB(Spells, NPC_UseFocusFromItems) && itembonuses.FocusEffects[type]){
const EQEmu::Item_Struct* TempItem = 0; const EQEmu::ItemBase* TempItem = 0;
const EQEmu::Item_Struct* UsedItem = 0; const EQEmu::ItemBase* UsedItem = 0;
uint16 UsedFocusID = 0; uint16 UsedFocusID = 0;
int16 Total = 0; int16 Total = 0;
int16 focus_max = 0; int16 focus_max = 0;
@ -5538,7 +5538,7 @@ int16 NPC::GetFocusEffect(focusType type, uint16 spell_id) {
//item focus //item focus
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){ for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){
const EQEmu::Item_Struct *cur = database.GetItem(equipment[i]); const EQEmu::ItemBase *cur = database.GetItem(equipment[i]);
if(!cur) if(!cur)
continue; continue;

8
zone/spells.cpp
View File

@ -1136,7 +1136,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot,
missingreags=true; missingreags=true;
} }
const EQEmu::Item_Struct *item = database.GetItem(component); const EQEmu::ItemBase *item = database.GetItem(component);
if(item) { if(item) {
c->Message_StringID(13, MISSING_SPELL_COMP_ITEM, item->Name); c->Message_StringID(13, MISSING_SPELL_COMP_ITEM, item->Name);
Log.Out(Logs::Detail, Logs::Spells, "Spell %d: Canceled. Missing required reagent %s (%d)", spell_id, item->Name, component); Log.Out(Logs::Detail, Logs::Spells, "Spell %d: Canceled. Missing required reagent %s (%d)", spell_id, item->Name, component);
@ -1198,7 +1198,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot,
{ {
bool fromaug = false; bool fromaug = false;
const ItemInst* inst = CastToClient()->GetInv()[inventory_slot]; const ItemInst* inst = CastToClient()->GetInv()[inventory_slot];
EQEmu::Item_Struct* augitem = 0; EQEmu::ItemBase* augitem = 0;
uint32 recastdelay = 0; uint32 recastdelay = 0;
uint32 recasttype = 0; uint32 recasttype = 0;
@ -1211,7 +1211,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot,
if (!aug_i) if (!aug_i)
continue; continue;
const EQEmu::Item_Struct* aug = aug_i->GetItem(); const EQEmu::ItemBase* aug = aug_i->GetItem();
if (!aug) if (!aug)
continue; continue;
@ -1247,7 +1247,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot,
if (inst && inst->IsClassCommon() && (inst->GetItem()->Click.Effect == spell_id) && inst->GetCharges() || fromaug) if (inst && inst->IsClassCommon() && (inst->GetItem()->Click.Effect == spell_id) && inst->GetCharges() || fromaug)
{ {
//const Item_Struct* item = inst->GetItem(); //const ItemBase* item = inst->GetItem();
int16 charges = inst->GetItem()->MaxCharges; int16 charges = inst->GetItem()->MaxCharges;
if(fromaug) { charges = -1; } //Don't destroy the parent item if(fromaug) { charges = -1; } //Don't destroy the parent item

4
zone/tasks.cpp
View File

@ -1885,7 +1885,7 @@ void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) {
if(!Task || !c) return; if(!Task || !c) return;
const EQEmu::Item_Struct* Item; const EQEmu::ItemBase* Item;
std::vector<int> RewardList; std::vector<int> RewardList;
switch(Task->RewardMethod) { switch(Task->RewardMethod) {
@ -2776,7 +2776,7 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, int SequenceN
} }
if(ItemID) { if(ItemID) {
const EQEmu::Item_Struct* reward_item = database.GetItem(ItemID); const EQEmu::ItemBase* reward_item = database.GetItem(ItemID);
EQEmu::saylink::SayLinkEngine linker; EQEmu::saylink::SayLinkEngine linker;
linker.SetLinkType(linker.SayLinkItemData); linker.SetLinkType(linker.SayLinkItemData);

16
zone/tradeskills.cpp
View File

@ -61,7 +61,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
inst = user_inv.GetItem(in_augment->container_slot); inst = user_inv.GetItem(in_augment->container_slot);
if (inst) if (inst)
{ {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag) && item->BagType == 53) if (item && inst->IsType(EQEmu::item::ItemClassBag) && item->BagType == 53)
{ {
// We have found an appropriate inventory augmentation sealer // We have found an appropriate inventory augmentation sealer
@ -276,7 +276,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
else { else {
inst = user_inv.GetItem(in_combine->container_slot); inst = user_inv.GetItem(in_combine->container_slot);
if (inst) { if (inst) {
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag)) { if (item && inst->IsType(EQEmu::item::ItemClassBag)) {
c_type = item->BagType; c_type = item->BagType;
some_id = item->ID; some_id = item->ID;
@ -294,7 +294,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
const ItemInst* inst = container->GetItem(0); const ItemInst* inst = container->GetItem(0);
bool AllowAll = RuleB(Inventory, AllowAnyWeaponTransformation); bool AllowAll = RuleB(Inventory, AllowAnyWeaponTransformation);
if (inst && ItemInst::CanTransform(inst->GetItem(), container->GetItem(), AllowAll)) { if (inst && ItemInst::CanTransform(inst->GetItem(), container->GetItem(), AllowAll)) {
const EQEmu::Item_Struct* new_weapon = inst->GetItem(); const EQEmu::ItemBase* new_weapon = inst->GetItem();
user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true); user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true);
container->Clear(); container->Clear();
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::legacy::SlotCursor, container->GetItem()->Icon, atoi(container->GetItem()->IDFile + 2)); user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::legacy::SlotCursor, container->GetItem()->Icon, atoi(container->GetItem()->IDFile + 2));
@ -314,7 +314,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeDetransformationmold) { if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeDetransformationmold) {
const ItemInst* inst = container->GetItem(0); const ItemInst* inst = container->GetItem(0);
if (inst && inst->GetOrnamentationIcon() && inst->GetOrnamentationIcon()) { if (inst && inst->GetOrnamentationIcon() && inst->GetOrnamentationIcon()) {
const EQEmu::Item_Struct* new_weapon = inst->GetItem(); const EQEmu::ItemBase* new_weapon = inst->GetItem();
user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true); user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true);
container->Clear(); container->Clear();
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::legacy::SlotCursor, 0, 0); user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::legacy::SlotCursor, 0, 0);
@ -537,7 +537,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
user->Message_StringID(MT_Skills, TRADESKILL_MISSING_COMPONENTS); user->Message_StringID(MT_Skills, TRADESKILL_MISSING_COMPONENTS);
for (auto it = MissingItems.begin(); it != MissingItems.end(); ++it) { for (auto it = MissingItems.begin(); it != MissingItems.end(); ++it) {
const EQEmu::Item_Struct* item = database.GetItem(*it); const EQEmu::ItemBase* item = database.GetItem(*it);
if(item) if(item)
user->Message_StringID(MT_Skills, TRADESKILL_MISSING_ITEM, item->Name); user->Message_StringID(MT_Skills, TRADESKILL_MISSING_ITEM, item->Name);
@ -962,7 +962,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
aa_chance = spellbonuses.ReduceTradeskillFail[spec->tradeskill] + itembonuses.ReduceTradeskillFail[spec->tradeskill] + aabonuses.ReduceTradeskillFail[spec->tradeskill]; aa_chance = spellbonuses.ReduceTradeskillFail[spec->tradeskill] + itembonuses.ReduceTradeskillFail[spec->tradeskill] + aabonuses.ReduceTradeskillFail[spec->tradeskill];
const EQEmu::Item_Struct* item = nullptr; const EQEmu::ItemBase* item = nullptr;
chance = mod_tradeskill_chance(chance, spec); chance = mod_tradeskill_chance(chance, spec);
@ -1113,7 +1113,7 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
if (!inst) if (!inst)
continue; continue;
const EQEmu::Item_Struct* item = GetItem(inst->GetItem()->ID); const EQEmu::ItemBase* item = GetItem(inst->GetItem()->ID);
if (!item) if (!item)
continue; continue;
@ -1242,7 +1242,7 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
if(!inst) if(!inst)
continue; continue;
const EQEmu::Item_Struct* item = GetItem(inst->GetItem()->ID); const EQEmu::ItemBase* item = GetItem(inst->GetItem()->ID);
if (!item) if (!item)
continue; continue;

24
zone/trading.cpp
View File

@ -885,7 +885,7 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
continue; continue;
} }
const EQEmu::Item_Struct* item = inst->GetItem(); const EQEmu::ItemBase* item = inst->GetItem();
if(item && quest_npc == false) { if(item && quest_npc == false) {
// if it was not a NO DROP or Attuned item (or if a GM is trading), let the NPC have it // if it was not a NO DROP or Attuned item (or if a GM is trading), let the NPC have it
if(GetGM() || (item->NoDrop != 0 && inst->IsAttuned() == false)) { if(GetGM() || (item->NoDrop != 0 && inst->IsAttuned() == false)) {
@ -894,7 +894,7 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
for (int16 bslot = SUB_INDEX_BEGIN; bslot < item->BagSlots; bslot++) { for (int16 bslot = SUB_INDEX_BEGIN; bslot < item->BagSlots; bslot++) {
const ItemInst* baginst = inst->GetItem(bslot); const ItemInst* baginst = inst->GetItem(bslot);
if (baginst) { if (baginst) {
const EQEmu::Item_Struct* bagitem = baginst->GetItem(); const EQEmu::ItemBase* bagitem = baginst->GetItem();
if (bagitem && (GetGM() || (bagitem->NoDrop != 0 && baginst->IsAttuned() == false))) { if (bagitem && (GetGM() || (bagitem->NoDrop != 0 && baginst->IsAttuned() == false))) {
tradingWith->CastToNPC()->AddLootDrop(bagitem, &tradingWith->CastToNPC()->itemlist, tradingWith->CastToNPC()->AddLootDrop(bagitem, &tradingWith->CastToNPC()->itemlist,
baginst->GetCharges(), 1, 127, true, true); baginst->GetCharges(), 1, 127, true, true);
@ -1158,7 +1158,7 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
std::string Packet; std::string Packet;
int16 FreeSlotID=0; int16 FreeSlotID=0;
const EQEmu::Item_Struct* item = database.GetItem(ItemID); const EQEmu::ItemBase* item = database.GetItem(ItemID);
if(!item){ if(!item){
Log.Out(Logs::Detail, Logs::Trading, "Bogus item deleted in Client::SendTraderItem!\n"); Log.Out(Logs::Detail, Logs::Trading, "Bogus item deleted in Client::SendTraderItem!\n");
@ -1192,7 +1192,7 @@ void Client::SendSingleTraderItem(uint32 CharID, int SerialNumber) {
} }
void Client::BulkSendTraderInventory(uint32 char_id) { void Client::BulkSendTraderInventory(uint32 char_id) {
const EQEmu::Item_Struct *item; const EQEmu::ItemBase *item;
TraderCharges_Struct* TraderItems = database.LoadTraderItemWithCharges(char_id); TraderCharges_Struct* TraderItems = database.LoadTraderItemWithCharges(char_id);
@ -2027,7 +2027,7 @@ static void UpdateTraderCustomerItemsAdded(uint32 CustomerID, TraderCharges_Stru
if(!Customer) return; if(!Customer) return;
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) return; if(!item) return;
@ -2071,7 +2071,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
if(!Customer) return; if(!Customer) return;
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) return; if(!item) return;
@ -2230,7 +2230,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
} }
const EQEmu::Item_Struct *item = 0; const EQEmu::ItemBase *item = 0;
if(IDOfItemToAdd) if(IDOfItemToAdd)
item = database.GetItem(IDOfItemToAdd); item = database.GetItem(IDOfItemToAdd);
@ -2396,7 +2396,7 @@ void Client::SendBuyerResults(char* searchString, uint32 searchID) {
char *buf = (char *)outapp->pBuffer; char *buf = (char *)outapp->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(itemID); const EQEmu::ItemBase* item = database.GetItem(itemID);
if(!item) { if(!item) {
safe_delete(outapp); safe_delete(outapp);
@ -2492,7 +2492,7 @@ void Client::ShowBuyLines(const EQApplicationPacket *app) {
char *Buf = (char *)outapp->pBuffer; char *Buf = (char *)outapp->pBuffer;
const EQEmu::Item_Struct* item = database.GetItem(ItemID); const EQEmu::ItemBase* item = database.GetItem(ItemID);
if(!item) { if(!item) {
safe_delete(outapp); safe_delete(outapp);
@ -2536,7 +2536,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
/*uint32 BuyerID2 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused /*uint32 BuyerID2 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
/*uint32 Unknown3 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused /*uint32 Unknown3 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item || !Quantity || !Price || !QtyBuyerWants) return; if(!item || !Quantity || !Price || !QtyBuyerWants) return;
@ -2927,7 +2927,7 @@ void Client::UpdateBuyLine(const EQApplicationPacket *app) {
/*uint32 UnknownZ =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused /*uint32 UnknownZ =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
uint32 ItemCount = VARSTRUCT_DECODE_TYPE(uint32, Buf); uint32 ItemCount = VARSTRUCT_DECODE_TYPE(uint32, Buf);
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) return; if(!item) return;
@ -2991,7 +2991,7 @@ void Client::BuyerItemSearch(const EQApplicationPacket *app) {
BuyerItemSearchResults_Struct* bisr = (BuyerItemSearchResults_Struct*)outapp->pBuffer; BuyerItemSearchResults_Struct* bisr = (BuyerItemSearchResults_Struct*)outapp->pBuffer;
const EQEmu::Item_Struct* item = 0; const EQEmu::ItemBase* item = 0;
int Count=0; int Count=0;

2
zone/tune.cpp
View File

@ -630,7 +630,7 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass()) if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass())
{ {
ucDamageBonus = GetWeaponDamageBonus( weapon ? weapon->GetItem() : (const EQEmu::Item_Struct*) nullptr ); ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
min_hit += (int) ucDamageBonus; min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus; max_hit += (int) ucDamageBonus;

8
zone/zonedb.cpp
View File

@ -629,7 +629,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
int Charges = atoi(row[3]); int Charges = atoi(row[3]);
int Cost = atoi(row[4]); int Cost = atoi(row[4]);
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) { if(!item) {
Log.Out(Logs::Detail, Logs::Trading, "Unable to create item\n"); Log.Out(Logs::Detail, Logs::Trading, "Unable to create item\n");
@ -684,7 +684,7 @@ void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charg
Log.Out(Logs::Detail, Logs::Trading, "ZoneDatabase::UpdateTraderPrice(%i, %i, %i, %i)", CharID, ItemID, Charges, NewPrice); Log.Out(Logs::Detail, Logs::Trading, "ZoneDatabase::UpdateTraderPrice(%i, %i, %i, %i)", CharID, ItemID, Charges, NewPrice);
const EQEmu::Item_Struct *item = database.GetItem(ItemID); const EQEmu::ItemBase *item = database.GetItem(ItemID);
if(!item) if(!item)
return; return;
@ -1197,7 +1197,7 @@ bool ZoneDatabase::LoadCharacterBandolier(uint32 character_id, PlayerProfile_Str
i = atoi(row[r]); /* Bandolier ID */ r++; i = atoi(row[r]); /* Bandolier ID */ r++;
si = atoi(row[r]); /* Bandolier Slot */ r++; si = atoi(row[r]); /* Bandolier Slot */ r++;
const EQEmu::Item_Struct* item_data = database.GetItem(atoi(row[r])); const EQEmu::ItemBase* item_data = database.GetItem(atoi(row[r]));
if (item_data) { if (item_data) {
pp->bandoliers[i].Items[si].ID = item_data->ID; r++; pp->bandoliers[i].Items[si].ID = item_data->ID; r++;
pp->bandoliers[i].Items[si].Icon = atoi(row[r]); r++; // Must use db value in case an Ornamentation is assigned pp->bandoliers[i].Items[si].Icon = atoi(row[r]); r++; // Must use db value in case an Ornamentation is assigned
@ -1249,7 +1249,7 @@ bool ZoneDatabase::LoadCharacterPotions(uint32 character_id, PlayerProfile_Struc
for (auto row = results.begin(); row != results.end(); ++row) { for (auto row = results.begin(); row != results.end(); ++row) {
i = atoi(row[0]); i = atoi(row[0]);
const EQEmu::Item_Struct *item_data = database.GetItem(atoi(row[1])); const EQEmu::ItemBase *item_data = database.GetItem(atoi(row[1]));
if (!item_data) if (!item_data)
continue; continue;
pp->potionbelt.Items[i].ID = item_data->ID; pp->potionbelt.Items[i].ID = item_data->ID;