LootTemplate Class Reference

#include "LootMgr.h"

Classes
class	LootGroup

Public Member Functions
	LootTemplate ()=default
	~LootTemplate ()
void	AddEntry (LootStoreItem *item)
void	Process (Loot &loot, LootStore const &store, uint16 lootMode, Player const *player, uint8 groupId=0, bool isTopLevel=true) const
void	CopyConditions (ConditionList conditions)
bool	CopyConditions (LootItem *li, uint32 conditionLootId=0) const
bool	HasQuestDrop (LootTemplateMap const &store, uint8 groupId=0) const
bool	HasQuestDropForPlayer (LootTemplateMap const &store, Player const *player, uint8 groupId=0) const
void	Verify (LootStore const &store, uint32 Id) const
void	CheckLootRefs (LootTemplateMap const &store, LootIdSet *ref_set) const
bool	addConditionItem (Condition *cond)
bool	isReference (uint32 id) const

Private Types
typedef std::vector< LootGroup * >	LootGroups

Private Member Functions
	LootTemplate (LootTemplate const &)
LootTemplate &	operator= (LootTemplate const &)

Private Attributes
LootStoreItemList	Entries
LootGroups	Groups

Detailed Description

Member Typedef Documentation

LootGroups

typedef std::vector<LootGroup*> LootTemplate::LootGroups

private

Constructor & Destructor Documentation

LootTemplate() [1/2]

LootTemplate::LootTemplate ( )

default

~LootTemplate()

LootTemplate::~LootTemplate

(

)

{
    while (!Entries.empty())
    {
        delete Entries.back();
        Entries.pop_back();
    }
 
    for (std::size_t i = 0; i < Groups.size(); ++i)
        delete Groups[i];
    Groups.clear();
}

LootTemplate() [2/2]

LootTemplate::LootTemplate ( LootTemplate const &  )

private

Member Function Documentation

addConditionItem()

bool LootTemplate::addConditionItem

(

Condition *

cond

)

