#include <Item.h>

Classes
struct	ValuesUpdateForPlayerWithMaskSender

Public Member Functions
Item *	CloneItem (uint32 count, Player const *player=nullptr) const

	Item ()

	~Item ()

virtual bool	Create (ObjectGuid::LowType guidlow, uint32 itemId, ItemContext context, Player const *owner)

std::string	GetNameForLocaleIdx (LocaleConstant locale) const override

ItemTemplate const *	GetTemplate () const

BonusData const *	GetBonus () const

ObjectGuid	GetOwnerGUID () const

void	SetOwnerGUID (ObjectGuid guid)

ObjectGuid	GetContainedIn () const

void	SetContainedIn (ObjectGuid guid)

ObjectGuid	GetCreator () const

void	SetCreator (ObjectGuid guid)

ObjectGuid	GetGiftCreator () const

void	SetGiftCreator (ObjectGuid guid)

Player *	GetOwner () const

void	SetExpiration (uint32 expiration)

ItemBondingType	GetBonding () const

void	SetBinding (bool val)

bool	HasItemFlag (ItemFieldFlags flag) const

void	SetItemFlag (ItemFieldFlags flags)

void	RemoveItemFlag (ItemFieldFlags flags)

void	ReplaceAllItemFlags (ItemFieldFlags flags)

bool	HasItemFlag2 (ItemFieldFlags2 flag) const

void	SetItemFlag2 (ItemFieldFlags2 flags)

void	RemoveItemFlag2 (ItemFieldFlags2 flags)

void	ReplaceAllItemFlags2 (ItemFieldFlags2 flags)

bool	IsSoulBound () const

bool	IsBoundAccountWide () const

bool	IsBattlenetAccountBound () const

bool	IsBindedNotWith (Player const *player) const

bool	IsBoundByEnchant () const

virtual void	SaveToDB (CharacterDatabaseTransaction trans)

virtual bool	LoadFromDB (ObjectGuid::LowType guid, ObjectGuid ownerGuid, Field *fields, uint32 entry)

void	LoadArtifactData (Player const *owner, uint64 xp, uint32 artifactAppearanceId, uint32 artifactTier, std::vector< ArtifactPowerData > &powers)

void	CheckArtifactRelicSlotUnlock (Player const *owner)

void	AddBonuses (uint32 bonusListID)

std::vector< int32 > const &	GetBonusListIDs () const

void	SetBonuses (std::vector< int32 > bonusListIDs)

void	ClearBonuses ()

virtual void	DeleteFromDB (CharacterDatabaseTransaction trans)

void	DeleteFromInventoryDB (CharacterDatabaseTransaction trans)

void	SaveRefundDataToDB ()

void	DeleteRefundDataFromDB (CharacterDatabaseTransaction *trans)

Bag *	ToBag ()

Bag const *	ToBag () const

AzeriteItem *	ToAzeriteItem ()

AzeriteItem const *	ToAzeriteItem () const

AzeriteEmpoweredItem *	ToAzeriteEmpoweredItem ()

AzeriteEmpoweredItem const *	ToAzeriteEmpoweredItem () const

bool	IsRefundable () const

bool	IsBOPTradeable () const

bool	IsWrapped () const

bool	IsLocked () const

bool	IsBag () const

bool	IsAzeriteItem () const

bool	IsAzeriteEmpoweredItem () const

bool	IsCurrencyToken () const

bool	IsNotEmptyBag () const

bool	IsBroken () const

void	SetDurability (uint32 durability)

void	SetMaxDurability (uint32 maxDurability)

bool	CanBeTraded (bool mail=false, bool trade=false) const

void	SetInTrade (bool b=true)

bool	IsInTrade () const

uint64	CalculateDurabilityRepairCost (float discount) const

bool	HasEnchantRequiredSkill (Player const *player) const

uint32	GetEnchantRequiredLevel () const

bool	IsFitToSpellRequirements (SpellInfo const *spellInfo) const

bool	IsLimitedToAnotherMapOrZone (uint32 cur_mapId, uint32 cur_zoneId) const

bool	GemsFitSockets () const

uint32	GetCount () const

void	SetCount (uint32 value)

uint32	GetMaxStackCount () const

uint8	GetGemCountWithID (uint32 GemID) const

uint8	GetGemCountWithLimitCategory (uint32 limitCategory) const

InventoryResult	CanBeMergedPartlyWith (ItemTemplate const *proto) const

uint8	GetSlot () const

Bag *	GetContainer ()

uint8	GetBagSlot () const

void	SetSlot (uint8 slot)

uint16	GetPos () const

void	SetContainer (Bag *container)

bool	IsInBag () const

bool	IsEquipped () const

uint32	GetSkill ()

ItemRandomBonusListId	GetItemRandomBonusListId () const

void	SetItemRandomBonusList (ItemRandomBonusListId bonusListId)

void	SetEnchantment (EnchantmentSlot slot, uint32 id, uint32 duration, uint32 charges, ObjectGuid caster=ObjectGuid::Empty)

void	SetEnchantmentDuration (EnchantmentSlot slot, uint32 duration, Player *owner)

void	SetEnchantmentCharges (EnchantmentSlot slot, uint32 charges)

void	ClearEnchantment (EnchantmentSlot slot)

uint32	GetEnchantmentId (EnchantmentSlot slot) const

uint32	GetEnchantmentDuration (EnchantmentSlot slot) const

uint32	GetEnchantmentCharges (EnchantmentSlot slot) const

UF::SocketedGem const *	GetGem (uint16 slot) const

void	SetGem (uint16 slot, ItemDynamicFieldGems const *gem, uint32 gemScalingLevel)

std::string const &	GetText () const

void	SetText (std::string const &text)

void	SendUpdateSockets ()

void	SendTimeUpdate (Player *owner)

void	UpdateDuration (Player *owner, uint32 diff)

void	SetCreatePlayedTime (uint32 createPlayedTime)

int32	GetSpellCharges (uint8 index=0) const

void	SetSpellCharges (uint8 index, int32 value)

Loot *	GetLootForPlayer (Player const *) const override

ItemUpdateState	GetState () const

void	SetState (ItemUpdateState state, Player *forplayer=nullptr)

bool	IsInUpdateQueue () const

uint16	GetQueuePos () const

void	FSetState (ItemUpdateState state)

bool	hasQuest (uint32 quest_id) const override

bool	hasInvolvedQuest (uint32) const override

bool	IsPotion () const

bool	IsVellum () const

bool	IsConjuredConsumable () const

bool	IsRangedWeapon () const

uint32	GetQuality () const

uint32	GetItemLevel (Player const *owner) const

int32	GetRequiredLevel () const

int32	GetItemStatType (uint32 index) const

float	GetItemStatValue (uint32 index, Player const *owner) const

SocketColor	GetSocketColor (uint32 index) const

uint32	GetAppearanceModId () const

void	SetAppearanceModId (uint32 appearanceModId)

uint32	GetDisplayId (Player const *owner) const

ItemModifiedAppearanceEntry const *	GetItemModifiedAppearance () const

float	GetRepairCostMultiplier () const

uint32	GetScalingContentTuningId () const

ItemDisenchantLootEntry const *	GetDisenchantLoot (Player const *owner) const

void	SetFixedLevel (uint8 level)

Trinity::IteratorPair< ItemEffectEntry const const >	GetEffects () const

void	SetNotRefundable (Player owner, bool changestate=true, CharacterDatabaseTransaction trans=nullptr, bool addToCollection=true)

void	SetRefundRecipient (ObjectGuid const &guid)

void	SetPaidMoney (uint64 money)

void	SetPaidExtendedCost (uint32 iece)

ObjectGuid const &	GetRefundRecipient () const

uint64	GetPaidMoney () const

uint32	GetPaidExtendedCost () const

void	UpdatePlayedTime (Player *owner)

uint32	GetPlayedTime ()

bool	IsRefundExpired ()

void	SetSoulboundTradeable (GuidSet const &allowedLooters)

void	ClearSoulboundTradeable (Player *currentOwner)

bool	CheckSoulboundTradeExpire ()

void	BuildUpdate (UpdateDataMapType &) override

void	BuildValuesUpdateWithFlag (ByteBuffer data, UF::UpdateFieldFlag flags, Player const target) const override

void	BuildValuesUpdateForPlayerWithMask (UpdateData data, UF::ObjectData::Mask const &requestedObjectMask, UF::ItemData::Mask const &requestedItemMask, Player const target) const

bool	AddToObjectUpdate () override

void	RemoveFromObjectUpdate () override

uint32	GetScriptId () const

bool	IsValidTransmogrificationTarget () const

bool	HasStats () const

uint32	GetBuyPrice (Player const *owner, bool &standardPrice) const

uint32	GetSellPrice (Player const *owner) const

uint32	GetVisibleEntry (Player const *owner) const

uint16	GetVisibleAppearanceModId (Player const *owner) const

int32	GetVisibleSecondaryModifiedAppearanceId (Player const *owner) const

uint32	GetVisibleEnchantmentId (Player const *owner) const

uint16	GetVisibleItemVisual (Player const *owner) const

uint32	GetModifier (ItemModifier modifier) const

void	SetModifier (ItemModifier modifier, uint32 value)

ObjectGuid	GetChildItem () const

void	SetChildItem (ObjectGuid childItem)

bool	IsArtifactDisabled () const

UF::ArtifactPower const *	GetArtifactPower (uint32 artifactPowerId) const

void	AddArtifactPower (ArtifactPowerData const *artifactPower)

void	SetArtifactPower (uint16 artifactPowerId, uint8 purchasedRank, uint8 currentRankWithBonus)

void	InitArtifactPowers (uint8 artifactId, uint8 artifactTier)

uint32	GetTotalUnlockedArtifactPowers () const

uint32	GetTotalPurchasedArtifactPowers () const

void	ApplyArtifactPowerEnchantmentBonuses (EnchantmentSlot slot, uint32 enchantId, bool apply, Player *owner)

void	CopyArtifactDataFromParent (Item *parent)

void	SetArtifactXP (uint64 xp)

void	GiveArtifactXp (uint64 amount, Item *sourceItem, uint32 artifactCategoryId)

ItemContext	GetContext () const

void	SetContext (ItemContext context)

void	SetPetitionId (uint32 petitionId)

void	SetPetitionNumSignatures (uint32 signatures)

std::string	GetDebugInfo () const override

Public Member Functions inherited from Object
virtual	~Object ()

bool	IsInWorld () const

virtual void	AddToWorld ()

virtual void	RemoveFromWorld ()

ObjectGuid const &	GetGUID () const

uint32	GetEntry () const

void	SetEntry (uint32 entry)

float	GetObjectScale () const

virtual void	SetObjectScale (float scale)

uint32	GetDynamicFlags () const

bool	HasDynamicFlag (uint32 flag) const

void	SetDynamicFlag (uint32 flag)

void	RemoveDynamicFlag (uint32 flag)

void	ReplaceAllDynamicFlags (uint32 flag)

TypeID	GetTypeId () const

bool	isType (uint16 mask) const

virtual void	BuildCreateUpdateBlockForPlayer (UpdateData data, Player target) const

void	SendUpdateToPlayer (Player *player)

void	BuildValuesUpdateBlockForPlayer (UpdateData data, Player const target) const

void	BuildValuesUpdateBlockForPlayerWithFlag (UpdateData data, UF::UpdateFieldFlag flags, Player const target) const

void	BuildDestroyUpdateBlock (UpdateData *data) const

void	BuildOutOfRangeUpdateBlock (UpdateData *data) const

ByteBuffer &	PrepareValuesUpdateBuffer (UpdateData *data) const

virtual void	DestroyForPlayer (Player *target) const

void	SendOutOfRangeForPlayer (Player *target) const

virtual void	ClearUpdateMask (bool remove)

virtual std::string	GetNameForLocaleIdx (LocaleConstant locale) const =0

virtual bool	hasQuest (uint32) const

virtual bool	hasInvolvedQuest (uint32) const

void	SetIsNewObject (bool enable)

bool	IsDestroyedObject () const

void	SetDestroyedObject (bool destroyed)

virtual void	BuildUpdate (UpdateDataMapType &)

void	BuildFieldsUpdate (Player *, UpdateDataMapType &) const

bool	IsPlayer () const

Player *	ToPlayer ()

Player const *	ToPlayer () const

bool	IsCreature () const

Creature *	ToCreature ()

Creature const *	ToCreature () const

bool	IsUnit () const

Unit *	ToUnit ()

Unit const *	ToUnit () const

bool	IsGameObject () const

GameObject *	ToGameObject ()

GameObject const *	ToGameObject () const

bool	IsCorpse () const

Corpse *	ToCorpse ()

Corpse const *	ToCorpse () const

bool	IsDynObject () const

DynamicObject *	ToDynObject ()

DynamicObject const *	ToDynObject () const

bool	IsAreaTrigger () const

AreaTrigger *	ToAreaTrigger ()

AreaTrigger const *	ToAreaTrigger () const

bool	IsSceneObject () const

SceneObject *	ToSceneObject ()

SceneObject const *	ToSceneObject () const

bool	IsConversation () const

Conversation *	ToConversation ()

Conversation const *	ToConversation () const

template<typename T >
void	ForceUpdateFieldChange (UF::UpdateFieldSetter< T > const &)

virtual std::string	GetDebugInfo () const

virtual Loot *	GetLootForPlayer (Player const *player) const

virtual void	BuildValuesUpdateWithFlag (ByteBuffer data, UF::UpdateFieldFlag flags, Player const target) const

Static Public Member Functions
static Item *	CreateItem (uint32 itemEntry, uint32 count, ItemContext context, Player const *player=nullptr)

static void	DeleteFromDB (CharacterDatabaseTransaction trans, ObjectGuid::LowType itemGuid)

static void	DeleteFromInventoryDB (CharacterDatabaseTransaction trans, ObjectGuid::LowType itemGuid)

static uint32	GetItemLevel (ItemTemplate const *itemTemplate, BonusData const &bonusData, uint32 level, uint32 fixedLevel, uint32 minItemLevel, uint32 minItemLevelCutoff, uint32 maxItemLevel, bool pvpBonus, uint32 azeriteLevel)

static ItemDisenchantLootEntry const *	GetDisenchantLoot (ItemTemplate const *itemTemplate, uint32 quality, uint32 itemLevel)

static bool	HasStats (WorldPackets::Item::ItemInstance const &itemInstance, BonusData const *bonus)

static bool	CanTransmogrifyItemWithItem (Item const item, ItemModifiedAppearanceEntry const itemModifiedAppearance)

static uint32	GetBuyPrice (ItemTemplate const *proto, uint32 quality, uint32 itemLevel, bool &standardPrice)

static uint32	GetSellPrice (ItemTemplate const *proto, uint32 quality, uint32 itemLevel)

Static Public Member Functions inherited from Object
static ObjectGuid	GetGUID (Object const *o)

static Player *	ToPlayer (Object *o)

static Player const *	ToPlayer (Object const *o)

static Creature *	ToCreature (Object *o)

static Creature const *	ToCreature (Object const *o)

static Unit *	ToUnit (Object *o)

static Unit const *	ToUnit (Object const *o)

static GameObject *	ToGameObject (Object *o)

