LootMgr.cpp File Reference

#include "LootMgr.h"
#include "Containers.h"
#include "DisableMgr.h"
#include "Group.h"
#include "ItemEnchantmentMgr.h"
#include "Log.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "SharedDefines.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "Util.h"
#include "World.h"

Go to the source code of this file.

Classes
struct	LootGroupInvalidSelector
class	LootTemplate::LootGroup

Functions
ByteBuffer &	operator<< (ByteBuffer &b, LootItem const &li)
ByteBuffer &	operator<< (ByteBuffer &b, LootView const &lv)
void	LoadLootTemplates_Creature ()
void	LoadLootTemplates_Disenchant ()
void	LoadLootTemplates_Fishing ()
void	LoadLootTemplates_Gameobject ()
void	LoadLootTemplates_Item ()
void	LoadLootTemplates_Milling ()
void	LoadLootTemplates_Pickpocketing ()
void	LoadLootTemplates_Prospecting ()
void	LoadLootTemplates_Mail ()
void	LoadLootTemplates_Skinning ()
void	LoadLootTemplates_Spell ()
void	LoadLootTemplates_Player ()
void	LoadLootTemplates_Reference ()

Variables
static Rates const	qualityToRate [MAX_ITEM_QUALITY]
LootStore	LootTemplates_Creature ("creature_loot_template", "creature entry", true)
LootStore	LootTemplates_Disenchant ("disenchant_loot_template", "item disenchant id", true)
LootStore	LootTemplates_Fishing ("fishing_loot_template", "area id", true)
LootStore	LootTemplates_Gameobject ("gameobject_loot_template", "gameobject entry", true)
LootStore	LootTemplates_Item ("item_loot_template", "item entry", true)
LootStore	LootTemplates_Mail ("mail_loot_template", "mail template id", false)
LootStore	LootTemplates_Milling ("milling_loot_template", "item entry (herb)", true)
LootStore	LootTemplates_Pickpocketing ("pickpocketing_loot_template", "creature pickpocket lootid", true)
LootStore	LootTemplates_Prospecting ("prospecting_loot_template", "item entry (ore)", true)
LootStore	LootTemplates_Reference ("reference_loot_template", "reference id", false)
LootStore	LootTemplates_Skinning ("skinning_loot_template", "creature skinning id", true)
LootStore	LootTemplates_Spell ("spell_loot_template", "spell id (random item creating)", false)
LootStore	LootTemplates_Player ("player_loot_template", "team id", true)

Function Documentation

LoadLootTemplates_Creature()

void LoadLootTemplates_Creature

(

)

