#include "Item.h"

Inheritance diagram for Item:

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

	Item ()

virtual bool	Create (ObjectGuid::LowType guidlow, uint32 itemid, Player const *owner)

ItemTemplate const *	GetTemplate () const

ObjectGuid	GetOwnerGUID () const

void	SetOwnerGUID (ObjectGuid guid)

Player *	GetOwner () const

void	SetBinding (bool val)

bool	IsSoulBound () const

bool	IsBoundAccountWide () const

bool	IsBindedNotWith (Player const *player) const

bool	IsBoundByEnchant () const

bool	IsBoundByTempEnchant () const

virtual void	SaveToDB (CharacterDatabaseTransaction trans)

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

virtual void	DeleteFromDB (CharacterDatabaseTransaction trans)

void	DeleteFromInventoryDB (CharacterDatabaseTransaction trans)

void	SaveRefundDataToDB ()

void	DeleteRefundDataFromDB (CharacterDatabaseTransaction *trans)

Bag *	ToBag ()

const Bag *	ToBag () const

bool	IsLocked () const

bool	IsBag () const

bool	IsCurrencyToken () const

bool	IsNotEmptyBag () const

bool	IsBroken () const

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

void	SetInTrade (bool b=true)

bool	IsInTrade () 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

bool	HasSocket () 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 ()

uint32	GetSpell ()

int32	GetItemRandomPropertyId () const

uint32	GetItemSuffixFactor () const

void	SetItemRandomProperties (int32 randomPropId)

void	UpdateItemSuffixFactor ()

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

std::string const &	GetText () const

void	SetText (std::string const &text)

void	SendUpdateSockets ()

void	SendTimeUpdate (Player *owner)

void	UpdateDuration (Player *owner, uint32 diff)

int32	GetSpellCharges (uint8 index=0) const

void	SetSpellCharges (uint8 index, int32 value)

ItemUpdateState	GetState () const

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

void	AddToUpdateQueueOf (Player *player)

void	RemoveFromUpdateQueueOf (Player *player)

bool	IsInUpdateQueue () const

uint32	GetQueuePos () const

void	FSetState (ItemUpdateState state)

bool	hasQuest (uint32 quest_id) const override

bool	hasInvolvedQuest (uint32) const override

bool	IsPotion () const

bool	IsWeaponVellum () const

bool	IsArmorVellum () const

bool	IsConjuredConsumable () const

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

void	SetRefundRecipient (ObjectGuid::LowType pGuidLow)

void	SetPaidMoney (uint32 money)

void	SetPaidExtendedCost (uint32 iece)

ObjectGuid::LowType	GetRefundRecipient ()

uint32	GetPaidMoney ()

uint32	GetPaidExtendedCost ()

void	UpdatePlayedTime (Player *owner)

uint32	GetPlayedTime ()

bool	IsRefundExpired ()

void	SetSoulboundTradeable (AllowedLooterSet &allowedLooters)

void	ClearSoulboundTradeable (Player *currentOwner)

bool	CheckSoulboundTradeExpire ()

void	BuildUpdate (UpdateDataMapType &data_map, UpdatePlayerSet &) override

void	AddToObjectUpdate () override

void	RemoveFromObjectUpdate () override

uint32	GetScriptId () const

std::string	GetDebugInfo () const override

Public Member Functions inherited from Object
virtual	~Object ()

bool	IsInWorld () const

virtual void	AddToWorld ()

virtual void	RemoveFromWorld ()

ObjectGuid	GetGUID () const

PackedGuid const &	GetPackGUID () const

uint32	GetEntry () const

void	SetEntry (uint32 entry)

float	GetObjectScale () const

virtual void	SetObjectScale (float scale)

virtual uint32	GetDynamicFlags () const

bool	HasDynamicFlag (uint32 flag) const

virtual void	SetDynamicFlag (uint32 flag)

virtual void	RemoveDynamicFlag (uint32 flag)

virtual 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 target) const

void	BuildOutOfRangeUpdateBlock (UpdateData *data) const

void	BuildMovementUpdateBlock (UpdateData *data, uint32 flags=0) const

virtual void	DestroyForPlayer (Player *target, bool onDeath=false) const

int32	GetInt32Value (uint16 index) const

uint32	GetUInt32Value (uint16 index) const

uint64	GetUInt64Value (uint16 index) const

float	GetFloatValue (uint16 index) const

uint8	GetByteValue (uint16 index, uint8 offset) const

uint16	GetUInt16Value (uint16 index, uint8 offset) const

ObjectGuid	GetGuidValue (uint16 index) const

void	SetInt32Value (uint16 index, int32 value)

void	SetUInt32Value (uint16 index, uint32 value)

void	UpdateUInt32Value (uint16 index, uint32 value)

void	SetUInt64Value (uint16 index, uint64 value)

void	SetFloatValue (uint16 index, float value)

void	SetByteValue (uint16 index, uint8 offset, uint8 value)

void	SetUInt16Value (uint16 index, uint8 offset, uint16 value)

void	SetInt16Value (uint16 index, uint8 offset, int16 value)

void	SetGuidValue (uint16 index, ObjectGuid value)

void	SetStatFloatValue (uint16 index, float value)

void	SetStatInt32Value (uint16 index, int32 value)

bool	AddGuidValue (uint16 index, ObjectGuid value)

bool	RemoveGuidValue (uint16 index, ObjectGuid value)

void	ApplyModUInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModUInt64Value (uint16 index, int32 val, bool apply)

void	ApplyModPositiveFloatValue (uint16 index, float val, bool apply)

void	ApplyModSignedFloatValue (uint16 index, float val, bool apply)

void	ApplyPercentModFloatValue (uint16 index, float val, bool apply)

void	SetFlag (uint16 index, uint32 newFlag)

void	RemoveFlag (uint16 index, uint32 oldFlag)

void	ToggleFlag (uint16 index, uint32 flag)

bool	HasFlag (uint16 index, uint32 flag) const

void	ApplyModFlag (uint16 index, uint32 flag, bool apply)

void	SetByteFlag (uint16 index, uint8 offset, uint8 newFlag)

void	RemoveByteFlag (uint16 index, uint8 offset, uint8 newFlag)

bool	HasByteFlag (uint16 index, uint8 offset, uint8 flag) const

void	SetFlag64 (uint16 index, uint64 newFlag)

void	RemoveFlag64 (uint16 index, uint64 oldFlag)

void	ToggleFlag64 (uint16 index, uint64 flag)

bool	HasFlag64 (uint16 index, uint64 flag) const

void	ApplyModFlag64 (uint16 index, uint64 flag, bool apply)

void	ClearUpdateMask (bool remove)

uint16	GetValuesCount () const

virtual bool	hasQuest (uint32) const

virtual bool	hasInvolvedQuest (uint32) const

virtual void	BuildUpdate (UpdateDataMapType &, UpdatePlayerSet &)

void	BuildFieldsUpdate (Player *, UpdateDataMapType &) const

void	SetFieldNotifyFlag (uint16 flag)

void	RemoveFieldNotifyFlag (uint16 flag)

void	ForceValuesUpdateAtIndex (uint32)

bool	IsPlayer () const

Player *	ToPlayer ()

Player const *	ToPlayer () const

Creature *	ToCreature ()

Creature const *	ToCreature () const

Unit *	ToUnit ()

Unit const *	ToUnit () const

GameObject *	ToGameObject ()

GameObject const *	ToGameObject () const

Corpse *	ToCorpse ()

Corpse const *	ToCorpse () const

DynamicObject *	ToDynObject ()

DynamicObject const *	ToDynObject () const

virtual std::string	GetDebugInfo () const

Static Public Member Functions
static Item *	CreateItem (uint32 item, uint32 count, Player const *player=nullptr, bool clone=false, uint32 randomPropertyId=0)

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

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

static int32	GenerateItemRandomPropertyId (uint32 item_id)

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

Public Attributes
Loot	loot

bool	m_lootGenerated

Public Attributes inherited from Object
DataMap	CustomData

Private Attributes
std::string	m_text

uint8	m_slot

Bag *	m_container

ItemUpdateState	uState

int32	uQueuePos

bool	mb_in_trade

time_t	m_lastPlayedTimeUpdate

uint32	m_refundRecipient

uint32	m_paidMoney

uint32	m_paidExtendedCost

AllowedLooterSet	allowedGUIDs

Additional Inherited Members
Protected Member Functions inherited from Object
	Object ()

void	_InitValues ()

void	_Create (ObjectGuid::LowType guidlow, uint32 entry, HighGuid guidhigh)

std::string	_ConcatFields (uint16 startIndex, uint16 size) const

bool	_LoadIntoDataField (std::string const &data, uint32 startOffset, uint32 count)

uint32	GetUpdateFieldData (Player const target, uint32 &flags) const

void	BuildMovementUpdate (ByteBuffer *data, uint16 flags) const

virtual void	BuildValuesUpdate (uint8 updatetype, ByteBuffer data, Player target) const

virtual void	AddToObjectUpdate ()=0

virtual void	RemoveFromObjectUpdate ()=0

void	AddToObjectUpdateIfNeeded ()

Protected Attributes inherited from Object
uint16	m_objectType

TypeID	m_objectTypeId

uint16	m_updateFlag

union {
int32 * m_int32Values

uint32 * m_uint32Values

float * m_floatValues

};

UpdateMask	_changesMask

uint16	m_valuesCount

uint16	_fieldNotifyFlags

bool	m_objectUpdated

Detailed Description

Constructor & Destructor Documentation

◆ Item()

Item::Item ( )

{
    m_objectType |= TYPEMASK_ITEM;
    m_objectTypeId = TYPEID_ITEM;
 
    m_updateFlag = UPDATEFLAG_LOWGUID;
 
    m_valuesCount = ITEM_END;
    m_slot = 0;
    uState = ITEM_NEW;
    uQueuePos = -1;
    m_container = nullptr;
    m_lootGenerated = false;
    mb_in_trade = false;
    m_lastPlayedTimeUpdate = GameTime::GetGameTime().count();
 
    m_refundRecipient = 0;
    m_paidMoney = 0;
    m_paidExtendedCost = 0;
}

References GameTime::GetGameTime(), ITEM_END, ITEM_NEW, m_container, m_lastPlayedTimeUpdate, m_lootGenerated, Object::m_objectType, Object::m_objectTypeId, m_paidExtendedCost, m_paidMoney, m_refundRecipient, m_slot, Object::m_updateFlag, Object::m_valuesCount, mb_in_trade, TYPEID_ITEM, TYPEMASK_ITEM, UPDATEFLAG_LOWGUID, uQueuePos, and uState.

Member Function Documentation

◆ AddToObjectUpdate()

void Item::AddToObjectUpdate ( )

overridevirtual

Implements Object.

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

References GetOwner().

◆ AddToUpdateQueueOf()

void Item::AddToUpdateQueueOf ( Player * player )

{
    if (IsInUpdateQueue())
        return;
 
    ASSERT(player);
 
    if (player->GetGUID() != GetOwnerGUID())
    {
        LOG_DEBUG("entities.player.items", "Item::AddToUpdateQueueOf - Owner's guid ({}) and player's guid ({}) don't match!", GetOwnerGUID().ToString(), player->GetGUID().ToString());
        return;
    }
 
    if (player->m_itemUpdateQueueBlocked)
        return;
 
    player->m_itemUpdateQueue.push_back(this);
    uQueuePos = player->m_itemUpdateQueue.size() - 1;
}