static GameObject const *	ToGameObject (Object const *o)

static Corpse *	ToCorpse (Object *o)

static Corpse const *	ToCorpse (Object const *o)

static DynamicObject *	ToDynObject (Object *o)

static DynamicObject const *	ToDynObject (Object const *o)

static AreaTrigger *	ToAreaTrigger (Object *o)

static AreaTrigger const *	ToAreaTrigger (Object const *o)

static SceneObject *	ToSceneObject (Object *o)

static SceneObject const *	ToSceneObject (Object const *o)

static Conversation *	ToConversation (Object *o)

static Conversation const *	ToConversation (Object const *o)

Public Attributes
std::unique_ptr< Loot >	m_loot

bool	m_lootGenerated

UF::UpdateField< UF::ItemData, 0, TYPEID_ITEM >	m_itemData

Public Attributes inherited from Object
UF::UpdateFieldHolder	m_values

UF::UpdateField< UF::ObjectData, 0, TYPEID_OBJECT >	m_objectData

Protected Member Functions
UF::UpdateFieldFlag	GetUpdateFieldFlagsFor (Player const *target) const override

void	BuildValuesCreate (ByteBuffer data, Player const target) const override

void	BuildValuesUpdate (ByteBuffer data, Player const target) const override

void	ClearUpdateMask (bool remove) override

void	ApplyBonusList (uint32 itemBonusListId)

Protected Member Functions inherited from Object
	Object ()

void	_Create (ObjectGuid const &guid)

template<typename T >
void	SetUpdateFieldValue (UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type value)

template<typename T >
void	SetUpdateFieldFlagValue (UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type flag)

template<typename T >
void	RemoveUpdateFieldFlagValue (UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type flag)

template<typename T >
UF::DynamicUpdateFieldSetter< T >::insert_result	AddDynamicUpdateFieldValue (UF::DynamicUpdateFieldSetter< T > setter)

template<typename T >
UF::DynamicUpdateFieldSetter< T >::insert_result	InsertDynamicUpdateFieldValue (UF::DynamicUpdateFieldSetter< T > setter, uint32 index)

template<typename T >
void	RemoveDynamicUpdateFieldValue (UF::DynamicUpdateFieldSetter< T > setter, uint32 index)

template<typename T >
void	ClearDynamicUpdateFieldValues (UF::DynamicUpdateFieldSetter< T > setter)

template<typename T >
void	RemoveOptionalUpdateFieldValue (UF::OptionalUpdateFieldSetter< T > setter)

template<typename T >
void	SetUpdateFieldStatValue (UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type value)

template<typename T >
void	ApplyModUpdateFieldValue (UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type mod, bool apply)

template<typename T >
void	ApplyPercentModUpdateFieldValue (UF::UpdateFieldSetter< T > setter, float percent, bool apply)

template<typename Action >
void	DoWithSuppressingObjectUpdates (Action &&action)

void	BuildMovementUpdate (ByteBuffer data, CreateObjectBits flags, Player target) const

virtual UF::UpdateFieldFlag	GetUpdateFieldFlagsFor (Player const *target) const

virtual void	BuildValuesCreate (ByteBuffer data, Player const target) const =0

virtual void	BuildValuesUpdate (ByteBuffer data, Player const target) const =0

virtual bool	AddToObjectUpdate ()=0

virtual void	RemoveFromObjectUpdate ()=0

void	AddToObjectUpdateIfNeeded ()

Protected Attributes
BonusData	_bonusData

Protected Attributes inherited from Object
uint16	m_objectType

TypeID	m_objectTypeId

CreateObjectBits	m_updateFlag

bool	m_objectUpdated

Private Attributes
std::string	m_text

uint8	m_slot

Bag *	m_container

ItemUpdateState	uState

int16	uQueuePos

bool	mb_in_trade

time_t	m_lastPlayedTimeUpdate

ObjectGuid	m_refundRecipient

uint64	m_paidMoney

uint32	m_paidExtendedCost

GuidSet	allowedGUIDs

ItemRandomBonusListId	m_randomBonusListId

ObjectGuid	m_childItem

std::unordered_map< uint32, uint16 >	m_artifactPowerIdToIndex

std::array< uint32, MAX_ITEM_PROTO_SOCKETS >	m_gemScalingLevels

Friends
void	AddItemToUpdateQueueOf (Item item, Player player)

void	RemoveItemFromUpdateQueueOf (Item item, Player player)

Constructor & Destructor Documentation

◆ Item()

Item::Item ( )

{
 m_objectType |= TYPEMASK_ITEM;
 m_objectTypeId = TYPEID_ITEM;
 
 m_slot = 0;
 uState = ITEM_NEW;
 uQueuePos = -1;
 m_container = nullptr;
 m_lootGenerated = false;
 mb_in_trade = false;
 m_lastPlayedTimeUpdate = GameTime::GetGameTime();
 
 m_paidMoney = 0;
 m_paidExtendedCost = 0;
 
 m_randomBonusListId = 0;
 m_gemScalingLevels = { };
 
 memset(&_bonusData, 0, sizeof(_bonusData));
}

Here is the call graph for this function:

◆ ~Item()

Item::~Item ( )

default

Member Function Documentation

◆ AddArtifactPower()

void Item::AddArtifactPower ( ArtifactPowerData const * artifactPower )

{
 uint16 index = uint16(m_artifactPowerIdToIndex.size());
 m_artifactPowerIdToIndex[artifactPower->ArtifactPowerId] = index;
 
 UF::ArtifactPower& powerField = AddDynamicUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ArtifactPowers));
 powerField.ArtifactPowerID = artifactPower->ArtifactPowerId;
 powerField.PurchasedRank = artifactPower->PurchasedRank;
 powerField.CurrentRankWithBonus = artifactPower->CurrentRankWithBonus;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddBonuses()

void Item::AddBonuses ( uint32 bonusListID )

{
 if (std::find(GetBonusListIDs().begin(), GetBonusListIDs().end(), int32(bonusListID)) != GetBonusListIDs().end())
 return;
 
 if (DB2Manager::ItemBonusList const* bonuses = sDB2Manager.GetItemBonusList(bonusListID))
 {
 WorldPackets::Item::ItemBonusKey itemBonusKey;
 itemBonusKey.ItemID = GetEntry();
 itemBonusKey.BonusListIDs = GetBonusListIDs();
 itemBonusKey.BonusListIDs.push_back(bonusListID);
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemBonusKey), std::move(itemBonusKey));
 for (ItemBonusEntry const* bonus : *bonuses)
 _bonusData.AddBonus(bonus->Type, bonus->Value);
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemAppearanceModID), _bonusData.AppearanceModID);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddToObjectUpdate()

bool Item::AddToObjectUpdate ( )

overridevirtual

Implements Object.

{
 if (Player* owner = GetOwner())
 {
 owner->GetMap()->AddUpdateObject(this);
 return true;
 }
 
 return false;
}

Here is the call graph for this function:

◆ ApplyArtifactPowerEnchantmentBonuses()

void Item::ApplyArtifactPowerEnchantmentBonuses	(	EnchantmentSlot	slot,
		uint32	enchantId,
		bool	apply,
		Player *	owner
	)

{
 if (SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(enchantId))
 {
 for (uint32 i = 0; i < MAX_ITEM_ENCHANTMENT_EFFECTS; ++i)
 {
 switch (enchant->Effect[i])
 {
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_BY_TYPE:
 for (uint32 artifactPowerIndex = 0; artifactPowerIndex < m_itemData->ArtifactPowers.size(); ++artifactPowerIndex)
 {
 UF::ArtifactPower const& artifactPower = m_itemData->ArtifactPowers[artifactPowerIndex];
 if (uint32(sArtifactPowerStore.AssertEntry(artifactPower.ArtifactPowerID)->Label) == enchant->EffectArg[i])
 {
 uint8 newRank = artifactPower.CurrentRankWithBonus;
 if (apply)
 newRank += enchant->EffectPointsMin[i];
 else
 newRank -= enchant->EffectPointsMin[i];
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData)
 .ModifyValue(&UF::ItemData::ArtifactPowers, artifactPowerIndex)
 .ModifyValue(&UF::ArtifactPower::CurrentRankWithBonus), newRank);
 
 if (IsEquipped())
 if (ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(artifactPower.ArtifactPowerID, newRank ? newRank - 1 : 0))
 owner->ApplyArtifactPowerRank(this, artifactPowerRank, newRank != 0);
 }
 }
 break;
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_BY_ID:
 {
 if (uint16 const* artifactPowerIndex = Trinity::Containers::MapGetValuePtr(m_artifactPowerIdToIndex, enchant->EffectArg[i]))
 {
 uint8 newRank = m_itemData->ArtifactPowers[*artifactPowerIndex].CurrentRankWithBonus;
 if (apply)
 newRank += enchant->EffectPointsMin[i];
 else
 newRank -= enchant->EffectPointsMin[i];
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData)
 .ModifyValue(&UF::ItemData::ArtifactPowers, *artifactPowerIndex)
 .ModifyValue(&UF::ArtifactPower::CurrentRankWithBonus), newRank);
 
 if (IsEquipped())
 if (ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(m_itemData->ArtifactPowers[*artifactPowerIndex].ArtifactPowerID, newRank ? newRank - 1 : 0))
 owner->ApplyArtifactPowerRank(this, artifactPowerRank, newRank != 0);
 }
 break;
 }
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_PICKER:
 if (slot >= SOCK_ENCHANTMENT_SLOT && slot <= SOCK_ENCHANTMENT_SLOT_3 && _bonusData.GemRelicType[slot - SOCK_ENCHANTMENT_SLOT] != -1)
 {
 if (ArtifactPowerPickerEntry const* artifactPowerPicker = sArtifactPowerPickerStore.LookupEntry(enchant->EffectArg[i]))
 {
 PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(artifactPowerPicker->PlayerConditionID);
 if (!playerCondition || sConditionMgr->IsPlayerMeetingCondition(owner, playerCondition))
 {
 for (uint32 artifactPowerIndex = 0; artifactPowerIndex < m_itemData->ArtifactPowers.size(); ++artifactPowerIndex)
 {
 UF::ArtifactPower const& artifactPower = m_itemData->ArtifactPowers[artifactPowerIndex];
 if (sArtifactPowerStore.AssertEntry(artifactPower.ArtifactPowerID)->Label == _bonusData.GemRelicType[slot - SOCK_ENCHANTMENT_SLOT])
 {
 uint8 newRank = artifactPower.CurrentRankWithBonus;
 if (apply)
 newRank += enchant->EffectPointsMin[i];
 else
 newRank -= enchant->EffectPointsMin[i];
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData)
 .ModifyValue(&UF::ItemData::ArtifactPowers, artifactPowerIndex)
 .ModifyValue(&UF::ArtifactPower::CurrentRankWithBonus), newRank);
 
 if (IsEquipped())
 if (ArtifactPowerRankEntry const* artifactPowerRank = sDB2Manager.GetArtifactPowerRank(artifactPower.ArtifactPowerID, newRank ? newRank - 1 : 0))
 owner->ApplyArtifactPowerRank(this, artifactPowerRank, newRank != 0);
 }
 }
 }
 }
 }
 break;
 default:
 break;
 }
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyBonusList()

void Item::ApplyBonusList ( uint32 itemBonusListId )

protected

◆ BuildUpdate()

void Item::BuildUpdate ( UpdateDataMapType & data_map )

overridevirtual

Reimplemented from Object.

{
 if (Player* owner = GetOwner())
 BuildFieldsUpdate(owner, data_map);
 ClearUpdateMask(false);
}

Here is the call graph for this function:

◆ BuildValuesCreate()

void Item::BuildValuesCreate	(	ByteBuffer *	data,
		Player const *	target
	)		const

overrideprotectedvirtual

Implements Object.

{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint8(flags);
 m_objectData->WriteCreate(*data, flags, this, target);
 m_itemData->WriteCreate(*data, flags, this, target);
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}

Here is the call graph for this function:

◆ BuildValuesUpdate()

void Item::BuildValuesUpdate	(	ByteBuffer *	data,
		Player const *	target
	)		const

overrideprotectedvirtual

Implements Object.

{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint32(m_values.GetChangedObjectTypeMask());
 
 if (m_values.HasChanged(TYPEID_OBJECT))
 m_objectData->WriteUpdate(*data, flags, this, target);
 
 if (m_values.HasChanged(TYPEID_ITEM))
 m_itemData->WriteUpdate(*data, flags, this, target);
 
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}

Here is the call graph for this function:

◆ BuildValuesUpdateForPlayerWithMask()

void Item::BuildValuesUpdateForPlayerWithMask	(	UpdateData *	data,
		UF::ObjectData::Mask const &	requestedObjectMask,
		UF::ItemData::Mask const &	requestedItemMask,
		Player const *	target
	)		const