{
    LOG_INFO("server.loading", "Loading Creature Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet, lootIdSetUsed;
    uint32 count = LootTemplates_Creature.LoadAndCollectLootIds(lootIdSet);
 
    // Remove real entries and check loot existence
    CreatureTemplateContainer const* ctc = sObjectMgr->GetCreatureTemplates();
    for (CreatureTemplateContainer::const_iterator itr = ctc->begin(); itr != ctc->end(); ++itr)
    {
        if (uint32 lootid = itr->second.lootid)
        {
            if (lootIdSet.find(lootid) == lootIdSet.end())
                LootTemplates_Creature.ReportNonExistingId(lootid, "Creature", itr->second.Entry);
            else
                lootIdSetUsed.insert(lootid);
        }
    }
 
    for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
        lootIdSet.erase(*itr);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Creature.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} Creature Loot Templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 creature loot templates. DB table `creature_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Creature, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesCreatureCommand(), and LoadLootTables().

LoadLootTemplates_Disenchant()

void LoadLootTemplates_Disenchant

(

)

{
    LOG_INFO("server.loading", "Loading Disenchanting Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet, lootIdSetUsed;
    uint32 count = LootTemplates_Disenchant.LoadAndCollectLootIds(lootIdSet);
 
    ItemTemplateContainer const* its = sObjectMgr->GetItemTemplateStore();
    for (ItemTemplateContainer::const_iterator itr = its->begin(); itr != its->end(); ++itr)
    {
        if (uint32 lootid = itr->second.DisenchantID)
        {
            if (lootIdSet.find(lootid) == lootIdSet.end())
                LootTemplates_Disenchant.ReportNonExistingId(lootid);
            else
                lootIdSetUsed.insert(lootid);
        }
    }
 
    for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
        lootIdSet.erase(*itr);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Disenchant.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} disenchanting loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 disenchanting loot templates. DB table `disenchant_loot_template` is empty");
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Disenchant, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesDisenchantCommand(), and LoadLootTables().

LoadLootTemplates_Fishing()

void LoadLootTemplates_Fishing

(

)

{
    LOG_INFO("server.loading", "Loading Fishing Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Fishing.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    for (uint32 i = 1; i < sAreaTableStore.GetNumRows(); ++i)
        if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(i))
            if (lootIdSet.find(areaEntry->ID) != lootIdSet.end())
                lootIdSet.erase(areaEntry->ID);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Fishing.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} Fishing Loot Templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 fishing loot templates. DB table `fishing_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Fishing, LootStore::ReportUnusedIds(), and sAreaTableStore.

Referenced by reload_commandscript::HandleReloadLootTemplatesFishingCommand(), and LoadLootTables().

LoadLootTemplates_Gameobject()

void LoadLootTemplates_Gameobject

(

)

{
    LOG_INFO("server.loading", "Loading Gameobject Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet, lootIdSetUsed;
    uint32 count = LootTemplates_Gameobject.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    GameObjectTemplateContainer const* gotc = sObjectMgr->GetGameObjectTemplates();
    for (GameObjectTemplateContainer::const_iterator itr = gotc->begin(); itr != gotc->end(); ++itr)
    {
        if (uint32 lootid = itr->second.GetLootId())
        {
            if (lootIdSet.find(lootid) == lootIdSet.end())
                LootTemplates_Gameobject.ReportNonExistingId(lootid, "Gameobject", itr->second.entry);
            else
                lootIdSetUsed.insert(lootid);
        }
    }
 
    for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
        lootIdSet.erase(*itr);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Gameobject.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} Gameobject Loot Templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 gameobject loot templates. DB table `gameobject_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Gameobject, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesGameobjectCommand(), and LoadLootTables().

LoadLootTemplates_Item()

void LoadLootTemplates_Item

(

)

{
    LOG_INFO("server.loading", "Loading Item Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Item.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    ItemTemplateContainer const* its = sObjectMgr->GetItemTemplateStore();
    for (ItemTemplateContainer::const_iterator itr = its->begin(); itr != its->end(); ++itr)
        if (lootIdSet.find(itr->second.ItemId) != lootIdSet.end() && itr->second.HasFlag(ITEM_FLAG_HAS_LOOT))
            lootIdSet.erase(itr->second.ItemId);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Item.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} item loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 item loot templates. DB table `item_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), ITEM_FLAG_HAS_LOOT, LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Item, LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesItemCommand(), and LoadLootTables().

LoadLootTemplates_Mail()

void LoadLootTemplates_Mail

(

)

{
    LOG_INFO("server.loading", "Loading Mail Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Mail.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    for (uint32 i = 1; i < sMailTemplateStore.GetNumRows(); ++i)
        if (sMailTemplateStore.LookupEntry(i))
            if (lootIdSet.find(i) != lootIdSet.end())
                lootIdSet.erase(i);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Mail.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} mail loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 mail loot templates. DB table `mail_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Mail, LootStore::ReportUnusedIds(), and sMailTemplateStore.

Referenced by reload_commandscript::HandleReloadLootTemplatesMailCommand(), and LoadLootTables().

LoadLootTemplates_Milling()

void LoadLootTemplates_Milling

(

)

{
    LOG_INFO("server.loading", "Loading Milling Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Milling.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    ItemTemplateContainer const* its = sObjectMgr->GetItemTemplateStore();
    for (ItemTemplateContainer::const_iterator itr = its->begin(); itr != its->end(); ++itr)
    {
        if (!itr->second.HasFlag(ITEM_FLAG_IS_MILLABLE))
            continue;
 
        if (lootIdSet.find(itr->second.ItemId) != lootIdSet.end())
            lootIdSet.erase(itr->second.ItemId);
    }
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Milling.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} milling loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 milling loot templates. DB table `milling_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), ITEM_FLAG_IS_MILLABLE, LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Milling, LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesMillingCommand(), and LoadLootTables().

LoadLootTemplates_Pickpocketing()

void LoadLootTemplates_Pickpocketing

(

)

{
    LOG_INFO("server.loading", "Loading Pickpocketing Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet, lootIdSetUsed;
    uint32 count = LootTemplates_Pickpocketing.LoadAndCollectLootIds(lootIdSet);
 
    // Remove real entries and check loot existence
    CreatureTemplateContainer const* ctc = sObjectMgr->GetCreatureTemplates();
    for (CreatureTemplateContainer::const_iterator itr = ctc->begin(); itr != ctc->end(); ++itr)
    {
        if (uint32 lootid = itr->second.pickpocketLootId)
        {
            if (lootIdSet.find(lootid) == lootIdSet.end())
                LootTemplates_Pickpocketing.ReportNonExistingId(lootid, "Creature", itr->second.Entry);
            else
                lootIdSetUsed.insert(lootid);
        }
    }
 
    for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
        lootIdSet.erase(*itr);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Pickpocketing.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} pickpocketing loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 pickpocketing loot templates. DB table `pickpocketing_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Pickpocketing, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesPickpocketingCommand(), and LoadLootTables().

LoadLootTemplates_Player()

void LoadLootTemplates_Player

(

)

{
    LOG_INFO("server.loading", "Loading Player Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Player.LoadAndCollectLootIds(lootIdSet);
 
    if (count)
    {
        LOG_INFO("server.loading", ">> Loaded {} player loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    }
    else
    {
        LOG_WARN("server.loading", ">> Loaded 0 player loot templates. DB table `player_loot_template` is empty");
    }
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, and LootTemplates_Player.

Referenced by reload_commandscript::HandleReloadLootTemplatesPlayerCommand(), and LoadLootTables().

LoadLootTemplates_Prospecting()

void LoadLootTemplates_Prospecting

(

)

{
    LOG_INFO("server.loading", "Loading Prospecting Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Prospecting.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    ItemTemplateContainer const* its = sObjectMgr->GetItemTemplateStore();
    for (ItemTemplateContainer::const_iterator itr = its->begin(); itr != its->end(); ++itr)
    {
        if (!itr->second.HasFlag(ITEM_FLAG_IS_PROSPECTABLE))
            continue;
 
        if (lootIdSet.find(itr->second.ItemId) != lootIdSet.end())
            lootIdSet.erase(itr->second.ItemId);
    }
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Prospecting.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} prospecting loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 prospecting loot templates. DB table `prospecting_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), ITEM_FLAG_IS_PROSPECTABLE, LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Prospecting, LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesProspectingCommand(), and LoadLootTables().

LoadLootTemplates_Reference()

void LoadLootTemplates_Reference

(

)

{
    LOG_INFO("server.loading", "Loading Reference Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    LootTemplates_Reference.LoadAndCollectLootIds(lootIdSet);
 
    // check references and remove used
    LootTemplates_Creature.CheckLootRefs(&lootIdSet);
    LootTemplates_Fishing.CheckLootRefs(&lootIdSet);
    LootTemplates_Gameobject.CheckLootRefs(&lootIdSet);
    LootTemplates_Item.CheckLootRefs(&lootIdSet);
    LootTemplates_Milling.CheckLootRefs(&lootIdSet);
    LootTemplates_Pickpocketing.CheckLootRefs(&lootIdSet);
    LootTemplates_Skinning.CheckLootRefs(&lootIdSet);
    LootTemplates_Disenchant.CheckLootRefs(&lootIdSet);
    LootTemplates_Prospecting.CheckLootRefs(&lootIdSet);
    LootTemplates_Mail.CheckLootRefs(&lootIdSet);
    LootTemplates_Reference.CheckLootRefs(&lootIdSet);
 
    // output error for any still listed ids (not referenced from any loot table)
    LootTemplates_Reference.ReportUnusedIds(lootIdSet);
 
    LOG_INFO("server.loading", ">> Loaded reference loot templates in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References LootStore::CheckLootRefs(), getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LootTemplates_Creature, LootTemplates_Disenchant, LootTemplates_Fishing, LootTemplates_Gameobject, LootTemplates_Item, LootTemplates_Mail, LootTemplates_Milling, LootTemplates_Pickpocketing, LootTemplates_Prospecting, LootTemplates_Reference, LootTemplates_Skinning, and LootStore::ReportUnusedIds().

Referenced by reload_commandscript::HandleReloadLootTemplatesReferenceCommand(), and LoadLootTables().

LoadLootTemplates_Skinning()

void LoadLootTemplates_Skinning

(

)

{
    LOG_INFO("server.loading", "Loading Skinning Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet, lootIdSetUsed;
    uint32 count = LootTemplates_Skinning.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    CreatureTemplateContainer const* ctc = sObjectMgr->GetCreatureTemplates();
    for (CreatureTemplateContainer::const_iterator itr = ctc->begin(); itr != ctc->end(); ++itr)
    {
        if (uint32 lootid = itr->second.SkinLootId)
        {
            if (lootIdSet.find(lootid) == lootIdSet.end())
                LootTemplates_Skinning.ReportNonExistingId(lootid, "Creature", itr->second.Entry);
            else
                lootIdSetUsed.insert(lootid);
        }
    }
 
    for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
        lootIdSet.erase(*itr);
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Skinning.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} skinning loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 skinning loot templates. DB table `skinning_loot_template` is empty");
 
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Skinning, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), and sObjectMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesSkinningCommand(), and LoadLootTables().

LoadLootTemplates_Spell()

void LoadLootTemplates_Spell

(

)

{
    LOG_INFO("server.loading", "Loading Spell Loot Templates...");
 
    uint32 oldMSTime = getMSTime();
 
    LootIdSet lootIdSet;
    uint32 count = LootTemplates_Spell.LoadAndCollectLootIds(lootIdSet);
 
    // remove real entries and check existence loot
    for (uint32 spell_id = 1; spell_id < sSpellMgr->GetSpellInfoStoreSize(); ++spell_id)
    {
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id);
        if (!spellInfo)
            continue;
 
        // possible cases
        if (!spellInfo->IsLootCrafting())
            continue;
 
        if (lootIdSet.find(spell_id) == lootIdSet.end())
        {
            // not report about not trainable spells (optionally supported by DB)
            // ignore 61756 (Northrend Inscription Research (FAST QA VERSION) for example
            if (!spellInfo->HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED) || spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL))
            {
                LootTemplates_Spell.ReportNonExistingId(spell_id, "Spell", spellInfo->Id);
            }
        }
        else
            lootIdSet.erase(spell_id);
    }
 
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Spell.ReportUnusedIds(lootIdSet);
 
    if (count)
        LOG_INFO("server.loading", ">> Loaded {} spell loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    else
        LOG_WARN("server.loading", ">> Loaded 0 spell loot templates. DB table `spell_loot_template` is empty");
    LOG_INFO("server.loading", " ");
}

References getMSTime(), GetMSTimeDiffToNow(), SpellInfo::HasAttribute(), SpellInfo::Id, SpellInfo::IsLootCrafting(), LootStore::LoadAndCollectLootIds(), LOG_INFO, LOG_WARN, LootTemplates_Spell, LootStore::ReportNonExistingId(), LootStore::ReportUnusedIds(), SPELL_ATTR0_IS_TRADESKILL, SPELL_ATTR0_NOT_SHAPESHIFTED, and sSpellMgr.

Referenced by reload_commandscript::HandleReloadLootTemplatesSpellCommand(), and LoadLootTables().

operator<<() [1/2]

ByteBuffer & operator<<	(	ByteBuffer &	b,
		LootItem const &	li
	)

{
    b << uint32(li.itemid);
    b << uint32(li.count);                                  // nr of items of this type
    b << uint32(sObjectMgr->GetItemTemplate(li.itemid)->DisplayInfoID);
    b << uint32(li.randomSuffix);
    b << uint32(li.randomPropertyId);
    //b << uint8(0);                                        // slot type - will send after this function call
    return b;
}

References LootItem::count, LootItem::itemid, LootItem::randomPropertyId, LootItem::randomSuffix, and sObjectMgr.

operator<<() [2/2]

ByteBuffer & operator<<	(	ByteBuffer &	b,
		LootView const &	lv
	)

{
    if (lv.permission == NONE_PERMISSION)
    {
        b << uint32(0);                                     //gold
        b << uint8(0);                                      // item count
        return b;                                           // nothing output more
    }
 
    Loot& l = lv.loot;
 
    uint8 itemsShown = 0;
 
    b << uint32(l.gold);                                    //gold
 
    std::size_t count_pos = b.wpos();                            // pos of item count byte
    b << uint8(0);                                          // item count placeholder
 
    switch (lv.permission)
    {
        case GROUP_PERMISSION:
        case MASTER_PERMISSION:
        case RESTRICTED_PERMISSION:
            {
                bool isMasterLooter = lv.viewer->GetGroup() && lv.viewer->GetGroup()->GetMasterLooterGuid() == lv.viewer->GetGUID();
 
                // if you are not the round-robin group looter, you can only see
                // blocked rolled items and quest items, and !ffa items
                for (uint8 i = 0; i < l.items.size(); ++i)
                {
                    if (!l.items[i].is_looted && !l.items[i].freeforall && (l.items[i].conditions.empty() || isMasterLooter) && l.items[i].AllowedForPlayer(lv.viewer, l.sourceWorldObjectGUID))
                    {
                        uint8 slot_type = 0;
 
                        if (l.items[i].is_blocked) // for ML & restricted is_blocked = !is_underthreshold
                        {
                            switch (lv.permission)
                            {
                                case GROUP_PERMISSION:
                                    slot_type = LOOT_SLOT_TYPE_ROLL_ONGOING;
                                    break;
                                case MASTER_PERMISSION:
                                    {
                                        if (lv.viewer->GetGroup())
                                        {
                                            if (lv.viewer->GetGroup()->GetMasterLooterGuid() == lv.viewer->GetGUID())
                                                slot_type = LOOT_SLOT_TYPE_MASTER;
                                            else
                                                slot_type = LOOT_SLOT_TYPE_LOCKED;
                                        }
                                        break;
                                    }
                                case RESTRICTED_PERMISSION:
                                    slot_type = LOOT_SLOT_TYPE_LOCKED;
                                    break;
                                default:
                                    continue;
                            }
                        }
                        else if (l.items[i].rollWinnerGUID)
                        {
                            if (l.items[i].rollWinnerGUID == lv.viewer->GetGUID())
                                slot_type = LOOT_SLOT_TYPE_OWNER;
                            else
                                continue;
                        }
                        else if (!l.roundRobinPlayer || lv.viewer->GetGUID() == l.roundRobinPlayer || !l.items[i].is_underthreshold)
                        {
                            // no round robin owner or he has released the loot
                            // or it IS the round robin group owner
                            // => item is lootable
                            slot_type = LOOT_SLOT_TYPE_ALLOW_LOOT;
                        }
                        else
                            // item shall not be displayed.
                            continue;
 
                        b << uint8(i) << l.items[i];
                        b << uint8(slot_type);
                        ++itemsShown;
                    }
                }
                break;
            }
        case ROUND_ROBIN_PERMISSION:
            {
                for (uint8 i = 0; i < l.items.size(); ++i)
                {
                    if (!l.items[i].is_looted && !l.items[i].freeforall && l.items[i].conditions.empty() && l.items[i].AllowedForPlayer(lv.viewer, l.sourceWorldObjectGUID))
                    {
                        if (l.roundRobinPlayer && lv.viewer->GetGUID() != l.roundRobinPlayer)
                            // item shall not be displayed.
                            continue;
 
                        b << uint8(i) << l.items[i];
                        b << uint8(LOOT_SLOT_TYPE_ALLOW_LOOT);
                        ++itemsShown;
                    }
                }
                break;
            }
        case ALL_PERMISSION:
        case OWNER_PERMISSION:
            {
                uint8 slot_type = lv.permission == OWNER_PERMISSION ? LOOT_SLOT_TYPE_OWNER : LOOT_SLOT_TYPE_ALLOW_LOOT;
                for (uint8 i = 0; i < l.items.size(); ++i)
                {
                    if (!l.items[i].is_looted && !l.items[i].freeforall && l.items[i].conditions.empty() && l.items[i].AllowedForPlayer(lv.viewer, l.sourceWorldObjectGUID))
                    {
                        b << uint8(i) << l.items[i];
                        b << uint8(slot_type);
                        ++itemsShown;
                    }
                }
                break;
            }
        default:
            return b;
    }
 
    LootSlotType slotType = lv.permission == OWNER_PERMISSION ? LOOT_SLOT_TYPE_OWNER : LOOT_SLOT_TYPE_ALLOW_LOOT;
 
    // Xinef: items that do not follow loot rules need this
    LootSlotType partySlotType = lv.permission == MASTER_PERMISSION ? LOOT_SLOT_TYPE_MASTER : slotType;
 
    QuestItemMap const& lootPlayerQuestItems = l.GetPlayerQuestItems();
    QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(lv.viewer->GetGUID());
    if (q_itr != lootPlayerQuestItems.end())
    {
        QuestItemList* q_list = q_itr->second;
        for (QuestItemList::const_iterator qi = q_list->begin(); qi != q_list->end(); ++qi)
        {
            LootItem& item = l.quest_items[qi->index];
            if (!qi->is_looted && !item.is_looted)
            {
                bool showInLoot = true;
                bool hasQuestForItem = lv.viewer->HasQuestForItem(item.itemid, 0, false, &showInLoot);
                if (!hasQuestForItem)
                {
                    if (!showInLoot)
                    {
                        const_cast<QuestItem*>(&(*qi))->is_looted = true;
                        if (!item.freeforall)
                        {
                            item.is_looted = true;
                        }
                        continue;
                    }
 
                    b << uint8(l.items.size() + (qi - q_list->begin()));
                    b << item;
                    b << uint8(lv.permission == MASTER_PERMISSION ? LOOT_SLOT_TYPE_MASTER : LOOT_SLOT_TYPE_LOCKED);
                }
                else
                {
                    b << uint8(l.items.size() + (qi - q_list->begin()));
                    b << item;
 
                    if (item.follow_loot_rules)
                    {
                        switch (lv.permission)
                        {
                            case MASTER_PERMISSION:
                                b << uint8(LOOT_SLOT_TYPE_MASTER);
                                break;
                            case RESTRICTED_PERMISSION:
                                b << (item.is_blocked ? uint8(LOOT_SLOT_TYPE_LOCKED) : uint8(slotType));
                                break;
                            case GROUP_PERMISSION:
                            case ROUND_ROBIN_PERMISSION:
                                if (!item.is_blocked)
                                    b << uint8(LOOT_SLOT_TYPE_ALLOW_LOOT);
                                else
                                    b << uint8(LOOT_SLOT_TYPE_ROLL_ONGOING);
                                break;
                            default:
                                b << uint8(slotType);
                                break;
                        }
                    }
                    else if (!item.freeforall)
                        b << uint8(partySlotType);
                    else
                        b << uint8(slotType);
                }
 
                ++itemsShown;
            }
        }
    }
 
    QuestItemMap const& lootPlayerFFAItems = l.GetPlayerFFAItems();
    QuestItemMap::const_iterator ffa_itr = lootPlayerFFAItems.find(lv.viewer->GetGUID());
    if (ffa_itr != lootPlayerFFAItems.end())
    {
        QuestItemList* ffa_list = ffa_itr->second;
        for (QuestItemList::const_iterator fi = ffa_list->begin(); fi != ffa_list->end(); ++fi)
        {
            LootItem& item = l.items[fi->index];
            if (!fi->is_looted && !item.is_looted)
            {
                b << uint8(fi->index);
                b << item;
                // Xinef: Here are FFA items, so dont use owner permision
                b << uint8(LOOT_SLOT_TYPE_ALLOW_LOOT /*slotType*/);
                ++itemsShown;
            }
        }
    }
 
    QuestItemMap const& lootPlayerNonQuestNonFFAConditionalItems = l.GetPlayerNonQuestNonFFAConditionalItems();
    QuestItemMap::const_iterator nn_itr = lootPlayerNonQuestNonFFAConditionalItems.find(lv.viewer->GetGUID());
    if (nn_itr != lootPlayerNonQuestNonFFAConditionalItems.end())
    {
        QuestItemList* conditional_list = nn_itr->second;
        for (QuestItemList::const_iterator ci = conditional_list->begin(); ci != conditional_list->end(); ++ci)
        {
            LootItem& item = l.items[ci->index];
            if (!ci->is_looted && !item.is_looted)
            {
                b << uint8(ci->index);
                b << item;
                if (item.follow_loot_rules)
                {
                    switch (lv.permission)
                    {
                        case MASTER_PERMISSION:
                            b << uint8(LOOT_SLOT_TYPE_MASTER);
                            break;
                        case RESTRICTED_PERMISSION:
                            b << (item.is_blocked ? uint8(LOOT_SLOT_TYPE_LOCKED) : uint8(slotType));
                            break;
                        case GROUP_PERMISSION:
                        case ROUND_ROBIN_PERMISSION:
                            if (!item.is_blocked)
                                b << uint8(LOOT_SLOT_TYPE_ALLOW_LOOT);
                            else
                                b << uint8(LOOT_SLOT_TYPE_ROLL_ONGOING);
                            break;
                        default:
                            b << uint8(slotType);
                            break;
                    }
                }
                else if (!item.freeforall)
                    b << uint8(partySlotType);
                else
                    b << uint8(slotType);
                ++itemsShown;
            }
        }
    }
 
    //update number of items shown
    b.put<uint8>(count_pos, itemsShown);
 
    return b;
}

Variable Documentation

LootTemplates_Creature

LootStore LootTemplates_Creature("creature_loot_template", "creature entry", true)	(	"creature_loot_template"	,
		"creature entry"	,
		true
	)

Referenced by boss_high_king_maulgar::DoAction(), reload_commandscript::HandleReloadLootTemplatesCreatureCommand(), ConditionMgr::isSourceTypeValid(), Unit::Kill(), ConditionMgr::LoadConditions(), instance_utgarde_keep::instance_utgarde_keep_InstanceMapScript::SetData(), and boss_priestess_delrissa::SummonedCreatureDies().

LootTemplates_Disenchant

LootStore LootTemplates_Disenchant("disenchant_loot_template", "item disenchant id", true)	(	"disenchant_loot_template"	,
		"item disenchant id"	,
		true
	)

Referenced by Group::CountTheRoll(), reload_commandscript::HandleReloadLootTemplatesDisenchantCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Fishing

LootStore LootTemplates_Fishing("fishing_loot_template", "area id", true)	(	"fishing_loot_template"	,
		"area id"	,
		true
	)

Referenced by GameObject::GetFishLoot(), GameObject::GetFishLootJunk(), reload_commandscript::HandleReloadLootTemplatesFishingCommand(), ConditionMgr::isSourceTypeValid(), and ConditionMgr::LoadConditions().

LootTemplates_Gameobject

LootStore LootTemplates_Gameobject("gameobject_loot_template", "gameobject entry", true)	(	"gameobject_loot_template"	,
		"gameobject entry"	,
		true
	)

Referenced by GameObject::ActivateToQuest(), reload_commandscript::HandleReloadLootTemplatesGameobjectCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), ObjectMgr::LoadGameObjectForQuests(), and Player::SendLoot().

LootTemplates_Item

LootStore LootTemplates_Item("item_loot_template", "item entry", true)	(	"item_loot_template"	,
		"item entry"	,
		true
	)

Referenced by reload_commandscript::HandleReloadLootTemplatesItemCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), LootItemStorage::LoadStoredLoot(), and Player::SendLoot().