{
    if (!cond || !cond->isLoaded())//should never happen, checked at loading
    {
        LOG_ERROR("condition", "LootTemplate::addConditionItem: condition is null");
        return false;
    }
 
    if (!Entries.empty())
    {
        for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i)
        {
            if ((*i)->itemid == uint32(cond->SourceEntry))
            {
                (*i)->conditions.push_back(cond);
                return true;
            }
        }
    }
 
    if (!Groups.empty())
    {
        for (LootGroups::iterator groupItr = Groups.begin(); groupItr != Groups.end(); ++groupItr)
        {
            LootGroup* group = *groupItr;
            if (!group)
                continue;
 
            LootStoreItemList* itemList = group->GetExplicitlyChancedItemList();
            if (!itemList->empty())
            {
                for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
                {
                    if ((*i)->itemid == uint32(cond->SourceEntry))
                    {
                        (*i)->conditions.push_back(cond);
                        return true;
                    }
                }
            }
 
            itemList = group->GetEqualChancedItemList();
            if (!itemList->empty())
            {
                for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
                {
                    if ((*i)->itemid == uint32(cond->SourceEntry))
                    {
                        (*i)->conditions.push_back(cond);
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

References LootTemplate::LootGroup::GetEqualChancedItemList(), LootTemplate::LootGroup::GetExplicitlyChancedItemList(), Condition::isLoaded(), LOG_ERROR, and Condition::SourceEntry.

Referenced by ConditionMgr::addToLootTemplate().

AddEntry()

void LootTemplate::AddEntry

(

LootStoreItem *

item

)

{
    // `item->reference` > 0 --> Reference is counted as a normal and non grouped entry
    // `item->reference` < 0 --> Reference is counted as grouped entry within shared groupid
    if (item->groupid > 0 && item->reference <= 0)  // Group and grouped reference
    {
        if (item->groupid >= Groups.size())
        {
            Groups.resize(item->groupid, nullptr);  // Adds new group the the loot template if needed
        }
 
        if (!Groups[item->groupid - 1])
        {
            Groups[item->groupid - 1] = new LootGroup();
        }
 
        Groups[item->groupid - 1]->AddEntry(item);  // Adds new entry to the group
    }
    else                                            // Non-grouped entries
        Entries.push_back(item);
}

References LootStoreItem::groupid, and LootStoreItem::reference.

CheckLootRefs()

void LootTemplate::CheckLootRefs	(	LootTemplateMap const &	store,
		LootIdSet *	ref_set
	)		const

{
    for (LootStoreItemList::const_iterator ieItr = Entries.begin(); ieItr != Entries.end(); ++ieItr)
    {
        LootStoreItem* item = *ieItr;
        if (item->reference)
        {
            if (!LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
            {
                LootTemplates_Reference.ReportNonExistingId(std::abs(item->reference), "Reference", item->itemid);
            }
            else if (ref_set)
            {
                ref_set->erase(std::abs(item->reference));
            }
        }
    }
 
    for (LootGroups::const_iterator grItr = Groups.begin(); grItr != Groups.end(); ++grItr)
        if (LootGroup* group = *grItr)
            group->CheckLootRefs(store, ref_set);
}

References LootStore::GetLootFor(), LootStoreItem::itemid, LootTemplates_Reference, LootStoreItem::reference, and LootStore::ReportNonExistingId().

CopyConditions() [1/2]

void LootTemplate::CopyConditions

(

ConditionList

conditions

)

{
    for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i)
        (*i)->conditions.clear();
 
    for (LootGroups::iterator i = Groups.begin(); i != Groups.end(); ++i)
        if (LootGroup* group = *i)
            group->CopyConditions(conditions);
}

CopyConditions() [2/2]

bool LootTemplate::CopyConditions	(	LootItem *	li,
		uint32	conditionLootId = 0
	)		const

{
    for (LootStoreItemList::const_iterator _iter = Entries.begin(); _iter != Entries.end(); ++_iter)
    {
        LootStoreItem* item = *_iter;
        if (item->reference)
        {
            if (LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
            {
                if (Referenced->CopyConditions(li, conditionLootId))
                {
                    return true;
                }
            }
        }
        else
        {
            if (item->itemid != li->itemid)
            {
                continue;
            }
 
            if (!item->conditions.empty() && conditionLootId && conditionLootId != item->conditions.front()->SourceGroup)
            {
                continue;
            }
 
            li->conditions = item->conditions;
            return true;
        }
    }
 
    for (LootGroups::const_iterator groupItr = Groups.begin(); groupItr != Groups.end(); ++groupItr)
    {
        LootGroup* group = *groupItr;
        if (!group)
            continue;
 
        LootStoreItemList* itemList = group->GetExplicitlyChancedItemList();
        for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
        {
            LootStoreItem* item = *i;
            if (item->reference)
            {
                if (LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
                {
                    if (Referenced->CopyConditions(li, conditionLootId))
                    {
                        return true;
                    }
                }
            }
            else
            {
                if (item->itemid != li->itemid)
                {
                    continue;
                }
 
                if (!item->conditions.empty() && conditionLootId && conditionLootId != item->conditions.front()->SourceGroup)
                {
                    continue;
                }
 
                li->conditions = item->conditions;
                return true;
            }
        }
 
        itemList = group->GetEqualChancedItemList();
        for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
        {
            LootStoreItem* item = *i;
            if (item->reference)
            {
                if (LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
                {
                    if (Referenced->CopyConditions(li, conditionLootId))
                    {
                        return true;
                    }
                }
            }
            else
            {
                if (item->itemid != li->itemid)
                {
                    continue;
                }
 
                if (!item->conditions.empty() && conditionLootId && conditionLootId != item->conditions.front()->SourceGroup)
                {
                    continue;
                }
 
                li->conditions = item->conditions;
                return true;
            }
        }
    }
 
    return false;
}

References LootStoreItem::conditions, LootItem::conditions, LootTemplate::LootGroup::GetEqualChancedItemList(), LootTemplate::LootGroup::GetExplicitlyChancedItemList(), LootStore::GetLootFor(), LootStoreItem::itemid, LootItem::itemid, LootTemplates_Reference, and LootStoreItem::reference.

HasQuestDrop()

bool LootTemplate::HasQuestDrop	(	LootTemplateMap const &	store,
		uint8	groupId = 0
	)		const

{
    if (groupId)                                            // Group reference
    {
        if (groupId > Groups.size())
            return false;                                   // Error message [should be] already printed at loading stage
 
        if (!Groups[groupId - 1])
            return false;
 
        return Groups[groupId - 1]->HasQuestDrop(store);
    }
 
    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        LootStoreItem* item = *i;
        if (item->reference)                                // References
        {
            LootTemplateMap::const_iterator Referenced = store.find(std::abs(item->reference));
            if (Referenced == store.end())
                continue;                                   // Error message [should be] already printed at loading stage
 
            if (Referenced->second->HasQuestDrop(store, item->groupid))
                return true;
        }
        else if (item->needs_quest)
            return true;                                    // quest drop found
    }
 
    // Now processing groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
    {
        if (LootGroup* group = *i)
        {
            if (group->HasQuestDrop(store))
            {
                return true;
            }
        }
    }
 
    return false;
}

References LootStoreItem::groupid, LootStoreItem::needs_quest, and LootStoreItem::reference.

HasQuestDropForPlayer()

bool LootTemplate::HasQuestDropForPlayer	(	LootTemplateMap const &	store,
		Player const *	player,
		uint8	groupId = 0
	)		const

{
    if (groupId)                                            // Group reference
    {
        if (groupId > Groups.size())
            return false;                                   // Error message already printed at loading stage
 
        if (!Groups[groupId - 1])
            return false;
 
        return Groups[groupId - 1]->HasQuestDropForPlayer(player, store);
    }
 
    // Checking non-grouped entries
    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        LootStoreItem* item = *i;
        if (item->reference)                                // References processing
        {
            LootTemplateMap::const_iterator Referenced = store.find(std::abs(item->reference));
            if (Referenced == store.end())
                continue;                                   // Error message already printed at loading stage
            if (Referenced->second->HasQuestDropForPlayer(store, player, item->groupid))
                return true;
        }
        else if (player->HasQuestForItem(item->itemid))
            return true;                                    // active quest drop found
    }
 
    // Now checking groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
    {
        if (LootGroup* group = *i)
        {
            if (group->HasQuestDropForPlayer(player, store))
            {
                return true;
            }
        }
    }
 
    return false;
}

References LootStoreItem::groupid, Player::HasQuestForItem(), LootStoreItem::itemid, and LootStoreItem::reference.

isReference()

bool LootTemplate::isReference

(

uint32

id

)

const

{
    for (LootStoreItemList::const_iterator ieItr = Entries.begin(); ieItr != Entries.end(); ++ieItr)
    {
        if ((*ieItr)->itemid == id && (*ieItr)->reference)
        {
            return true;
        }
    }
 
    return false;//not found or not reference
}

Referenced by ConditionMgr::isSourceTypeValid().

operator=()

LootTemplate & LootTemplate::operator= ( LootTemplate const &  )

private

Process()

void LootTemplate::Process	(	Loot &	loot,
		LootStore const &	store,
		uint16	lootMode,
		Player const *	player,
		uint8	groupId = 0,
		bool	isTopLevel = true
	)		const

{
    bool rate = store.IsRatesAllowed();
 
    if (groupId)                                            // Group reference uses own processing of the group
    {
        if (groupId > Groups.size())
            return;                                         // Error message already printed at loading stage
 
        if (!Groups[groupId - 1])
            return;
 
        // Rate.Drop.Item.GroupAmount is only in effect for the top loot template level
        if (isTopLevel)
        {
            Groups[groupId - 1]->Process(loot, player, store, lootMode, sWorld->getRate(RATE_DROP_ITEM_GROUP_AMOUNT));
        }
        else
        {
            Groups[groupId - 1]->Process(loot, player, store, lootMode, 0);
        }
        return;
    }
 
    // Rolling non-grouped items
    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        LootStoreItem* item = *i;
        if (!(item->lootmode & lootMode))                         // Do not add if mode mismatch
            continue;
        if (!item->Roll(rate, player, loot, store))
            continue;                                           // Bad luck for the entry
 
        if (item->reference)                                    // References processing
        {
            LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(std::abs(item->reference));
            if (!Referenced)
                continue;                                       // Error message already printed at loading stage
 
            uint32 maxcount = uint32(float(item->maxcount) * sWorld->getRate(RATE_DROP_ITEM_REFERENCED_AMOUNT));
            sScriptMgr->OnAfterRefCount(player, loot, rate, lootMode, item, maxcount, store);
            for (uint32 loop = 0; loop < maxcount; ++loop)      // Ref multiplicator
                // we're no longer in the top level, so isTopLevel is false
                Referenced->Process(loot, store, lootMode, player, item->groupid, false);
        }
        else
        {
            // Plain entries (not a reference, not grouped)
            sScriptMgr->OnBeforeDropAddItem(player, loot, rate, lootMode, item, store);
            loot.AddItem(*item);                                // Chance is already checked, just add
        }
    }
 
    // Now processing groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
        if (LootGroup* group = *i)
        {
            // Rate.Drop.Item.GroupAmount is only in effect for the top loot template level
            if (isTopLevel)
            {
                uint32 groupAmount = sWorld->getRate(RATE_DROP_ITEM_GROUP_AMOUNT);
                sScriptMgr->OnAfterCalculateLootGroupAmount(player, loot, lootMode, groupAmount, store);
                group->Process(loot, player, store, lootMode, groupAmount);
            }
            else
            {
                group->Process(loot, player, store, lootMode, 0);
            }
        }
}

References Loot::AddItem(), LootStore::GetLootFor(), LootStoreItem::groupid, LootStore::IsRatesAllowed(), LootStoreItem::lootmode, LootTemplates_Reference, LootStoreItem::maxcount, Process(), RATE_DROP_ITEM_GROUP_AMOUNT, RATE_DROP_ITEM_REFERENCED_AMOUNT, LootStoreItem::reference, LootStoreItem::Roll(), sScriptMgr, and sWorld.

Referenced by Loot::FillLoot(), Process(), and LootTemplate::LootGroup::Process().

Verify()

void LootTemplate::Verify	(	LootStore const &	store,
		uint32	Id
	)		const

Todo:

: References validity checks

{
    // Checking group chances
    for (uint32 i = 0; i < Groups.size(); ++i)
        if (Groups[i])
            Groups[i]->Verify(lootstore, id, i + 1);
 
}

Member Data Documentation

Entries

LootStoreItemList LootTemplate::Entries

private

Groups

LootGroups LootTemplate::Groups

private