{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 UpdateMask<NUM_CLIENT_OBJECT_TYPES> valuesMask;
 if (requestedObjectMask.IsAnySet())
 valuesMask.Set(TYPEID_OBJECT);
 
 UF::ItemData::Mask itemMask = requestedItemMask;
 m_itemData->FilterDisallowedFieldsMaskForFlag(itemMask, flags);
 if (itemMask.IsAnySet())
 valuesMask.Set(TYPEID_ITEM);
 
 ByteBuffer& buffer = PrepareValuesUpdateBuffer(data);
 std::size_t sizePos = buffer.wpos();
 buffer << uint32(0);
 buffer << uint32(valuesMask.GetBlock(0));
 
 if (valuesMask[TYPEID_OBJECT])
 m_objectData->WriteUpdate(buffer, requestedObjectMask, true, this, target);
 
 if (valuesMask[TYPEID_ITEM])
 m_itemData->WriteUpdate(buffer, itemMask, true, this, target);
 
 buffer.put<uint32>(sizePos, buffer.wpos() - sizePos - 4);
 
 data->AddUpdateBlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildValuesUpdateWithFlag()

void Item::BuildValuesUpdateWithFlag	(	ByteBuffer *	data,
		UF::UpdateFieldFlag	flags,
		Player const *	target
	)		const

overridevirtual

Reimplemented from Object.

{
 UpdateMask<NUM_CLIENT_OBJECT_TYPES> valuesMask;
 valuesMask.Set(TYPEID_ITEM);
 
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint32(valuesMask.GetBlock(0));
 
 UF::ItemData::Mask mask;
 m_itemData->AppendAllowedFieldsMaskForFlag(mask, flags);
 m_itemData->WriteUpdate(*data, mask, true, this, target);
 
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}

Here is the call graph for this function:

◆ CalculateDurabilityRepairCost()

uint64 Item::CalculateDurabilityRepairCost ( float discount ) const

{
 uint32 maxDurability = m_itemData->MaxDurability;
 if (!maxDurability)
 return 0;
 
 uint32 curDurability = m_itemData->Durability;
 ASSERT(maxDurability >= curDurability);
 
 uint32 lostDurability = maxDurability - curDurability;
 if (!lostDurability)
 return 0;
 
 ItemTemplate const* itemTemplate = GetTemplate();
 
 DurabilityCostsEntry const* durabilityCost = sDurabilityCostsStore.LookupEntry(GetItemLevel(GetOwner()));
 if (!durabilityCost)
 return 0;
 
 uint32 durabilityQualityEntryId = (GetQuality() + 1) * 2;
 DurabilityQualityEntry const* durabilityQualityEntry = sDurabilityQualityStore.LookupEntry(durabilityQualityEntryId);
 if (!durabilityQualityEntry)
 return 0;
 
 uint32 dmultiplier = 0;
 if (itemTemplate->GetClass() == ITEM_CLASS_WEAPON)
 dmultiplier = durabilityCost->WeaponSubClassCost[itemTemplate->GetSubClass()];
 else if (itemTemplate->GetClass() == ITEM_CLASS_ARMOR)
 dmultiplier = durabilityCost->ArmorSubClassCost[itemTemplate->GetSubClass()];
 
 uint64 cost = std::round(lostDurability * dmultiplier * durabilityQualityEntry->Data * GetRepairCostMultiplier());
 cost = uint64(cost * discount * sWorld->getRate(RATE_REPAIRCOST));
 
 if (cost == 0) // Fix for ITEM_QUALITY_ARTIFACT
 cost = 1;
 
 return cost;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanBeMergedPartlyWith()

InventoryResult Item::CanBeMergedPartlyWith ( ItemTemplate const * proto ) const

{
 // not allow merge looting currently items
 if (m_lootGenerated)
 return EQUIP_ERR_LOOT_GONE;
 
 // check item type
 if (GetEntry() != proto->GetId())
 return EQUIP_ERR_CANT_STACK;
 
 // check free space (full stacks can't be target of merge
 if (GetCount() >= proto->GetMaxStackSize())
 return EQUIP_ERR_CANT_STACK;
 
 return EQUIP_ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanBeTraded()

bool Item::CanBeTraded	(	bool	mail = `false`,
		bool	trade = `false`
	)		const

{
 if (m_lootGenerated)
 return false;
 
 if ((!mail || !IsBoundAccountWide()) && (IsSoulBound() && (!IsBOPTradeable() || !trade)))
 return false;
 
 if (IsBag() && (Player::IsBagPos(GetPos()) || !ToBag()->IsEmpty()))
 return false;
 
 if (Player* owner = GetOwner())
 {
 if (owner->CanUnequipItem(GetPos(), false) != EQUIP_ERR_OK)
 return false;
 if (owner->GetLootGUID() == GetGUID())
 return false;
 }
 
 if (IsBoundByEnchant())
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanTransmogrifyItemWithItem()

bool Item::CanTransmogrifyItemWithItem	(	Item const *	item,
		ItemModifiedAppearanceEntry const *	itemModifiedAppearance
	)

static

{
 ItemTemplate const* source = sObjectMgr->GetItemTemplate(itemModifiedAppearance->ItemID); // source
 ItemTemplate const* target = item->GetTemplate(); // dest
 
 if (!source || !target)
 return false;
 
 if (itemModifiedAppearance == item->GetItemModifiedAppearance())
 return false;
 
 if (!item->IsValidTransmogrificationTarget())
 return false;
 
 if (source->GetClass() != target->GetClass())
 return false;
 
 if (source->GetInventoryType() == INVTYPE_BAG ||
 source->GetInventoryType() == INVTYPE_RELIC ||
 source->GetInventoryType() == INVTYPE_FINGER ||
 source->GetInventoryType() == INVTYPE_TRINKET ||
 source->GetInventoryType() == INVTYPE_AMMO ||
 source->GetInventoryType() == INVTYPE_QUIVER)
 return false;
 
 if (source->GetSubClass() != target->GetSubClass())
 {
 switch (source->GetClass())
 {
 case ITEM_CLASS_WEAPON:
 if (GetTransmogrificationWeaponCategory(source) != GetTransmogrificationWeaponCategory(target))
 return false;
 break;
 case ITEM_CLASS_ARMOR:
 if (source->GetSubClass() != ITEM_SUBCLASS_ARMOR_COSMETIC)
 return false;
 if (source->GetInventoryType() != target->GetInventoryType())
 if (ItemTransmogrificationSlots[source->GetInventoryType()] != ItemTransmogrificationSlots[target->GetInventoryType()])
 return false;
 break;
 default:
 return false;
 }
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckArtifactRelicSlotUnlock()

void Item::CheckArtifactRelicSlotUnlock ( Player const * owner )

{
 if (!owner)
  return;
 
 uint8 artifactId = GetTemplate()->GetArtifactID();
 if (!artifactId)
 return;
 
 for (ArtifactUnlockEntry const* artifactUnlock : sArtifactUnlockStore)
 if (artifactUnlock->ArtifactID == artifactId)
 if (owner->MeetPlayerCondition(artifactUnlock->PlayerConditionID))
 AddBonuses(artifactUnlock->ItemBonusListID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckSoulboundTradeExpire()

bool Item::CheckSoulboundTradeExpire ( )

{
 // called from owner's update - GetOwner() MUST be valid
 if (m_itemData->CreatePlayedTime + 2*HOUR < GetOwner()->GetTotalPlayedTime())
 {
 ClearSoulboundTradeable(GetOwner());
 return true; // remove from tradeable list
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearBonuses()

void Item::ClearBonuses ( )

{
 WorldPackets::Item::ItemBonusKey itemBonusKey;
 itemBonusKey.ItemID = GetEntry();
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemBonusKey), std::move(itemBonusKey));
 _bonusData.Initialize(GetTemplate());
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemAppearanceModID), _bonusData.AppearanceModID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearEnchantment()

void Item::ClearEnchantment ( EnchantmentSlot slot )

{
 if (!GetEnchantmentId(slot))
 return;
 
 auto enchantmentField = m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Enchantment, slot);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::ID), 0);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Duration), 0);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Charges), 0);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Inactive), 0);
 SetState(ITEM_CHANGED, GetOwner());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearSoulboundTradeable()

void Item::ClearSoulboundTradeable ( Player * currentOwner )

{
 RemoveItemFlag(ITEM_FIELD_FLAG_BOP_TRADEABLE);
 if (allowedGUIDs.empty())
 return;
 
 currentOwner->GetSession()->GetCollectionMgr()->AddItemAppearance(this);
 allowedGUIDs.clear();
 SetState(ITEM_CHANGED, currentOwner);
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_BOP_TRADE);
 stmt->setUInt64(0, GetGUID().GetCounter());
 CharacterDatabase.Execute(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearUpdateMask()

void Item::ClearUpdateMask ( bool remove )

overrideprotectedvirtual

Reimplemented from Object.

{
 m_values.ClearChangesMask(&Item::m_itemData);
 Object::ClearUpdateMask(remove);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloneItem()

Item * Item::CloneItem	(	uint32	count,
		Player const *	player = `nullptr`
	)		const

{
 Item* newItem = CreateItem(GetEntry(), count, GetContext(), player);
 if (!newItem)
 return nullptr;
 
 newItem->SetCreator(GetCreator());
 newItem->SetGiftCreator(GetGiftCreator());
 newItem->ReplaceAllItemFlags(ItemFieldFlags(*m_itemData->DynamicFlags) & ~(ITEM_FIELD_FLAG_REFUNDABLE | ITEM_FIELD_FLAG_BOP_TRADEABLE));
 newItem->SetExpiration(m_itemData->Expiration);
 // player CAN be NULL in which case we must not update random properties because that accesses player's item update queue
 if (player)
 newItem->SetItemRandomBonusList(m_randomBonusListId);
 return newItem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyArtifactDataFromParent()

void Item::CopyArtifactDataFromParent ( Item * parent )

{
 memcpy(_bonusData.GemItemLevelBonus, parent->GetBonus()->GemItemLevelBonus, sizeof(_bonusData.GemItemLevelBonus));
 SetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID, parent->GetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID));
 SetAppearanceModId(parent->GetAppearanceModId());
}

Here is the call graph for this function:

◆ Create()

bool Item::Create	(	ObjectGuid::LowType	guidlow,
		uint32	itemId,
		ItemContext	context,
		Player const *	owner
	)

virtual

Reimplemented in AzeriteEmpoweredItem, AzeriteItem, and Bag.

{
 Object::_Create(ObjectGuid::Create<HighGuid::Item>(guidlow));
 
 SetEntry(itemId);
 SetObjectScale(1.0f);
 
 if (owner)
 {
 SetOwnerGUID(owner->GetGUID());
 SetContainedIn(owner->GetGUID());
 }
 
 ItemTemplate const* itemProto = sObjectMgr->GetItemTemplate(itemId);
 if (!itemProto)
 return false;
 
 _bonusData.Initialize(itemProto);
 SetCount(1);
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::MaxDurability), itemProto->MaxDurability);
 SetDurability(itemProto->MaxDurability);
 
 for (std::size_t i = 0; i < itemProto->Effects.size(); ++i)
 if (itemProto->Effects[i]->LegacySlotIndex < 5)
 SetSpellCharges(itemProto->Effects[i]->LegacySlotIndex, itemProto->Effects[i]->Charges);
 
 SetExpiration(itemProto->GetDuration());
 SetCreatePlayedTime(0);
 SetContext(context);
 
 if (itemProto->GetArtifactID())
 {
 InitArtifactPowers(itemProto->GetArtifactID(), 0);
 for (ArtifactAppearanceEntry const* artifactAppearance : sArtifactAppearanceStore)
 {
 if (ArtifactAppearanceSetEntry const* artifactAppearanceSet = sArtifactAppearanceSetStore.LookupEntry(artifactAppearance->ArtifactAppearanceSetID))
 {
 if (itemProto->GetArtifactID() != artifactAppearanceSet->ArtifactID)
 continue;
 
 if (PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(artifactAppearance->UnlockPlayerConditionID))
 if (!owner || !sConditionMgr->IsPlayerMeetingCondition(owner, playerCondition))
 continue;
 
 SetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID, artifactAppearance->ID);
 SetAppearanceModId(artifactAppearance->ItemAppearanceModifierID);
 break;
 }
 }
 
 CheckArtifactRelicSlotUnlock(owner ? owner : GetOwner());
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateItem()

Item * Item::CreateItem	(	uint32	itemEntry,
		uint32	count,
		ItemContext	context,
		Player const *	player = `nullptr`
	)

static

{
 if (count < 1)
 return nullptr; //don't create item at zero count
 
 ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemEntry);
 if (proto)
 {
 if (count > proto->GetMaxStackSize())
 count = proto->GetMaxStackSize();
 
 ASSERT_NODEBUGINFO(count != 0, "proto->Stackable == 0 but checked at loading already");
 
 Item* item = NewItemOrBag(proto);
 if (item->Create(sObjectMgr->GetGenerator<HighGuid::Item>().Generate(), itemEntry, context, player))
 {
 item->SetCount(count);
 return item;
 }
 else
 delete item;
 }
 else
 ABORT();
 return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteFromDB() [1/2]

void Item::DeleteFromDB ( CharacterDatabaseTransaction trans )

virtual

Reimplemented in AzeriteEmpoweredItem, AzeriteItem, and Bag.

{
 DeleteFromDB(trans, GetGUID().GetCounter());
 
 // Delete the items if this is a container
 if (m_loot && !m_loot->isLooted())
 sLootItemStorage->RemoveStoredLootForContainer(GetGUID().GetCounter());
}

Here is the call graph for this function:

◆ DeleteFromDB() [2/2]

void Item::DeleteFromDB	(	CharacterDatabaseTransaction	trans,
		ObjectGuid::LowType	itemGuid
	)

static

{
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_GEMS);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_TRANSMOG);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT_POWERS);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_MODIFIERS);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
 stmt->setUInt64(0, itemGuid);
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteFromInventoryDB() [1/2]

void Item::DeleteFromInventoryDB ( CharacterDatabaseTransaction trans )

{
 DeleteFromInventoryDB(trans, GetGUID().GetCounter());
}

Here is the call graph for this function:

◆ DeleteFromInventoryDB() [2/2]

void Item::DeleteFromInventoryDB	(	CharacterDatabaseTransaction	trans,
		ObjectGuid::LowType	itemGuid
	)

static