References ASSERT, Object::GetGUID(), GetOwnerGUID(), IsInUpdateQueue(), LOG_DEBUG, Player::m_itemUpdateQueue, Player::m_itemUpdateQueueBlocked, ObjectGuid::ToString(), and uQueuePos.

Referenced by SetState().

◆ BuildUpdate()

void Item::BuildUpdate	(	UpdateDataMapType &	data_map,
		UpdatePlayerSet &
	)

overridevirtual

Reimplemented from Object.

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

References Object::BuildFieldsUpdate(), Object::ClearUpdateMask(), and GetOwner().

◆ CanBeMergedPartlyWith()

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

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

References EQUIP_ERR_ALREADY_LOOTED, EQUIP_ERR_ITEM_CANT_STACK, EQUIP_ERR_OK, GetCount(), Object::GetEntry(), ItemTemplate::GetMaxStackSize(), ItemTemplate::ItemId, and m_lootGenerated.

Referenced by Player::CanStoreItem_InBag(), Player::CanStoreItem_InInventorySlots(), Player::CanStoreItem_InSpecificSlot(), and Player::CanStoreItems().

◆ CanBeTraded()

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

{
    if ((!mail || !IsBoundAccountWide()) && (IsSoulBound() && (!HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE) || !trade)))
        return false;
 
    if (IsBag() && (Player::IsBagPos(GetPos()) || !((Bag const*)this)->IsEmpty()))
        return false;
 
    if (Player* owner = GetOwner())
    {
        if (owner->CanUnequipItem(GetPos(), false) != EQUIP_ERR_OK)
            return false;
 
        // Xinef: check if item is looted now
        if (owner->GetLootGUID() == GetGUID())
            return false;
    }
 
    if (IsBoundByTempEnchant()) // pussywizard
        return false;
 
    if ((!mail || !IsBoundAccountWide()) && IsBoundByEnchant())
        return false;
 
    return true;
}

References EQUIP_ERR_OK, Object::GetGUID(), GetOwner(), GetPos(), Object::HasFlag(), IsBag(), Player::IsBagPos(), IsBoundAccountWide(), IsBoundByEnchant(), IsBoundByTempEnchant(), IsSoulBound(), ITEM_FIELD_FLAG_BOP_TRADEABLE, and ITEM_FIELD_FLAGS.

Referenced by WorldSession::HandleAuctionSellItem(), WorldSession::HandleSendMail(), and WorldSession::HandleSetTradeItemOpcode().

◆ CheckSoulboundTradeExpire()

bool Item::CheckSoulboundTradeExpire ( )

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

References ClearSoulboundTradeable(), GetOwner(), Object::GetUInt32Value(), HOUR, and ITEM_FIELD_CREATE_PLAYED_TIME.

◆ ClearEnchantment()

void Item::ClearEnchantment ( EnchantmentSlot slot )

{
    if (!GetEnchantmentId(slot))
        return;
 
    for (uint8 x = 0; x < MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS; ++x)
        SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + x, 0);
    SetState(ITEM_CHANGED, GetOwner());
}

References GetEnchantmentId(), GetOwner(), ITEM_CHANGED, ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_OFFSET, MAX_SPELL_ITEM_ENCHANTMENT_EFFECTS, SetState(), and Object::SetUInt32Value().

Referenced by Player::CastItemCombatSpell(), WorldSession::HandleCancelTempEnchantmentOpcode(), and Player::SetVirtualItemSlot().

◆ ClearSoulboundTradeable()

void Item::ClearSoulboundTradeable ( Player * currentOwner )

{
    RemoveFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE);
    if (allowedGUIDs.empty())
        return;
 
    allowedGUIDs.clear();
    SetState(ITEM_CHANGED, currentOwner);
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_BOP_TRADE);
    stmt->SetData(0, GetGUID().GetCounter());
    CharacterDatabase.Execute(stmt);
}

References allowedGUIDs, CHAR_DEL_ITEM_BOP_TRADE, CharacterDatabase, Object::GetGUID(), ITEM_CHANGED, ITEM_FIELD_FLAG_BOP_TRADEABLE, ITEM_FIELD_FLAGS, Object::RemoveFlag(), PreparedStatementBase::SetData(), and SetState().

Referenced by Player::_LoadItem(), Player::_StoreItem(), CheckSoulboundTradeExpire(), Player::DestroyItem(), Spell::EffectEnchantItemPerm(), Spell::EffectEnchantItemPrismatic(), Spell::EffectEnchantItemTmp(), Player::EquipItem(), and WorldSession::HandleSocketOpcode().

◆ CloneItem()

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

{
    // player CAN be nullptr in which case we must not update random properties because that accesses player's item update queue
    Item* newItem = CreateItem(GetEntry(), count, player, true, player ? GetItemRandomPropertyId() : 0);
    if (!newItem)
        return nullptr;
 
    newItem->SetUInt32Value(ITEM_FIELD_CREATOR,      GetUInt32Value(ITEM_FIELD_CREATOR));
    newItem->SetUInt32Value(ITEM_FIELD_GIFTCREATOR,  GetUInt32Value(ITEM_FIELD_GIFTCREATOR));
    newItem->SetUInt32Value(ITEM_FIELD_FLAGS,        GetUInt32Value(ITEM_FIELD_FLAGS) & ~(ITEM_FIELD_FLAG_REFUNDABLE | ITEM_FIELD_FLAG_BOP_TRADEABLE));
    newItem->SetUInt32Value(ITEM_FIELD_DURATION,     GetUInt32Value(ITEM_FIELD_DURATION));
    return newItem;
}

References CreateItem(), Object::GetEntry(), GetItemRandomPropertyId(), Object::GetUInt32Value(), ITEM_FIELD_CREATOR, ITEM_FIELD_DURATION, ITEM_FIELD_FLAG_BOP_TRADEABLE, ITEM_FIELD_FLAG_REFUNDABLE, ITEM_FIELD_FLAGS, ITEM_FIELD_GIFTCREATOR, and Object::SetUInt32Value().

Referenced by Guild::BankMoveItemData::_StoreItem(), Player::_StoreItem(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleSellItemOpcode(), and Player::SplitItem().

◆ Create()

bool Item::Create	(	ObjectGuid::LowType	guidlow,
		uint32	itemid,
		Player const *	owner
	)

virtual

Reimplemented in Bag.

{
    Object::_Create(guidlow, 0, HighGuid::Item);
 
    SetEntry(itemid);
    SetObjectScale(1.0f);
 
    SetGuidValue(ITEM_FIELD_OWNER, owner ? owner->GetGUID() : ObjectGuid::Empty);
    SetGuidValue(ITEM_FIELD_CONTAINED, owner ? owner->GetGUID() : ObjectGuid::Empty);
 
    ItemTemplate const* itemProto = sObjectMgr->GetItemTemplate(itemid);
    if (!itemProto)
        return false;
 
    SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
    SetUInt32Value(ITEM_FIELD_MAXDURABILITY, itemProto->MaxDurability);
    SetUInt32Value(ITEM_FIELD_DURABILITY, itemProto->MaxDurability);
 
    for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
        SetSpellCharges(i, itemProto->Spells[i].SpellCharges);
 
    SetUInt32Value(ITEM_FIELD_DURATION, itemProto->Duration);
    SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, 0);
    sScriptMgr->OnItemCreate(this, itemProto, owner);
    return true;
}

References Object::_Create(), ItemTemplate::Duration, ObjectGuid::Empty, Object::GetGUID(), ITEM_FIELD_CONTAINED, ITEM_FIELD_CREATE_PLAYED_TIME, ITEM_FIELD_DURABILITY, ITEM_FIELD_DURATION, ITEM_FIELD_MAXDURABILITY, ITEM_FIELD_OWNER, ITEM_FIELD_STACK_COUNT, MAX_ITEM_PROTO_SPELLS, ItemTemplate::MaxDurability, Object::SetEntry(), Object::SetGuidValue(), Object::SetObjectScale(), SetSpellCharges(), Object::SetUInt32Value(), sObjectMgr, _Spell::SpellCharges, ItemTemplate::Spells, and sScriptMgr.

Referenced by CreateItem(), and WorldSession::HandleMailCreateTextItem().

◆ CreateItem()

Item * Item::CreateItem	(	uint32	item,
		uint32	count,
		Player const *	player = `nullptr`,
		bool	clone = `false`,
		uint32	randomPropertyId = `0`
	)

static

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

References ABORT, ASSERT_NODEBUGINFO, Create(), GenerateItemRandomPropertyId(), ItemTemplate::GetMaxStackSize(), NewItemOrBag(), SetCount(), SetItemRandomProperties(), and sObjectMgr.

Referenced by Player::CanEquipNewItem(), CloneItem(), AchievementMgr::CompletedAchievement(), Spell::EffectSummonChangeItem(), Player::EquipNewItem(), item_commandscript::HandleItemRefundCommand(), item_commandscript::HandleItemRestoreCommand(), quest_commandscript::HandleQuestComplete(), quest_commandscript::HandleQuestReward(), send_commandscript::HandleSendItemsCommand(), MailDraft::prepareItems(), Player::SendItemRetrievalMail(), ObjectMgr::SendServerMail(), and Player::StoreNewItem().

◆ DeleteFromDB() [1/2]

void Item::DeleteFromDB ( CharacterDatabaseTransaction trans )

virtual

Reimplemented in Bag.

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

References DeleteFromDB(), and Object::GetGUID().

◆ DeleteFromDB() [2/2]

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

static

{
    sScriptMgr->OnGlobalItemDelFromDB(trans, itemGuid);
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE);
    stmt->SetData(0, itemGuid);
    trans->Append(stmt);
}

References CHAR_DEL_ITEM_INSTANCE, CharacterDatabase, PreparedStatementBase::SetData(), and sScriptMgr.

Referenced by Player::_LoadItem(), Guild::BankMoveItemData::_StoreItem(), DeleteFromDB(), Bag::DeleteFromDB(), and WorldSession::HandleAuctionSellItem().

◆ DeleteFromInventoryDB() [1/2]

void Item::DeleteFromInventoryDB ( CharacterDatabaseTransaction trans )

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

References DeleteFromInventoryDB(), and Object::GetGUID().

◆ DeleteFromInventoryDB() [2/2]

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

static

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

References CHAR_DEL_CHAR_INVENTORY_BY_ITEM, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by Player::_LoadItem(), Player::AutoUnequipOffhandIfNeed(), DeleteFromInventoryDB(), WorldSession::HandleAuctionSellItem(), and WorldSession::HandleSendMail().

◆ DeleteRefundDataFromDB()

void Item::DeleteRefundDataFromDB ( CharacterDatabaseTransaction * trans )

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

References CHAR_DEL_ITEM_REFUND_INSTANCE, CharacterDatabase, Object::GetGUID(), and PreparedStatementBase::SetData().

Referenced by SetNotRefundable().

◆ FSetState()

void Item::FSetState ( ItemUpdateState state )

inline

    {
        uState = state;
    }

References uState.

Referenced by Player::_LoadItem(), Player::_LoadMailedItem(), Player::_SaveInventory(), and WorldSession::HandleSendMail().

◆ GemsFitSockets()

bool Item::GemsFitSockets ( ) const

