#include "ItemTemplate.h"

Public Member Functions
bool	HasSignature () const

bool	CanChangeEquipStateInCombat () const

bool	IsCurrencyToken () const

uint32	GetMaxStackSize () const

float	getDPS () const

int32	getFeralBonus (int32 extraDPS=0) const

float	GetItemLevelIncludingQuality (uint8 pLevel) const

uint32	GetSkill () const

bool	IsPotion () const

bool	IsWeaponVellum () const

bool	IsArmorVellum () const

bool	IsConjuredConsumable () const

bool	HasStat (ItemModType stat) const

bool	HasSpellPowerStat () const

void	InitializeQueryData ()

Public Attributes
uint32	ItemId

uint32	Class

uint32	SubClass

int32	SoundOverrideSubclass

std::string	Name1

uint32	DisplayInfoID

uint32	Quality

uint32	Flags

uint32	Flags2

uint32	BuyCount

int32	BuyPrice

uint32	SellPrice

uint32	InventoryType

uint32	AllowableClass

uint32	AllowableRace

uint32	ItemLevel

uint32	RequiredLevel

uint32	RequiredSkill

uint32	RequiredSkillRank

uint32	RequiredSpell

uint32	RequiredHonorRank

uint32	RequiredCityRank

uint32	RequiredReputationFaction

uint32	RequiredReputationRank

int32	MaxCount

int32	Stackable

uint32	ContainerSlots

uint32	StatsCount

_ItemStat	ItemStat [MAX_ITEM_PROTO_STATS]

uint32	ScalingStatDistribution

uint32	ScalingStatValue

_Damage	Damage [MAX_ITEM_PROTO_DAMAGES]

uint32	Armor

int32	HolyRes

int32	FireRes

int32	NatureRes

int32	FrostRes

int32	ShadowRes

int32	ArcaneRes

uint32	Delay

uint32	AmmoType

float	RangedModRange

_Spell	Spells [MAX_ITEM_PROTO_SPELLS]

uint32	Bonding

std::string	Description

uint32	PageText

uint32	LanguageID

uint32	PageMaterial

uint32	StartQuest

uint32	LockID

int32	Material

uint32	Sheath

int32	RandomProperty

int32	RandomSuffix

uint32	Block

uint32	ItemSet

uint32	MaxDurability

uint32	Area

uint32	Map

uint32	BagFamily

uint32	TotemCategory

_Socket	Socket [MAX_ITEM_PROTO_SOCKETS]

uint32	socketBonus

uint32	GemProperties

uint32	RequiredDisenchantSkill

float	ArmorDamageModifier

uint32	Duration

uint32	ItemLimitCategory

uint32	HolidayId

uint32	ScriptId

uint32	DisenchantID

uint32	FoodType

uint32	MinMoneyLoot

uint32	MaxMoneyLoot

uint32	FlagsCu

WorldPacket	queryData

Detailed Description

Member Function Documentation

◆ CanChangeEquipStateInCombat()

bool ItemTemplate::CanChangeEquipStateInCombat ( ) const

inline

    {
        switch (InventoryType)
        {
            case INVTYPE_RELIC:
            case INVTYPE_SHIELD:
            case INVTYPE_HOLDABLE:
                return true;
        }
 
        switch (Class)
        {
            case ITEM_CLASS_WEAPON:
            case ITEM_CLASS_PROJECTILE:
                return true;
        }
 
        return false;
    }

References Class, INVTYPE_HOLDABLE, INVTYPE_RELIC, INVTYPE_SHIELD, ITEM_CLASS_PROJECTILE, and ITEM_CLASS_WEAPON.

Referenced by Player::CanEquipItem(), and Player::CanUnequipItem().

◆ getDPS()

float ItemTemplate::getDPS ( ) const

inline

    {
        if (Delay == 0)
            return 0;
        float temp = 0;
        for (auto i : Damage)
            temp += i.DamageMin + i.DamageMax;
        return temp * 500 / Delay;
    }

References Damage, and Delay.

Referenced by getFeralBonus().

◆ getFeralBonus()

int32 ItemTemplate::getFeralBonus ( int32 extraDPS = 0 ) const

