Item Class Reference

#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	IsRefundable () const
bool	IsBOPTradable () const
bool	IsWrapped () 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)
void	SendUpdateToPlayer (Player *player)
void	BuildValuesUpdateBlockForPlayer (UpdateData *data, Player *target)
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 &)
void	SetFieldNotifyFlag (uint16 flag)
void	RemoveFieldNotifyFlag (uint16 flag)
void	ForceValuesUpdateAtIndex (uint32)
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	IsDynamicObject () const
DynamicObject *	ToDynObject ()
DynamicObject const *	ToDynObject () const
bool	IsItem () 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)
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() && (!IsBOPTradable() || !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(), IsBag(), Player::IsBagPos(), IsBOPTradable(), IsBoundAccountWide(), IsBoundByEnchant(), IsBoundByTempEnchant(), and IsSoulBound().

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(), spell_gen_spirit_of_competition_participant::HandleScript(), spell_gen_spirit_of_competition_winner::HandleScript(), 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

{ return m_container; }

References m_container.

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

GetCount()

uint32 Item::GetCount ( ) const

inline

{ 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

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

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

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

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

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

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

{ return GetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID); }

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

{ return GetUInt32Value(ITEM_FIELD_PROPERTY_SEED); }

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

{ 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

{ return GetGuidValue(ITEM_FIELD_OWNER); }

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

{ return m_paidExtendedCost; }

References m_paidExtendedCost.

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

GetPaidMoney()

uint32 Item::GetPaidMoney ( )

inline

{ 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

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

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

{ return uQueuePos; }

References uQueuePos.

Referenced by debug_commandscript::HandleDebugGetItemStateCommand().

GetRefundRecipient()

ObjectGuid::LowType Item::GetRefundRecipient ( )

inline

{ return m_refundRecipient; }

References m_refundRecipient.

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

GetScriptId()

uint32 Item::GetScriptId ( ) const

inline

{ return GetTemplate()->ScriptId; }

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

{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;
}

References ItemTemplate::Class, GetTemplate(), ITEM_CLASS_ARMOR, ITEM_CLASS_WEAPON, ITEM_SUBCLASS_ARMOR_CLOTH, ITEM_SUBCLASS_ARMOR_LEATHER, ITEM_SUBCLASS_ARMOR_MAIL, ITEM_SUBCLASS_ARMOR_PLATE, ITEM_SUBCLASS_ARMOR_SHIELD, ITEM_SUBCLASS_WEAPON_AXE, ITEM_SUBCLASS_WEAPON_AXE2, ITEM_SUBCLASS_WEAPON_BOW, ITEM_SUBCLASS_WEAPON_CROSSBOW, ITEM_SUBCLASS_WEAPON_DAGGER, ITEM_SUBCLASS_WEAPON_GUN, ITEM_SUBCLASS_WEAPON_MACE, ITEM_SUBCLASS_WEAPON_MACE2, ITEM_SUBCLASS_WEAPON_POLEARM, ITEM_SUBCLASS_WEAPON_SPEAR, ITEM_SUBCLASS_WEAPON_STAFF, ITEM_SUBCLASS_WEAPON_SWORD, ITEM_SUBCLASS_WEAPON_SWORD2, ITEM_SUBCLASS_WEAPON_THROWN, ITEM_SUBCLASS_WEAPON_WAND, and ItemTemplate::SubClass.

GetSpellCharges()

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

inline

{ return GetInt32Value(ITEM_FIELD_SPELL_CHARGES + index); }

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

{ 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.

Referenced by Player::_ApplyAllItemMods(), Player::_ApplyAllLevelScaleItemMods(), Player::_ApplyItemMods(), Player::_LoadItem(), Player::_RemoveAllItemMods(), Player::_SaveInventory(), Player::_StoreItem(), AddItemsSetItem(), Player::AddQuestAndCheckCompletion(), Player::ApplyEnchantment(), Player::ApplyEquipCooldown(), Player::ApplyItemEquipSpell(), Player::AutoUnequipOffhandIfNeed(), AuctionHouseObject::BuildListAuctionItems(), AuraEffect::CalculateAmount(), Player::CanBankItem(), Player::CanEquipItem(), Player::CanEquipUniqueItem(), Guild::BankMoveItemData::CanStore(), Player::CanStoreItem_InBag(), Player::CanStoreItem_InSpecificSlot(), Player::CanStoreItems(), Player::CanUnequipItem(), Player::CanUseItem(), Player::CastItemUseSpell(), Player::CheckAmmoCompatibility(), Spell::CheckCast(), Spell::CheckItems(), Player::CreateCorpse(), Player::DestroyItem(), Spell::DoCreateItem(), WorldSession::DoLootRelease(), Spell::DoSpellHitOnUnit(), Player::DurabilityRepair(), Spell::EffectDisEnchant(), Spell::EffectEnchantItemPerm(), Spell::EffectFeedPet(), Spell::EffectMilling(), Spell::EffectOpenLock(), Spell::EffectProspecting(), Player::EquipItem(), EquippedOk(), GemsFitSockets(), AuctionHouseMgr::GetAuctionDeposit(), Player::GetAverageItemLevel(), Player::GetAverageItemLevelForDF(), Player::GetItemCount(), Bag::GetItemCount(), GetMaxStackCount(), GetScriptId(), Player::GetShield(), GetSkill(), GetSpell(), Unit::GetUnitBlockChance(), Player::GetWeaponForAttack(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleAutoEquipItemOpcode(), debug_commandscript::HandleDebugItemExpireCommand(), WorldSession::HandleDestroyItemOpcode(), WorldSession::HandleOpenItemOpcode(), WorldSession::HandleOpenWrappedItemCallback(), WorldSession::HandleReadItem(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleSendMail(), WorldSession::HandleSocketOpcode(), WorldSession::HandleUseItemOpcode(), WorldSession::HandleWrapItemOpcode(), Player::HasItemOrGemWithIdEquipped(), Player::HasItemOrGemWithLimitCategoryEquipped(), Player::HasItemTotemCategory(), hasQuest(), HasSocket(), IsArmorVellum(), IsBag(), IsBoundAccountWide(), IsConjuredConsumable(), IsCurrencyToken(), IsFitToSpellRequirements(), IsLimitedToAnotherMapOrZone(), IsPotion(), Unit::IsTriggeredAtSpellProcEvent(), Player::IsTwoHandUsed(), IsWeaponVellum(), LoadFromDB(), Bag::LoadFromDB(), WorldSession::recoveryItem(), Player::RemoveItem(), Player::SendEquipError(), Player::SendLoot(), Player::SetRegularAttackTime(), Player::StoreItem(), Player::StoreNewItem(), Spell::SummonGuardian(), Player::SwapItem(), Spell::TakeAmmo(), Spell::TakeCastItem(), Spell::TakeReagents(), Player::ToggleMetaGemsActive(), UpdateDuration(), Player::UpdateItemDuration(), Player::UpdateWeaponSkill(), Player::VisualizeItem(), and Spell::WriteAmmoToPacket().

GetText()

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

inline

{ return m_text; }

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.

{ return false; }

hasQuest()

bool Item::hasQuest ( uint32  quest_id ) const

inlineoverridevirtual

Reimplemented from Object.

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

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

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

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

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

IsBag()

bool Item::IsBag ( ) const

inline

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

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 (IsBOPTradable())
        if (allowedGUIDs.find(player->GetGUID()) != allowedGUIDs.end())
            return false;
 
    // BOA item case
    if (IsBoundAccountWide())
        return false;
 
    return true;
}

References allowedGUIDs, Object::GetGUID(), GetOwnerGUID(), IsBOPTradable(), IsBoundAccountWide(), and IsSoulBound().

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

IsBOPTradable()

bool Item::IsBOPTradable ( ) const

inline

{ return HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_BOP_TRADEABLE); }

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

Referenced by Player::_LoadItem(), CanBeTraded(), IsBindedNotWith(), and Player::MoveItemToInventory().

IsBoundAccountWide()

bool Item::IsBoundAccountWide ( ) const

inline

{ return GetTemplate()->HasFlag(ITEM_FLAG_IS_BOUND_TO_ACCOUNT) != 0; }

References GetTemplate(), ItemTemplate::HasFlag(), 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()

bool Item::IsBroken ( ) const

inline

{ return GetUInt32Value(ITEM_FIELD_MAXDURABILITY) > 0 && GetUInt32Value(ITEM_FIELD_DURABILITY) == 0; }

References Object::GetUInt32Value(), ITEM_FIELD_DURABILITY, and ITEM_FIELD_MAXDURABILITY.

Referenced by Player::_ApplyItemMods(), Player::_ApplyWeaponDependentAuraCritMod(), Player::_ApplyWeaponDependentAuraDamageMod(), Player::ApplyEnchantment(), Player::CheckAmmoCompatibility(), Spell::CheckItems(), Player::EnchantmentFitsRequirements(), Player::GetShield(), Unit::GetUnitBlockChance(), Player::GetWeaponForAttack(), Aura::IsProcTriggeredOnEvent(), Unit::IsTriggeredAtSpellProcEvent(), Player::SetRegularAttackTime(), Spell::TakeAmmo(), and Player::UpdateWeaponSkill().

IsConjuredConsumable()

bool Item::IsConjuredConsumable ( ) const

inline

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

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

IsCurrencyToken()

bool Item::IsCurrencyToken ( ) const

inline

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

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

{ return m_container != nullptr; }

References m_container.

Referenced by IsEquipped().

IsInTrade()

bool Item::IsInTrade ( ) const

inline

{ return mb_in_trade; }

References mb_in_trade.

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

IsInUpdateQueue()

bool Item::IsInUpdateQueue ( ) const

inline

{ 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

{ return !HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_UNLOCKED); }

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::CanUnequipItem(), Player::DestroyItem(), WorldSession::HandleAuctionSellItem(), WorldSession::HandleSellItemOpcode(), WorldSession::HandleSendMail(), and Player::SwapItem().

IsPotion()

bool Item::IsPotion ( ) const

inline

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

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

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

IsRefundable()

bool Item::IsRefundable ( ) const

inline

{ return HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_REFUNDABLE); }

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

Referenced by Player::_LoadItem(), WorldSession::HandleSellItemOpcode(), Player::RefundItem(), Player::SendRefundInfo(), and SetNotRefundable().

IsRefundExpired()

bool Item::IsRefundExpired

(

)

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

References GetPlayedTime(), and HOUR.

Referenced by Player::RefundItem().

IsSoulBound()

bool Item::IsSoulBound ( ) const

inline

{ return HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_SOULBOUND); }

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

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

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

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

IsWrapped()

bool Item::IsWrapped ( ) const

inline

{ return HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED); }

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

Referenced by Player::DestroyItem(), WorldSession::HandleOpenItemOpcode(), WorldSession::HandleOpenWrappedItemCallback(), WorldSession::HandleSendMail(), LoadFromDB(), and SaveToDB().

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 && !IsWrapped())
    {
        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(), IsSoulBound(), IsWrapped(), 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_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) && IsWrapped())
                {
                    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 (IsWrapped())
                {
                    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(), IsWrapped(), ITEM_CHANGED, ITEM_FIELD_CREATE_PLAYED_TIME, ITEM_FIELD_CREATOR, ITEM_FIELD_DURABILITY, ITEM_FIELD_DURATION, 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

{ 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::HandleAddItemSetCommand(), WorldSession::HandleUseItemOpcode(), and Player::VisualizeItem().

SetContainer()

void Item::SetContainer ( Bag *  container )

inline

{ m_container = container; }

References m_container.

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

SetCount()

void Item::SetCount ( uint32  value )

inline

{ 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

{ 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 (!IsRefundable())
        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(), IsRefundable(), 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

{ 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

{ m_paidExtendedCost = iece; }

References m_paidExtendedCost.

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

SetPaidMoney()

void Item::SetPaidMoney ( uint32  money )

inline

{ m_paidMoney = money; }

References m_paidMoney.

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

SetRefundRecipient()

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

inline

{ m_refundRecipient = pGuidLow; }

References m_refundRecipient.

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

SetSlot()

void Item::SetSlot ( uint8  slot )

inline

{ 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

{ 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

{ m_text = text; }

References m_text.

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

ToBag() [1/2]

Bag * Item::ToBag ( )

inline

{ 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

{ 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().