{
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INVENTORY_BY_ITEM);
 stmt->setUInt64(0, itemGuid);
 trans->Append(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteRefundDataFromDB()

void Item::DeleteRefundDataFromDB ( CharacterDatabaseTransaction * trans )

{
 if (trans)
 {
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_REFUND_INSTANCE);
 stmt->setUInt64(0, GetGUID().GetCounter());
 (*trans)->Append(stmt);
 
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FSetState()

void Item::FSetState ( ItemUpdateState state )

inline

 {
 uState = state;
 }

Here is the caller graph for this function:

◆ GemsFitSockets()

bool Item::GemsFitSockets ( ) const

{
 uint32 gemSlot = 0;
 for (UF::SocketedGem const& gemData : m_itemData->Gems)
 {
 SocketColor color = GetTemplate()->GetSocketColor(gemSlot);
 if (!color) // no socket slot
 continue;
 
 uint32 GemColor = 0;
 
 ItemTemplate const* gemProto = sObjectMgr->GetItemTemplate(gemData.ItemID);
 if (gemProto)
 {
 GemPropertiesEntry const* gemProperty = sGemPropertiesStore.LookupEntry(gemProto->GetGemProperties());
 if (gemProperty)
 GemColor = gemProperty->Type;
 }
 
 if (!(GemColor & SocketColorToGemTypeMask[color])) // bad gem color on this socket
 return false;
 }
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAppearanceModId()

uint32 Item::GetAppearanceModId ( ) const

inline

345{ return m_itemData->ItemAppearanceModID; }

Here is the caller graph for this function:

◆ GetArtifactPower()

UF::ArtifactPower const * Item::GetArtifactPower ( uint32 artifactPowerId ) const

{
 auto indexItr = m_artifactPowerIdToIndex.find(artifactPowerId);
 if (indexItr != m_artifactPowerIdToIndex.end())
 return &m_itemData->ArtifactPowers[indexItr->second];
 
 return nullptr;
}

Here is the caller graph for this function:

◆ GetBagSlot()

uint8 Item::GetBagSlot ( ) const

{
 return m_container ? m_container->GetSlot() : uint8(INVENTORY_SLOT_BAG_0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBonding()

ItemBondingType Item::GetBonding ( ) const

inline

200{ return _bonusData.Bonding; }

BonusData::Bonding

ItemBondingType Bonding

Definition: Item.h:77

Here is the caller graph for this function:

◆ GetBonus()

BonusData const * Item::GetBonus ( ) const

inline

186{ return &_bonusData; }

Here is the caller graph for this function:

◆ GetBonusListIDs()

std::vector< int32 > const & Item::GetBonusListIDs ( ) const

inline

229{ return m_itemData->ItemBonusKey->BonusListIDs; }

Here is the caller graph for this function:

◆ GetBuyPrice() [1/2]

uint32 Item::GetBuyPrice	(	ItemTemplate const *	proto,
		uint32	quality,
		uint32	itemLevel,
		bool &	standardPrice
	)

static

{
 standardPrice = false;
 
 if (proto->HasFlag(ITEM_FLAG2_OVERRIDE_GOLD_COST))
 return proto->GetBuyPrice();
 
 ImportPriceQualityEntry const* qualityPrice = sImportPriceQualityStore.LookupEntry(quality + 1);
 if (!qualityPrice)
 return 0;
 
 ItemPriceBaseEntry const* basePrice = sItemPriceBaseStore.LookupEntry(itemLevel);
 if (!basePrice)
 return 0;
 
 float qualityFactor = qualityPrice->Data;
 float baseFactor = 0.0f;
 
 uint32 inventoryType = proto->GetInventoryType();
 
 if (inventoryType == INVTYPE_WEAPON ||
 inventoryType == INVTYPE_2HWEAPON ||
 inventoryType == INVTYPE_WEAPONMAINHAND ||
 inventoryType == INVTYPE_WEAPONOFFHAND ||
 inventoryType == INVTYPE_RANGED ||
 inventoryType == INVTYPE_THROWN ||
 inventoryType == INVTYPE_RANGEDRIGHT)
 baseFactor = basePrice->Weapon;
 else
 baseFactor = basePrice->Armor;
 
 if (inventoryType == INVTYPE_ROBE)
 inventoryType = INVTYPE_CHEST;
 
 if (proto->GetClass() == ITEM_CLASS_GEM && proto->GetSubClass() == ITEM_SUBCLASS_GEM_ARTIFACT_RELIC)
 {
 inventoryType = INVTYPE_WEAPON;
 baseFactor = basePrice->Weapon / 3.0f;
 }
 
 float typeFactor = 0.0f;
 int8 weapType = -1;
 
 switch (inventoryType)
 {
 case INVTYPE_HEAD:
 case INVTYPE_NECK:
 case INVTYPE_SHOULDERS:
 case INVTYPE_CHEST:
 case INVTYPE_WAIST:
 case INVTYPE_LEGS:
 case INVTYPE_FEET:
 case INVTYPE_WRISTS:
 case INVTYPE_HANDS:
 case INVTYPE_FINGER:
 case INVTYPE_TRINKET:
 case INVTYPE_CLOAK:
 case INVTYPE_HOLDABLE:
 {
 ImportPriceArmorEntry const* armorPrice = sImportPriceArmorStore.LookupEntry(inventoryType);
 if (!armorPrice)
 return 0;
 
 switch (proto->GetSubClass())
 {
 case ITEM_SUBCLASS_ARMOR_MISCELLANEOUS:
 case ITEM_SUBCLASS_ARMOR_CLOTH:
 typeFactor = armorPrice->ClothModifier;
 break;
 case ITEM_SUBCLASS_ARMOR_LEATHER:
 typeFactor = armorPrice->LeatherModifier;
 break;
 case ITEM_SUBCLASS_ARMOR_MAIL:
 typeFactor = armorPrice->ChainModifier;
 break;
 case ITEM_SUBCLASS_ARMOR_PLATE:
 typeFactor = armorPrice->PlateModifier;
 break;
 default:
 typeFactor = 1.0f;
 break;
 }
 
 break;
 }
 case INVTYPE_SHIELD:
 {
 ImportPriceShieldEntry const* shieldPrice = sImportPriceShieldStore.LookupEntry(2);
 if (!shieldPrice)
 return 0;
 
 typeFactor = shieldPrice->Data;
 break;
 }
 case INVTYPE_WEAPONMAINHAND:
 weapType = 0;
 break;
 case INVTYPE_WEAPONOFFHAND:
 weapType = 1;
 break;
 case INVTYPE_WEAPON:
 weapType = 2;
 break;
 case INVTYPE_2HWEAPON:
 weapType = 3;
 break;
 case INVTYPE_RANGED:
 case INVTYPE_RANGEDRIGHT:
 case INVTYPE_RELIC:
 weapType = 4;
 break;
 default:
 return proto->GetBuyPrice();
 }
 
 if (weapType != -1)
 {
 ImportPriceWeaponEntry const* weaponPrice = sImportPriceWeaponStore.LookupEntry(weapType + 1);
 if (!weaponPrice)
 return 0;
 
 typeFactor = weaponPrice->Data;
 }
 
 standardPrice = false;
 return uint32(proto->GetPriceVariance() * typeFactor * baseFactor * qualityFactor * proto->GetPriceRandomValue());
}

Here is the call graph for this function:

◆ GetBuyPrice() [2/2]

uint32 Item::GetBuyPrice	(	Player const *	owner,
		bool &	standardPrice
	)		const

{
 return Item::GetBuyPrice(GetTemplate(), GetQuality(), GetItemLevel(owner), standardPrice);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChildItem()

ObjectGuid Item::GetChildItem ( ) const

inline

422{ return m_childItem; }

Item::m_childItem

ObjectGuid m_childItem

Definition: Item.h:467

Here is the caller graph for this function:

◆ GetContainedIn()

ObjectGuid Item::GetContainedIn ( ) const

inline

190{ return m_itemData->ContainedIn; }

◆ GetContainer()

Bag * Item::GetContainer ( )

inline

281{ return m_container; }

Here is the caller graph for this function:

◆ GetContext()

ItemContext Item::GetContext ( ) const

inline

440{ return ItemContext(*m_itemData->Context); }

ItemContext

Definition: DBCEnums.h:922

Here is the caller graph for this function:

◆ GetCount()

uint32 Item::GetCount ( ) const

inline

273{ return m_itemData->StackCount; }

Here is the caller graph for this function:

◆ GetCreator()

ObjectGuid Item::GetCreator ( ) const

inline

192{ return m_itemData->Creator; }

Here is the caller graph for this function:

◆ GetDebugInfo()

std::string Item::GetDebugInfo ( ) const

overridevirtual

Reimplemented from Object.

{
 std::stringstream sstr;
 sstr << Object::GetDebugInfo() << "\n"
 << std::boolalpha
 << "Owner: " << GetOwnerGUID().ToString() << " Count: " << GetCount()
 << " BagSlot: " << std::to_string(GetBagSlot()) << " Slot: " << std::to_string(GetSlot()) << " Equipped: " << IsEquipped();
 return sstr.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDisenchantLoot() [1/2]

ItemDisenchantLootEntry const * Item::GetDisenchantLoot	(	ItemTemplate const *	itemTemplate,
		uint32	quality,
		uint32	itemLevel
	)

static

{
 if (itemTemplate->HasFlag(ITEM_FLAG_CONJURED) || itemTemplate->HasFlag(ITEM_FLAG_NO_DISENCHANT) || itemTemplate->GetBonding() == BIND_QUEST)
 return nullptr;
 
 if (itemTemplate->GetArea(0) || itemTemplate->GetArea(1) || itemTemplate->GetMap() || itemTemplate->GetMaxStackSize() > 1)
 return nullptr;
 
 if (!Item::GetSellPrice(itemTemplate, quality, itemLevel) && !sDB2Manager.HasItemCurrencyCost(itemTemplate->GetId()))
 return nullptr;
 
 uint32 itemClass = itemTemplate->GetClass();
 int8 itemSubClass = itemTemplate->GetSubClass();
 uint8 expansion = itemTemplate->GetRequiredExpansion();
 for (ItemDisenchantLootEntry const* disenchant : sItemDisenchantLootStore)
 {
 if (disenchant->Class != itemClass)
 continue;
 
 if (disenchant->Subclass >= 0 && itemSubClass)
 continue;
 
 if (disenchant->Quality != quality)
 continue;
 
 if (disenchant->MinLevel > itemLevel || disenchant->MaxLevel < itemLevel)
 continue;
 
 if (disenchant->ExpansionID != -2 && disenchant->ExpansionID != expansion)
 continue;
 
 return disenchant;
 }
 
 return nullptr;
}

Here is the call graph for this function:

◆ GetDisenchantLoot() [2/2]

ItemDisenchantLootEntry const * Item::GetDisenchantLoot ( Player const * owner ) const

{
 if (!_bonusData.CanDisenchant)
 return nullptr;
 
 return Item::GetDisenchantLoot(GetTemplate(), GetQuality(), GetItemLevel(owner));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDisplayId()

uint32 Item::GetDisplayId ( Player const * owner ) const

{
 uint32 itemModifiedAppearanceId = GetModifier(AppearanceModifierSlotBySpec[owner->GetActiveTalentGroup()]);
 if (!itemModifiedAppearanceId)
 itemModifiedAppearanceId = GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS);
 
 if (ItemModifiedAppearanceEntry const* transmog = sItemModifiedAppearanceStore.LookupEntry(itemModifiedAppearanceId))
 if (ItemAppearanceEntry const* itemAppearance = sItemAppearanceStore.LookupEntry(transmog->ItemAppearanceID))
 return itemAppearance->ItemDisplayInfoID;
 
 return sDB2Manager.GetItemDisplayId(GetEntry(), GetAppearanceModId());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEffects()

Trinity::IteratorPair< ItemEffectEntry const *const * > Item::GetEffects ( ) const

inline

354{ return { std::make_pair(&_bonusData.Effects[0], &_bonusData.Effects[0] + _bonusData.EffectCount) }; }

BonusData::Effects

std::array< ItemEffectEntry const *, 13 > Effects

Definition: Item.h:91

BonusData::EffectCount

std::size_t EffectCount

Definition: Item.h:92

Here is the caller graph for this function:

◆ GetEnchantmentCharges()

uint32 Item::GetEnchantmentCharges ( EnchantmentSlot slot ) const

inline

300{ return m_itemData->Enchantment[slot].Charges; }

Here is the caller graph for this function:

◆ GetEnchantmentDuration()

uint32 Item::GetEnchantmentDuration ( EnchantmentSlot slot ) const

inline

299{ return m_itemData->Enchantment[slot].Duration; }

Here is the caller graph for this function:

◆ GetEnchantmentId()

uint32 Item::GetEnchantmentId ( EnchantmentSlot slot ) const

inline

298{ return m_itemData->Enchantment[slot].ID; }

Here is the caller graph for this function:

◆ GetEnchantRequiredLevel()

uint32 Item::GetEnchantRequiredLevel ( ) const

{
 uint32 level = 0;
 
 // Check all enchants for required level
 for (uint32 enchant_slot = PERM_ENCHANTMENT_SLOT; enchant_slot < MAX_ENCHANTMENT_SLOT; ++enchant_slot)
 if (uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot)))
 if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id))
 if (enchantEntry->MinLevel > level)
 level = enchantEntry->MinLevel;
 
 return level;
}

Here is the call graph for this function:

◆ GetGem()

UF::SocketedGem const * Item::GetGem ( uint16 slot ) const

{
 ASSERT(slot < MAX_GEM_SOCKETS);
 return slot < m_itemData->Gems.size() ? &m_itemData->Gems[slot] : nullptr;
}

Here is the caller graph for this function:

◆ GetGemCountWithID()

uint8 Item::GetGemCountWithID ( uint32 GemID ) const

{
 return uint8(std::count_if(m_itemData->Gems.begin(), m_itemData->Gems.end(), [GemID](UF::SocketedGem const& gemData)
 {
 return gemData.ItemID == int32(GemID);
 }));
}

Here is the caller graph for this function:

◆ GetGemCountWithLimitCategory()

uint8 Item::GetGemCountWithLimitCategory ( uint32 limitCategory ) const

{
 return uint8(std::count_if(m_itemData->Gems.begin(), m_itemData->Gems.end(), [limitCategory](UF::SocketedGem const& gemData)
 {
 ItemTemplate const* gemProto = sObjectMgr->GetItemTemplate(gemData.ItemID);
 if (!gemProto)
 return false;
 
 return gemProto->GetItemLimitCategory() == limitCategory;
 }));
}

Here is the caller graph for this function:

◆ GetGiftCreator()

ObjectGuid Item::GetGiftCreator ( ) const

inline

194{ return m_itemData->GiftCreator; }

Here is the caller graph for this function:

◆ GetItemLevel() [1/2]

uint32 Item::GetItemLevel	(	ItemTemplate const *	itemTemplate,
		BonusData const &	bonusData,
		uint32	level,
		uint32	fixedLevel,
		uint32	minItemLevel,
		uint32	minItemLevelCutoff,
		uint32	maxItemLevel,
		bool	pvpBonus,
		uint32	azeriteLevel
	)

static

{
 if (!itemTemplate)
 return MIN_ITEM_LEVEL;
 
 uint32 itemLevel = itemTemplate->GetBaseItemLevel();
 if (AzeriteLevelInfoEntry const* azeriteLevelInfo = sAzeriteLevelInfoStore.LookupEntry(azeriteLevel))
 itemLevel = azeriteLevelInfo->ItemLevel;
 
 if (bonusData.PlayerLevelToItemLevelCurveId)
 {
 if (fixedLevel)
 level = fixedLevel;
 else if (Optional<ContentTuningLevels> levels = sDB2Manager.GetContentTuningData(bonusData.ContentTuningId, 0, true))
 level = std::min(std::max(int16(level), levels->MinLevel), levels->MaxLevel);
 
 itemLevel = uint32(sDB2Manager.GetCurveValueAt(bonusData.PlayerLevelToItemLevelCurveId, level));
 }
 
 itemLevel += bonusData.ItemLevelBonus;
 
 for (uint32 i = 0; i < MAX_ITEM_PROTO_SOCKETS; ++i)
 itemLevel += bonusData.GemItemLevelBonus[i];
 
 uint32 itemLevelBeforeUpgrades = itemLevel;
 
 if (pvpBonus)
 itemLevel += sDB2Manager.GetPvpItemLevelBonus(itemTemplate->GetId());
 
 if (itemTemplate->GetInventoryType() != INVTYPE_NON_EQUIP)
 {
 if (minItemLevel && (!minItemLevelCutoff || itemLevelBeforeUpgrades >= minItemLevelCutoff) && itemLevel < minItemLevel)
  itemLevel = minItemLevel;
 
 if (maxItemLevel && itemLevel > maxItemLevel)
 itemLevel = maxItemLevel;
 }
 
 return std::min(std::max(itemLevel, uint32(MIN_ITEM_LEVEL)), uint32(MAX_ITEM_LEVEL));
}

Here is the call graph for this function:

◆ GetItemLevel() [2/2]

uint32 Item::GetItemLevel ( Player const * owner ) const

{
 ItemTemplate const* itemTemplate = GetTemplate();
 uint32 minItemLevel = owner->m_unitData->MinItemLevel;
 uint32 minItemLevelCutoff = owner->m_unitData->MinItemLevelCutoff;
 uint32 maxItemLevel = itemTemplate->HasFlag(ITEM_FLAG3_IGNORE_ITEM_LEVEL_CAP_IN_PVP) ? 0 : owner->m_unitData->MaxItemLevel;
 bool pvpBonus = owner->IsUsingPvpItemLevels();
 uint32 azeriteLevel = 0;
 if (AzeriteItem const* azeriteItem = ToAzeriteItem())
 azeriteLevel = azeriteItem->GetEffectiveLevel();
 return Item::GetItemLevel(itemTemplate, _bonusData, owner->GetLevel(), GetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL),
 minItemLevel, minItemLevelCutoff, maxItemLevel, pvpBonus, azeriteLevel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetItemModifiedAppearance()

ItemModifiedAppearanceEntry const * Item::GetItemModifiedAppearance ( ) const

{
  return sDB2Manager.GetItemModifiedAppearance(GetEntry(), _bonusData.AppearanceModID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetItemRandomBonusListId()

ItemRandomBonusListId Item::GetItemRandomBonusListId ( ) const

inline

292{ return m_randomBonusListId; }

Here is the caller graph for this function:

◆ GetItemStatType()

int32 Item::GetItemStatType ( uint32 index ) const

inline

342{ ASSERT(index < MAX_ITEM_PROTO_STATS); return _bonusData.ItemStatType[index]; }

MAX_ITEM_PROTO_STATS

#define MAX_ITEM_PROTO_STATS

Definition: DBCEnums.h:849

BonusData::ItemStatType

int32 ItemStatType[MAX_ITEM_PROTO_STATS]

Definition: Item.h:73

Here is the caller graph for this function:

◆ GetItemStatValue()

float Item::GetItemStatValue	(	uint32	index,
		Player const *	owner
	)		const

{
 ASSERT(index < MAX_ITEM_PROTO_STATS);
 switch (GetItemStatType(index))
 {
 case ITEM_MOD_CORRUPTION:
 case ITEM_MOD_CORRUPTION_RESISTANCE:
 return _bonusData.StatPercentEditor[index];
 default:
 break;
 }
 
 uint32 itemLevel = GetItemLevel(owner);
 if (float randomPropPoints = GetRandomPropertyPoints(itemLevel, GetQuality(), GetTemplate()->GetInventoryType(), GetTemplate()->GetSubClass()))
 {
 float statValue = float(_bonusData.StatPercentEditor[index] * randomPropPoints) * 0.0001f;
 if (GtItemSocketCostPerLevelEntry const* gtCost = sItemSocketCostPerLevelGameTable.GetRow(itemLevel))
 statValue -= float(int32(_bonusData.ItemStatSocketCostMultiplier[index] * gtCost->SocketCost));
 
 return statValue;
 }
 
 return 0.0f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLootForPlayer()

Loot * Item::GetLootForPlayer ( Player const * ) const

inlineoverridevirtual

Reimplemented from Object.

319{ return m_loot.get(); }

◆ GetMaxStackCount()

uint32 Item::GetMaxStackCount ( ) const

inline

275{ return GetTemplate()->GetMaxStackSize(); }

Here is the caller graph for this function:

◆ GetModifier()

uint32 Item::GetModifier ( ItemModifier modifier ) const

{
 int32 modifierIndex = m_itemData->Modifiers->Values.FindIndexIf([modifier](UF::ItemMod mod)
 {
 return mod.Type == modifier;
 });
 
 if (modifierIndex != -1)
 return m_itemData->Modifiers->Values[modifierIndex].Value;
 
 return 0;
}

Here is the caller graph for this function:

◆ GetNameForLocaleIdx()

std::string Item::GetNameForLocaleIdx ( LocaleConstant locale ) const

overridevirtual

Implements Object.

{
 ItemTemplate const* itemTemplate = GetTemplate();
 if (ItemNameDescriptionEntry const* suffix = sItemNameDescriptionStore.LookupEntry(_bonusData.Suffix))
 return Trinity::StringFormat("{} {}", itemTemplate->GetName(locale), suffix->Description[locale]);
 
 return itemTemplate->GetName(locale);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOwner()

Player * Item::GetOwner ( ) const

{
 return ObjectAccessor::FindPlayer(GetOwnerGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOwnerGUID()

ObjectGuid Item::GetOwnerGUID ( ) const

inline

188{ return m_itemData->Owner; }

Here is the caller graph for this function:

◆ GetPaidExtendedCost()

uint32 Item::GetPaidExtendedCost ( ) const

inline

364{ return m_paidExtendedCost; }

Here is the caller graph for this function:

◆ GetPaidMoney()

uint64 Item::GetPaidMoney ( ) const

inline

363{ return m_paidMoney; }

Here is the caller graph for this function:

◆ GetPlayedTime()

uint32 Item::GetPlayedTime ( )

{
 time_t curtime = GameTime::GetGameTime();
 uint32 elapsed = uint32(curtime - m_lastPlayedTimeUpdate);
 return *m_itemData->CreatePlayedTime + elapsed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPos()

uint16 Item::GetPos ( ) const

inline

284{ return uint16(GetBagSlot()) << 8 | GetSlot(); }

Here is the caller graph for this function:

◆ GetQuality()

uint32 Item::GetQuality ( ) const

inline

337{ return _bonusData.Quality; }

BonusData::Quality

uint32 Quality

Definition: Item.h:70

Here is the caller graph for this function:

◆ GetQueuePos()

uint16 Item::GetQueuePos ( ) const

inline

325{ return uQueuePos; }

Here is the caller graph for this function:

◆ GetRefundRecipient()

ObjectGuid const & Item::GetRefundRecipient ( ) const

inline

362{ return m_refundRecipient; }

Item::m_refundRecipient

ObjectGuid m_refundRecipient

Definition: Item.h:462

Here is the caller graph for this function:

◆ GetRepairCostMultiplier()

float Item::GetRepairCostMultiplier ( ) const

inline

349{ return _bonusData.RepairCostMultiplier; }

BonusData::RepairCostMultiplier

float RepairCostMultiplier

Definition: Item.h:79

Here is the caller graph for this function:

◆ GetRequiredLevel()

int32 Item::GetRequiredLevel ( ) const

{
 int32 fixedLevel = GetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL);
 if (_bonusData.RequiredLevelCurve)
 return sDB2Manager.GetCurveValueAt(_bonusData.RequiredLevelCurve, fixedLevel);
 if (_bonusData.RequiredLevelOverride)
 return _bonusData.RequiredLevelOverride;
 if (_bonusData.HasFixedLevel && _bonusData.PlayerLevelToItemLevelCurveId)
 return fixedLevel;
 return _bonusData.RequiredLevel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetScalingContentTuningId()

uint32 Item::GetScalingContentTuningId ( ) const

inline

350{ return _bonusData.ContentTuningId; }

BonusData::ContentTuningId

uint32 ContentTuningId

Definition: Item.h:80

Here is the caller graph for this function:

◆ GetScriptId()

uint32 Item::GetScriptId ( ) const

inline

402{ return GetTemplate()->ScriptId; }

ItemTemplate::ScriptId

uint32 ScriptId

Definition: ItemTemplate.h:813

Here is the caller graph for this function:

◆ GetSellPrice() [1/2]

uint32 Item::GetSellPrice	(	ItemTemplate const *	proto,
		uint32	quality,
		uint32	itemLevel
	)

static

{
 if (proto->HasFlag(ITEM_FLAG2_OVERRIDE_GOLD_COST))
 return proto->GetSellPrice();
 else
 {
 bool standardPrice;
 uint32 cost = Item::GetBuyPrice(proto, quality, itemLevel, standardPrice);
 
 if (standardPrice)
 {
 if (ItemClassEntry const* classEntry = sDB2Manager.GetItemClassByOldEnum(proto->GetClass()))
 {
 uint32 buyCount = std::max(proto->GetBuyCount(), 1u);
 return cost * classEntry->PriceModifier / buyCount;
 }
 
 return 0;
 }
 else
 return proto->GetSellPrice();
 }
 
 return 0;
}

Here is the call graph for this function:

◆ GetSellPrice() [2/2]

uint32 Item::GetSellPrice ( Player const * owner ) const

{
 return Item::GetSellPrice(GetTemplate(), GetQuality(), GetItemLevel(owner));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSkill()

uint32 Item::GetSkill ( )

{
 ItemTemplate const* proto = GetTemplate();
 return proto->GetSkill();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSlot()

uint8 Item::GetSlot ( ) const

inline

280{return m_slot;}

Here is the caller graph for this function:

◆ GetSocketColor()

SocketColor Item::GetSocketColor ( uint32 index ) const

inline

344{ ASSERT(index < MAX_ITEM_PROTO_SOCKETS); return SocketColor(_bonusData.SocketColor[index]); }

BonusData::SocketColor

uint32 SocketColor[MAX_ITEM_PROTO_SOCKETS]

Definition: Item.h:76

Here is the caller graph for this function:

◆ GetSpellCharges()

int32 Item::GetSpellCharges ( uint8 index = 0 ) const

inline

314{ return m_itemData->SpellCharges[index]; }

Here is the caller graph for this function:

◆ GetState()

ItemUpdateState Item::GetState ( ) const

inline

322{ return uState; }

Here is the caller graph for this function:

◆ GetTemplate()

ItemTemplate const * Item::GetTemplate ( ) const

{
 return sObjectMgr->GetItemTemplate(GetEntry());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetText()

std::string const & Item::GetText ( ) const

inline

304{ return m_text; }

Item::m_text

std::string m_text

Definition: Item.h:455

◆ GetTotalPurchasedArtifactPowers()

uint32 Item::GetTotalPurchasedArtifactPowers ( ) const

{
 uint32 purchasedRanks = 0;
 for (UF::ArtifactPower const& power : m_itemData->ArtifactPowers)
 purchasedRanks += power.PurchasedRank;
 
 return purchasedRanks;
}

Here is the caller graph for this function:

◆ GetTotalUnlockedArtifactPowers()

uint32 Item::GetTotalUnlockedArtifactPowers ( ) const

{
 uint32 purchased = GetTotalPurchasedArtifactPowers();
 uint64 artifactXp = m_itemData->ArtifactXP;
 uint32 currentArtifactTier = GetModifier(ITEM_MODIFIER_ARTIFACT_TIER);
 uint32 extraUnlocked = 0;
 do
 {
 uint64 xpCost = 0;
 if (GtArtifactLevelXPEntry const* cost = sArtifactLevelXPGameTable.GetRow(purchased + extraUnlocked + 1))
 xpCost = uint64(currentArtifactTier == MAX_ARTIFACT_TIER ? cost->XP2 : cost->XP);
 
 if (artifactXp < xpCost)
 break;
 
 artifactXp -= xpCost;
 ++extraUnlocked;
 
 } while (true);
 
 return purchased + extraUnlocked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetUpdateFieldFlagsFor()

UF::UpdateFieldFlag Item::GetUpdateFieldFlagsFor ( Player const * target ) const

overrideprotectedvirtual

Reimplemented from Object.

{
 if (target->GetGUID() == GetOwnerGUID())
 return UF::UpdateFieldFlag::Owner;
 
 return UF::UpdateFieldFlag::None;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVisibleAppearanceModId()

uint16 Item::GetVisibleAppearanceModId ( Player const * owner ) const

{
 uint32 itemModifiedAppearanceId = GetModifier(AppearanceModifierSlotBySpec[owner->GetActiveTalentGroup()]);
 if (!itemModifiedAppearanceId)
 itemModifiedAppearanceId = GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS);
 
 if (ItemModifiedAppearanceEntry const* transmog = sItemModifiedAppearanceStore.LookupEntry(itemModifiedAppearanceId))
 return transmog->ItemAppearanceModifierID;
 
 return uint16(GetAppearanceModId());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVisibleEnchantmentId()

uint32 Item::GetVisibleEnchantmentId ( Player const * owner ) const

{
 uint32 enchantmentId = GetModifier(IllusionModifierSlotBySpec[owner->GetActiveTalentGroup()]);
 if (!enchantmentId)
 enchantmentId = GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS);
 
 if (!enchantmentId)
 enchantmentId = GetEnchantmentId(PERM_ENCHANTMENT_SLOT);
 
 return enchantmentId;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVisibleEntry()

uint32 Item::GetVisibleEntry ( Player const * owner ) const

{
 uint32 itemModifiedAppearanceId = GetModifier(AppearanceModifierSlotBySpec[owner->GetActiveTalentGroup()]);
 if (!itemModifiedAppearanceId)
 itemModifiedAppearanceId = GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS);
 
 if (ItemModifiedAppearanceEntry const* transmog = sItemModifiedAppearanceStore.LookupEntry(itemModifiedAppearanceId))
 return transmog->ItemID;
 
 return GetEntry();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVisibleItemVisual()

uint16 Item::GetVisibleItemVisual ( Player const * owner ) const

{
 if (SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(GetVisibleEnchantmentId(owner)))
 return enchant->ItemVisual;
 
 return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVisibleSecondaryModifiedAppearanceId()

int32 Item::GetVisibleSecondaryModifiedAppearanceId ( Player const * owner ) const

{
 uint32 itemModifiedAppearanceId = GetModifier(SecondaryAppearanceModifierSlotBySpec[owner->GetActiveTalentGroup()]);
 if (!itemModifiedAppearanceId)
 itemModifiedAppearanceId = GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_ALL_SPECS);
 
 return itemModifiedAppearanceId;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GiveArtifactXp()

void Item::GiveArtifactXp	(	uint64	amount,
		Item *	sourceItem,
		uint32	artifactCategoryId
	)

{
 Player* owner = GetOwner();
 if (!owner)
 return;
 
 if (artifactCategoryId)
 {
 uint32 artifactKnowledgeLevel = 1;
 if (sourceItem && sourceItem->GetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL))
 artifactKnowledgeLevel = sourceItem->GetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL);
 
 if (GtArtifactKnowledgeMultiplierEntry const* artifactKnowledge = sArtifactKnowledgeMultiplierGameTable.GetRow(artifactKnowledgeLevel))
 amount = uint64(amount * artifactKnowledge->Multiplier);
 
 if (amount >= 5000)
 amount = 50 * (amount / 50);
 else if (amount >= 1000)
 amount = 25 * (amount / 25);
 else if (amount >= 50)
 amount = 5 * (amount / 5);
 }
 
 SetArtifactXP(m_itemData->ArtifactXP + amount);
 
 WorldPackets::Artifact::ArtifactXpGain artifactXpGain;
 artifactXpGain.ArtifactGUID = GetGUID();
 artifactXpGain.Amount = amount;
 owner->SendDirectMessage(artifactXpGain.Write());
 
 SetState(ITEM_CHANGED, owner);
}

Here is the call graph for this function:

◆ HasEnchantRequiredSkill()

bool Item::HasEnchantRequiredSkill ( Player const * player ) const

{
 // Check all enchants for required skill
 for (uint32 enchant_slot = PERM_ENCHANTMENT_SLOT; enchant_slot < MAX_ENCHANTMENT_SLOT; ++enchant_slot)
 {
 if (uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot)))
 if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id))
 if (enchantEntry->RequiredSkillID && player->GetSkillValue(enchantEntry->RequiredSkillID) < enchantEntry->RequiredSkillRank)
 return false;
 }
 
 return true;
}

Here is the call graph for this function:

◆ hasInvolvedQuest()

bool Item::hasInvolvedQuest ( uint32 ) const

inlineoverridevirtual

Reimplemented from Object.

332{ return false; }

◆ HasItemFlag()

bool Item::HasItemFlag ( ItemFieldFlags flag ) const

inline

208{ return (*m_itemData->DynamicFlags & flag) != 0; }

Here is the caller graph for this function:

◆ HasItemFlag2()

bool Item::HasItemFlag2 ( ItemFieldFlags2 flag ) const

inline

213{ return (*m_itemData->DynamicFlags2 & flag) != 0; }

◆ hasQuest()

bool Item::hasQuest ( uint32 quest_id ) const

inlineoverridevirtual

Reimplemented from Object.

331{ return GetTemplate()->GetStartQuest() == quest_id; }

ItemTemplate::GetStartQuest

uint32 GetStartQuest() const

Definition: ItemTemplate.h:791

◆ HasStats() [1/2]

bool Item::HasStats ( ) const

{
 ItemTemplate const* proto = GetTemplate();
 Player const* owner = GetOwner();
 for (uint8 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
 if ((owner ? GetItemStatValue(i, owner) : proto->GetStatPercentEditor(i)) != 0)
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasStats() [2/2]

bool Item::HasStats	(	WorldPackets::Item::ItemInstance const &	itemInstance,
		BonusData const *	bonus
	)

static

{
 for (uint8 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
 if (bonus->StatPercentEditor[i] != 0)
 return true;
 
 return false;
}

◆ InitArtifactPowers()

void Item::InitArtifactPowers	(	uint8	artifactId,
		uint8	artifactTier
	)

{
 for (ArtifactPowerEntry const* artifactPower : sDB2Manager.GetArtifactPowers(artifactId))
 {
 if (artifactPower->Tier != artifactTier)
 continue;
 
 if (m_artifactPowerIdToIndex.find(artifactPower->ID) != m_artifactPowerIdToIndex.end())
 continue;
 
 ArtifactPowerData powerData;
 powerData.ArtifactPowerId = artifactPower->ID;
 powerData.PurchasedRank = 0;
 powerData.CurrentRankWithBonus = (artifactPower->Flags & ARTIFACT_POWER_FLAG_FIRST) == ARTIFACT_POWER_FLAG_FIRST ? 1 : 0;
 AddArtifactPower(&powerData);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsArtifactDisabled()

bool Item::IsArtifactDisabled ( ) const

{
 if (ArtifactEntry const* artifact = sArtifactStore.LookupEntry(GetTemplate()->GetArtifactID()))
 return artifact->ArtifactCategoryID != 2; // fishing artifact
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAzeriteEmpoweredItem()

bool Item::IsAzeriteEmpoweredItem ( ) const

inline

254{ return GetTypeId() == TYPEID_AZERITE_EMPOWERED_ITEM; }

TYPEID_AZERITE_EMPOWERED_ITEM

@ TYPEID_AZERITE_EMPOWERED_ITEM

Definition: ObjectGuid.h:36

Object::GetTypeId

TypeID GetTypeId() const

Definition: Object.h:171

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAzeriteItem()

bool Item::IsAzeriteItem ( ) const

inline

253{ return GetTypeId() == TYPEID_AZERITE_ITEM; }

TYPEID_AZERITE_ITEM

@ TYPEID_AZERITE_ITEM

Definition: ObjectGuid.h:37

Here is the call graph for this function:

◆ IsBag()

bool Item::IsBag ( ) const

inline

252{ return GetTemplate()->GetInventoryType() == INVTYPE_BAG; }

Here is the caller graph for this function:

◆ IsBattlenetAccountBound()

bool Item::IsBattlenetAccountBound ( ) const

inline

220{ return GetTemplate()->HasFlag(ITEM_FLAG2_BNET_ACCOUNT_TRADE_OK); }

ITEM_FLAG2_BNET_ACCOUNT_TRADE_OK

@ ITEM_FLAG2_BNET_ACCOUNT_TRADE_OK

Definition: ItemTemplate.h:229

Here is the caller graph for this function:

◆ IsBindedNotWith()

bool Item::IsBindedNotWith ( Player const * player ) const

{
 // not binded item
 if (!IsSoulBound())
 return false;
 
 // own item
 if (GetOwnerGUID() == player->GetGUID())
 return false;
 
 if (IsBOPTradeable())
 if (allowedGUIDs.find(player->GetGUID()) != allowedGUIDs.end())
 return false;
 
 // BOA item case
 if (IsBoundAccountWide())
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsBOPTradeable()

bool Item::IsBOPTradeable ( ) const

inline

249{ return HasItemFlag(ITEM_FIELD_FLAG_BOP_TRADEABLE); }

Item::HasItemFlag

bool HasItemFlag(ItemFieldFlags flag) const

Definition: Item.h:208

Here is the caller graph for this function:

◆ IsBoundAccountWide()

bool Item::IsBoundAccountWide ( ) const

inline

219{ return GetTemplate()->HasFlag(ITEM_FLAG_IS_BOUND_TO_ACCOUNT); }

ITEM_FLAG_IS_BOUND_TO_ACCOUNT

@ ITEM_FLAG_IS_BOUND_TO_ACCOUNT

Definition: ItemTemplate.h:203

Here is the caller graph for this function:

◆ IsBoundByEnchant()

bool Item::IsBoundByEnchant ( ) const

{
 // Check all enchants for soulbound
 for (uint32 enchant_slot = PERM_ENCHANTMENT_SLOT; enchant_slot < MAX_ENCHANTMENT_SLOT; ++enchant_slot)
 if (uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot)))
 if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id))
 if (enchantEntry->GetFlags().HasFlag(SpellItemEnchantmentFlags::Soulbound))
 return true;
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsBroken()

bool Item::IsBroken ( ) const

inline

257{ return *m_itemData->MaxDurability > 0 && *m_itemData->Durability == 0; }

Here is the caller graph for this function:

◆ IsConjuredConsumable()

bool Item::IsConjuredConsumable ( ) const

inline

335{ return GetTemplate()->IsConjuredConsumable(); }

ItemTemplate::IsConjuredConsumable

bool IsConjuredConsumable() const

Definition: ItemTemplate.h:837

◆ IsCurrencyToken()

bool Item::IsCurrencyToken ( ) const

inline

255{ return GetTemplate()->IsCurrencyToken(); }

ItemTemplate::IsCurrencyToken

bool IsCurrencyToken() const

Definition: ItemTemplate.h:826

Here is the caller graph for this function:

◆ IsEquipped()

bool Item::IsEquipped ( ) const

{
 return !IsInBag() && (m_slot < EQUIPMENT_SLOT_END
 || (m_slot >= PROFESSION_SLOT_START && m_slot < PROFESSION_SLOT_END));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsFitToSpellRequirements()

bool Item::IsFitToSpellRequirements ( SpellInfo const * spellInfo ) const

{
 ItemTemplate const* proto = GetTemplate();
 
 bool isEnchantSpell = spellInfo->HasEffect(SPELL_EFFECT_ENCHANT_ITEM) || spellInfo->HasEffect(SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY) || spellInfo->HasEffect(SPELL_EFFECT_ENCHANT_ITEM_PRISMATIC);
 if (spellInfo->EquippedItemClass != -1) // -1 == any item class
 {
 if (isEnchantSpell && proto->HasFlag(ITEM_FLAG3_CAN_STORE_ENCHANTS))
 return true;
 
 if (spellInfo->EquippedItemClass != int32(proto->GetClass()))
 return false; // wrong item class
 
 if (spellInfo->EquippedItemSubClassMask != 0) // 0 == any subclass
 {
 if ((spellInfo->EquippedItemSubClassMask & (1 << proto->GetSubClass())) == 0)
 return false; // subclass not present in mask
 }
 }
 
 if (isEnchantSpell && spellInfo->EquippedItemInventoryTypeMask != 0) // 0 == any inventory type
 {
 // Special case - accept weapon type for main and offhand requirements
 if (proto->GetInventoryType() == INVTYPE_WEAPON &&
 (spellInfo->EquippedItemInventoryTypeMask & (1 << INVTYPE_WEAPONMAINHAND) ||
 spellInfo->EquippedItemInventoryTypeMask & (1 << INVTYPE_WEAPONOFFHAND)))
 return true;
 else if ((spellInfo->EquippedItemInventoryTypeMask & (1 << proto->GetInventoryType())) == 0)
 return false; // inventory type not present in mask
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsInBag()

bool Item::IsInBag ( ) const

inline

287{ return m_container != nullptr; }

Here is the caller graph for this function:

◆ IsInTrade()

bool Item::IsInTrade ( ) const

inline

262{ return mb_in_trade; }

Here is the caller graph for this function:

◆ IsInUpdateQueue()

bool Item::IsInUpdateQueue ( ) const

inline

324{ return uQueuePos != -1; }

Here is the caller graph for this function:

◆ IsLimitedToAnotherMapOrZone()

bool Item::IsLimitedToAnotherMapOrZone	(	uint32	cur_mapId,
		uint32	cur_zoneId
	)		const

{
 ItemTemplate const* proto = GetTemplate();
 return proto && ((proto->GetMap() && proto->GetMap() != cur_mapId) ||
 ((proto->GetArea(0) && proto->GetArea(0) != cur_zoneId) && (proto->GetArea(1) && proto->GetArea(1) != cur_zoneId)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsLocked()

bool Item::IsLocked ( ) const

inline

251{ return !HasItemFlag(ITEM_FIELD_FLAG_UNLOCKED); }

ITEM_FIELD_FLAG_UNLOCKED

@ ITEM_FIELD_FLAG_UNLOCKED

Definition: ItemTemplate.h:133

Here is the caller graph for this function:

◆ IsNotEmptyBag()

bool Item::IsNotEmptyBag ( ) const

{
 if (Bag const* bag = ToBag())
 return !bag->IsEmpty();
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsPotion()

bool Item::IsPotion ( ) const

inline

333{ return GetTemplate()->IsPotion(); }

ItemTemplate::IsPotion

bool IsPotion() const

Definition: ItemTemplate.h:835

Here is the caller graph for this function:

◆ IsRangedWeapon()

bool Item::IsRangedWeapon ( ) const

inline

336{ return GetTemplate()->IsRangedWeapon(); }

ItemTemplate::IsRangedWeapon

bool IsRangedWeapon() const

Definition: ItemTemplate.h:844

◆ IsRefundable()

bool Item::IsRefundable ( ) const

inline

248{ return HasItemFlag(ITEM_FIELD_FLAG_REFUNDABLE); }

Here is the caller graph for this function:

◆ IsRefundExpired()

bool Item::IsRefundExpired ( )

{
 return (GetPlayedTime() > 2*HOUR);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsSoulBound()

bool Item::IsSoulBound ( ) const

inline

218{ return HasItemFlag(ITEM_FIELD_FLAG_SOULBOUND); }

ITEM_FIELD_FLAG_SOULBOUND

@ ITEM_FIELD_FLAG_SOULBOUND

Definition: ItemTemplate.h:131

Here is the caller graph for this function:

◆ IsValidTransmogrificationTarget()

bool Item::IsValidTransmogrificationTarget ( ) const

{
 ItemTemplate const* proto = GetTemplate();
 if (!proto)
 return false;
 
 if (proto->GetClass() != ITEM_CLASS_ARMOR &&
 proto->GetClass() != ITEM_CLASS_WEAPON)
 return false;
 
 if (proto->GetClass() == ITEM_CLASS_WEAPON && proto->GetSubClass() == ITEM_SUBCLASS_WEAPON_FISHING_POLE)
 return false;
 
 if (proto->HasFlag(ITEM_FLAG2_NO_ALTER_ITEM_VISUAL))
 return false;
 
 if (!HasStats())
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsVellum()

bool Item::IsVellum ( ) const

inline

334{ return GetTemplate()->IsVellum(); }

ItemTemplate::IsVellum

bool IsVellum() const

Definition: ItemTemplate.h:836

Here is the caller graph for this function:

◆ IsWrapped()

bool Item::IsWrapped ( ) const

inline

250{ return HasItemFlag(ITEM_FIELD_FLAG_WRAPPED); }

ITEM_FIELD_FLAG_WRAPPED

@ ITEM_FIELD_FLAG_WRAPPED

Definition: ItemTemplate.h:134

Here is the caller graph for this function:

◆ LoadArtifactData()

void Item::LoadArtifactData	(	Player const *	owner,
		uint64	xp,
		uint32	artifactAppearanceId,
		uint32	artifactTier,
		std::vector< ArtifactPowerData > &	powers
	)

{
 for (uint8 i = 0; i <= artifactTier; ++i)
 InitArtifactPowers(GetTemplate()->GetArtifactID(), i);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ArtifactXP), xp);
 SetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID, artifactAppearanceId);
 SetModifier(ITEM_MODIFIER_ARTIFACT_TIER, artifactTier);
 
 if (ArtifactAppearanceEntry const* artifactAppearance = sArtifactAppearanceStore.LookupEntry(artifactAppearanceId))
 SetAppearanceModId(artifactAppearance->ItemAppearanceModifierID);
 
 uint8 totalPurchasedRanks = 0;
 for (ArtifactPowerData& power : powers)
 {
 power.CurrentRankWithBonus += power.PurchasedRank;
 totalPurchasedRanks += power.PurchasedRank;
 
 ArtifactPowerEntry const* artifactPower = sArtifactPowerStore.AssertEntry(power.ArtifactPowerId);
 for (uint32 e = SOCK_ENCHANTMENT_SLOT; e <= SOCK_ENCHANTMENT_SLOT_3; ++e)
 {
 if (SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(GetEnchantmentId(EnchantmentSlot(e))))
 {
 for (uint32 i = 0; i < MAX_ITEM_ENCHANTMENT_EFFECTS; ++i)
 {
 switch (enchant->Effect[i])
 {
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_BY_TYPE:
 if (uint32(artifactPower->Label) == enchant->EffectArg[i])
 power.CurrentRankWithBonus += enchant->EffectPointsMin[i];
 break;
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_BY_ID:
 if (artifactPower->ID == enchant->EffectArg[i])
 power.CurrentRankWithBonus += enchant->EffectPointsMin[i];
 break;
 case ITEM_ENCHANTMENT_TYPE_ARTIFACT_POWER_BONUS_RANK_PICKER:
 if (_bonusData.GemRelicType[e - SOCK_ENCHANTMENT_SLOT] != -1)
 {
 if (ArtifactPowerPickerEntry const* artifactPowerPicker = sArtifactPowerPickerStore.LookupEntry(enchant->EffectArg[i]))
 {
 PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(artifactPowerPicker->PlayerConditionID);
 if (!playerCondition || (owner && sConditionMgr->IsPlayerMeetingCondition(owner, playerCondition)))
 if (artifactPower->Label == _bonusData.GemRelicType[e - SOCK_ENCHANTMENT_SLOT])
 power.CurrentRankWithBonus += enchant->EffectPointsMin[i];
 }
 }
 break;
 default:
 break;
 }
 }
 }
 }
 
 SetArtifactPower(power.ArtifactPowerId, power.PurchasedRank, power.CurrentRankWithBonus);
 }
 
 for (ArtifactPowerData& power : powers)
 {
 ArtifactPowerEntry const* scaledArtifactPowerEntry = sArtifactPowerStore.AssertEntry(power.ArtifactPowerId);
 if (!(scaledArtifactPowerEntry->Flags & ARTIFACT_POWER_FLAG_SCALES_WITH_NUM_POWERS))
 continue;
 
 SetArtifactPower(power.ArtifactPowerId, power.PurchasedRank, totalPurchasedRanks + 1);
 }
 
 CheckArtifactRelicSlotUnlock(owner);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadFromDB()

bool Item::LoadFromDB	(	ObjectGuid::LowType	guid,
		ObjectGuid	ownerGuid,
		Field *	fields,
		uint32	entry
	)

virtual

Reimplemented in Bag.

{
 // 0 1 2 3 4 5 6 7 8 9 10 11 12
 // SELECT guid, itemEntry, creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments, randomBonusListId, durability, playedTime, text,
 // 13 14 15 16 17 18
 // battlePetSpeciesId, battlePetBreedData, battlePetLevel, battlePetDisplayId, context, bonusListIDs,
 // 19 20 21 22 23 24
 // itemModifiedAppearanceAllSpecs, itemModifiedAppearanceSpec1, itemModifiedAppearanceSpec2, itemModifiedAppearanceSpec3, itemModifiedAppearanceSpec4, itemModifiedAppearanceSpec5,
 // 25 26 27 28 29 30
 // spellItemEnchantmentAllSpecs, spellItemEnchantmentSpec1, spellItemEnchantmentSpec2, spellItemEnchantmentSpec3, spellItemEnchantmentSpec4, spellItemEnchantmentSpec5,
 // 31 32 33
 // secondaryItemModifiedAppearanceAllSpecs, secondaryItemModifiedAppearanceSpec1, secondaryItemModifiedAppearanceSpec2,
 // 34 35 36
 // secondaryItemModifiedAppearanceSpec3, secondaryItemModifiedAppearanceSpec4, secondaryItemModifiedAppearanceSpec5,
 // 37 38 39 40 41 42 43 44 45 46 47 48
 // gemItemId1, gemBonuses1, gemContext1, gemScalingLevel1, gemItemId2, gemBonuses2, gemContext2, gemScalingLevel2, gemItemId3, gemBonuses3, gemContext3, gemScalingLevel3
 // 49 50
 // fixedScalingLevel, artifactKnowledgeLevel FROM item_instance
 
 // create item before any checks for store correct guid
 // and allow use "FSetState(ITEM_REMOVED); SaveToDB();" for deleting item from DB
 Object::_Create(ObjectGuid::Create<HighGuid::Item>(guid));
 
 // Set entry, MUST be before proto check
 SetEntry(entry);
 SetObjectScale(1.0f);
 
 ItemTemplate const* proto = GetTemplate();
 if (!proto)
 {
 TC_LOG_ERROR("entities.item", "Invalid entry {} for item {}. Refusing to load.", GetEntry(), GetGUID().ToString());
 return false;
 }
 
 _bonusData.Initialize(proto);
 
 // set owner (not if item is only loaded for gbank/auction/mail
 if (!ownerGuid.IsEmpty())
 SetOwnerGUID(ownerGuid);
 
 uint32 itemFlags = fields[7].GetUInt32();
 bool need_save = false; // need explicit save data at load fixes
 if (uint64 creator = fields[2].GetUInt64())
 {
 if (!(itemFlags & ITEM_FIELD_FLAG_CHILD))
 SetCreator(ObjectGuid::Create<HighGuid::Player>(creator));
 else
 SetCreator(ObjectGuid::Create<HighGuid::Item>(creator));
 }
 if (uint64 giftCreator = fields[3].GetUInt64())
 SetGiftCreator(ObjectGuid::Create<HighGuid::Player>(giftCreator));
 SetCount(fields[4].GetUInt32());
 
 uint32 duration = fields[5].GetUInt32();
 SetExpiration(duration);
 // update duration if need, and remove if not need
 if ((proto->GetDuration() == 0) != (duration == 0))
 {
 SetExpiration(proto->GetDuration());
 need_save = true;
 }
 
 ReplaceAllItemFlags(ItemFieldFlags(itemFlags));
 
 uint32 durability = fields[10].GetUInt16();
 SetDurability(durability);
 // update max durability (and durability) if need
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::MaxDurability), proto->MaxDurability);
 
 // do not overwrite durability for wrapped items
 if (durability > proto->MaxDurability && !IsWrapped())
 {
 SetDurability(proto->MaxDurability);
 need_save = true;
 }
 
 SetCreatePlayedTime(fields[11].GetUInt32());
 SetText(fields[12].GetString());
 
 SetModifier(ITEM_MODIFIER_BATTLE_PET_SPECIES_ID, fields[13].GetUInt32());
 SetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA, fields[14].GetUInt32());
 SetModifier(ITEM_MODIFIER_BATTLE_PET_LEVEL, fields[15].GetUInt16());
 SetModifier(ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID, fields[16].GetUInt32());
 
 SetContext(ItemContext(fields[17].GetUInt8()));
 
 std::vector<std::string_view> bonusListString = Trinity::Tokenize(fields[18].GetStringView(), ' ', false);
 std::vector<int32> bonusListIDs;
 bonusListIDs.reserve(bonusListString.size());
 for (std::string_view token : bonusListString)
 if (Optional<int32> bonusListID = Trinity::StringTo<int32>(token))
 bonusListIDs.push_back(*bonusListID);
 SetBonuses(std::move(bonusListIDs));
 
 // load charges after bonuses, they can add more item effects
 std::vector<std::string_view> tokens = Trinity::Tokenize(fields[6].GetStringView(), ' ', false);
 for (uint8 i = 0; i < m_itemData->SpellCharges.size() && i < _bonusData.EffectCount && i < tokens.size(); ++i)
 SetSpellCharges(i, Trinity::StringTo<int32>(tokens[i]).value_or(0));
 
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS, fields[19].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_1, fields[20].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_2, fields[21].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_3, fields[22].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_4, fields[23].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_5, fields[24].GetUInt32());
 
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS, fields[25].GetUInt32());
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_1, fields[26].GetUInt32());
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_2, fields[27].GetUInt32());
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_3, fields[28].GetUInt32());
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_4, fields[29].GetUInt32());
 SetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_5, fields[30].GetUInt32());
 
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_ALL_SPECS, fields[31].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_1, fields[32].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_2, fields[33].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_3, fields[34].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_4, fields[35].GetUInt32());
 SetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_5, fields[36].GetUInt32());
 
 uint32 const gemFields = 4;
 ItemDynamicFieldGems gemData[MAX_GEM_SOCKETS];
 memset(gemData, 0, sizeof(gemData));
 for (uint32 i = 0; i < MAX_GEM_SOCKETS; ++i)
 {
 gemData[i].ItemId = fields[37 + i * gemFields].GetUInt32();
 std::vector<std::string_view> gemBonusListIDs = Trinity::Tokenize(fields[38 + i * gemFields].GetStringView(), ' ', false);
 uint32 b = 0;
 for (std::string_view token : gemBonusListIDs)
 if (Optional<uint16> bonusListID = Trinity::StringTo<uint16>(token))
 gemData[i].BonusListIDs[b++] = *bonusListID;
 
 gemData[i].Context = fields[39 + i * gemFields].GetUInt8();
 if (gemData[i].ItemId)
 SetGem(i, &gemData[i], fields[40 + i * gemFields].GetUInt32());
 }
 
 SetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL, fields[49].GetUInt32());
 SetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL, fields[50].GetUInt32());
 
 // Enchants must be loaded after all other bonus/scaling data
 std::vector<std::string_view> enchantmentTokens = Trinity::Tokenize(fields[8].GetStringView(), ' ', false);
 if (enchantmentTokens.size() == MAX_ENCHANTMENT_SLOT * MAX_ENCHANTMENT_OFFSET)
 {
 for (uint32 i = 0; i < MAX_ENCHANTMENT_SLOT; ++i)
 {
 auto enchantmentField = m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Enchantment, i);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::ID), Trinity::StringTo<int32>(enchantmentTokens[i * MAX_ENCHANTMENT_OFFSET + 0]).value_or(0));
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Duration), Trinity::StringTo<uint32>(enchantmentTokens[i * MAX_ENCHANTMENT_OFFSET + 1]).value_or(0));
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Charges), Trinity::StringTo<int16>(enchantmentTokens[i * MAX_ENCHANTMENT_OFFSET + 2]).value_or(0));
 }
 }
 m_randomBonusListId = fields[9].GetUInt32();
 
 // Remove bind flag for items vs BIND_NONE set
 if (IsSoulBound() && GetBonding() == BIND_NONE)
 {
 RemoveItemFlag(ITEM_FIELD_FLAG_SOULBOUND);
 need_save = true;
 }
 
 if (need_save) // normal item changed state set not work at loading
 {
 uint8 index = 0;
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_INSTANCE_ON_LOAD);
 stmt->setUInt32(index++, m_itemData->Expiration);
 stmt->setUInt32(index++, m_itemData->DynamicFlags);
 stmt->setUInt32(index++, m_itemData->Durability);
 stmt->setUInt64(index++, guid);
 CharacterDatabase.Execute(stmt);
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveFromObjectUpdate()

void Item::RemoveFromObjectUpdate ( )

overridevirtual

Implements Object.

{
 if (Player* owner = GetOwner())
 owner->GetMap()->RemoveUpdateObject(this);
}

Here is the call graph for this function:

◆ RemoveItemFlag()

void Item::RemoveItemFlag ( ItemFieldFlags flags )

inline

210{ RemoveUpdateFieldFlagValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::DynamicFlags), flags); }

Object::RemoveUpdateFieldFlagValue

void RemoveUpdateFieldFlagValue(UF::UpdateFieldSetter< T > setter, typename UF::UpdateFieldSetter< T >::value_type flag)

Definition: Object.h:285

UF::ItemData::DynamicFlags

UpdateField< uint32, 0, 9 > DynamicFlags

Definition: UpdateFields.h:128

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveItemFlag2()

void Item::RemoveItemFlag2 ( ItemFieldFlags2 flags )

inline

215{ RemoveUpdateFieldFlagValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::DynamicFlags2), flags); }

