LootMgr.h File Reference

#include "ByteBuffer.h"
#include "ConditionMgr.h"
#include "ObjectGuid.h"
#include "RefMgr.h"
#include "SharedDefines.h"
#include <list>
#include <map>
#include <unordered_map>
#include <vector>

Go to the source code of this file.

Classes
struct	LootStoreItem
struct	LootItem
struct	QuestItem
class	LootStore
class	LootTemplate
class	LootValidatorRef
class	LootValidatorRefMgr
struct	Loot
struct	LootView

Macros
#define	MAX_NR_LOOT_ITEMS   18
#define	MAX_NR_QUEST_ITEMS   32

Typedefs
typedef GuidSet	AllowedLooterSet
typedef std::vector< QuestItem >	QuestItemList
typedef std::vector< LootItem >	LootItemList
typedef std::map< ObjectGuid, QuestItemList * >	QuestItemMap
typedef std::list< LootStoreItem * >	LootStoreItemList
typedef std::unordered_map< uint32, LootTemplate * >	LootTemplateMap
typedef std::set< uint32 >	LootIdSet

Enumerations
enum	RollType {   ROLL_PASS = 0 ,   ROLL_NEED = 1 ,   ROLL_GREED = 2 ,   ROLL_DISENCHANT = 3 ,   MAX_ROLL_TYPE = 4 }
enum	RollMask {   ROLL_FLAG_TYPE_PASS = 0x01 ,   ROLL_FLAG_TYPE_NEED = 0x02 ,   ROLL_FLAG_TYPE_GREED = 0x04 ,   ROLL_FLAG_TYPE_DISENCHANT = 0x08 ,   ROLL_ALL_TYPE_NO_DISENCHANT = 0x07 ,   ROLL_ALL_TYPE_MASK = 0x0F }
enum	LootMethod {   FREE_FOR_ALL = 0 ,   ROUND_ROBIN = 1 ,   MASTER_LOOT = 2 ,   GROUP_LOOT = 3 ,   NEED_BEFORE_GREED = 4 }
enum	PermissionTypes {   ALL_PERMISSION = 0 ,   GROUP_PERMISSION = 1 ,   MASTER_PERMISSION = 2 ,   RESTRICTED_PERMISSION = 3 ,   ROUND_ROBIN_PERMISSION = 4 ,   OWNER_PERMISSION = 5 ,   NONE_PERMISSION = 6 }
enum	LootType {   LOOT_NONE = 0 ,   LOOT_CORPSE = 1 ,   LOOT_PICKPOCKETING = 2 ,   LOOT_FISHING = 3 ,   LOOT_DISENCHANTING = 4 ,   LOOT_SKINNING = 6 ,   LOOT_PROSPECTING = 7 ,   LOOT_MILLING = 8 ,   LOOT_FISHINGHOLE = 20 ,   LOOT_INSIGNIA = 21 ,   LOOT_FISHING_JUNK = 22 }
enum	LootError {   LOOT_ERROR_DIDNT_KILL = 0 ,   LOOT_ERROR_TOO_FAR = 4 ,   LOOT_ERROR_BAD_FACING = 5 ,   LOOT_ERROR_LOCKED = 6 ,   LOOT_ERROR_NOTSTANDING = 8 ,   LOOT_ERROR_STUNNED = 9 ,   LOOT_ERROR_PLAYER_NOT_FOUND = 10 ,   LOOT_ERROR_PLAY_TIME_EXCEEDED = 11 ,   LOOT_ERROR_MASTER_INV_FULL = 12 ,   LOOT_ERROR_MASTER_UNIQUE_ITEM = 13 ,   LOOT_ERROR_MASTER_OTHER = 14 ,   LOOT_ERROR_ALREADY_PICKPOCKETED = 15 ,   LOOT_ERROR_NOT_WHILE_SHAPESHIFTED = 16 }
enum	LootSlotType {   LOOT_SLOT_TYPE_ALLOW_LOOT = 0 ,   LOOT_SLOT_TYPE_ROLL_ONGOING = 1 ,   LOOT_SLOT_TYPE_MASTER = 2 ,   LOOT_SLOT_TYPE_LOCKED = 3 ,   LOOT_SLOT_TYPE_OWNER = 4 }

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