{
    for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + MAX_GEM_SOCKETS; ++enchant_slot)
    {
        uint8 SocketColor = GetTemplate()->Socket[enchant_slot - SOCK_ENCHANTMENT_SLOT].Color;
 
        if (!SocketColor) // no socket slot
            continue;
 
        uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
        if (!enchant_id) // no gems on this socket
            return false;
 
        SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
        if (!enchantEntry) // invalid gem id on this socket
            return false;
 
        uint8 GemColor = 0;
 
        uint32 gemid = enchantEntry->GemID;
        if (gemid)
        {
            ItemTemplate const* gemProto = sObjectMgr->GetItemTemplate(gemid);
            if (gemProto)
            {
                GemPropertiesEntry const* gemProperty = sGemPropertiesStore.LookupEntry(gemProto->GemProperties);
                if (gemProperty)
                    GemColor = gemProperty->color;
            }
        }
 
        if (!(GemColor & SocketColor)) // bad gem color on this socket
            return false;
    }
    return true;
}

References _Socket::Color, GemPropertiesEntry::color, SpellItemEnchantmentEntry::GemID, ItemTemplate::GemProperties, GetEnchantmentId(), GetTemplate(), MAX_GEM_SOCKETS, sGemPropertiesStore, sObjectMgr, SOCK_ENCHANTMENT_SLOT, ItemTemplate::Socket, and sSpellItemEnchantmentStore.

Referenced by WorldSession::HandleSocketOpcode().

◆ GenerateItemRandomPropertyId()

int32 Item::GenerateItemRandomPropertyId ( uint32 item_id )

static

{
    ItemTemplate const* itemProto = sObjectMgr->GetItemTemplate(item_id);
 
    if (!itemProto)
        return 0;
 
    // item must have one from this field values not null if it can have random enchantments
    if ((!itemProto->RandomProperty) && (!itemProto->RandomSuffix))
        return 0;
 
    // item can have not null only one from field values
    if ((itemProto->RandomProperty) && (itemProto->RandomSuffix))
    {
        LOG_ERROR("sql.sql", "Item template {} have RandomProperty == {} and RandomSuffix == {}, but must have one from field =0", itemProto->ItemId, itemProto->RandomProperty, itemProto->RandomSuffix);
        return 0;
    }
 
    // RandomProperty case
    if (itemProto->RandomProperty)
    {
        uint32 randomPropId = GetItemEnchantMod(itemProto->RandomProperty);
        ItemRandomPropertiesEntry const* random_id = sItemRandomPropertiesStore.LookupEntry(randomPropId);
        if (!random_id)
        {
            LOG_ERROR("sql.sql", "Enchantment id #{} used but it doesn't have records in 'ItemRandomProperties.dbc'", randomPropId);
            return 0;
        }
 
        return random_id->ID;
    }
    // RandomSuffix case
    else
    {
        uint32 randomPropId = GetItemEnchantMod(itemProto->RandomSuffix);
        ItemRandomSuffixEntry const* random_id = sItemRandomSuffixStore.LookupEntry(randomPropId);
        if (!random_id)
        {
            LOG_ERROR("sql.sql", "Enchantment id #{} used but it doesn't have records in sItemRandomSuffixStore.", randomPropId);
            return 0;
        }
 
        return -int32(random_id->ID);
    }
}

References GetItemEnchantMod(), ItemRandomPropertiesEntry::ID, ItemRandomSuffixEntry::ID, ItemTemplate::ItemId, LOG_ERROR, ItemTemplate::RandomProperty, ItemTemplate::RandomSuffix, sItemRandomPropertiesStore, sItemRandomSuffixStore, and sObjectMgr.

Referenced by CreateItem(), and LootItem::LootItem().

◆ GetBagSlot()

uint8 Item::GetBagSlot ( ) const

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

References GetSlot(), INVENTORY_SLOT_BAG_0, and m_container.

Referenced by Player::_SaveInventory(), Player::AddQuestAndCheckCompletion(), Player::DestroyItemCount(), WorldSession::DoLootRelease(), Spell::EffectSummonChangeItem(), GetDebugInfo(), GetPos(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleAutoEquipItemOpcode(), debug_commandscript::HandleDebugItemExpireCommand(), WorldSession::HandleOpenWrappedItemCallback(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleTurnInPetitionOpcode(), Player::RefundItem(), Player::SendNewItem(), UpdateDuration(), and Bag::~Bag().

◆ GetContainer()

Bag * Item::GetContainer ( )

inline

273{ return m_container; }

References m_container.

Referenced by Player::_SaveInventory(), and debug_commandscript::HandleDebugGetItemStateCommand().

◆ GetCount()

uint32 Item::GetCount ( ) const

inline

263{ return GetUInt32Value(ITEM_FIELD_STACK_COUNT); }

References Object::GetUInt32Value(), and ITEM_FIELD_STACK_COUNT.

Referenced by Guild::_DoItemsMove(), Guild::BankMoveItemData::_ReserveSpace(), Player::_StoreItem(), AuctionEntry::BuildAuctionInfo(), Player::CanBankItem(), CanBeMergedPartlyWith(), Player::CanEquipItem(), Guild::BankMoveItemData::CanStore(), Player::CanStoreItem(), Player::CanStoreItem_InBag(), Player::CanStoreItem_InInventorySlots(), Player::CanStoreItem_InSpecificSlot(), Player::CanStoreItems(), Player::CanTakeMoreSimilarItems(), Player::CanUnequipItem(), Spell::CheckItems(), Group::CountTheRoll(), Player::DestroyItem(), Player::DestroyItemCount(), WorldSession::DoLootRelease(), Spell::EffectMilling(), Spell::EffectProspecting(), Player::EquipItem(), GetDebugInfo(), Bag::GetItemCount(), Bag::GetItemCountWithLimitCategory(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleAutoBankItemOpcode(), WorldSession::HandleAutoStoreBankItemOpcode(), WorldSession::HandleBuybackItem(), WorldSession::HandleGetMailList(), WorldSession::HandleMailTakeItem(), WorldSession::HandleSellItemOpcode(), Player::HasItemCount(), Player::HasItemOrGemWithIdEquipped(), Player::HasItemOrGemWithLimitCategoryEquipped(), Player::MoveItemToInventory(), WorldSession::recoveryItem(), SaveToDB(), Player::SendNewItem(), Player::SplitItem(), Guild::BankMoveItemData::StoreItem(), and Player::SwapItem().

◆ 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();
}

References GetBagSlot(), GetCount(), Object::GetDebugInfo(), GetOwnerGUID(), GetSlot(), IsEquipped(), and ObjectGuid::ToString().

Referenced by Bag::GetDebugInfo().

◆ GetEnchantmentCharges()

uint32 Item::GetEnchantmentCharges ( EnchantmentSlot slot ) const

inline

297{ return GetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_CHARGES_OFFSET);}

ENCHANTMENT_CHARGES_OFFSET

@ ENCHANTMENT_CHARGES_OFFSET

Definition: Item.h:188

References ENCHANTMENT_CHARGES_OFFSET, Object::GetUInt32Value(), ITEM_FIELD_ENCHANTMENT_1_1, and MAX_ENCHANTMENT_OFFSET.

Referenced by AuctionEntry::BuildAuctionInfo(), Player::CastItemCombatSpell(), Spell::EffectSummonChangeItem(), WorldSession::HandleGetMailList(), SaveToDB(), SetEnchantment(), SetEnchantmentCharges(), and Player::SetVirtualItemSlot().

◆ GetEnchantmentDuration()

uint32 Item::GetEnchantmentDuration ( EnchantmentSlot slot ) const

inline

296{ return GetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_DURATION_OFFSET);}

ENCHANTMENT_DURATION_OFFSET

@ ENCHANTMENT_DURATION_OFFSET

Definition: Item.h:187

References ENCHANTMENT_DURATION_OFFSET, Object::GetUInt32Value(), ITEM_FIELD_ENCHANTMENT_1_1, and MAX_ENCHANTMENT_OFFSET.

Referenced by Player::AddEnchantmentDurations(), Player::ApplyEnchantment(), AuctionEntry::BuildAuctionInfo(), Spell::EffectSummonChangeItem(), WorldSession::HandleGetMailList(), SaveToDB(), SetEnchantment(), and SetEnchantmentDuration().

◆ GetEnchantmentId()

uint32 Item::GetEnchantmentId ( EnchantmentSlot slot ) const

inline

295{ return GetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_ID_OFFSET);}

ENCHANTMENT_ID_OFFSET

@ ENCHANTMENT_ID_OFFSET

Definition: Item.h:186

References ENCHANTMENT_ID_OFFSET, Object::GetUInt32Value(), ITEM_FIELD_ENCHANTMENT_1_1, and MAX_ENCHANTMENT_OFFSET.

Referenced by Player::AddEnchantmentDurations(), Player::ApplyEnchantment(), AuctionEntry::BuildAuctionInfo(), Player::BuildEnchantmentsInfoData(), Player::CanEquipUniqueItem(), Player::CastItemCombatSpell(), Player::CastItemUseSpell(), Spell::CheckItems(), ClearEnchantment(), Player::CorrectMetaGemEnchants(), Spell::EffectEnchantHeldItem(), Spell::EffectSummonChangeItem(), Player::EnchantmentFitsRequirements(), GemsFitSockets(), GetEnchantRequiredLevel(), GetGemCountWithID(), GetGemCountWithLimitCategory(), spell_rog_deadly_poison::HandleAfterHit(), WorldSession::HandleCancelTempEnchantmentOpcode(), Unit::HandleDummyAuraProc(), WorldSession::HandleGetMailList(), WorldSession::HandleSocketOpcode(), HasEnchantRequiredSkill(), Player::HasItemOrGemWithLimitCategoryEquipped(), HasSocket(), IsBoundByEnchant(), IsBoundByTempEnchant(), SaveToDB(), SendUpdateSockets(), SetEnchantment(), Player::SetVirtualItemSlot(), Player::SetVisibleItemSlot(), Player::ToggleMetaGemsActive(), and Player::UpdateSkillEnchantments().

◆ 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->requiredLevel > level)
                    level = enchantEntry->requiredLevel;
 
    return level;
}

References GetEnchantmentId(), MAX_ENCHANTMENT_SLOT, PERM_ENCHANTMENT_SLOT, and sSpellItemEnchantmentStore.

◆ GetGemCountWithID()

uint8 Item::GetGemCountWithID ( uint32 GemID ) const

{
    uint8 count = 0;
    for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + MAX_GEM_SOCKETS; ++enchant_slot)
    {
        uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
        if (!enchant_id)
            continue;
 
        SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
        if (!enchantEntry)
            continue;
 
        if (GemID == enchantEntry->GemID)
            ++count;
    }
    return count;
}

References SpellItemEnchantmentEntry::GemID, GetEnchantmentId(), MAX_GEM_SOCKETS, SOCK_ENCHANTMENT_SLOT, and sSpellItemEnchantmentStore.

Referenced by Bag::GetItemCount(), and Player::HasItemOrGemWithIdEquipped().

◆ GetGemCountWithLimitCategory()

uint8 Item::GetGemCountWithLimitCategory ( uint32 limitCategory ) const

{
    uint8 count = 0;
    for (uint32 enchant_slot = SOCK_ENCHANTMENT_SLOT; enchant_slot < SOCK_ENCHANTMENT_SLOT + MAX_GEM_SOCKETS; ++enchant_slot)
    {
        uint32 enchant_id = GetEnchantmentId(EnchantmentSlot(enchant_slot));
        if (!enchant_id)
            continue;
 
        SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
        if (!enchantEntry)
            continue;
 
        ItemTemplate const* gemProto = sObjectMgr->GetItemTemplate(enchantEntry->GemID);
        if (!gemProto)
            continue;
 
        if (gemProto->ItemLimitCategory == limitCategory)
            ++count;
    }
    return count;
}