LootTemplates_Mail

LootStore LootTemplates_Mail("mail_loot_template", "mail template id", false)	(	"mail_loot_template"	,
		"mail template id"	,
		false
	)

Referenced by reload_commandscript::HandleReloadLootTemplatesMailCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and MailDraft::prepareItems().

LootTemplates_Milling

LootStore LootTemplates_Milling("milling_loot_template", "item entry (herb)", true)	(	"milling_loot_template"	,
		"item entry (herb)"	,
		true
	)

Referenced by Spell::CheckItems(), reload_commandscript::HandleReloadLootTemplatesMillingCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Pickpocketing

LootStore LootTemplates_Pickpocketing("pickpocketing_loot_template", "creature pickpocket lootid", true)	(	"pickpocketing_loot_template"	,
		"creature pickpocket lootid"	,
		true
	)

Referenced by SpellInfo::CheckTarget(), reload_commandscript::HandleReloadLootTemplatesPickpocketingCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Player

LootStore LootTemplates_Player("player_loot_template", "team id", true)	(	"player_loot_template"	,
		"team id"	,
		true
	)

Referenced by reload_commandscript::HandleReloadLootTemplatesPlayerCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Prospecting

LootStore LootTemplates_Prospecting("prospecting_loot_template", "item entry (ore)", true)	(	"prospecting_loot_template"	,
		"item entry (ore)"	,
		true
	)

