Item.cpp File Reference

#include "Common.h"
#include "Item.h"
#include "ObjectMgr.h"
#include "WorldPacket.h"
#include "DatabaseEnv.h"
#include "ItemEnchantmentMgr.h"
#include "SpellMgr.h"
#include "SpellInfo.h"
#include "ScriptMgr.h"
#include "ConditionMgr.h"
#include "Player.h"
#include "Opcodes.h"
#include "WorldSession.h"
#include "ItemPackets.h"
#include "TradeData.h"

Include dependency graph for Item.cpp:

Enumerations
enum	ItemTransmogrificationWeaponCategory : uint8 {   ItemTransmogrificationWeaponCategory::MELEE_2H, ItemTransmogrificationWeaponCategory::RANGED, ItemTransmogrificationWeaponCategory::AXE_MACE_SWORD_1H, ItemTransmogrificationWeaponCategory::DAGGER,   ItemTransmogrificationWeaponCategory::FIST, ItemTransmogrificationWeaponCategory::INVALID }

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

Variables
int32 const	ItemTransmogrificationSlots [MAX_INVTYPE]

Enumeration Type Documentation

enum ItemTransmogrificationWeaponCategory : uint8

strong

Enumerator
MELEE_2H
RANGED
AXE_MACE_SWORD_1H
DAGGER
FIST
INVALID

 : uint8
{
 // Two-handed
 MELEE_2H,
 RANGED,

 // One-handed
 AXE_MACE_SWORD_1H,
 DAGGER,
 FIST,

 INVALID
};

Function Documentation

void AddItemsSetItem	(	Player *	player,
		Item *	item
	)

{
 ItemTemplate const* proto = item->GetTemplate();
 uint32 setid = proto->GetItemSet();

 ItemSetEntry const* set = sItemSetStore.LookupEntry(setid);

 if (!set)
 {
 TC_LOG_ERROR("sql.sql", "Item set %u for item (id %u) not found, mods not applied.", setid, proto->GetId());
 return;
 }

 if (set->RequiredSkill && player->GetSkillValue(set->RequiredSkill) < set->RequiredSkillRank)
 return;

 ItemSetEffect* eff = NULL;

 for (size_t x = 0; x < player->ItemSetEff.size(); ++x)
 {
 if (player->ItemSetEff[x] && player->ItemSetEff[x]->ItemSetID == setid)
 {
 eff = player->ItemSetEff[x];
 break;
 }
 }

 if (!eff)
 {
 eff = new ItemSetEffect();
 eff->ItemSetID = setid;
 eff->EquippedItemCount = 0;

 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->EquippedItemCount;

 ItemSetSpells& spells = sItemSetSpellsStore[setid];

 for (ItemSetSpellEntry const* itemSetSpell : spells)
 {
 //not enough for spell
 if (itemSetSpell->Threshold > eff->EquippedItemCount)
 continue;

 if (eff->SetBonuses.count(itemSetSpell))
 continue;

 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itemSetSpell->SpellID);
 if (!spellInfo)
 {
 TC_LOG_ERROR("entities.player.items", "WORLD: unknown spell id %u in items set %u effects", itemSetSpell->SpellID, setid);
 continue;
 }

 eff->SetBonuses.insert(itemSetSpell);
 // spell cast only if fit form requirement, in other case will cast at form change
 if (!itemSetSpell->ChrSpecID || itemSetSpell->ChrSpecID == player->GetUInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID))
 player->ApplyEquipSpell(spellInfo, NULL, true);
 }
}

Here is the call graph for this function:

static ItemTransmogrificationWeaponCategory GetTransmogrificationWeaponCategory ( ItemTemplate const *  proto )

static

