LootTemplate::LootGroup Class Reference

Public Member Functions
	LootGroup ()
	~LootGroup ()
void	AddEntry (LootStoreItem *item)
bool	HasQuestDrop (LootTemplateMap const &store) const
bool	HasQuestDropForPlayer (Player const *player, LootTemplateMap const &store) const
void	Process (Loot &loot, Player const *player, LootStore const &lootstore, uint16 lootMode, uint16 nonRefIterationsLeft) const
float	RawTotalChance () const
float	TotalChance () const
void	Verify (LootStore const &lootstore, uint32 id, uint8 group_id) const
void	CollectLootIds (LootIdSet &set) const
void	CheckLootRefs (LootStore const &lootstore, uint32 Id, LootIdSet *ref_set) const
LootStoreItemList *	GetExplicitlyChancedItemList ()
LootStoreItemList *	GetEqualChancedItemList ()
void	CopyConditions (ConditionList conditions)

Private Member Functions
LootStoreItem const *	Roll (Loot &loot, Player const *player, LootStore const &store, uint16 lootMode) const
	LootGroup (LootGroup const &)
LootGroup &	operator= (LootGroup const &)

Private Attributes
LootStoreItemList	ExplicitlyChanced
LootStoreItemList	EqualChanced

Detailed Description

Constructor & Destructor Documentation

LootGroup() [1/2]

LootTemplate::LootGroup::LootGroup ( )

inline

{ }

~LootGroup()

LootTemplate::LootGroup::~LootGroup

(

)

{
    while (!ExplicitlyChanced.empty())
    {
        delete ExplicitlyChanced.back();
        ExplicitlyChanced.pop_back();
    }
 
    while (!EqualChanced.empty())
    {
        delete EqualChanced.back();
        EqualChanced.pop_back();
    }
}

References EqualChanced, and ExplicitlyChanced.

LootGroup() [2/2]

LootTemplate::LootGroup::LootGroup ( LootGroup const &  )

private

Member Function Documentation

AddEntry()

void LootTemplate::LootGroup::AddEntry

(

LootStoreItem *

item

)

{
    if (item->chance != 0)
        ExplicitlyChanced.push_back(item);
    else
        EqualChanced.push_back(item);
}

References LootStoreItem::chance.

CheckLootRefs()

void LootTemplate::LootGroup::CheckLootRefs	(	LootStore const &	lootstore,
		uint32	Id,
		LootIdSet *	ref_set
	)		const

{
    for (LootStoreItemList::const_iterator ieItr = ExplicitlyChanced.begin(); ieItr != ExplicitlyChanced.end(); ++ieItr)
    {
        LootStoreItem* item = *ieItr;
        if (item->reference)
        {
            if (item->mincount != item->maxcount)
                LootTemplates_Reference.ReportInvalidCount(std::abs(item->reference), lootstore.GetName(), Id, item->itemid, item->mincount, item->maxcount);
 
            if (!LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
                LootTemplates_Reference.ReportNonExistingId(std::abs(item->reference), lootstore.GetName(), item->itemid);
            else if (ref_set)
                ref_set->erase(std::abs(item->reference));
        }
    }
 
    for (LootStoreItemList::const_iterator ieItr = EqualChanced.begin(); ieItr != EqualChanced.end(); ++ieItr)
    {
        LootStoreItem* item = *ieItr;
        if (item->reference)
        {
            if (item->mincount != item->maxcount)
                LootTemplates_Reference.ReportInvalidCount(std::abs(item->reference), lootstore.GetName(), Id, item->itemid, item->mincount, item->maxcount);
 
            if (!LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
                LootTemplates_Reference.ReportNonExistingId(std::abs(item->reference), lootstore.GetName(), item->itemid);
            else if (ref_set)
                ref_set->erase(std::abs(item->reference));
        }
    }
}

References LootStore::GetLootFor(), LootStore::GetName(), LootStoreItem::itemid, LootTemplates_Reference, LootStoreItem::maxcount, LootStoreItem::mincount, LootStoreItem::reference, LootStore::ReportInvalidCount(), and LootStore::ReportNonExistingId().

CollectLootIds()

void LootTemplate::LootGroup::CollectLootIds

(

LootIdSet &

set

)

const

CopyConditions()

void LootTemplate::LootGroup::CopyConditions

(

ConditionList

conditions

)

{
    for (LootStoreItemList::iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
        (*i)->conditions.clear();
 
    for (LootStoreItemList::iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
        (*i)->conditions.clear();
}

References LootStoreItem::conditions.

GetEqualChancedItemList()

LootStoreItemList * LootTemplate::LootGroup::GetEqualChancedItemList ( )

inline

{ return &EqualChanced; }

References EqualChanced.

Referenced by LootTemplate::addConditionItem(), and LootTemplate::CopyConditions().

GetExplicitlyChancedItemList()

LootStoreItemList * LootTemplate::LootGroup::GetExplicitlyChancedItemList ( )

inline

{ return &ExplicitlyChanced; }

References ExplicitlyChanced.

Referenced by LootTemplate::addConditionItem(), and LootTemplate::CopyConditions().

HasQuestDrop()

bool LootTemplate::LootGroup::HasQuestDrop

(

LootTemplateMap const &

store

)

const

{
    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.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;
        }
    }
 
    for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.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;
        }
    }
 
    return false;
}

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

HasQuestDropForPlayer()

bool LootTemplate::LootGroup::HasQuestDropForPlayer	(	Player const *	player,
		LootTemplateMap const &	store
	)		const

