#include "LootMgr.h"

Public Member Functions
	LootStoreItem (uint32 _itemid, int32 _reference, float _chance, bool _needs_quest, uint16 _lootmode, uint8 _groupid, int32 _mincount, uint8 _maxcount)

bool	Roll (bool rate, Player const *player, Loot &loot, LootStore const &store) const

bool	IsValid (LootStore const &store, uint32 entry) const

Public Attributes
uint32	itemid

int32	reference

float	chance

bool	needs_quest: 1

uint16	lootmode

uint8	groupid: 7

uint8	mincount

uint8	maxcount

ConditionList	conditions

Detailed Description

Constructor & Destructor Documentation

◆ LootStoreItem()

LootStoreItem::LootStoreItem	(	uint32	_itemid,
		int32	_reference,
		float	_chance,
		bool	_needs_quest,
		uint16	_lootmode,
		uint8	_groupid,
		int32	_mincount,
		uint8	_maxcount
	)

inline

        : itemid(_itemid), reference(_reference), chance(_chance), needs_quest(_needs_quest),
          lootmode(_lootmode), groupid(_groupid), mincount(_mincount), maxcount(_maxcount)
    {}

Member Function Documentation

◆ IsValid()

bool LootStoreItem::IsValid	(	LootStore const &	store,
		uint32	entry
	)		const

{
    if (groupid >= 1 << 7)                                     // it stored in 7 bit field
    {
        LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: GroupId ({}) must be less {} - skipped", store.GetName(), entry, itemid, groupid, 1 << 7);
        return false;
    }
 
    if (mincount == 0)
    {
        LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: wrong MinCount ({}) - skipped", store.GetName(), entry, itemid, mincount);
        return false;
    }
 
    if (!reference)                                  // item (quest or non-quest) entry, maybe grouped
    {
        ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemid);
        if (!proto)
        {
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: item entry not listed in `item_template` - skipped", store.GetName(), entry, itemid);
            return false;
        }
 
        if (chance == 0 && groupid == 0)                     // Zero chance is allowed for grouped entries only
        {
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: equal-chanced grouped entry, but group not defined - skipped", store.GetName(), entry, itemid);
            return false;
        }
 
        if (chance != 0 && chance < 0.000001f)             // loot with low chance
        {
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: low chance ({}) - skipped",
                             store.GetName(), entry, itemid, chance);
            return false;
        }
 
        if (maxcount < mincount)                       // wrong max count
        {
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: MaxCount ({}) less that MinCount ({}) - skipped", store.GetName(), entry, itemid, int32(maxcount), mincount);
            return false;
        }
    }
    else                                                    // if reference loot
    {
        if (needs_quest)
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: quest required will be ignored", store.GetName(), entry, itemid);
        else if (chance == 0)                              // no chance for the reference
        {
            LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: zero chance is specified for a reference, skipped", store.GetName(), entry, itemid);
            return false;
        }
    }
    return true;                                            // Referenced template existence is checked at whole store level
}

References chance, LootStore::GetName(), groupid, itemid, LOG_ERROR, maxcount, mincount, needs_quest, reference, and sObjectMgr.

Referenced by LootStore::LoadLootTable().

◆ Roll()

bool LootStoreItem::Roll	(	bool	rate,
		Player const *	player,
		Loot &	loot,
		LootStore const &	store
	)		const

{
    float _chance = chance;
 
    if (!sScriptMgr->OnItemRoll(player, this, _chance, loot, store))
        return false;
 
    if (_chance >= 100.0f)
        return true;
 
    if (reference)                                   // reference case
        return roll_chance_f(_chance * (rate ? sWorld->getRate(RATE_DROP_ITEM_REFERENCED) : 1.0f));
 
    ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(itemid);
 
    float qualityModifier = pProto && rate ? sWorld->getRate(qualityToRate[pProto->Quality]) : 1.0f;
 
    return roll_chance_f(_chance * qualityModifier);
}