Item.cpp File Reference

#include "Item.h"
#include "Common.h"
#include "ConditionMgr.h"
#include "DatabaseEnv.h"
#include "GameTime.h"
#include "ItemEnchantmentMgr.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "Tokenize.h"
#include "StringConvert.h"

Go to the source code of this file.

Functions
void	AddItemsSetItem (Player *player, Item *item)
void	RemoveItemsSetItem (Player *player, ItemTemplate const *proto)
bool	ItemCanGoIntoBag (ItemTemplate const *pProto, ItemTemplate const *pBagProto)

Function Documentation

AddItemsSetItem()

void AddItemsSetItem	(	Player *	player,
		Item *	item
	)

{
    ItemTemplate const* proto = item->GetTemplate();
    uint32 setid = proto->ItemSet;
 
    ItemSetEntry const* set = sItemSetStore.LookupEntry(setid);
 
    if (!set)
    {
        LOG_ERROR("sql.sql", "Item set {} for item (id {}) not found, mods not applied.", setid, proto->ItemId);
        return;
    }
 
    if (set->required_skill_id && player->GetSkillValue(set->required_skill_id) < set->required_skill_value)
        return;
 
    ItemSetEffect* eff = nullptr;
 
    for (size_t x = 0; x < player->ItemSetEff.size(); ++x)
    {
        if (player->ItemSetEff[x] && player->ItemSetEff[x]->setid == setid)
        {
            eff = player->ItemSetEff[x];
            break;
        }
    }
 
    if (!eff)
    {
        eff = new ItemSetEffect();
        eff->setid = setid;
 
        size_t x = 0;
        for (; x < player->ItemSetEff.size(); ++x)
            if (!player->ItemSetEff[x])
                break;
 
        if (x < player->ItemSetEff.size())
            player->ItemSetEff[x] = eff;
        else
            player->ItemSetEff.push_back(eff);
    }
 
    ++eff->item_count;
 
    for (uint32 x = 0; x < MAX_ITEM_SET_SPELLS; ++x)
    {
        if (!set->spells [x])
            continue;
        //not enough for  spell
        if (set->items_to_triggerspell[x] > eff->item_count)
            continue;
 
        uint32 z = 0;
        for (; z < MAX_ITEM_SET_SPELLS; ++z)
            if (eff->spells[z] && eff->spells[z]->Id == set->spells[x])
                break;
 
        if (z < MAX_ITEM_SET_SPELLS)
            continue;
 
        //new spell
        for (uint32 y = 0; y < MAX_ITEM_SET_SPELLS; ++y)
        {
            if (!eff->spells[y])                             // free slot
            {
                SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(set->spells[x]);
                if (!spellInfo)
                {
                    LOG_ERROR("entities.item", "WORLD: unknown spell id {} in items set {} effects", set->spells[x], setid);
                    break;
                }
 
                // spell casted only if fit form requirement, in other case will casted at form change
                if (sScriptMgr->CanItemApplyEquipSpell(player, item))
                {
                    player->ApplyEquipSpell(spellInfo, nullptr, true);
                }
 
                eff->spells[y] = spellInfo;
                break;
            }
        }
    }
}

References Player::ApplyEquipSpell(), Player::GetSkillValue(), Item::GetTemplate(), SpellInfo::Id, ItemSetEffect::item_count, ItemTemplate::ItemId, ItemSetEntry::items_to_triggerspell, ItemTemplate::ItemSet, Player::ItemSetEff, LOG_ERROR, MAX_ITEM_SET_SPELLS, ItemSetEntry::required_skill_id, ItemSetEntry::required_skill_value, ItemSetEffect::setid, sItemSetStore, ItemSetEffect::spells, ItemSetEntry::spells, sScriptMgr, and sSpellMgr.

Referenced by Player::_ApplyAllItemMods(), and Player::EquipItem().

ItemCanGoIntoBag()

bool ItemCanGoIntoBag	(	ItemTemplate const *	pProto,
		ItemTemplate const *	pBagProto
	)