References SpellItemEnchantmentEntry::GemID, GetEnchantmentId(), ItemTemplate::ItemLimitCategory, MAX_GEM_SOCKETS, sObjectMgr, SOCK_ENCHANTMENT_SLOT, and sSpellItemEnchantmentStore.

Referenced by Player::CanEquipUniqueItem(), and Player::HasItemOrGemWithLimitCategoryEquipped().

◆ GetItemRandomPropertyId()

int32 Item::GetItemRandomPropertyId ( ) const

inline

286{ return GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID); }

ITEM_FIELD_RANDOM_PROPERTIES_ID

@ ITEM_FIELD_RANDOM_PROPERTIES_ID

Definition: UpdateFields.h:68

Object::GetInt32Value

int32 GetInt32Value(uint16 index) const

Definition: Object.cpp:299

References Object::GetInt32Value(), and ITEM_FIELD_RANDOM_PROPERTIES_ID.

Referenced by Player::ApplyEnchantment(), AuctionEntry::BuildAuctionInfo(), Player::BuildEnchantmentsInfoData(), AuctionHouseObject::BuildListAuctionItems(), CloneItem(), WorldSession::HandleGetMailList(), LoadFromDB(), SaveToDB(), and Player::SendNewItem().

◆ GetItemSuffixFactor()

uint32 Item::GetItemSuffixFactor ( ) const

inline

287{ return GetUInt32Value(ITEM_FIELD_PROPERTY_SEED); }

ITEM_FIELD_PROPERTY_SEED

@ ITEM_FIELD_PROPERTY_SEED

Definition: UpdateFields.h:67

References Object::GetUInt32Value(), and ITEM_FIELD_PROPERTY_SEED.

Referenced by Player::ApplyEnchantment(), AuctionEntry::BuildAuctionInfo(), Player::BuildEnchantmentsInfoData(), WorldSession::HandleGetMailList(), Player::SendNewItem(), SetItemRandomProperties(), and UpdateItemSuffixFactor().

◆ GetMaxStackCount()

uint32 Item::GetMaxStackCount ( ) const

inline

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

References ItemTemplate::GetMaxStackSize(), and GetTemplate().

Referenced by Guild::BankMoveItemData::_ReserveSpace(), Guild::BankMoveItemData::CanStore(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleWrapItemOpcode(), and Spell::TakeAmmo().

◆ GetOwner()

Player * Item::GetOwner ( ) const

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

References ObjectAccessor::FindPlayer(), and GetOwnerGUID().

Referenced by AddToObjectUpdate(), BuildUpdate(), CanBeTraded(), Spell::CheckItems(), CheckSoulboundTradeExpire(), ClearEnchantment(), Spell::EffectEnchantItemPerm(), Spell::EffectEnchantItemPrismatic(), Spell::EffectEnchantItemTmp(), Spell::EffectOpenLock(), RemoveFromObjectUpdate(), SendUpdateSockets(), SetEnchantment(), SetEnchantmentCharges(), and SetItemRandomProperties().

◆ GetOwnerGUID()

ObjectGuid Item::GetOwnerGUID ( ) const

inline

225{ return GetGuidValue(ITEM_FIELD_OWNER); }

Object::GetGuidValue

ObjectGuid GetGuidValue(uint16 index) const

Definition: Object.cpp:337

References Object::GetGuidValue(), and ITEM_FIELD_OWNER.

Referenced by AddToUpdateQueueOf(), Spell::CheckItems(), Spell::EffectSummonChangeItem(), GetDebugInfo(), GetOwner(), debug_commandscript::HandleDebugGetItemStateCommand(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleWrapItemOpcode(), IsBindedNotWith(), Player::MoveItemToInventory(), WorldSession::recoveryItem(), RemoveFromUpdateQueueOf(), SaveToDB(), SetEnchantment(), and Bag::StoreItem().

◆ GetPaidExtendedCost()

uint32 Item::GetPaidExtendedCost ( )

inline

340{ return m_paidExtendedCost; }

References m_paidExtendedCost.

Referenced by Player::RefundItem(), SaveRefundDataToDB(), and Player::SendRefundInfo().

◆ GetPaidMoney()

uint32 Item::GetPaidMoney ( )

inline

339{ return m_paidMoney; }

References m_paidMoney.

Referenced by Player::RefundItem(), SaveRefundDataToDB(), and Player::SendRefundInfo().

◆ GetPlayedTime()

uint32 Item::GetPlayedTime ( )

{
    time_t curtime = GameTime::GetGameTime().count();
    uint32 elapsed = uint32(curtime - m_lastPlayedTimeUpdate);
    return GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME) + elapsed;
}

References GameTime::GetGameTime(), Object::GetUInt32Value(), ITEM_FIELD_CREATE_PLAYED_TIME, and m_lastPlayedTimeUpdate.

Referenced by Player::_LoadItem(), IsRefundExpired(), and Player::SendRefundInfo().

◆ GetPos()

uint16 Item::GetPos ( ) const

inline

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

uint16

std::uint16_t uint16

Definition: Define.h:109

References GetBagSlot(), and GetSlot().

Referenced by CanBeTraded(), Spell::EffectSummonChangeItem(), WorldSession::HandleAutoBankItemOpcode(), WorldSession::HandleAutoEquipItemOpcode(), WorldSession::HandleAutoEquipItemSlotOpcode(), WorldSession::HandleAutoStoreBagItemOpcode(), WorldSession::HandleEquipmentSetUse(), WorldSession::HandleGossipSelectOptionOpcode(), and WorldSession::HandleRepairItemOpcode().

◆ GetQueuePos()

uint32 Item::GetQueuePos ( ) const

inline

320{ return uQueuePos; }

References uQueuePos.

Referenced by debug_commandscript::HandleDebugGetItemStateCommand().

◆ GetRefundRecipient()

ObjectGuid::LowType Item::GetRefundRecipient ( )

inline

338{ return m_refundRecipient; }

References m_refundRecipient.

Referenced by Player::RefundItem(), SaveRefundDataToDB(), and Player::SendRefundInfo().

◆ GetScriptId()

uint32 Item::GetScriptId ( ) const

inline

355{ return GetTemplate()->ScriptId; }

ItemTemplate::ScriptId

uint32 ScriptId

Definition: ItemTemplate.h:698

References GetTemplate(), and ItemTemplate::ScriptId.

Referenced by ScriptMgr::OnCastItemCombatSpell(), ScriptMgr::OnGossipSelect(), ScriptMgr::OnGossipSelectCode(), ScriptMgr::OnItemRemove(), ScriptMgr::OnItemUse(), and ScriptMgr::OnQuestAccept().

◆ GetSkill()

uint32 Item::GetSkill ( )

{
    return GetTemplate()->GetSkill();
}

References ItemTemplate::GetSkill(), and GetTemplate().

Referenced by Player::CanUseItem(), Player::GetBaseWeaponSkillValue(), Unit::GetWeaponSkillValue(), and Player::UpdateWeaponSkill().

◆ GetSlot()

uint8 Item::GetSlot ( ) const

inline

272{return m_slot;}

References m_slot.

Referenced by Player::_SaveInventory(), Player::AddQuestAndCheckCompletion(), Player::ApplyEnchantment(), Player::CanBankItem(), Player::CanUnequipItem(), Player::DestroyItemCount(), WorldSession::DoLootRelease(), Player::DurabilityPointsLoss(), Spell::EffectSummonChangeItem(), GetBagSlot(), GetDebugInfo(), GetPos(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleAutoEquipItemOpcode(), debug_commandscript::HandleDebugGetItemStateCommand(), debug_commandscript::HandleDebugItemExpireCommand(), Unit::HandleDummyAuraProc(), WorldSession::HandleOpenWrappedItemCallback(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleSendMail(), WorldSession::HandleSocketOpcode(), WorldSession::HandleTurnInPetitionOpcode(), Player::RefundItem(), Player::SendNewItem(), UpdateDuration(), and Bag::~Bag().

◆ GetSpell()

uint32 Item::GetSpell ( )

{
    ItemTemplate const* proto = GetTemplate();
 
    switch (proto->Class)
    {
        case ITEM_CLASS_WEAPON:
            switch (proto->SubClass)
            {
                case ITEM_SUBCLASS_WEAPON_AXE:
                    return  196;
                case ITEM_SUBCLASS_WEAPON_AXE2:
                    return  197;
                case ITEM_SUBCLASS_WEAPON_BOW:
                    return  264;
                case ITEM_SUBCLASS_WEAPON_GUN:
                    return  266;
                case ITEM_SUBCLASS_WEAPON_MACE:
                    return  198;
                case ITEM_SUBCLASS_WEAPON_MACE2:
                    return  199;
                case ITEM_SUBCLASS_WEAPON_POLEARM:
                    return  200;
                case ITEM_SUBCLASS_WEAPON_SWORD:
                    return  201;
                case ITEM_SUBCLASS_WEAPON_SWORD2:
                    return  202;
                case ITEM_SUBCLASS_WEAPON_STAFF:
                    return  227;
                case ITEM_SUBCLASS_WEAPON_DAGGER:
                    return 1180;
                case ITEM_SUBCLASS_WEAPON_THROWN:
                    return 2567;
                case ITEM_SUBCLASS_WEAPON_SPEAR:
                    return 3386;
                case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                    return 5011;
                case ITEM_SUBCLASS_WEAPON_WAND:
                    return 5009;
                default:
                    return 0;
            }
        case ITEM_CLASS_ARMOR:
            switch (proto->SubClass)
            {
                case ITEM_SUBCLASS_ARMOR_CLOTH:
                    return 9078;
                case ITEM_SUBCLASS_ARMOR_LEATHER:
                    return 9077;
                case ITEM_SUBCLASS_ARMOR_MAIL:
                    return 8737;
                case ITEM_SUBCLASS_ARMOR_PLATE:
                    return  750;
                case ITEM_SUBCLASS_ARMOR_SHIELD:
                    return 9116;
                default:
                    return 0;
            }
    }
    return 0;
}

◆ GetSpellCharges()

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

inline

308{ return GetInt32Value(ITEM_FIELD_SPELL_CHARGES + index); }

ITEM_FIELD_SPELL_CHARGES

@ ITEM_FIELD_SPELL_CHARGES

Definition: UpdateFields.h:41

References Object::GetInt32Value(), and ITEM_FIELD_SPELL_CHARGES.

Referenced by AuctionEntry::BuildAuctionInfo(), Spell::CheckItems(), WorldSession::HandleGetMailList(), SaveToDB(), Spell::TakeCastItem(), and Spell::TakeReagents().

◆ GetState()

ItemUpdateState Item::GetState ( ) const

inline

315{ return uState; }

References uState.

Referenced by Player::_SaveInventory(), debug_commandscript::HandleDebugGetItemStateCommand(), WorldSession::HandleSendMail(), and WorldSession::HandleWrapItemOpcode().

◆ GetTemplate()

ItemTemplate const * Item::GetTemplate ( ) const

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

References Object::GetEntry(), and sObjectMgr.

◆ GetText()

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

inline

299{ return m_text; }

Item::m_text

std::string m_text

Definition: Item.h:359

References m_text.

◆ 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->requiredSkill && player->GetSkillValue(enchantEntry->requiredSkill) < enchantEntry->requiredSkillValue)
                    return false;
 
    return true;
}

References GetEnchantmentId(), Player::GetSkillValue(), MAX_ENCHANTMENT_SLOT, PERM_ENCHANTMENT_SLOT, and sSpellItemEnchantmentStore.

◆ hasInvolvedQuest()

bool Item::hasInvolvedQuest ( uint32 ) const

inlineoverridevirtual

Reimplemented from Object.

327{ return false; }

◆ hasQuest()

bool Item::hasQuest ( uint32 quest_id ) const

inlineoverridevirtual

Reimplemented from Object.

326{ return GetTemplate()->StartQuest == quest_id; }

ItemTemplate::StartQuest

uint32 StartQuest

Definition: ItemTemplate.h:677

References GetTemplate(), and ItemTemplate::StartQuest.

◆ HasSocket()

bool Item::HasSocket ( ) const

{
    // There can only be one socket added, and it's always in slot `PRISMATIC_ENCHANTMENT_SLOT`.
    //     Built-in sockets                        Socket from upgrade
    return this->GetTemplate()->Socket[0].Color || this->GetEnchantmentId(EnchantmentSlot(PRISMATIC_ENCHANTMENT_SLOT));
}

References _Socket::Color, GetEnchantmentId(), GetTemplate(), PRISMATIC_ENCHANTMENT_SLOT, and ItemTemplate::Socket.

Referenced by Player::_ApplyItemMods(), Player::CorrectMetaGemEnchants(), and Player::EnchantmentFitsRequirements().

◆ IsArmorVellum()

bool Item::IsArmorVellum ( ) const

inline

330{ return GetTemplate()->IsArmorVellum(); }

ItemTemplate::IsArmorVellum

bool IsArmorVellum() const

Definition: ItemTemplate.h:828

References GetTemplate(), and ItemTemplate::IsArmorVellum().

Referenced by Spell::CheckItems(), and Spell::EffectEnchantItemPerm().

◆ IsBag()

bool Item::IsBag ( ) const

inline

248{ return GetTemplate()->InventoryType == INVTYPE_BAG; }

INVTYPE_BAG

@ INVTYPE_BAG

Definition: ItemTemplate.h:283

ItemTemplate::InventoryType

uint32 InventoryType

Definition: ItemTemplate.h:641

References GetTemplate(), ItemTemplate::InventoryType, and INVTYPE_BAG.

Referenced by Player::CanBankItem(), CanBeTraded(), Player::CanStoreItem(), WorldSession::HandleAutoEquipItemOpcode(), WorldSession::HandleWrapItemOpcode(), Player::SwapItem(), and ToBag().

◆ IsBindedNotWith()

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

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

References allowedGUIDs, Object::GetGUID(), GetOwnerGUID(), Object::HasFlag(), IsBoundAccountWide(), IsSoulBound(), ITEM_FIELD_FLAG_BOP_TRADEABLE, and ITEM_FIELD_FLAGS.

Referenced by Player::CanBankItem(), Player::CanEquipItem(), Player::CanStoreItem(), Player::CanStoreItems(), and Player::CanUseItem().

◆ IsBoundAccountWide()

bool Item::IsBoundAccountWide ( ) const

inline

231{ return (GetTemplate()->Flags & ITEM_FLAG_IS_BOUND_TO_ACCOUNT) != 0; }

ITEM_FLAG_IS_BOUND_TO_ACCOUNT

@ ITEM_FLAG_IS_BOUND_TO_ACCOUNT

Definition: ItemTemplate.h:175

References GetTemplate(), and ITEM_FLAG_IS_BOUND_TO_ACCOUNT.

Referenced by CanBeTraded(), WorldSession::HandleSendMail(), and IsBindedNotWith().

◆ 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->slot & ENCHANTMENT_CAN_SOULBOUND)
                    return true;
    return false;
}