inline

    {
        constexpr uint32 feralApEnabledInventoryTypeMaks = 1 << INVTYPE_WEAPON | 1 << INVTYPE_2HWEAPON | 1 << INVTYPE_WEAPONMAINHAND | 1 << INVTYPE_WEAPONOFFHAND;
 
        // 0x02A5F3 - is mask for Melee weapon from ItemSubClassMask.dbc
        if (Class == ITEM_CLASS_WEAPON && (1 << InventoryType) & feralApEnabledInventoryTypeMaks)
        {
            int32 bonus = int32((extraDPS + getDPS()) * 14.0f) - 767;
            if (bonus < 0)
                return 0;
            return bonus;
        }
        return 0;
    }

References Class, getDPS(), INVTYPE_2HWEAPON, INVTYPE_WEAPON, INVTYPE_WEAPONMAINHAND, INVTYPE_WEAPONOFFHAND, and ITEM_CLASS_WEAPON.

Referenced by Player::_ApplyItemBonuses(), and Player::UpdateAttackPowerAndDamage().

◆ GetItemLevelIncludingQuality()

float ItemTemplate::GetItemLevelIncludingQuality ( uint8 pLevel ) const

inline

    {
        auto itemLevel = (float)ItemLevel;
        switch (Quality)
        {
            case ITEM_QUALITY_POOR:
            case ITEM_QUALITY_NORMAL:
            case ITEM_QUALITY_UNCOMMON:
                itemLevel -= 26.0f;
                break;
            case ITEM_QUALITY_RARE:
                itemLevel -= 13.0f;
                break;
            case ITEM_QUALITY_HEIRLOOM:
                itemLevel = pLevel * 2.33f;
                break;
            case ITEM_QUALITY_ARTIFACT:
            case ITEM_QUALITY_EPIC:
            case ITEM_QUALITY_LEGENDARY:
            default:
                break;
        }
        return std::max<float>(0.f, itemLevel);
    }

References ITEM_QUALITY_ARTIFACT, ITEM_QUALITY_EPIC, ITEM_QUALITY_HEIRLOOM, ITEM_QUALITY_LEGENDARY, ITEM_QUALITY_NORMAL, ITEM_QUALITY_POOR, ITEM_QUALITY_RARE, ITEM_QUALITY_UNCOMMON, ItemLevel, and Quality.

Referenced by Player::GetAverageItemLevel().

◆ GetMaxStackSize()

uint32 ItemTemplate::GetMaxStackSize ( ) const

inline

    {
        return (Stackable == 2147483647 || Stackable <= 0) ? uint32(0x7FFFFFFF - 1) : uint32(Stackable);
    }

References Stackable.

Referenced by Player::_LoadItem(), Player::_StoreOrEquipNewItem(), Loot::AddItem(), Item::CanBeMergedPartlyWith(), Player::CanStoreItem_InBag(), Player::CanStoreItem_InInventorySlots(), Player::CanStoreItem_InSpecificSlot(), Player::CanStoreItems(), Spell::CheckItems(), Player::Create(), Item::CreateItem(), Spell::DoCreateItem(), Item::GetMaxStackCount(), send_commandscript::HandleSendItemsCommand(), HasSignature(), Player::SendItemRetrievalMail(), Player::StoreNewItem(), and Player::SwapItem().

◆ GetSkill()

uint32 ItemTemplate::GetSkill ( ) const

inline

    {
        const static uint32 item_weapon_skills[MAX_ITEM_SUBCLASS_WEAPON] =
        {
            SKILL_AXES,     SKILL_2H_AXES,  SKILL_BOWS,          SKILL_GUNS,      SKILL_MACES,
            SKILL_2H_MACES, SKILL_POLEARMS, SKILL_SWORDS,        SKILL_2H_SWORDS, 0,
            SKILL_STAVES,   0,              0,                   SKILL_FIST_WEAPONS,   0,
            SKILL_DAGGERS,  SKILL_THROWN,   SKILL_ASSASSINATION, SKILL_CROSSBOWS, SKILL_WANDS,
            SKILL_FISHING
        };
 
        const static uint32 item_armor_skills[MAX_ITEM_SUBCLASS_ARMOR] =
        {
            0, SKILL_CLOTH, SKILL_LEATHER, SKILL_MAIL, SKILL_PLATE_MAIL, 0, SKILL_SHIELD, 0, 0, 0, 0
        };
 
        switch (Class)
        {
            case ITEM_CLASS_WEAPON:
                if (SubClass >= MAX_ITEM_SUBCLASS_WEAPON)
                    return 0;
                else
                    return item_weapon_skills[SubClass];
 
            case ITEM_CLASS_ARMOR:
                if (SubClass >= MAX_ITEM_SUBCLASS_ARMOR)
                    return 0;
                else
                    return item_armor_skills[SubClass];
 
            default:
                return 0;
        }
    }