Referenced by Spell::CheckItems(), reload_commandscript::HandleReloadLootTemplatesProspectingCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Reference

LootStore LootTemplates_Reference("reference_loot_template", "reference id", false)	(	"reference_loot_template"	,
		"reference id"	,
		false
	)

Referenced by ConditionMgr::isSourceTypeValid(), and ConditionMgr::LoadConditions().

LootTemplates_Skinning

LootStore LootTemplates_Skinning("skinning_loot_template", "creature skinning id", true)	(	"skinning_loot_template"	,
		"creature skinning id"	,
		true
	)

Referenced by Creature::AllLootRemovedFromCorpse(), AuraEffect::HandlePeriodicTriggerSpellAuraTick(), reload_commandscript::HandleReloadLootTemplatesSkinningCommand(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Player::SendLoot().

LootTemplates_Spell

LootStore LootTemplates_Spell("spell_loot_template", "spell id (random item creating)", false)	(	"spell_loot_template"	,
		"spell id (random item creating)"	,
		false
	)

Referenced by Spell::EffectCreateItem2(), Spell::EffectCreateRandomItem(), reload_commandscript::HandleReloadLootTemplatesSpellCommand(), ConditionMgr::isSourceTypeValid(), and ConditionMgr::LoadConditions().

qualityToRate

Rates const qualityToRate[MAX_ITEM_QUALITY]

static

Initial value:

=
{
    RATE_DROP_ITEM_POOR,                                    
    RATE_DROP_ITEM_NORMAL,                                  
    RATE_DROP_ITEM_UNCOMMON,                                
    RATE_DROP_ITEM_RARE,                                    
    RATE_DROP_ITEM_EPIC,                                    
    RATE_DROP_ITEM_LEGENDARY,                               
    RATE_DROP_ITEM_ARTIFACT,                                
}