References ENCHANTMENT_CAN_SOULBOUND, GetEnchantmentId(), MAX_ENCHANTMENT_SLOT, PERM_ENCHANTMENT_SLOT, and sSpellItemEnchantmentStore.

Referenced by CanBeTraded().

◆ IsBoundByTempEnchant()

bool Item::IsBoundByTempEnchant ( ) const

{
    if (uint32 enchant_id = GetEnchantmentId(TEMP_ENCHANTMENT_SLOT))
        if (SpellItemEnchantmentEntry const* enchantEntry = sSpellItemEnchantmentStore.LookupEntry(enchant_id))
            if (enchantEntry->slot & ENCHANTMENT_CAN_SOULBOUND)
                return true;
    return false;
}

References ENCHANTMENT_CAN_SOULBOUND, GetEnchantmentId(), sSpellItemEnchantmentStore, and TEMP_ENCHANTMENT_SLOT.

Referenced by CanBeTraded().

◆ IsBroken()

◆ IsConjuredConsumable()

bool Item::IsConjuredConsumable ( ) const

inline

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

ItemTemplate::IsConjuredConsumable

bool IsConjuredConsumable() const

Definition: ItemTemplate.h:829

References GetTemplate(), and ItemTemplate::IsConjuredConsumable().

◆ IsCurrencyToken()

bool Item::IsCurrencyToken ( ) const

inline

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

ItemTemplate::IsCurrencyToken

bool IsCurrencyToken() const

Definition: ItemTemplate.h:736

References GetTemplate(), and ItemTemplate::IsCurrencyToken().

◆ IsEquipped()

bool Item::IsEquipped ( ) const

{
    return !IsInBag() && m_slot < EQUIPMENT_SLOT_END;
}

References EQUIPMENT_SLOT_END, IsInBag(), and m_slot.

Referenced by Player::ApplyEnchantment(), Player::CanEquipUniqueItem(), Player::DurabilityPointsLoss(), Spell::EffectEnchantHeldItem(), GetDebugInfo(), Unit::HandleDummyAuraProc(), WorldSession::HandleEquipmentSetUse(), WorldSession::HandleSocketOpcode(), WorldSession::HandleUseItemOpcode(), and WorldSession::HandleWrapItemOpcode().

◆ IsFitToSpellRequirements()

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

{
    ItemTemplate const* proto = GetTemplate();
 
    if (spellInfo->EquippedItemClass != -1)                 // -1 == any item class
    {
        // Special case - accept vellum for armor/weapon requirements
        if ((spellInfo->EquippedItemClass == ITEM_CLASS_ARMOR && proto->IsArmorVellum())
                || (spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON && proto->IsWeaponVellum()))
            if (spellInfo->IsAbilityOfSkillType(SKILL_ENCHANTING)) // only for enchanting spells
                return true;
 
        if (spellInfo->EquippedItemClass != int32(proto->Class))
            return false;                                   //  wrong item class
 
        if (spellInfo->EquippedItemSubClassMask != 0)        // 0 == any subclass
        {
            if ((spellInfo->EquippedItemSubClassMask & (1 << proto->SubClass)) == 0)
                return false;                               // subclass not present in mask
        }
    }
 
    if (spellInfo->EquippedItemInventoryTypeMask != 0)       // 0 == any inventory type
    {
        // Special case - accept weapon type for main and offhand requirements
        if (proto->InventoryType == INVTYPE_WEAPON &&
                (spellInfo->EquippedItemInventoryTypeMask & (1 << INVTYPE_WEAPONMAINHAND) ||
                 spellInfo->EquippedItemInventoryTypeMask & (1 << INVTYPE_WEAPONOFFHAND)))
            return true;
        else if ((spellInfo->EquippedItemInventoryTypeMask & (1 << proto->InventoryType)) == 0)
            return false;                                   // inventory type not present in mask
    }
 
    return true;
}

References ItemTemplate::Class, SpellInfo::EquippedItemClass, SpellInfo::EquippedItemInventoryTypeMask, SpellInfo::EquippedItemSubClassMask, GetTemplate(), ItemTemplate::InventoryType, INVTYPE_WEAPON, INVTYPE_WEAPONMAINHAND, INVTYPE_WEAPONOFFHAND, SpellInfo::IsAbilityOfSkillType(), ItemTemplate::IsArmorVellum(), ItemTemplate::IsWeaponVellum(), ITEM_CLASS_ARMOR, ITEM_CLASS_WEAPON, SKILL_ENCHANTING, and ItemTemplate::SubClass.

Referenced by Player::_ApplyWeaponDependentAuraCritMod(), Player::_ApplyWeaponDependentAuraDamageMod(), Spell::CheckItems(), Player::HasItemFitToSpellRequirements(), Aura::IsProcTriggeredOnEvent(), and Player::UpdateExpertise().

◆ IsInBag()

bool Item::IsInBag ( ) const

inline

279{ return m_container != nullptr; }

References m_container.

Referenced by IsEquipped().

◆ IsInTrade()

bool Item::IsInTrade ( ) const

inline

254{ return mb_in_trade; }

References mb_in_trade.

Referenced by Player::CanStoreItems(), and Player::HasItemCount().

◆ IsInUpdateQueue()

bool Item::IsInUpdateQueue ( ) const

inline

319{ return uQueuePos != -1; }

References uQueuePos.

Referenced by AddToUpdateQueueOf(), debug_commandscript::HandleDebugGetItemStateCommand(), and RemoveFromUpdateQueueOf().

◆ IsLimitedToAnotherMapOrZone()

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

{
    ItemTemplate const* proto = GetTemplate();
    return proto && ((proto->Map && proto->Map != cur_mapId) || (proto->Area && proto->Area != cur_zoneId));
}

References ItemTemplate::Area, GetTemplate(), and ItemTemplate::Map.

Referenced by Player::_LoadItem().

◆ IsLocked()

bool Item::IsLocked ( ) const

inline

247{ return !HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_UNLOCKED); }

ITEM_FIELD_FLAG_UNLOCKED

@ ITEM_FIELD_FLAG_UNLOCKED

Definition: ItemTemplate.h:112

References Object::HasFlag(), ITEM_FIELD_FLAG_UNLOCKED, and ITEM_FIELD_FLAGS.

Referenced by Spell::CheckCast(), and WorldSession::HandleOpenItemOpcode().

◆ IsNotEmptyBag()

bool Item::IsNotEmptyBag ( ) const

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

References ToBag().

Referenced by Player::CanBankItem(), Player::CanStoreItem(), Player::CanStoreItem_InBag(), Player::CanStoreItem_InInventorySlots(), Player::CanStoreItem_InSpecificSlot(), Player::CanUnequipItem(), Player::DestroyItem(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleSendMail(), and Player::SwapItem().

◆ IsPotion()

bool Item::IsPotion ( ) const

inline

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

ItemTemplate::IsPotion

bool IsPotion() const

Definition: ItemTemplate.h:826

References GetTemplate(), and ItemTemplate::IsPotion().

Referenced by Spell::CheckCast(), and Spell::SendSpellCooldown().

◆ IsRefundExpired()

bool Item::IsRefundExpired ( )

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

References GetPlayedTime(), and HOUR.

Referenced by Player::RefundItem().

◆ IsSoulBound()

bool Item::IsSoulBound ( ) const

inline

230{ return HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_SOULBOUND); }

ITEM_FIELD_FLAG_SOULBOUND

@ ITEM_FIELD_FLAG_SOULBOUND

Definition: ItemTemplate.h:110

References Object::HasFlag(), ITEM_FIELD_FLAG_SOULBOUND, and ITEM_FIELD_FLAGS.