Variables
LootStore	LootTemplates_Creature
LootStore	LootTemplates_Fishing
LootStore	LootTemplates_Gameobject
LootStore	LootTemplates_Item
LootStore	LootTemplates_Mail
LootStore	LootTemplates_Milling
LootStore	LootTemplates_Pickpocketing
LootStore	LootTemplates_Reference
LootStore	LootTemplates_Skinning
LootStore	LootTemplates_Disenchant
LootStore	LootTemplates_Prospecting
LootStore	LootTemplates_Spell
LootStore	LootTemplates_Player

Macro Definition Documentation

MAX_NR_LOOT_ITEMS

#define MAX_NR_LOOT_ITEMS   18

MAX_NR_QUEST_ITEMS

#define MAX_NR_QUEST_ITEMS   32

Typedef Documentation

AllowedLooterSet

typedef GuidSet AllowedLooterSet

LootIdSet

typedef std::set<uint32> LootIdSet

LootItemList

typedef std::vector<LootItem> LootItemList

LootStoreItemList

typedef std::list<LootStoreItem*> LootStoreItemList

LootTemplateMap

typedef std::unordered_map<uint32, LootTemplate*> LootTemplateMap

QuestItemList

typedef std::vector<QuestItem> QuestItemList

QuestItemMap

typedef std::map<ObjectGuid, QuestItemList*> QuestItemMap

Enumeration Type Documentation

LootError

enum LootError

Enumerator
LOOT_ERROR_DIDNT_KILL
LOOT_ERROR_TOO_FAR
LOOT_ERROR_BAD_FACING
LOOT_ERROR_LOCKED
LOOT_ERROR_NOTSTANDING
LOOT_ERROR_STUNNED
LOOT_ERROR_PLAYER_NOT_FOUND
LOOT_ERROR_PLAY_TIME_EXCEEDED
LOOT_ERROR_MASTER_INV_FULL
LOOT_ERROR_MASTER_UNIQUE_ITEM
LOOT_ERROR_MASTER_OTHER
LOOT_ERROR_ALREADY_PICKPOCKETED
LOOT_ERROR_NOT_WHILE_SHAPESHIFTED

{
    LOOT_ERROR_DIDNT_KILL               = 0,    // You don't have permission to loot that corpse.
    LOOT_ERROR_TOO_FAR                  = 4,    // You are too far away to loot that corpse.
    LOOT_ERROR_BAD_FACING               = 5,    // You must be facing the corpse to loot it.
    LOOT_ERROR_LOCKED                   = 6,    // Someone is already looting that corpse.
    LOOT_ERROR_NOTSTANDING              = 8,    // You need to be standing up to loot something!
    LOOT_ERROR_STUNNED                  = 9,    // You can't loot anything while stunned!
    LOOT_ERROR_PLAYER_NOT_FOUND         = 10,   // Player not found
    LOOT_ERROR_PLAY_TIME_EXCEEDED       = 11,   // Maximum play time exceeded
    LOOT_ERROR_MASTER_INV_FULL          = 12,   // That player's inventory is full
    LOOT_ERROR_MASTER_UNIQUE_ITEM       = 13,   // Player has too many of that item already
    LOOT_ERROR_MASTER_OTHER             = 14,   // Can't assign item to that player
    LOOT_ERROR_ALREADY_PICKPOCKETED     = 15,   // Your target has already had its pockets picked
    LOOT_ERROR_NOT_WHILE_SHAPESHIFTED   = 16    // You can't do that while shapeshifted.
};

LootMethod

enum LootMethod