{
    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.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
        }
    }
 
    for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.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
        }
    }
 
    return false;
}

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

operator=()

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

private

Process()

void LootTemplate::LootGroup::Process	(	Loot &	loot,
		Player const *	player,
		LootStore const &	lootstore,
		uint16	lootMode,
		uint16	nonRefIterationsLeft
	)		const

{
    if (LootStoreItem const* item = Roll(loot, player, store, lootMode))
    {
        bool rate = store.IsRatesAllowed();
 
        if (item->reference) // References processing
        {
            if (LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(std::abs(item->reference)))
            {
                uint32 maxcount = uint32(float(item->maxcount) * sWorld->getRate(RATE_DROP_ITEM_REFERENCED_AMOUNT));
                sScriptMgr->OnAfterRefCount(player, loot, rate, lootMode, const_cast<LootStoreItem*>(item), maxcount, store);
                for (uint32 loop = 0; loop < maxcount; ++loop) // Ref multiplicator
                    // This reference needs to be processed further, but it is marked isTopLevel=false so that any groups inside
                    // the reference are not multiplied by Rate.Drop.Item.GroupAmount
                    Referenced->Process(loot, store, lootMode, player, item->groupid, false);
            }
        }
        else
        {
            // Plain entries (not a reference, not grouped)
            sScriptMgr->OnBeforeDropAddItem(player, loot, rate, lootMode, const_cast<LootStoreItem*>(item), store);
            loot.AddItem(*item); // Chance is already checked, just add
 
            // If we still have non-ref runs to do for this group AND this item wasn't a reference,
            // recursively call this function to produce more items for this group.
            // However, if this is a quest item we shouldn't multiply this group.
            if (nonRefIterationsLeft > 1 && !item->needs_quest)
            {
                this->Process(loot, player, store, lootMode, nonRefIterationsLeft-1);
            }
        }
    }
}

References Loot::AddItem(), LootStore::GetLootFor(), LootStore::IsRatesAllowed(), LootTemplates_Reference, LootTemplate::Process(), RATE_DROP_ITEM_REFERENCED_AMOUNT, sScriptMgr, and sWorld.

RawTotalChance()

float LootTemplate::LootGroup::RawTotalChance

(

)

const

{
    float result = 0;
 
    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
        if (!(*i)->needs_quest)
            result += (*i)->chance;
 
    return result;
}

Roll()

LootStoreItem const * LootTemplate::LootGroup::Roll ( Loot &  loot, Player const *  player, LootStore const &  store, uint16  lootMode  ) const

private

{
    LootStoreItemList possibleLoot = ExplicitlyChanced;
    possibleLoot.remove_if(LootGroupInvalidSelector(loot, lootMode));
 
    if (!possibleLoot.empty())                             // First explicitly chanced entries are checked
    {
        float roll = (float)rand_chance();
 
        for (LootStoreItemList::const_iterator itr = possibleLoot.begin(); itr != possibleLoot.end(); ++itr)   // check each explicitly chanced entry in the template and modify its chance based on quality.
        {
            LootStoreItem* item = *itr;
            float chance = item->chance;
 
            if (!sScriptMgr->OnItemRoll(player, item, chance, loot, store))
                return nullptr;
 
            if (chance >= 100.0f)
                return item;
 
            roll -= chance;
            if (roll < 0)
                return item;
        }
    }
 
    if (!sScriptMgr->OnBeforeLootEqualChanced(player, EqualChanced, loot, store))
        return nullptr;
 
    possibleLoot = EqualChanced;
    possibleLoot.remove_if(LootGroupInvalidSelector(loot, lootMode));
    if (!possibleLoot.empty())                              // If nothing selected yet - an item is taken from equal-chanced part
        return Acore::Containers::SelectRandomContainerElement(possibleLoot);
 
    return nullptr;                                            // Empty drop from the group
}

References LootStoreItem::chance, rand_chance(), Acore::Containers::SelectRandomContainerElement(), and sScriptMgr.

TotalChance()

float LootTemplate::LootGroup::TotalChance

(

)

const

{
    float result = RawTotalChance();
 
    if (!EqualChanced.empty() && result < 100.0f)
        return 100.0f;
 
    return result;
}

Verify()

void LootTemplate::LootGroup::Verify	(	LootStore const &	lootstore,
		uint32	id,
		uint8	group_id
	)		const

Todo:

: replace with 100% when DBs will be ready

{
    float chance = RawTotalChance();
    if (chance > 101.0f)                                    
    {
        LOG_ERROR("sql.sql", "Table '{}' entry {} group {} has total chance > 100% ({})", lootstore.GetName(), id, group_id, chance);
    }
 
    if (chance >= 100.0f && !EqualChanced.empty())
    {
        LOG_ERROR("sql.sql", "Table '{}' entry {} group {} has items with chance=0% but group total chance >= 100% ({})", lootstore.GetName(), id, group_id, chance);
    }
}

References LootStore::GetName(), and LOG_ERROR.

Member Data Documentation

EqualChanced

LootStoreItemList LootTemplate::LootGroup::EqualChanced

private

Referenced by GetEqualChancedItemList(), and ~LootGroup().

ExplicitlyChanced

LootStoreItemList LootTemplate::LootGroup::ExplicitlyChanced

private

Referenced by GetExplicitlyChancedItemList(), and ~LootGroup().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/server/game/Loot/LootMgr.cpp