Referenced by Player::_LoadItem(), CanBeTraded(), Guild::BankMoveItemData::CanStore(), WorldSession::HandleSendMail(), WorldSession::HandleUseItemOpcode(), WorldSession::HandleWrapItemOpcode(), IsBindedNotWith(), LoadFromDB(), and Player::StoreNewItem().

◆ IsWeaponVellum()

bool Item::IsWeaponVellum ( ) const

inline

329{ return GetTemplate()->IsWeaponVellum(); }

References GetTemplate(), and ItemTemplate::IsWeaponVellum().

Referenced by Spell::CheckItems(), and Spell::EffectEnchantItemPerm().

◆ LoadFromDB()

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

virtual

Reimplemented in Bag.

{
    //                                                    0                1      2         3        4      5             6                 7           8           9    10
    //result = CharacterDatabase.Query("SELECT creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments, randomPropertyId, durability, playedTime, text FROM item_instance WHERE guid = '{}'", guid);
 
    // create item before any checks for store correct guid
    // and allow use "FSetState(ITEM_REMOVED); SaveToDB();" for deleting item from DB
    Object::_Create(guid, 0, HighGuid::Item);
 
    // Set entry, MUST be before proto check
    SetEntry(entry);
    SetObjectScale(1.0f);
 
    ItemTemplate const* proto = GetTemplate();
    if (!proto)
    {
        LOG_ERROR("entities.item", "Invalid entry {} for item {}. Refusing to load.", GetEntry(), GetGUID().ToString());
        return false;
    }
 
    // set owner (not if item is only loaded for gbank/auction/mail
    if (owner_guid)
        SetOwnerGUID(owner_guid);
 
    bool need_save = false;                                 // need explicit save data at load fixes
    SetGuidValue(ITEM_FIELD_CREATOR, ObjectGuid::Create<HighGuid::Player>(fields[0].Get<uint32>()));
    SetGuidValue(ITEM_FIELD_GIFTCREATOR, ObjectGuid::Create<HighGuid::Player>(fields[1].Get<uint32>()));
    SetCount(fields[2].Get<uint32>());
 
    uint32 duration = fields[3].Get<uint32>();
    SetUInt32Value(ITEM_FIELD_DURATION, duration);
    // update duration if need, and remove if not need
    if ((proto->Duration == 0) != (duration == 0))
    {
        SetUInt32Value(ITEM_FIELD_DURATION, proto->Duration);
        need_save = true;
    }
 
    std::vector<std::string_view> tokens = Acore::Tokenize(fields[4].Get<std::string_view>(), ' ', false);
    if (tokens.size() == MAX_ITEM_PROTO_SPELLS)
    {
        for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
        {
            if (Optional<int32> charges = Acore::StringTo<int32>(tokens[i]))
                SetSpellCharges(i, *charges);
            else
                LOG_ERROR("entities.item", "Invalid charge info '{}' for item {}, charge data not loaded.", tokens.at(i), GetGUID().ToString());
        }
    }
 
    SetUInt32Value(ITEM_FIELD_FLAGS, fields[5].Get<uint32>());
    // Remove bind flag for items vs NO_BIND set
    if (IsSoulBound() && proto->Bonding == NO_BIND && sScriptMgr->CanApplySoulboundFlag(this, proto))
    {
        ApplyModFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_SOULBOUND, false);
        need_save = true;
    }
 
    std::string enchants = fields[6].Get<std::string>();
 
    if (!_LoadIntoDataField(fields[6].Get<std::string>(), ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_SLOT * MAX_ENCHANTMENT_OFFSET))
    {
        LOG_WARN("entities.item", "Invalid enchantment data '{}' for item {}. Forcing partial load.", fields[6].Get<std::string>(), GetGUID().ToString());
    }
 
    SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID, fields[7].Get<int16>());
    // recalculate suffix factor
    if (GetItemRandomPropertyId() < 0)
        UpdateItemSuffixFactor();
 
    uint32 durability = fields[8].Get<uint16>();
    SetUInt32Value(ITEM_FIELD_DURABILITY, durability);
 
    // update max durability (and durability) if need
    // xinef: do not overwrite durability for wrapped items!!
    SetUInt32Value(ITEM_FIELD_MAXDURABILITY, proto->MaxDurability);
    if (durability > proto->MaxDurability && !HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
    {
        SetUInt32Value(ITEM_FIELD_DURABILITY, proto->MaxDurability);
        need_save = true;
    }
 
    SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, fields[9].Get<uint32>());
    SetText(fields[10].Get<std::string>());
 
    if (need_save)                                           // normal item changed state set not work at loading
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_INSTANCE_ON_LOAD);
        stmt->SetData(0, GetUInt32Value(ITEM_FIELD_DURATION));
        stmt->SetData(1, GetUInt32Value(ITEM_FIELD_FLAGS));
        stmt->SetData(2, GetUInt32Value(ITEM_FIELD_DURABILITY));
        stmt->SetData(3, guid);
        CharacterDatabase.Execute(stmt);
    }
 
    return true;
}

References Object::_Create(), Object::_LoadIntoDataField(), Object::ApplyModFlag(), ItemTemplate::Bonding, CHAR_UPD_ITEM_INSTANCE_ON_LOAD, CharacterDatabase, ItemTemplate::Duration, Field::Get(), Object::GetEntry(), Object::GetGUID(), GetItemRandomPropertyId(), GetTemplate(), Object::GetUInt32Value(), Object::HasFlag(), IsSoulBound(), ITEM_FIELD_CREATE_PLAYED_TIME, ITEM_FIELD_CREATOR, ITEM_FIELD_DURABILITY, ITEM_FIELD_DURATION, ITEM_FIELD_ENCHANTMENT_1_1, ITEM_FIELD_FLAG_SOULBOUND, ITEM_FIELD_FLAG_WRAPPED, ITEM_FIELD_FLAGS, ITEM_FIELD_GIFTCREATOR, ITEM_FIELD_MAXDURABILITY, ITEM_FIELD_RANDOM_PROPERTIES_ID, LOG_ERROR, LOG_WARN, MAX_ENCHANTMENT_OFFSET, MAX_ENCHANTMENT_SLOT, MAX_ITEM_PROTO_SPELLS, ItemTemplate::MaxDurability, NO_BIND, SetCount(), PreparedStatementBase::SetData(), Object::SetEntry(), Object::SetGuidValue(), Object::SetInt32Value(), Object::SetObjectScale(), SetOwnerGUID(), SetSpellCharges(), SetText(), Object::SetUInt32Value(), sScriptMgr, Acore::Tokenize(), and UpdateItemSuffixFactor().

Referenced by Player::_LoadItem(), Player::_LoadMailedItem(), AuctionHouseMgr::LoadAuctionItems(), Bag::LoadFromDB(), and Guild::BankTab::LoadItemFromDB().

◆ RemoveFromObjectUpdate()

void Item::RemoveFromObjectUpdate ( )

overridevirtual

Implements Object.

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

References GetOwner().

◆ RemoveFromUpdateQueueOf()

void Item::RemoveFromUpdateQueueOf ( Player * player )

{
    if (!IsInUpdateQueue())
        return;
 
    ASSERT(player);
 
    if (player->GetGUID() != GetOwnerGUID())
    {
        LOG_DEBUG("entities.player.items", "Item::RemoveFromUpdateQueueOf - Owner's guid ({}) and player's guid ({}) don't match!", GetOwnerGUID().ToString(), player->GetGUID().ToString());
        return;
    }
 
    if (player->m_itemUpdateQueueBlocked)
        return;
 
    player->m_itemUpdateQueue[uQueuePos] = nullptr;
    uQueuePos = -1;
}

References ASSERT, Object::GetGUID(), GetOwnerGUID(), IsInUpdateQueue(), LOG_DEBUG, Player::m_itemUpdateQueue, Player::m_itemUpdateQueueBlocked, ObjectGuid::ToString(), and uQueuePos.

Referenced by WorldSession::HandleSellItemOpcode(), and SetState().

◆ SaveRefundDataToDB()

void Item::SaveRefundDataToDB ( )

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

References CHAR_DEL_ITEM_REFUND_INSTANCE, CHAR_INS_ITEM_REFUND_INSTANCE, CharacterDatabase, Object::GetGUID(), GetPaidExtendedCost(), GetPaidMoney(), GetRefundRecipient(), and PreparedStatementBase::SetData().

Referenced by Player::_StoreOrEquipNewItem().

◆ SaveToDB()

void Item::SaveToDB ( CharacterDatabaseTransaction trans )

virtual

Reimplemented in Bag.

{
    bool isInTransaction = static_cast<bool>(trans);
    if (!isInTransaction)
        trans = CharacterDatabase.BeginTransaction();
 
    ObjectGuid::LowType guid = GetGUID().GetCounter();
    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->SetData(  index, GetEntry());
                stmt->SetData(++index, GetOwnerGUID().GetCounter());
                stmt->SetData(++index, GetGuidValue(ITEM_FIELD_CREATOR).GetCounter());
                stmt->SetData(++index, GetGuidValue(ITEM_FIELD_GIFTCREATOR).GetCounter());
                stmt->SetData(++index, GetCount());
                stmt->SetData(++index, GetUInt32Value(ITEM_FIELD_DURATION));
 
                std::ostringstream ssSpells;
                for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
                    ssSpells << GetSpellCharges(i) << ' ';
                stmt->SetData(++index, ssSpells.str());
 
                stmt->SetData(++index, GetUInt32Value(ITEM_FIELD_FLAGS));
 
                std::ostringstream ssEnchants;
                for (uint8 i = 0; i < MAX_ENCHANTMENT_SLOT; ++i)
                {
                    ssEnchants << GetEnchantmentId(EnchantmentSlot(i)) << ' ';
                    ssEnchants << GetEnchantmentDuration(EnchantmentSlot(i)) << ' ';
                    ssEnchants << GetEnchantmentCharges(EnchantmentSlot(i)) << ' ';
                }
                stmt->SetData(++index, ssEnchants.str());
 
                stmt->SetData (++index, GetItemRandomPropertyId());
                stmt->SetData(++index, GetUInt32Value(ITEM_FIELD_DURABILITY));
                stmt->SetData(++index, GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME));
                stmt->SetData(++index, m_text);
                stmt->SetData(++index, guid);
 
                trans->Append(stmt);
 
                if ((uState == ITEM_CHANGED) && HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
                {
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GIFT_OWNER);
                    stmt->SetData(0, GetOwnerGUID().GetCounter());
                    stmt->SetData(1, guid);
                    trans->Append(stmt);
                }
                break;
            }
        case ITEM_REMOVED:
            {
                CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE);
                stmt->SetData(0, guid);
                trans->Append(stmt);
 
                if (HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED))
                {
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
                    stmt->SetData(0, guid);
                    trans->Append(stmt);
                }
 
                if (!isInTransaction)
                    CharacterDatabase.CommitTransaction(trans);
 
                delete this;
                return;
            }
        case ITEM_UNCHANGED:
            break;
    }
 
    SetState(ITEM_UNCHANGED);
 
    if (!isInTransaction)
        CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_GIFT, CHAR_DEL_ITEM_INSTANCE, CHAR_REP_ITEM_INSTANCE, CHAR_UPD_GIFT_OWNER, CHAR_UPD_ITEM_INSTANCE, CharacterDatabase, GetCount(), ObjectGuid::GetCounter(), GetEnchantmentCharges(), GetEnchantmentDuration(), GetEnchantmentId(), Object::GetEntry(), Object::GetGUID(), Object::GetGuidValue(), GetItemRandomPropertyId(), GetOwnerGUID(), GetSpellCharges(), Object::GetUInt32Value(), Object::HasFlag(), ITEM_CHANGED, ITEM_FIELD_CREATE_PLAYED_TIME, ITEM_FIELD_CREATOR, ITEM_FIELD_DURABILITY, ITEM_FIELD_DURATION, ITEM_FIELD_FLAG_WRAPPED, ITEM_FIELD_FLAGS, ITEM_FIELD_GIFTCREATOR, ITEM_NEW, ITEM_REMOVED, ITEM_UNCHANGED, m_text, MAX_ENCHANTMENT_SLOT, MAX_ITEM_PROTO_SPELLS, PreparedStatementBase::SetData(), SetState(), and uState.