References Class, ITEM_CLASS_ARMOR, ITEM_CLASS_WEAPON, MAX_ITEM_SUBCLASS_ARMOR, MAX_ITEM_SUBCLASS_WEAPON, SKILL_2H_AXES, SKILL_2H_MACES, SKILL_2H_SWORDS, SKILL_ASSASSINATION, SKILL_AXES, SKILL_BOWS, SKILL_CLOTH, SKILL_CROSSBOWS, SKILL_DAGGERS, SKILL_FISHING, SKILL_FIST_WEAPONS, SKILL_GUNS, SKILL_LEATHER, SKILL_MACES, SKILL_MAIL, SKILL_PLATE_MAIL, SKILL_POLEARMS, SKILL_SHIELD, SKILL_STAVES, SKILL_SWORDS, SKILL_THROWN, SKILL_WANDS, and SubClass.

Referenced by Item::GetSkill().

◆ HasSignature()

bool ItemTemplate::HasSignature ( ) const

inline

    {
        return GetMaxStackSize() == 1 &&
               Class != ITEM_CLASS_CONSUMABLE &&
               Class != ITEM_CLASS_QUEST &&
               (Flags & ITEM_FLAG_NO_CREATOR) == 0 &&
               ItemId != 6948; /*Hearthstone*/
    }

References Class, Flags, GetMaxStackSize(), ITEM_CLASS_CONSUMABLE, ITEM_CLASS_QUEST, ITEM_FLAG_NO_CREATOR, and ItemId.

Referenced by Spell::DoCreateItem().

◆ HasSpellPowerStat()

bool ItemTemplate::HasSpellPowerStat ( ) const

{
    bool invalid = false;
    for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
    {
        _Spell const& spellData = Spells[i];
        if (!spellData.SpellId)
        {
            continue;
        }
 
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellData.SpellId);
        if (!spellInfo)
        {
            continue;
        }
 
        for (uint8 j = EFFECT_0; j <= EFFECT_2; ++j)
        {
            switch (spellInfo->Effects[j].ApplyAuraName)
            {
                case SPELL_AURA_MOD_HEALING_DONE:
                case SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT:
                case SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER:
                case SPELL_AURA_MOD_HEALING:
                    invalid = true;
                    break;
                case SPELL_AURA_MOD_DAMAGE_DONE:
                case SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT:
                case SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER:
                case SPELL_AURA_MOD_DAMAGE_TAKEN:
                    if (!(spellInfo->Effects[j].MiscValue & SPELL_SCHOOL_MASK_SPELL))
                    {
                        return false;
                    }
                    invalid = true;
                    break;
                default:
                    break;
            }
        }
    }
 
    return invalid;
}

References EFFECT_0, EFFECT_2, SpellInfo::Effects, MAX_ITEM_PROTO_SPELLS, SPELL_AURA_MOD_DAMAGE_DONE, SPELL_AURA_MOD_DAMAGE_TAKEN, SPELL_AURA_MOD_HEALING, SPELL_AURA_MOD_HEALING_DONE, SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER, SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT, SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER, SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT, SPELL_SCHOOL_MASK_SPELL, _Spell::SpellId, and sSpellMgr.

Referenced by Player::CanRollForItemInLFG().

◆ HasStat()

bool ItemTemplate::HasStat ( ItemModType stat ) const