Enumerator
FREE_FOR_ALL
ROUND_ROBIN
MASTER_LOOT
GROUP_LOOT
NEED_BEFORE_GREED

{
    FREE_FOR_ALL                        = 0,
    ROUND_ROBIN                         = 1,
    MASTER_LOOT                         = 2,
    GROUP_LOOT                          = 3,
    NEED_BEFORE_GREED                   = 4
};

LootSlotType

enum LootSlotType

Enumerator
LOOT_SLOT_TYPE_ALLOW_LOOT
LOOT_SLOT_TYPE_ROLL_ONGOING
LOOT_SLOT_TYPE_MASTER
LOOT_SLOT_TYPE_LOCKED
LOOT_SLOT_TYPE_OWNER

{
    LOOT_SLOT_TYPE_ALLOW_LOOT           = 0,    // player can loot the item.
    LOOT_SLOT_TYPE_ROLL_ONGOING         = 1,    // roll is ongoing. player cannot loot.
    LOOT_SLOT_TYPE_MASTER               = 2,    // item can only be distributed by group loot master.
    LOOT_SLOT_TYPE_LOCKED               = 3,    // item is shown in red. player cannot loot.
    LOOT_SLOT_TYPE_OWNER                = 4,    // ignore binding confirmation and etc, for single player looting
};

LootType

enum LootType

Enumerator
LOOT_NONE
LOOT_CORPSE
LOOT_PICKPOCKETING
LOOT_FISHING
LOOT_DISENCHANTING
LOOT_SKINNING
LOOT_PROSPECTING
LOOT_MILLING
LOOT_FISHINGHOLE
LOOT_INSIGNIA
LOOT_FISHING_JUNK

{
    LOOT_NONE                           = 0,
 
    LOOT_CORPSE                         = 1,
    LOOT_PICKPOCKETING                  = 2,
    LOOT_FISHING                        = 3,
    LOOT_DISENCHANTING                  = 4,
    // ignored always by client
    LOOT_SKINNING                       = 6,
    LOOT_PROSPECTING                    = 7,
    LOOT_MILLING                        = 8,
 
    LOOT_FISHINGHOLE                    = 20,   // unsupported by client, sending LOOT_FISHING instead
    LOOT_INSIGNIA                       = 21,   // unsupported by client, sending LOOT_CORPSE instead
    LOOT_FISHING_JUNK                   = 22    // unsupported by client, sending LOOT_FISHING instead
};

PermissionTypes

enum PermissionTypes

Enumerator
ALL_PERMISSION
GROUP_PERMISSION
MASTER_PERMISSION
RESTRICTED_PERMISSION
ROUND_ROBIN_PERMISSION
OWNER_PERMISSION
NONE_PERMISSION

{
    ALL_PERMISSION                      = 0,
    GROUP_PERMISSION                    = 1,
    MASTER_PERMISSION                   = 2,
    RESTRICTED_PERMISSION               = 3,
    ROUND_ROBIN_PERMISSION              = 4,
    OWNER_PERMISSION                    = 5,
    NONE_PERMISSION                     = 6
};

RollMask

enum RollMask

Enumerator
ROLL_FLAG_TYPE_PASS
ROLL_FLAG_TYPE_NEED
ROLL_FLAG_TYPE_GREED
ROLL_FLAG_TYPE_DISENCHANT
ROLL_ALL_TYPE_NO_DISENCHANT
ROLL_ALL_TYPE_MASK

{
    ROLL_FLAG_TYPE_PASS                 = 0x01,
    ROLL_FLAG_TYPE_NEED                 = 0x02,
    ROLL_FLAG_TYPE_GREED                = 0x04,
    ROLL_FLAG_TYPE_DISENCHANT           = 0x08,
 
    ROLL_ALL_TYPE_NO_DISENCHANT         = 0x07,
    ROLL_ALL_TYPE_MASK                  = 0x0F
};

RollType

enum RollType