{
    if (!pProto || !pBagProto)
        return false;
 
    switch (pBagProto->Class)
    {
        case ITEM_CLASS_CONTAINER:
        {
            if (pBagProto->SubClass == ITEM_SUBCLASS_CONTAINER)
            {
                return true;
            }
            else
            {
                if (pProto->Class == ITEM_CLASS_CONTAINER)
                {
                    return false;
                }
 
                switch (pBagProto->SubClass)
                {
                    case ITEM_SUBCLASS_SOUL_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_SOUL_SHARDS))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_HERB_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_HERBS))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_ENCHANTING_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_ENCHANTING_SUPP))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_MINING_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_MINING_SUPP))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_ENGINEERING_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_ENGINEERING_SUPP))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_GEM_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_GEMS))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_LEATHERWORKING_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_LEATHERWORKING_SUPP))
                            return false;
                        return true;
                    case ITEM_SUBCLASS_INSCRIPTION_CONTAINER:
                        if (!(pProto->BagFamily & BAG_FAMILY_MASK_INSCRIPTION_SUPP))
                            return false;
                        return true;
                    default:
                        return false;
                }
            }
        }
        case ITEM_CLASS_QUIVER:
        {
            if (pProto->Class == ITEM_CLASS_QUIVER)
            {
                return false;
            }
 
            switch (pBagProto->SubClass)
            {
                case ITEM_SUBCLASS_QUIVER:
                    if (!(pProto->BagFamily & BAG_FAMILY_MASK_ARROWS))
                        return false;
                    return true;
                case ITEM_SUBCLASS_AMMO_POUCH:
                    if (!(pProto->BagFamily & BAG_FAMILY_MASK_BULLETS))
                        return false;
                    return true;
                default:
                    return false;
            }
        }
    }
 
    return false;
}

References BAG_FAMILY_MASK_ARROWS, BAG_FAMILY_MASK_BULLETS, BAG_FAMILY_MASK_ENCHANTING_SUPP, BAG_FAMILY_MASK_ENGINEERING_SUPP, BAG_FAMILY_MASK_GEMS, BAG_FAMILY_MASK_HERBS, BAG_FAMILY_MASK_INSCRIPTION_SUPP, BAG_FAMILY_MASK_LEATHERWORKING_SUPP, BAG_FAMILY_MASK_MINING_SUPP, BAG_FAMILY_MASK_SOUL_SHARDS, ItemTemplate::BagFamily, ItemTemplate::Class, ITEM_CLASS_CONTAINER, ITEM_CLASS_QUIVER, ITEM_SUBCLASS_AMMO_POUCH, ITEM_SUBCLASS_CONTAINER, ITEM_SUBCLASS_ENCHANTING_CONTAINER, ITEM_SUBCLASS_ENGINEERING_CONTAINER, ITEM_SUBCLASS_GEM_CONTAINER, ITEM_SUBCLASS_HERB_CONTAINER, ITEM_SUBCLASS_INSCRIPTION_CONTAINER, ITEM_SUBCLASS_LEATHERWORKING_CONTAINER, ITEM_SUBCLASS_MINING_CONTAINER, ITEM_SUBCLASS_QUIVER, ITEM_SUBCLASS_SOUL_CONTAINER, and ItemTemplate::SubClass.

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

RemoveItemsSetItem()

void RemoveItemsSetItem	(	Player *	player,
		ItemTemplate const *	proto
	)

{
    uint32 setid = proto->ItemSet;
 
    ItemSetEntry const* set = sItemSetStore.LookupEntry(setid);
 
    if (!set)
    {
        LOG_ERROR("sql.sql", "Item set #{} for item #{} not found, mods not removed.", setid, proto->ItemId);
        return;
    }
 
    ItemSetEffect* eff = nullptr;
    size_t setindex = 0;
    for (; setindex < player->ItemSetEff.size(); setindex++)
    {
        if (player->ItemSetEff[setindex] && player->ItemSetEff[setindex]->setid == setid)
        {
            eff = player->ItemSetEff[setindex];
            break;
        }
    }
 
    // can be in case now enough skill requirement for set appling but set has been appliend when skill requirement not enough
    if (!eff)
        return;
 
    --eff->item_count;
 
    for (uint32 x = 0; x < MAX_ITEM_SET_SPELLS; x++)
    {
        if (!set->spells[x])
            continue;
 
        // enough for spell
        if (set->items_to_triggerspell[x] <= eff->item_count)
            continue;
 
        for (uint32 z = 0; z < MAX_ITEM_SET_SPELLS; z++)
        {
            if (eff->spells[z] && eff->spells[z]->Id == set->spells[x])
            {
                // spell can be not active if not fit form requirement
                player->ApplyEquipSpell(eff->spells[z], nullptr, false);
                eff->spells[z] = nullptr;
                break;
            }
        }
    }
 
    if (!eff->item_count)                                    //all items of a set were removed
    {
        ASSERT(eff == player->ItemSetEff[setindex]);
        delete eff;
        player->ItemSetEff[setindex] = nullptr;
    }
}

References Player::ApplyEquipSpell(), ASSERT, SpellInfo::Id, ItemSetEffect::item_count, ItemTemplate::ItemId, ItemSetEntry::items_to_triggerspell, ItemTemplate::ItemSet, Player::ItemSetEff, LOG_ERROR, MAX_ITEM_SET_SPELLS, sItemSetStore, ItemSetEffect::spells, and ItemSetEntry::spells.

Referenced by Player::_RemoveAllItemMods(), Player::DestroyItem(), and Player::RemoveItem().