Referenced by Player::_LoadItem(), Player::_LoadMailedItem(), Player::_SaveInventory(), Player::AutoUnequipOffhandIfNeed(), AchievementMgr::CompletedAchievement(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleSendMail(), Bag::SaveToDB(), and MailDraft::SendReturnToSender().

◆ SendTimeUpdate()

void Item::SendTimeUpdate ( Player * owner )

{
    uint32 duration = GetUInt32Value(ITEM_FIELD_DURATION);
    if (!duration)
        return;
 
    WorldPacket data(SMSG_ITEM_TIME_UPDATE, (8 + 4));
    data << GetGUID();
    data << uint32(duration);
    owner->GetSession()->SendPacket(&data);
}

References Object::GetGUID(), Player::GetSession(), Object::GetUInt32Value(), ITEM_FIELD_DURATION, WorldSession::SendPacket(), and SMSG_ITEM_TIME_UPDATE.

Referenced by Player::AddItemDurations().

◆ SendUpdateSockets()

void Item::SendUpdateSockets ( )

{
    WorldPacket data(SMSG_SOCKET_GEMS_RESULT, 8 + 4 + 4 + 4 + 4);
    data << GetGUID();
    for (uint32 i = SOCK_ENCHANTMENT_SLOT; i <= BONUS_ENCHANTMENT_SLOT; ++i)
        data << uint32(GetEnchantmentId(EnchantmentSlot(i)));
 
    GetOwner()->GetSession()->SendPacket(&data);
}

References BONUS_ENCHANTMENT_SLOT, GetEnchantmentId(), Object::GetGUID(), GetOwner(), Player::GetSession(), WorldSession::SendPacket(), SMSG_SOCKET_GEMS_RESULT, and SOCK_ENCHANTMENT_SLOT.

Referenced by WorldSession::HandleSocketOpcode().

◆ SetBinding()

void Item::SetBinding ( bool val )

inline

229{ ApplyModFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_SOULBOUND, val); }

References Object::ApplyModFlag(), ITEM_FIELD_FLAG_SOULBOUND, and ITEM_FIELD_FLAGS.

Referenced by Player::_StoreItem(), misc_commandscript::HandleAddItemCommand(), misc_commandscript::HandleAddItemSetCommand(), WorldSession::HandleUseItemOpcode(), and Player::VisualizeItem().

◆ SetContainer()

void Item::SetContainer ( Bag * container )

inline

277{ m_container = container; }

References m_container.

Referenced by Player::_StoreItem(), Bag::RemoveItem(), Bag::StoreItem(), and Player::VisualizeItem().

◆ SetCount()

void Item::SetCount ( uint32 value )

inline

264{ SetUInt32Value(ITEM_FIELD_STACK_COUNT, value); }

References ITEM_FIELD_STACK_COUNT, and Object::SetUInt32Value().

Referenced by Guild::BankMoveItemData::_StoreItem(), Player::_StoreItem(), CreateItem(), Player::DestroyItemCount(), Player::EquipItem(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleSellItemOpcode(), LoadFromDB(), Player::SplitItem(), and Player::SwapItem().

◆ 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 (uint32 oldEnchant = GetEnchantmentId(slot))
            owner->GetSession()->SendEnchantmentLog(GetOwnerGUID(), ObjectGuid::Empty, GetEntry(), oldEnchant);
 
        if (id)
            owner->GetSession()->SendEnchantmentLog(GetOwnerGUID(), caster, GetEntry(), id);
    }
 
    SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_ID_OFFSET, id);
    SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_DURATION_OFFSET, duration);
    SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_CHARGES_OFFSET, charges);
    SetState(ITEM_CHANGED, owner);
}

References ObjectGuid::Empty, ENCHANTMENT_CHARGES_OFFSET, ENCHANTMENT_DURATION_OFFSET, ENCHANTMENT_ID_OFFSET, GetEnchantmentCharges(), GetEnchantmentDuration(), GetEnchantmentId(), Object::GetEntry(), GetOwner(), GetOwnerGUID(), Player::GetSession(), ITEM_CHANGED, ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_OFFSET, MAX_INSPECTED_ENCHANTMENT_SLOT, WorldSession::SendEnchantmentLog(), SetState(), and Object::SetUInt32Value().

Referenced by Spell::EffectEnchantHeldItem(), Spell::EffectEnchantItemPerm(), Spell::EffectEnchantItemPrismatic(), Spell::EffectEnchantItemTmp(), Spell::EffectSummonChangeItem(), WorldSession::HandleSocketOpcode(), and SetItemRandomProperties().

◆ SetEnchantmentCharges()

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

{
    if (GetEnchantmentCharges(slot) == charges)
        return;
 
    SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_CHARGES_OFFSET, charges);
    SetState(ITEM_CHANGED, GetOwner());
}

References ENCHANTMENT_CHARGES_OFFSET, GetEnchantmentCharges(), GetOwner(), ITEM_CHANGED, ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_OFFSET, SetState(), and Object::SetUInt32Value().

Referenced by Player::CastItemCombatSpell(), and Player::SetVirtualItemSlot().

◆ SetEnchantmentDuration()

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

{
    if (GetEnchantmentDuration(slot) == duration)
        return;
 
    SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1 + slot * MAX_ENCHANTMENT_OFFSET + ENCHANTMENT_DURATION_OFFSET, duration);
    SetState(ITEM_CHANGED, owner);
    // Cannot use GetOwner() here, has to be passed as an argument to avoid freeze due to hashtable locking
}

References ENCHANTMENT_DURATION_OFFSET, GetEnchantmentDuration(), ITEM_CHANGED, ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_OFFSET, SetState(), and Object::SetUInt32Value().

Referenced by Player::RemoveEnchantmentDurations().

◆ SetInTrade()

void Item::SetInTrade ( bool b = true )

inline

253{ mb_in_trade = b; }

References mb_in_trade.

Referenced by clearAcceptTradeMode(), and setAcceptTradeMode().

◆ SetItemRandomProperties()

void Item::SetItemRandomProperties ( int32 randomPropId )

{
    if (!randomPropId)
        return;
 
    if (randomPropId > 0)
    {
        ItemRandomPropertiesEntry const* item_rand = sItemRandomPropertiesStore.LookupEntry(randomPropId);
        if (item_rand)
        {
            if (GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID) != int32(item_rand->ID))
            {
                SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID, item_rand->ID);
                SetState(ITEM_CHANGED, GetOwner());
            }
            for (uint32 i = PROP_ENCHANTMENT_SLOT_0; i < MAX_ENCHANTMENT_SLOT; ++i)
                SetEnchantment(EnchantmentSlot(i), item_rand->Enchantment[i - PROP_ENCHANTMENT_SLOT_0], 0, 0);
        }
    }
    else
    {
        ItemRandomSuffixEntry const* item_rand = sItemRandomSuffixStore.LookupEntry(-randomPropId);
        if (item_rand)
        {
            if (GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID) != -int32(item_rand->ID) ||
                    !GetItemSuffixFactor())
            {
                SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID, -int32(item_rand->ID));
                UpdateItemSuffixFactor();
                SetState(ITEM_CHANGED, GetOwner());
            }
 
            for (uint32 i = PROP_ENCHANTMENT_SLOT_0; i < MAX_ENCHANTMENT_SLOT; ++i)
                SetEnchantment(EnchantmentSlot(i), item_rand->Enchantment[i - PROP_ENCHANTMENT_SLOT_0], 0, 0);
        }
    }
}

References ItemRandomPropertiesEntry::Enchantment, ItemRandomSuffixEntry::Enchantment, Object::GetInt32Value(), GetItemSuffixFactor(), GetOwner(), ItemRandomPropertiesEntry::ID, ItemRandomSuffixEntry::ID, ITEM_CHANGED, ITEM_FIELD_RANDOM_PROPERTIES_ID, MAX_ENCHANTMENT_SLOT, PROP_ENCHANTMENT_SLOT_0, SetEnchantment(), Object::SetInt32Value(), SetState(), sItemRandomPropertiesStore, sItemRandomSuffixStore, and UpdateItemSuffixFactor().

Referenced by CreateItem().

◆ SetNotRefundable()

void Item::SetNotRefundable	(	Player *	owner,
		bool	changestate = `true`,
		CharacterDatabaseTransaction *	trans = `nullptr`
	)

{
    if (!HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_REFUNDABLE))
        return;
 
    RemoveFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_REFUNDABLE);
    // Following is not applicable in the trading procedure
    if (changestate)
        SetState(ITEM_CHANGED, owner);
 
    SetRefundRecipient(0);
    SetPaidMoney(0);
    SetPaidExtendedCost(0);
    DeleteRefundDataFromDB(trans);
 
    owner->DeleteRefundReference(GetGUID());
}

References DeleteRefundDataFromDB(), Player::DeleteRefundReference(), Object::GetGUID(), Object::HasFlag(), ITEM_CHANGED, ITEM_FIELD_FLAG_REFUNDABLE, ITEM_FIELD_FLAGS, Object::RemoveFlag(), SetPaidExtendedCost(), SetPaidMoney(), SetRefundRecipient(), and SetState().

Referenced by Player::_StoreItem(), Player::DestroyItem(), Player::EquipItem(), WorldSession::HandleSendMail(), Player::RefundItem(), Player::SendRefundInfo(), and UpdatePlayedTime().

◆ SetOwnerGUID()

void Item::SetOwnerGUID ( ObjectGuid guid )

inline

226{ SetGuidValue(ITEM_FIELD_OWNER, guid); }

References ITEM_FIELD_OWNER, and Object::SetGuidValue().

Referenced by Player::_StoreItem(), Player::EquipItem(), WorldSession::HandleSendMail(), LoadFromDB(), and Player::MoveItemToInventory().

◆ SetPaidExtendedCost()

void Item::SetPaidExtendedCost ( uint32 iece )

inline

337{ m_paidExtendedCost = iece; }

References m_paidExtendedCost.

Referenced by Player::_LoadItem(), Player::_StoreOrEquipNewItem(), and SetNotRefundable().

◆ SetPaidMoney()

void Item::SetPaidMoney ( uint32 money )

inline

336{ m_paidMoney = money; }

References m_paidMoney.

Referenced by Player::_LoadItem(), Player::_StoreOrEquipNewItem(), and SetNotRefundable().

◆ SetRefundRecipient()

void Item::SetRefundRecipient ( ObjectGuid::LowType pGuidLow )

inline

335{ m_refundRecipient = pGuidLow; }

References m_refundRecipient.

Referenced by Player::_LoadItem(), Player::_StoreOrEquipNewItem(), and SetNotRefundable().