{
 if (proto->GetClass() == ITEM_CLASS_WEAPON)
 {
 switch (proto->GetSubClass())
 {
 case ITEM_SUBCLASS_WEAPON_AXE2:
 case ITEM_SUBCLASS_WEAPON_MACE2:
 case ITEM_SUBCLASS_WEAPON_SWORD2:
 case ITEM_SUBCLASS_WEAPON_STAFF:
 case ITEM_SUBCLASS_WEAPON_POLEARM:
 return ItemTransmogrificationWeaponCategory::MELEE_2H;
 case ITEM_SUBCLASS_WEAPON_BOW:
 case ITEM_SUBCLASS_WEAPON_GUN:
 case ITEM_SUBCLASS_WEAPON_CROSSBOW:
 return ItemTransmogrificationWeaponCategory::RANGED;
 case ITEM_SUBCLASS_WEAPON_AXE:
 case ITEM_SUBCLASS_WEAPON_MACE:
 case ITEM_SUBCLASS_WEAPON_SWORD:
 return ItemTransmogrificationWeaponCategory::AXE_MACE_SWORD_1H;
 case ITEM_SUBCLASS_WEAPON_DAGGER:
 return ItemTransmogrificationWeaponCategory::DAGGER;
 case ITEM_SUBCLASS_WEAPON_FIST_WEAPON:
 return ItemTransmogrificationWeaponCategory::FIST;
 default:
 break;
 }
 }

 return ItemTransmogrificationWeaponCategory::INVALID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
 if (!pProto || !pBagProto)
 return false;

 switch (pBagProto->GetClass())
 {
 case ITEM_CLASS_CONTAINER:
 switch (pBagProto->GetSubClass())
 {
 case ITEM_SUBCLASS_CONTAINER:
 return true;
 case ITEM_SUBCLASS_SOUL_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_SOUL_SHARDS))
 return false;
 return true;
 case ITEM_SUBCLASS_HERB_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_HERBS))
 return false;
 return true;
 case ITEM_SUBCLASS_ENCHANTING_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_ENCHANTING_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_MINING_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_MINING_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_ENGINEERING_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_ENGINEERING_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_GEM_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_GEMS))
 return false;
 return true;
 case ITEM_SUBCLASS_LEATHERWORKING_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_LEATHERWORKING_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_INSCRIPTION_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_INSCRIPTION_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_TACKLE_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_FISHING_SUPP))
 return false;
 return true;
 case ITEM_SUBCLASS_COOKING_CONTAINER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_COOKING_SUPP))
 return false;
 return true;
 default:
 return false;
 }
 case ITEM_CLASS_QUIVER:
 switch (pBagProto->GetSubClass())
 {
 case ITEM_SUBCLASS_QUIVER:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_ARROWS))
 return false;
 return true;
 case ITEM_SUBCLASS_AMMO_POUCH:
 if (!(pProto->GetBagFamily() & BAG_FAMILY_MASK_BULLETS))
 return false;
 return true;
 default:
 return false;
 }
 }
 return false;
}

Here is the call graph for this function:

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

{
 uint32 setid = proto->GetItemSet();

 ItemSetEntry const* set = sItemSetStore.LookupEntry(setid);

 if (!set)
 {
 TC_LOG_ERROR("sql.sql", "Item set #%u for item #%u not found, mods not removed.", setid, proto->GetId());
 return;
 }

 ItemSetEffect* eff = NULL;
 size_t setindex = 0;
 for (; setindex < player->ItemSetEff.size(); setindex++)
 {
 if (player->ItemSetEff[setindex] && player->ItemSetEff[setindex]->ItemSetID == 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->EquippedItemCount;

 ItemSetSpells const& spells = sItemSetSpellsStore[setid];
 for (ItemSetSpellEntry const* itemSetSpell : spells)
 {
 // enough for spell
 if (itemSetSpell->Threshold <= eff->EquippedItemCount)
 continue;

 if (!eff->SetBonuses.count(itemSetSpell))
 continue;

 player->ApplyEquipSpell(sSpellMgr->AssertSpellInfo(itemSetSpell->SpellID), nullptr, false);
 eff->SetBonuses.erase(itemSetSpell);
 }

 if (!eff->EquippedItemCount) //all items of a set were removed
 {
 ASSERT(eff == player->ItemSetEff[setindex]);
 delete eff;
 player->ItemSetEff[setindex] = NULL;
 }
}

Here is the call graph for this function:

Variable Documentation

int32 const ItemTransmogrificationSlots[MAX_INVTYPE]