Enumerator
ROLL_PASS
ROLL_NEED
ROLL_GREED
ROLL_DISENCHANT
MAX_ROLL_TYPE

{
    ROLL_PASS                           = 0,
    ROLL_NEED                           = 1,
    ROLL_GREED                          = 2,
    ROLL_DISENCHANT                     = 3,
    MAX_ROLL_TYPE                       = 4
};

Function Documentation

LoadLootTables()

void LoadLootTables ( )

inline

{
    LoadLootTemplates_Creature();
    LoadLootTemplates_Fishing();
    LoadLootTemplates_Gameobject();
    LoadLootTemplates_Item();
    LoadLootTemplates_Mail();
    LoadLootTemplates_Milling();
    LoadLootTemplates_Pickpocketing();
    LoadLootTemplates_Skinning();
    LoadLootTemplates_Disenchant();
    LoadLootTemplates_Prospecting();
    LoadLootTemplates_Spell();
 
    LoadLootTemplates_Reference();
 
    LoadLootTemplates_Player();
}

References LoadLootTemplates_Creature(), LoadLootTemplates_Disenchant(), LoadLootTemplates_Fishing(), LoadLootTemplates_Gameobject(), LoadLootTemplates_Item(), LoadLootTemplates_Mail(), LoadLootTemplates_Milling(), LoadLootTemplates_Pickpocketing(), LoadLootTemplates_Player(), LoadLootTemplates_Prospecting(), LoadLootTemplates_Reference(), LoadLootTemplates_Skinning(), and LoadLootTemplates_Spell().

Referenced by reload_commandscript::HandleReloadAllLootCommand(), and World::SetInitialWorldSettings().

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

extern

Referenced by LoadLootTemplates_Creature(), and LoadLootTemplates_Reference().

LootTemplates_Disenchant

LootStore LootTemplates_Disenchant

extern

Referenced by LoadLootTemplates_Disenchant(), and LoadLootTemplates_Reference().

LootTemplates_Fishing

LootStore LootTemplates_Fishing

extern

Referenced by LoadLootTemplates_Fishing(), and LoadLootTemplates_Reference().

LootTemplates_Gameobject

LootStore LootTemplates_Gameobject

extern

Referenced by LoadLootTemplates_Gameobject(), and LoadLootTemplates_Reference().

LootTemplates_Item

LootStore LootTemplates_Item

extern

Referenced by LoadLootTemplates_Item(), and LoadLootTemplates_Reference().

LootTemplates_Mail

LootStore LootTemplates_Mail

extern

Referenced by LoadLootTemplates_Mail(), and LoadLootTemplates_Reference().

LootTemplates_Milling

LootStore LootTemplates_Milling

extern

Referenced by LoadLootTemplates_Milling(), and LoadLootTemplates_Reference().

LootTemplates_Pickpocketing

LootStore LootTemplates_Pickpocketing

extern

Referenced by LoadLootTemplates_Pickpocketing(), and LoadLootTemplates_Reference().

LootTemplates_Player

LootStore LootTemplates_Player

extern

Referenced by LoadLootTemplates_Player().

LootTemplates_Prospecting

LootStore LootTemplates_Prospecting

extern

Referenced by LoadLootTemplates_Prospecting(), and LoadLootTemplates_Reference().

LootTemplates_Reference

LootStore LootTemplates_Reference

extern

Referenced by LootTemplate::LootGroup::CheckLootRefs(), LootTemplate::CheckLootRefs(), LootTemplate::CopyConditions(), LoadLootTemplates_Reference(), LootTemplate::Process(), and LootTemplate::LootGroup::Process().

LootTemplates_Skinning

LootStore LootTemplates_Skinning

extern

Referenced by LoadLootTemplates_Reference(), and LoadLootTemplates_Skinning().

LootTemplates_Spell

LootStore LootTemplates_Spell

extern

Referenced by LoadLootTemplates_Spell().