◆ SetSlot()

void Item::SetSlot ( uint8 slot )

inline

275{ m_slot = slot; }

References m_slot.

Referenced by Player::_StoreItem(), Player::DestroyItem(), Player::RemoveItem(), Bag::StoreItem(), and Player::VisualizeItem().

◆ SetSoulboundTradeable()

void Item::SetSoulboundTradeable ( AllowedLooterSet & allowedLooters )

{
    SetFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE);
    allowedGUIDs = allowedLooters;
}

References allowedGUIDs, ITEM_FIELD_FLAG_BOP_TRADEABLE, ITEM_FIELD_FLAGS, and Object::SetFlag().

Referenced by Player::_LoadItem(), and Player::StoreNewItem().

◆ SetSpellCharges()

void Item::SetSpellCharges	(	uint8	index,
		int32	value
	)

inline

309{ SetInt32Value(ITEM_FIELD_SPELL_CHARGES + index, value); }

References ITEM_FIELD_SPELL_CHARGES, and Object::SetInt32Value().

Referenced by Create(), LoadFromDB(), and Spell::TakeCastItem().

◆ SetState()

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

{
    if (uState == ITEM_NEW && state == ITEM_REMOVED)
    {
        // pretend the item never existed
        if (forplayer)
        {
            RemoveFromUpdateQueueOf(forplayer);
            forplayer->DeleteRefundReference(GetGUID());
        }
        delete this;
        return;
    }
    if (state != ITEM_UNCHANGED)
    {
        // new items must stay in new state until saved
        if (uState != ITEM_NEW)
            uState = state;
        if (forplayer)
            AddToUpdateQueueOf(forplayer);
    }
    else
    {
        // unset in queue
        // the item must be removed from the queue manually
        uQueuePos = -1;
        uState = ITEM_UNCHANGED;
    }
}

References AddToUpdateQueueOf(), Player::DeleteRefundReference(), Object::GetGUID(), ITEM_NEW, ITEM_REMOVED, ITEM_UNCHANGED, RemoveFromUpdateQueueOf(), uQueuePos, and uState.

Referenced by Player::_StoreItem(), ClearEnchantment(), ClearSoulboundTradeable(), Player::DestroyItem(), Player::DestroyItemCount(), Player::DurabilityPointsLoss(), Player::DurabilityRepair(), Spell::EffectOpenLock(), Player::EquipItem(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleMailTakeItem(), WorldSession::HandleOpenWrappedItemCallback(), WorldSession::HandlePetitionBuyOpcode(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleUseItemOpcode(), WorldSession::HandleWrapItemOpcode(), Player::MoveItemToInventory(), Player::RemoveItemFromBuyBackSlot(), SaveToDB(), SetEnchantment(), SetEnchantmentCharges(), SetEnchantmentDuration(), SetItemRandomProperties(), SetNotRefundable(), Player::SplitItem(), Player::SwapItem(), Spell::TakeCastItem(), UpdateDuration(), UpdatePlayedTime(), and Player::VisualizeItem().

◆ SetText()

void Item::SetText ( std::string const & text )

inline

300{ m_text = text; }

References m_text.

Referenced by WorldSession::HandleMailCreateTextItem(), and LoadFromDB().

◆ ToBag() [1/2]

Bag * Item::ToBag ( )

inline

244{ if (IsBag()) return reinterpret_cast<Bag*>(this); else return nullptr; }

References IsBag().

Referenced by Player::_LoadInventory(), Player::GetBagByPos(), debug_commandscript::HandleDebugGetItemStateCommand(), IsNotEmptyBag(), and Player::SwapItem().

◆ ToBag() [2/2]

const Bag * Item::ToBag ( ) const

inline

245{ if (IsBag()) return reinterpret_cast<const Bag*>(this); else return nullptr; }

References IsBag().

◆ UpdateDuration()

void Item::UpdateDuration	(	Player *	owner,
		uint32	diff
	)

{
    if (!GetUInt32Value(ITEM_FIELD_DURATION))
        return;
 
    LOG_DEBUG("entities.player.items", "Item::UpdateDuration Item (Entry: {} Duration {} Diff {})", GetEntry(), GetUInt32Value(ITEM_FIELD_DURATION), diff);
 
    if (GetUInt32Value(ITEM_FIELD_DURATION) <= diff)
    {
        sScriptMgr->OnItemExpire(owner, GetTemplate());
        owner->DestroyItem(GetBagSlot(), GetSlot(), true);
        return;
    }
 
    SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);
    SetState(ITEM_CHANGED, owner);                          // save new time in database
}

References Player::DestroyItem(), GetBagSlot(), Object::GetEntry(), GetSlot(), GetTemplate(), Object::GetUInt32Value(), ITEM_CHANGED, ITEM_FIELD_DURATION, LOG_DEBUG, SetState(), Object::SetUInt32Value(), and sScriptMgr.

Referenced by Player::UpdateItemDuration().

◆ UpdateItemSuffixFactor()

void Item::UpdateItemSuffixFactor ( )

{
    uint32 suffixFactor = GenerateEnchSuffixFactor(GetEntry());
    if (GetItemSuffixFactor() == suffixFactor)
        return;
    SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, suffixFactor);
}

References GenerateEnchSuffixFactor(), Object::GetEntry(), GetItemSuffixFactor(), ITEM_FIELD_PROPERTY_SEED, and Object::SetUInt32Value().

Referenced by LoadFromDB(), and SetItemRandomProperties().

◆ UpdatePlayedTime()

void Item::UpdatePlayedTime ( Player * owner )

{
    /*  Here we update our played time
        We simply add a number to the current played time,
        based on the time elapsed since the last update hereof.
    */
    // Get current played time
    uint32 current_playtime = GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME);
    // Calculate time elapsed since last played time update
    time_t curtime = GameTime::GetGameTime().count();
    uint32 elapsed = uint32(curtime - m_lastPlayedTimeUpdate);
    uint32 new_playtime = current_playtime + elapsed;
    // Check if the refund timer has expired yet
    if (new_playtime <= 2 * HOUR)
    {
        // No? Proceed.
        // Update the data field
        SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, new_playtime);
        // Flag as changed to get saved to DB
        SetState(ITEM_CHANGED, owner);
        // Speaks for itself
        m_lastPlayedTimeUpdate = curtime;
        return;
    }
    // Yes
    SetNotRefundable(owner);
}

References GameTime::GetGameTime(), Object::GetUInt32Value(), HOUR, ITEM_CHANGED, ITEM_FIELD_CREATE_PLAYED_TIME, m_lastPlayedTimeUpdate, SetNotRefundable(), SetState(), and Object::SetUInt32Value().

Referenced by Player::_SaveInventory(), and Player::SendRefundInfo().

Member Data Documentation

◆ allowedGUIDs

AllowedLooterSet Item::allowedGUIDs

private

Referenced by ClearSoulboundTradeable(), IsBindedNotWith(), and SetSoulboundTradeable().

◆ loot

Loot Item::loot

Referenced by WorldSession::DoLootRelease(), WorldSession::HandleAutostoreLootItemOpcode(), LootItemStorage::LoadStoredLoot(), and Player::SendLoot().

◆ m_container

Bag* Item::m_container

private

Referenced by GetBagSlot(), GetContainer(), IsInBag(), Item(), and SetContainer().

◆ m_lastPlayedTimeUpdate

time_t Item::m_lastPlayedTimeUpdate

private

Referenced by GetPlayedTime(), Item(), and UpdatePlayedTime().

◆ m_lootGenerated

bool Item::m_lootGenerated

Referenced by CanBeMergedPartlyWith(), Player::CanEquipItem(), Player::CanUnequipItem(), WorldSession::DoLootRelease(), Item(), LootItemStorage::LoadStoredLoot(), Player::SendLoot(), and Player::SplitItem().

◆ m_paidExtendedCost

uint32 Item::m_paidExtendedCost

private

Referenced by GetPaidExtendedCost(), Item(), and SetPaidExtendedCost().

◆ m_paidMoney

uint32 Item::m_paidMoney

private

Referenced by GetPaidMoney(), Item(), and SetPaidMoney().

◆ m_refundRecipient

uint32 Item::m_refundRecipient

private

Referenced by GetRefundRecipient(), Item(), and SetRefundRecipient().

◆ m_slot

uint8 Item::m_slot

private

Referenced by GetSlot(), IsEquipped(), Item(), and SetSlot().

◆ m_text

std::string Item::m_text

private

Referenced by GetText(), SaveToDB(), and SetText().

◆ mb_in_trade

bool Item::mb_in_trade

private

Referenced by IsInTrade(), Item(), and SetInTrade().

◆ uQueuePos

int32 Item::uQueuePos

private

Referenced by AddToUpdateQueueOf(), GetQueuePos(), IsInUpdateQueue(), Item(), RemoveFromUpdateQueueOf(), and SetState().

◆ uState

ItemUpdateState Item::uState

private

Referenced by FSetState(), GetState(), Item(), SaveToDB(), and SetState().

Public Member Functions

Static Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Item()

Member Function Documentation

◆ AddToObjectUpdate()

◆ AddToUpdateQueueOf()

◆ BuildUpdate()

◆ CanBeMergedPartlyWith()

◆ CanBeTraded()

◆ CheckSoulboundTradeExpire()

◆ ClearEnchantment()

◆ ClearSoulboundTradeable()

◆ CloneItem()

◆ Create()

◆ CreateItem()

◆ DeleteFromDB() [1/2]

◆ DeleteFromDB() [2/2]

◆ DeleteFromInventoryDB() [1/2]

◆ DeleteFromInventoryDB() [2/2]

◆ DeleteRefundDataFromDB()

◆ FSetState()

◆ GemsFitSockets()

◆ GenerateItemRandomPropertyId()

◆ GetBagSlot()

◆ GetContainer()

◆ GetCount()

◆ GetDebugInfo()

◆ GetEnchantmentCharges()

◆ GetEnchantmentDuration()

◆ GetEnchantmentId()

◆ GetEnchantRequiredLevel()

◆ GetGemCountWithID()

◆ GetGemCountWithLimitCategory()

◆ GetItemRandomPropertyId()

◆ GetItemSuffixFactor()

◆ GetMaxStackCount()

◆ GetOwner()

◆ GetOwnerGUID()

◆ GetPaidExtendedCost()

◆ GetPaidMoney()

◆ GetPlayedTime()

◆ GetPos()

◆ GetQueuePos()

◆ GetRefundRecipient()

◆ GetScriptId()

◆ GetSkill()

◆ GetSlot()

◆ GetSpell()

◆ GetSpellCharges()

◆ GetState()

◆ GetTemplate()

◆ GetText()

◆ HasEnchantRequiredSkill()

◆ hasInvolvedQuest()

◆ hasQuest()

◆ HasSocket()

◆ IsArmorVellum()

◆ IsBag()

◆ IsBindedNotWith()

◆ IsBoundAccountWide()

◆ IsBoundByEnchant()

◆ IsBoundByTempEnchant()

◆ IsBroken()

◆ IsConjuredConsumable()

◆ IsCurrencyToken()

◆ IsEquipped()

◆ IsFitToSpellRequirements()

◆ IsInBag()

◆ IsInTrade()

◆ IsInUpdateQueue()

◆ IsLimitedToAnotherMapOrZone()

◆ IsLocked()

◆ IsNotEmptyBag()

◆ IsPotion()

◆ IsRefundExpired()