UF::ItemData::DynamicFlags2

UpdateField< uint32, 0, 18 > DynamicFlags2

Definition: UpdateFields.h:137

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReplaceAllItemFlags()

void Item::ReplaceAllItemFlags ( ItemFieldFlags flags )

inline

211{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::DynamicFlags), flags); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReplaceAllItemFlags2()

void Item::ReplaceAllItemFlags2 ( ItemFieldFlags2 flags )

inline

216{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::DynamicFlags2), flags); }

Here is the call graph for this function:

◆ SaveRefundDataToDB()

void Item::SaveRefundDataToDB ( )

{
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_REFUND_INSTANCE);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_REFUND_INSTANCE);
 stmt->setUInt64(0, GetGUID().GetCounter());
 stmt->setUInt64(1, GetRefundRecipient().GetCounter());
 stmt->setUInt64(2, GetPaidMoney());
 stmt->setUInt16(3, uint16(GetPaidExtendedCost()));
 trans->Append(stmt);
 
 CharacterDatabase.CommitTransaction(trans);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveToDB()

void Item::SaveToDB ( CharacterDatabaseTransaction trans )

virtual

Reimplemented in AzeriteEmpoweredItem, AzeriteItem, and Bag.

{
 bool isInTransaction = bool(trans);
 if (!isInTransaction)
 trans = CharacterDatabase.BeginTransaction();
 
 switch (uState)
 {
 case ITEM_NEW:
 case ITEM_CHANGED:
 {
 uint8 index = 0;
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(uState == ITEM_NEW ? CHAR_REP_ITEM_INSTANCE : CHAR_UPD_ITEM_INSTANCE);
 stmt->setUInt32( index, GetEntry());
 stmt->setUInt64(++index, GetOwnerGUID().GetCounter());
 stmt->setUInt64(++index, GetCreator().GetCounter());
 stmt->setUInt64(++index, GetGiftCreator().GetCounter());
 stmt->setUInt32(++index, GetCount());
 stmt->setUInt32(++index, m_itemData->Expiration);
 
 std::ostringstream ssSpells;
 for (uint8 i = 0; i < m_itemData->SpellCharges.size() && i < _bonusData.EffectCount; ++i)
 ssSpells << GetSpellCharges(i) << ' ';
 stmt->setString(++index, ssSpells.str());
 
 stmt->setUInt32(++index, m_itemData->DynamicFlags);
 
 std::ostringstream ssEnchants;
 for (uint8 i = 0; i < MAX_ENCHANTMENT_SLOT; ++i)
 {
 if (SpellItemEnchantmentEntry const* enchantment = sSpellItemEnchantmentStore.LookupEntry(GetEnchantmentId(EnchantmentSlot(i)));
 enchantment && !enchantment->GetFlags().HasFlag(SpellItemEnchantmentFlags::DoNotSaveToDB))
 {
 ssEnchants << GetEnchantmentId(EnchantmentSlot(i)) << ' ';
 ssEnchants << GetEnchantmentDuration(EnchantmentSlot(i)) << ' ';
 ssEnchants << GetEnchantmentCharges(EnchantmentSlot(i)) << ' ';
 }
 else
 {
 ssEnchants << "0 0 0 ";
 }
 }
 stmt->setString(++index, ssEnchants.str());
 
 stmt->setUInt32(++index, m_randomBonusListId);
 stmt->setUInt16(++index, m_itemData->Durability);
 stmt->setUInt32(++index, m_itemData->CreatePlayedTime);
 stmt->setString(++index, m_text);
 stmt->setUInt32(++index, GetModifier(ITEM_MODIFIER_BATTLE_PET_SPECIES_ID));
 stmt->setUInt32(++index, GetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA));
 stmt->setUInt32(++index, GetModifier(ITEM_MODIFIER_BATTLE_PET_LEVEL));
 stmt->setUInt32(++index, GetModifier(ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID));
 stmt->setUInt8(++index, uint8(m_itemData->Context));
 
 std::ostringstream bonusListIDs;
 for (int32 bonusListID : GetBonusListIDs())
 bonusListIDs << bonusListID << ' ';
 stmt->setString(++index, bonusListIDs.str());
 
 stmt->setUInt64(++index, GetGUID().GetCounter());
 
 trans->Append(stmt);
 
 if ((uState == ITEM_CHANGED) && IsWrapped())
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GIFT_OWNER);
 stmt->setUInt64(0, GetOwnerGUID().GetCounter());
 stmt->setUInt64(1, GetGUID().GetCounter());
 trans->Append(stmt);
 }
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_GEMS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 if (m_itemData->Gems.size())
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_GEMS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 uint32 i = 0;
 uint32 const gemFields = 4;
 for (UF::SocketedGem const& gemData : m_itemData->Gems)
 {
 if (gemData.ItemID)
 {
 stmt->setUInt32(1 + i * gemFields, gemData.ItemID);
 std::ostringstream gemBonusListIDs;
 for (uint16 bonusListID : gemData.BonusListIDs)
 if (bonusListID)
 gemBonusListIDs << bonusListID << ' ';
 stmt->setString(2 + i * gemFields, gemBonusListIDs.str());
 stmt->setUInt8(3 + i * gemFields, gemData.Context);
 stmt->setUInt32(4 + i * gemFields, m_gemScalingLevels[i]);
 }
 else
 {
 stmt->setUInt32(1 + i * gemFields, 0);
 stmt->setString(2 + i * gemFields, "");
 stmt->setUInt8(3 + i * gemFields, 0);
 stmt->setUInt32(4 + i * gemFields, 0);
 }
 ++i;
 }
 for (; i < MAX_GEM_SOCKETS; ++i)
 {
 stmt->setUInt32(1 + i * gemFields, 0);
 stmt->setString(2 + i * gemFields, "");
 stmt->setUInt8(3 + i * gemFields, 0);
 stmt->setUInt32(4 + i * gemFields, 0);
 }
 trans->Append(stmt);
 }
 
 static ItemModifier const transmogMods[18] =
 {
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS,
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_1,
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_2,
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_3,
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_4,
 ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_5,
 
 ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS,
 ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_1,
 ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_2,
 ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_3,
 ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_4,
 ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_5,
 
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_ALL_SPECS,
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_1,
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_2,
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_3,
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_4,
 ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_5
 };
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_TRANSMOG);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 if (std::find_if(std::begin(transmogMods), std::end(transmogMods), [this](ItemModifier modifier) { return GetModifier(modifier) != 0; }) != std::end(transmogMods))
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_TRANSMOG);
 stmt->setUInt64(0, GetGUID().GetCounter());
 stmt->setUInt32(1, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_ALL_SPECS));
 stmt->setUInt32(2, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_1));
 stmt->setUInt32(3, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_2));
 stmt->setUInt32(4, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_3));
 stmt->setUInt32(5, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_4));
 stmt->setUInt32(6, GetModifier(ITEM_MODIFIER_TRANSMOG_APPEARANCE_SPEC_5));
 stmt->setUInt32(7, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_ALL_SPECS));
 stmt->setUInt32(8, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_1));
 stmt->setUInt32(9, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_2));
 stmt->setUInt32(10, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_3));
 stmt->setUInt32(11, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_4));
 stmt->setUInt32(12, GetModifier(ITEM_MODIFIER_ENCHANT_ILLUSION_SPEC_5));
 stmt->setUInt32(13, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_ALL_SPECS));
 stmt->setUInt32(14, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_1));
 stmt->setUInt32(15, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_2));
 stmt->setUInt32(16, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_3));
 stmt->setUInt32(17, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_4));
 stmt->setUInt32(18, GetModifier(ITEM_MODIFIER_TRANSMOG_SECONDARY_APPEARANCE_SPEC_5));
 trans->Append(stmt);
 }
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT_POWERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 if (GetTemplate()->GetArtifactID())
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_ARTIFACT);
 stmt->setUInt64(0, GetGUID().GetCounter());
 stmt->setUInt64(1, m_itemData->ArtifactXP);
 stmt->setUInt32(2, GetModifier(ITEM_MODIFIER_ARTIFACT_APPEARANCE_ID));
 stmt->setUInt32(3, GetModifier(ITEM_MODIFIER_ARTIFACT_TIER));
 trans->Append(stmt);
 
 for (UF::ArtifactPower const& artifactPower : m_itemData->ArtifactPowers)
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_ARTIFACT_POWERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 stmt->setUInt32(1, artifactPower.ArtifactPowerID);
 stmt->setUInt8(2, artifactPower.PurchasedRank);
 trans->Append(stmt);
 }
 }
 
 static ItemModifier const modifiersTable[] =
 {
 ITEM_MODIFIER_TIMEWALKER_LEVEL,
 ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL
 };
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_MODIFIERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 if (std::find_if(std::begin(modifiersTable), std::end(modifiersTable), [this](ItemModifier modifier) { return GetModifier(modifier) != 0; }) != std::end(modifiersTable))
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEM_INSTANCE_MODIFIERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 stmt->setUInt32(1, GetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL));
 stmt->setUInt32(2, GetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL));
 trans->Append(stmt);
 }
 
 break;
 }
 case ITEM_REMOVED:
 {
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_GEMS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_TRANSMOG);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT_POWERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_MODIFIERS);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 
 if (IsWrapped())
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
 stmt->setUInt64(0, GetGUID().GetCounter());
 trans->Append(stmt);
 }
 
 if (!isInTransaction)
 CharacterDatabase.CommitTransaction(trans);
 
 // Delete the items if this is a container
 if (m_loot && !m_loot->isLooted())
 sLootItemStorage->RemoveStoredLootForContainer(GetGUID().GetCounter());
 
 delete this;
 return;
 }
 case ITEM_UNCHANGED:
 break;
 }
 
 SetState(ITEM_UNCHANGED);
 
 if (!isInTransaction)
 CharacterDatabase.CommitTransaction(trans);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendTimeUpdate()