{
    for (uint8 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
    {
        if (i >= StatsCount)
        {
            break;
        }
 
        if (ItemStat[i].ItemStatType == stat)
        {
            return true;
        }
    }
 
    return false;
}

References ItemStat, MAX_ITEM_PROTO_STATS, and StatsCount.

Referenced by Player::CanRollForItemInLFG().

◆ InitializeQueryData()

void ItemTemplate::InitializeQueryData ( )

{
    queryData.Initialize(SMSG_ITEM_QUERY_SINGLE_RESPONSE, 1);
 
    queryData << ItemId;
    queryData << Class;
    queryData << SubClass;
    queryData << SoundOverrideSubclass;
    queryData << Name1;
    queryData << uint8(0x00);                                //pProto->Name2; // blizz not send name there, just uint8(0x00); <-- \0 = empty string = empty name...
    queryData << uint8(0x00);                                //pProto->Name3; // blizz not send name there, just uint8(0x00);
    queryData << uint8(0x00);                                //pProto->Name4; // blizz not send name there, just uint8(0x00);
    queryData << DisplayInfoID;
    queryData << Quality;
    queryData << Flags;
    queryData << Flags2;
    queryData << BuyPrice;
    queryData << SellPrice;
    queryData << InventoryType;
    queryData << AllowableClass;
    queryData << AllowableRace;
    queryData << ItemLevel;
    queryData << RequiredLevel;
    queryData << RequiredSkill;
    queryData << RequiredSkillRank;
    queryData << RequiredSpell;
    queryData << RequiredHonorRank;
    queryData << RequiredCityRank;
    queryData << RequiredReputationFaction;
    queryData << RequiredReputationRank;
    queryData << int32(MaxCount);
    queryData << int32(Stackable);
    queryData << ContainerSlots;
    queryData << StatsCount;                         // item stats count
    for (uint32 i = 0; i < StatsCount; ++i)
    {
        queryData << ItemStat[i].ItemStatType;
        queryData << ItemStat[i].ItemStatValue;
    }
    queryData << ScalingStatDistribution;            // scaling stats distribution
    queryData << ScalingStatValue;                   // some kind of flags used to determine stat values column
    for (int i = 0; i < MAX_ITEM_PROTO_DAMAGES; ++i)
    {
        queryData << Damage[i].DamageMin;
        queryData << Damage[i].DamageMax;
        queryData << Damage[i].DamageType;
    }
 
    // resistances (7)
    queryData << Armor;
    queryData << HolyRes;
    queryData << FireRes;
    queryData << NatureRes;
    queryData << FrostRes;
    queryData << ShadowRes;
    queryData << ArcaneRes;
 
    queryData << Delay;
    queryData << AmmoType;
    queryData << RangedModRange;
 
    for (int s = 0; s < MAX_ITEM_PROTO_SPELLS; ++s)
    {
        // send DBC data for cooldowns in same way as it used in Spell::SendSpellCooldown
        // use `item_template` or if not set then only use spell cooldowns
        SpellInfo const* spell = sSpellMgr->GetSpellInfo(Spells[s].SpellId);
        if (spell)
        {
            bool db_data = Spells[s].SpellCooldown >= 0 || Spells[s].SpellCategoryCooldown >= 0;
 
            queryData << Spells[s].SpellId;
            queryData << Spells[s].SpellTrigger;
            queryData << int32(Spells[s].SpellCharges);
 
            if (db_data)
            {
                queryData << uint32(Spells[s].SpellCooldown);
                queryData << uint32(Spells[s].SpellCategory);
                queryData << uint32(Spells[s].SpellCategoryCooldown);
            }
            else
            {
                queryData << uint32(spell->RecoveryTime);
                queryData << uint32(spell->GetCategory());
                queryData << uint32(spell->CategoryRecoveryTime);
            }
        }
        else
        {
            queryData << uint32(0);
            queryData << uint32(0);
            queryData << uint32(0);
            queryData << uint32(-1);
            queryData << uint32(0);
            queryData << uint32(-1);
        }
    }
    queryData << Bonding;
    queryData << Description;
    queryData << PageText;
    queryData << LanguageID;
    queryData << PageMaterial;
    queryData << StartQuest;
    queryData << LockID;
    queryData << int32(Material);
    queryData << Sheath;
    queryData << RandomProperty;
    queryData << RandomSuffix;
    queryData << Block;
    queryData << ItemSet;
    queryData << MaxDurability;
    queryData << Area;
    queryData << Map;                                // Added in 1.12.x & 2.0.1 client branch
    queryData << BagFamily;
    queryData << TotemCategory;
    for (int s = 0; s < MAX_ITEM_PROTO_SOCKETS; ++s)
    {
        queryData << Socket[s].Color;
        queryData << Socket[s].Content;
    }
    queryData << socketBonus;
    queryData << GemProperties;
    queryData << RequiredDisenchantSkill;
    queryData << ArmorDamageModifier;
    queryData << Duration;                           // added in 2.4.2.8209, duration (seconds)
    queryData << ItemLimitCategory;                  // WotLK, ItemLimitCategory
    queryData << HolidayId;                          // Holiday.dbc?
}