void Item::SendTimeUpdate ( Player * owner )

{
 uint32 duration = m_itemData->Expiration;
 if (!duration)
 return;
 
 WorldPackets::Item::ItemTimeUpdate itemTimeUpdate;
 itemTimeUpdate.ItemGuid = GetGUID();
 itemTimeUpdate.DurationLeft = duration;
 owner->GetSession()->SendPacket(itemTimeUpdate.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendUpdateSockets()

void Item::SendUpdateSockets ( )

{
 WorldPackets::Item::SocketGemsSuccess socketGems;
 socketGems.Item = GetGUID();
 GetOwner()->GetSession()->SendPacket(socketGems.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAppearanceModId()

void Item::SetAppearanceModId ( uint32 appearanceModId )

inline

346{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemAppearanceModID), appearanceModId); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetArtifactPower()

void Item::SetArtifactPower	(	uint16	artifactPowerId,
		uint8	purchasedRank,
		uint8	currentRankWithBonus
	)

{
 auto indexItr = m_artifactPowerIdToIndex.find(artifactPowerId);
 if (indexItr != m_artifactPowerIdToIndex.end())
 {
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData)
 .ModifyValue(&UF::ItemData::ArtifactPowers, indexItr->second)
 .ModifyValue(&UF::ArtifactPower::PurchasedRank), purchasedRank);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData)
 .ModifyValue(&UF::ItemData::ArtifactPowers, indexItr->second)
 .ModifyValue(&UF::ArtifactPower::CurrentRankWithBonus), currentRankWithBonus);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetArtifactXP()

void Item::SetArtifactXP ( uint64 xp )

inline

437{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ArtifactXP), xp); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBinding()

void Item::SetBinding ( bool val )

inline

 {
 if (val)
 SetItemFlag(ITEM_FIELD_FLAG_SOULBOUND);
 else
 RemoveItemFlag(ITEM_FIELD_FLAG_SOULBOUND);
 }

Here is the caller graph for this function:

◆ SetBonuses()

void Item::SetBonuses ( std::vector< int32 > bonusListIDs )

{
 WorldPackets::Item::ItemBonusKey itemBonusKey;
 itemBonusKey.ItemID = GetEntry();
 itemBonusKey.BonusListIDs = std::move(bonusListIDs);
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemBonusKey), std::move(itemBonusKey));
 
 for (int32 bonusListID : GetBonusListIDs())
 _bonusData.AddBonusList(bonusListID);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ItemAppearanceModID), _bonusData.AppearanceModID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetChildItem()

void Item::SetChildItem ( ObjectGuid childItem )

inline

423{ m_childItem = childItem; }

Here is the caller graph for this function:

◆ SetContainedIn()

void Item::SetContainedIn ( ObjectGuid guid )

inline

191{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::ContainedIn), guid); }

UF::ItemData::ContainedIn

UpdateField< ObjectGuid, 0, 4 > ContainedIn

Definition: UpdateFields.h:123

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetContainer()

void Item::SetContainer ( Bag * container )

inline

285{ m_container = container; }

Here is the caller graph for this function:

◆ SetContext()

void Item::SetContext ( ItemContext context )

inline

441{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Context), int32(context)); }

UF::ItemData::Context

UpdateField< int32, 0, 13 > Context

Definition: UpdateFields.h:132

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCount()

void Item::SetCount ( uint32 value )

{
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::StackCount), value);
 
 if (Player* player = GetOwner())
 {
 if (TradeData* tradeData = player->GetTradeData())
 {
 TradeSlots slot = tradeData->GetTradeSlotForItem(GetGUID());
 
 if (slot != TRADE_SLOT_INVALID)
 tradeData->SetItem(slot, this, true);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCreatePlayedTime()

void Item::SetCreatePlayedTime ( uint32 createPlayedTime )

inline

311{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::CreatePlayedTime), createPlayedTime); }

UF::ItemData::CreatePlayedTime

UpdateField< uint32, 0, 12 > CreatePlayedTime

Definition: UpdateFields.h:131

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCreator()

void Item::SetCreator ( ObjectGuid guid )

inline

193{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Creator), guid); }

UF::ItemData::Creator

UpdateField< ObjectGuid, 0, 5 > Creator

Definition: UpdateFields.h:124

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDurability()

void Item::SetDurability ( uint32 durability )

inline

258{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Durability), durability); }

UF::ItemData::Durability

UpdateField< uint32, 0, 10 > Durability

Definition: UpdateFields.h:129

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEnchantment()

void Item::SetEnchantment	(	EnchantmentSlot	slot,
		uint32	id,
		uint32	duration,
		uint32	charges,
		ObjectGuid	caster = `ObjectGuid::Empty`
	)

{
 // Better lost small time at check in comparison lost time at item save to DB.
 if ((GetEnchantmentId(slot) == id) && (GetEnchantmentDuration(slot) == duration) && (GetEnchantmentCharges(slot) == charges))
 return;
 
 Player* owner = GetOwner();
 if (slot < MAX_INSPECTED_ENCHANTMENT_SLOT)
 {
 if (SpellItemEnchantmentEntry const* oldEnchant = sSpellItemEnchantmentStore.LookupEntry(GetEnchantmentId(slot)))
 if (!oldEnchant->GetFlags().HasFlag(SpellItemEnchantmentFlags::DoNotLog))
 owner->GetSession()->SendEnchantmentLog(GetOwnerGUID(), ObjectGuid::Empty, GetGUID(), GetEntry(), oldEnchant->ID, slot);
 
 if (SpellItemEnchantmentEntry const* newEnchant = sSpellItemEnchantmentStore.LookupEntry(id))
 if (!newEnchant->GetFlags().HasFlag(SpellItemEnchantmentFlags::DoNotLog))
 owner->GetSession()->SendEnchantmentLog(GetOwnerGUID(), caster, GetGUID(), GetEntry(), id, slot);
 }
 
 ApplyArtifactPowerEnchantmentBonuses(slot, GetEnchantmentId(slot), false, owner);
 ApplyArtifactPowerEnchantmentBonuses(slot, id, true, owner);
 
 auto enchantmentField = m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Enchantment, slot);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::ID), id);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Duration), duration);
 SetUpdateFieldValue(enchantmentField.ModifyValue(&UF::ItemEnchantment::Charges), charges);
 SetState(ITEM_CHANGED, owner);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEnchantmentCharges()

void Item::SetEnchantmentCharges	(	EnchantmentSlot	slot,
		uint32	charges
	)

{
 if (GetEnchantmentCharges(slot) == charges)
 return;
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Enchantment, slot).ModifyValue(&UF::ItemEnchantment::Charges), charges);
 SetState(ITEM_CHANGED, GetOwner());
}

Here is the call graph for this function:

◆ SetEnchantmentDuration()

void Item::SetEnchantmentDuration	(	EnchantmentSlot	slot,
		uint32	duration,
		Player *	owner
	)

{
 if (GetEnchantmentDuration(slot) == duration)
 return;
 
 SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Enchantment, slot).ModifyValue(&UF::ItemEnchantment::Duration), duration);
 SetState(ITEM_CHANGED, owner);
 // Cannot use GetOwner() here, has to be passed as an argument to avoid freeze due to hashtable locking
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetExpiration()

void Item::SetExpiration ( uint32 expiration )

inline

198{ SetUpdateFieldValue(m_values.ModifyValue(&Item::m_itemData).ModifyValue(&UF::ItemData::Expiration), expiration); }

UF::ItemData::Expiration

UpdateField< uint32, 0, 8 > Expiration

Definition: UpdateFields.h:127

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFixedLevel()

void Item::SetFixedLevel ( uint8 level )

{
 if (!_bonusData.HasFixedLevel || GetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL))
 return;
 
 if (_bonusData.PlayerLevelToItemLevelCurveId)
 {
 if (Optional<ContentTuningLevels> levels = sDB2Manager.GetContentTuningData(_bonusData.ContentTuningId, 0, true))
 level = std::min(std::max(int16(level), levels->MinLevel), levels->MaxLevel);
 
 SetModifier(ITEM_MODIFIER_TIMEWALKER_LEVEL, level);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetGem()

void Item::SetGem	(	uint16	slot,
		ItemDynamicFieldGems const *	gem,
		uint32	gemScalingLevel
	)

{
 ASSERT(slot < MAX_GEM_SOCKETS);
 m_gemScalingLevels[slot] = gemScalingLevel;
 _bonusData.GemItemLevelBonus[slot] = 0;
 if (ItemTemplate const* gemTemplate = sObjectMgr->GetItemTemplate(gem->ItemId))

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Friends

Constructor & Destructor Documentation

◆ Item()

◆ ~Item()

Member Function Documentation

◆ AddArtifactPower()

◆ AddBonuses()

◆ AddToObjectUpdate()

◆ ApplyArtifactPowerEnchantmentBonuses()

◆ ApplyBonusList()

◆ BuildUpdate()

◆ BuildValuesCreate()

◆ BuildValuesUpdate()

◆ BuildValuesUpdateForPlayerWithMask()

◆ BuildValuesUpdateWithFlag()

◆ CalculateDurabilityRepairCost()

◆ CanBeMergedPartlyWith()

◆ CanBeTraded()

◆ CanTransmogrifyItemWithItem()

◆ CheckArtifactRelicSlotUnlock()

◆ CheckSoulboundTradeExpire()

◆ ClearBonuses()

◆ ClearEnchantment()

◆ ClearSoulboundTradeable()

◆ ClearUpdateMask()

◆ CloneItem()

◆ CopyArtifactDataFromParent()

◆ Create()

◆ CreateItem()

◆ DeleteFromDB() [1/2]

◆ DeleteFromDB() [2/2]

◆ DeleteFromInventoryDB() [1/2]

◆ DeleteFromInventoryDB() [2/2]

◆ DeleteRefundDataFromDB()

◆ FSetState()

◆ GemsFitSockets()

◆ GetAppearanceModId()

◆ GetArtifactPower()

◆ GetBagSlot()

◆ GetBonding()

◆ GetBonus()

◆ GetBonusListIDs()

◆ GetBuyPrice() [1/2]

◆ GetBuyPrice() [2/2]

◆ GetChildItem()

◆ GetContainedIn()

◆ GetContainer()

◆ GetContext()

◆ GetCount()

◆ GetCreator()

◆ GetDebugInfo()

◆ GetDisenchantLoot() [1/2]

◆ GetDisenchantLoot() [2/2]

◆ GetDisplayId()

◆ GetEffects()

◆ GetEnchantmentCharges()

◆ GetEnchantmentDuration()

◆ GetEnchantmentId()

◆ GetEnchantRequiredLevel()

◆ GetGem()

◆ GetGemCountWithID()

◆ GetGemCountWithLimitCategory()

◆ GetGiftCreator()

◆ GetItemLevel() [1/2]

◆ GetItemLevel() [2/2]

◆ GetItemModifiedAppearance()

◆ GetItemRandomBonusListId()

◆ GetItemStatType()

◆ GetItemStatValue()

◆ GetLootForPlayer()

◆ GetMaxStackCount()

◆ GetModifier()

◆ GetNameForLocaleIdx()