Loot Struct Reference

#include "LootMgr.h"

Public Member Functions
QuestItemMap const &	GetPlayerQuestItems () const
QuestItemMap const &	GetPlayerFFAItems () const
QuestItemMap const &	GetPlayerNonQuestNonFFAConditionalItems () const
	Loot (uint32 _gold=0)
	~Loot ()
void	addLootValidatorRef (LootValidatorRef *pLootValidatorRef)
void	clear ()
bool	empty () const
bool	isLooted () const
void	NotifyItemRemoved (uint8 lootIndex)
void	NotifyQuestItemRemoved (uint8 questIndex)
void	NotifyMoneyRemoved ()
void	AddLooter (ObjectGuid GUID)
void	RemoveLooter (ObjectGuid GUID)
void	generateMoneyLoot (uint32 minAmount, uint32 maxAmount)
bool	FillLoot (uint32 lootId, LootStore const &store, Player *lootOwner, bool personal, bool noEmptyError=false, uint16 lootMode=LOOT_MODE_DEFAULT, WorldObject *lootSource=nullptr)
void	AddItem (LootStoreItem const &item)
LootItem *	LootItemInSlot (uint32 lootslot, Player *player, QuestItem **qitem=nullptr, QuestItem **ffaitem=nullptr, QuestItem **conditem=nullptr)
uint32	GetMaxSlotInLootFor (Player *player) const
bool	hasItemForAll () const
bool	hasItemFor (Player *player) const
bool	hasOverThresholdItem () const
void	FillNotNormalLootFor (Player *player)

Public Attributes
std::vector< LootItem >	items
std::vector< LootItem >	quest_items
uint32	gold
uint8	unlootedCount {0}
ObjectGuid	roundRobinPlayer
ObjectGuid	lootOwnerGUID
LootType	loot_type {LOOT_NONE}
ObjectGuid	containerGUID
ObjectGuid	sourceWorldObjectGUID
GameObject *	sourceGameObject {nullptr}

Private Types
typedef GuidSet	PlayersLootingSet

Private Member Functions
QuestItemList *	FillFFALoot (Player *player)
QuestItemList *	FillQuestLoot (Player *player)
QuestItemList *	FillNonQuestNonFFAConditionalLoot (Player *player)

Private Attributes
PlayersLootingSet	PlayersLooting
QuestItemMap	PlayerQuestItems
QuestItemMap	PlayerFFAItems
QuestItemMap	PlayerNonQuestNonFFAConditionalItems
LootValidatorRefMgr	i_LootValidatorRefMgr

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

Detailed Description

Member Typedef Documentation

PlayersLootingSet

typedef GuidSet Loot::PlayersLootingSet

private

Constructor & Destructor Documentation

Loot()

Loot::Loot ( uint32  _gold = 0 )

inline

: gold(_gold) { }

~Loot()

Loot::~Loot ( )

inline

{ clear(); }

References clear().

Member Function Documentation

AddItem()

void Loot::AddItem

(

LootStoreItem const &

item

)

{
    ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item.itemid);
    if (!proto)
        return;
 
    uint32 count = urand(item.mincount, item.maxcount);
    uint32 stacks = count / proto->GetMaxStackSize() + (count % proto->GetMaxStackSize() ? 1 : 0);
 
    std::vector<LootItem>& lootItems = item.needs_quest ? quest_items : items;
    uint32 limit = item.needs_quest ? MAX_NR_QUEST_ITEMS : MAX_NR_LOOT_ITEMS;
 
    for (uint32 i = 0; i < stacks && lootItems.size() < limit; ++i)
    {
        LootItem generatedLoot(item);
        generatedLoot.count = std::min(count, proto->GetMaxStackSize());
        generatedLoot.itemIndex = lootItems.size();
        lootItems.push_back(generatedLoot);
        count -= proto->GetMaxStackSize();
 
        // In some cases, a dropped item should be visible/lootable only for some players in group
        bool canSeeItemInLootWindow = false;
        if (auto player = ObjectAccessor::FindPlayer(lootOwnerGUID))
        {
            if (auto group = player->GetGroup())
            {
                for (auto itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
                {
                    if (auto member = itr->GetSource())
                    {
                        if (generatedLoot.AllowedForPlayer(member, sourceWorldObjectGUID))
                        {
                            canSeeItemInLootWindow = true;
                            break;
                        }
                    }
                }
            }
            else if (generatedLoot.AllowedForPlayer(player, sourceWorldObjectGUID))
            {
                canSeeItemInLootWindow = true;
            }
        }
 
        if (!canSeeItemInLootWindow)
        {
            LOG_DEBUG("loot", "Skipping ++unlootedCount for unlootable item: {}", item.itemid);
            continue;
        }
 
        // non-conditional one-player only items are counted here,
        // free for all items are counted in FillFFALoot(),
        // non-ffa conditionals are counted in FillNonQuestNonFFAConditionalLoot()
        if (!item.needs_quest && item.conditions.empty() && !proto->HasFlag(ITEM_FLAG_MULTI_DROP))
            ++unlootedCount;
    }
}

References LootItem::AllowedForPlayer(), LootStoreItem::conditions, LootItem::count, ObjectAccessor::FindPlayer(), Player::GetGroup(), ItemTemplate::GetMaxStackSize(), ItemTemplate::HasFlag(), ITEM_FLAG_MULTI_DROP, LootStoreItem::itemid, LootItem::itemIndex, items, LOG_DEBUG, lootOwnerGUID, MAX_NR_LOOT_ITEMS, MAX_NR_QUEST_ITEMS, LootStoreItem::maxcount, LootStoreItem::mincount, LootStoreItem::needs_quest, quest_items, sObjectMgr, sourceWorldObjectGUID, unlootedCount, and urand().

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

AddLooter()

void Loot::AddLooter ( ObjectGuid  GUID )

inline

{ PlayersLooting.insert(GUID); }

References PlayersLooting.

Referenced by Player::SendLoot().

addLootValidatorRef()

void Loot::addLootValidatorRef ( LootValidatorRef *  pLootValidatorRef )

inline

    {
        i_LootValidatorRefMgr.insertFirst(pLootValidatorRef);
    }

References i_LootValidatorRefMgr, and LinkedListHead::insertFirst().

Referenced by Roll::targetObjectBuildLink().

clear()

void Loot::clear ( )

inline

    {
        for (QuestItemMap::const_iterator itr = PlayerQuestItems.begin(); itr != PlayerQuestItems.end(); ++itr)
            delete itr->second;
        PlayerQuestItems.clear();
 
        for (QuestItemMap::const_iterator itr = PlayerFFAItems.begin(); itr != PlayerFFAItems.end(); ++itr)
            delete itr->second;
        PlayerFFAItems.clear();
 
        for (QuestItemMap::const_iterator itr = PlayerNonQuestNonFFAConditionalItems.begin(); itr != PlayerNonQuestNonFFAConditionalItems.end(); ++itr)
            delete itr->second;
        PlayerNonQuestNonFFAConditionalItems.clear();
 
        PlayersLooting.clear();
        items.clear();
        quest_items.clear();
        gold = 0;
        unlootedCount = 0;
        roundRobinPlayer.Clear();
        i_LootValidatorRefMgr.clearReferences();
        loot_type = LOOT_NONE;
    }

References ObjectGuid::Clear(), RefMgr< TO, FROM >::clearReferences(), gold, i_LootValidatorRefMgr, items, LOOT_NONE, loot_type, PlayerFFAItems, PlayerNonQuestNonFFAConditionalItems, PlayerQuestItems, PlayersLooting, quest_items, roundRobinPlayer, and unlootedCount.

Referenced by NPCStaveQuestAI::ClearLootIfUnfair(), boss_high_king_maulgar::DoAction(), WorldSession::DoLootRelease(), GameObject::GetFishLoot(), GameObject::GetFishLootJunk(), Unit::Kill(), Creature::RemoveCorpse(), Creature::Respawn(), Player::SendLoot(), boss_priestess_delrissa::SummonedCreatureDies(), GameObject::Update(), and ~Loot().

empty()

bool Loot::empty ( ) const

inline

{ return items.empty() && gold == 0; }

References gold, and items.

Referenced by GameObject::GetFishLoot(), GameObject::GetFishLootJunk(), gobject_commandscript::HandleGameObjectInfoCommand(), Unit::Kill(), and Player::SendLoot().

FillFFALoot()

QuestItemList * Loot::FillFFALoot ( Player *  player )

private

{
    QuestItemList* ql = new QuestItemList();
 
    for (uint8 i = 0; i < items.size(); ++i)
    {
        LootItem& item = items[i];
        if (!item.is_looted && item.freeforall && item.AllowedForPlayer(player, containerGUID))
        {
            ql->push_back(QuestItem(i));
            ++unlootedCount;
        }
    }
    if (ql->empty())
    {
        delete ql;
        return nullptr;
    }
 
    PlayerFFAItems[player->GetGUID()] = ql;
    return ql;
}

References LootItem::AllowedForPlayer(), containerGUID, LootItem::freeforall, Object::GetGUID(), LootItem::is_looted, items, PlayerFFAItems, and unlootedCount.

Referenced by FillNotNormalLootFor().

FillLoot()

bool Loot::FillLoot	(	uint32	lootId,
		LootStore const &	store,
		Player *	lootOwner,
		bool	personal,
		bool	noEmptyError = false,
		uint16	lootMode = LOOT_MODE_DEFAULT,
		WorldObject *	lootSource = nullptr
	)

{
    // Must be provided
    if (!lootOwner)
        return false;
 
    lootOwnerGUID = lootOwner->GetGUID();
 
    LootTemplate const* tab = store.GetLootFor(lootId);
 
    if (!tab)
    {
        if (!noEmptyError)
            LOG_ERROR("sql.sql", "Table '{}' loot id #{} used but it doesn't have records.", store.GetName(), lootId);
        return false;
    }
 
    items.reserve(MAX_NR_LOOT_ITEMS);
    quest_items.reserve(MAX_NR_QUEST_ITEMS);
 
    // Initial group is 0, top level set to True
    tab->Process(*this, store, lootMode, lootOwner, 0, true);          // Processing is done there, callback via Loot::AddItem()
 
    sScriptMgr->OnAfterLootTemplateProcess(this, tab, store, lootOwner, personal, noEmptyError, lootMode);
 
    // Setting access rights for group loot case
    Group* group = lootOwner->GetGroup();
    if (!personal && group)
    {
        roundRobinPlayer = lootOwner->GetGUID();
 
        for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            if (Player* player = itr->GetSource()) // should actually be looted object instead of lootOwner but looter has to be really close so doesnt really matter
            {
                if (player->IsAtLootRewardDistance(lootSource ? lootSource : lootOwner))
                {
                    FillNotNormalLootFor(player);
                }
            }
        }
 
        for (uint8 i = 0; i < items.size(); ++i)
        {
            if (ItemTemplate const* proto = sObjectMgr->GetItemTemplate(items[i].itemid))
                if (proto->Quality < uint32(group->GetLootThreshold()))
                    items[i].is_underthreshold = true;
        }
    }
    // ... for personal loot
    else
        FillNotNormalLootFor(lootOwner);
 
    return true;
}

References FillNotNormalLootFor(), Group::GetFirstMember(), Player::GetGroup(), Object::GetGUID(), LootStore::GetLootFor(), Group::GetLootThreshold(), LootStore::GetName(), Player::IsAtLootRewardDistance(), items, LOG_ERROR, lootOwnerGUID, MAX_NR_LOOT_ITEMS, MAX_NR_QUEST_ITEMS, GroupReference::next(), LootTemplate::Process(), quest_items, roundRobinPlayer, sObjectMgr, and sScriptMgr.

Referenced by Player::AutoStoreLoot(), Group::CountTheRoll(), boss_high_king_maulgar::DoAction(), GameObject::GetFishLoot(), GameObject::GetFishLootJunk(), Unit::Kill(), MailDraft::prepareItems(), Player::SendLoot(), and boss_priestess_delrissa::SummonedCreatureDies().

FillNonQuestNonFFAConditionalLoot()

QuestItemList * Loot::FillNonQuestNonFFAConditionalLoot ( Player *  player )

private

{
    QuestItemList* ql = new QuestItemList();
 
    for (uint8 i = 0; i < items.size(); ++i)
    {
        LootItem& item = items[i];
 
        if (!item.is_looted && !item.freeforall && item.AllowedForPlayer(player, sourceWorldObjectGUID))
        {
            item.AddAllowedLooter(player);
 
            if (!item.conditions.empty())
            {
                ql->push_back(QuestItem(i));
                if (!item.is_counted)
                {
                    ++unlootedCount;
                    item.is_counted = true;
                }
            }
        }
    }
    if (ql->empty())
    {
        delete ql;
        return nullptr;
    }
 
    PlayerNonQuestNonFFAConditionalItems[player->GetGUID()] = ql;
    return ql;
}

References LootItem::AddAllowedLooter(), LootItem::AllowedForPlayer(), LootItem::conditions, LootItem::freeforall, Object::GetGUID(), LootItem::is_counted, LootItem::is_looted, items, PlayerNonQuestNonFFAConditionalItems, sourceWorldObjectGUID, and unlootedCount.

Referenced by FillNotNormalLootFor().

FillNotNormalLootFor()

void Loot::FillNotNormalLootFor

(

Player *

player

)

{
    ObjectGuid playerGuid = player->GetGUID();
 
    QuestItemMap::const_iterator qmapitr = PlayerQuestItems.find(playerGuid);
    if (qmapitr == PlayerQuestItems.end())
        FillQuestLoot(player);
 
    qmapitr = PlayerFFAItems.find(playerGuid);
    if (qmapitr == PlayerFFAItems.end())
        FillFFALoot(player);
 
    qmapitr = PlayerNonQuestNonFFAConditionalItems.find(playerGuid);
    if (qmapitr == PlayerNonQuestNonFFAConditionalItems.end())
        FillNonQuestNonFFAConditionalLoot(player);
 
    // Process currency items
    uint32 max_slot = GetMaxSlotInLootFor(player);
    LootItem const* item = nullptr;
    uint32 itemsSize = uint32(items.size());
    for (uint32 i = 0; i < max_slot; ++i)
    {
        if (i < items.size())
            item = &items[i];
        else
            item = &quest_items[i - itemsSize];
 
        if (!item->is_looted && item->freeforall && item->AllowedForPlayer(player, sourceWorldObjectGUID))
            if (ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item->itemid))
                if (proto->IsCurrencyToken())
                {
                    InventoryResult msg;
                    player->StoreLootItem(i, this, msg);
                }
    }
}

References LootItem::AllowedForPlayer(), FillFFALoot(), FillNonQuestNonFFAConditionalLoot(), FillQuestLoot(), LootItem::freeforall, Object::GetGUID(), GetMaxSlotInLootFor(), LootItem::is_looted, LootItem::itemid, items, PlayerFFAItems, PlayerNonQuestNonFFAConditionalItems, PlayerQuestItems, quest_items, sObjectMgr, sourceWorldObjectGUID, and Player::StoreLootItem().

Referenced by FillLoot(), and LootItemStorage::LoadStoredLoot().

FillQuestLoot()

QuestItemList * Loot::FillQuestLoot ( Player *  player )

private

{
    if (items.size() == MAX_NR_LOOT_ITEMS)
        return nullptr;
 
    QuestItemList* ql = new QuestItemList();
 
    Player* lootOwner = (roundRobinPlayer) ? ObjectAccessor::FindPlayer(roundRobinPlayer) : player;
 
    for (uint8 i = 0; i < quest_items.size(); ++i)
    {
        LootItem& item = quest_items[i];
 
        sScriptMgr->OnBeforeFillQuestLootItem(player, item);
 
        // Quest item is not free for all and is already assigned to another player
        // or player doesn't need it
        if (item.is_blocked || !item.AllowedForPlayer(player, sourceWorldObjectGUID))
        {
            continue;
        }
 
        // Player is not the loot owner, and loot owner still needs this quest item
        if (!item.freeforall &&
            lootOwner && lootOwner != player &&
            item.AllowedForPlayer(lootOwner, sourceWorldObjectGUID))
        {
            continue;
        }
 
        ql->push_back(QuestItem(i));
        ++unlootedCount;
 
        if (!item.freeforall)
        {
            item.is_blocked = true;
        }
 
        if (items.size() + ql->size() == MAX_NR_LOOT_ITEMS)
            break;
    }
    if (ql->empty())
    {
        delete ql;
        return nullptr;
    }
 
    PlayerQuestItems[player->GetGUID()] = ql;
    return ql;
}

References LootItem::AllowedForPlayer(), ObjectAccessor::FindPlayer(), LootItem::freeforall, Object::GetGUID(), LootItem::is_blocked, items, MAX_NR_LOOT_ITEMS, PlayerQuestItems, quest_items, roundRobinPlayer, sourceWorldObjectGUID, sScriptMgr, and unlootedCount.

Referenced by FillNotNormalLootFor().

generateMoneyLoot()

void Loot::generateMoneyLoot	(	uint32	minAmount,
		uint32	maxAmount
	)

{
    if (maxAmount > 0)
    {
        if (maxAmount <= minAmount)
            gold = uint32(maxAmount * sWorld->getRate(RATE_DROP_MONEY));
        else if ((maxAmount - minAmount) < 32700)
            gold = uint32(urand(minAmount, maxAmount) * sWorld->getRate(RATE_DROP_MONEY));
        else
            gold = uint32(urand(minAmount >> 8, maxAmount >> 8) * sWorld->getRate(RATE_DROP_MONEY)) << 8;
    }
}

References gold, RATE_DROP_MONEY, sWorld, and urand().

Referenced by Unit::Kill(), and Player::SendLoot().

GetMaxSlotInLootFor()

uint32 Loot::GetMaxSlotInLootFor

(

Player *

player

)

const

{
    QuestItemMap::const_iterator itr = PlayerQuestItems.find(player->GetGUID());
    return items.size() + (itr != PlayerQuestItems.end() ?  itr->second->size() : 0);
}

References Object::GetGUID(), items, and PlayerQuestItems.

Referenced by Player::AutoStoreLoot(), Group::CountTheRoll(), FillNotNormalLootFor(), and MailDraft::prepareItems().

GetPlayerFFAItems()

QuestItemMap const & Loot::GetPlayerFFAItems ( ) const

inline

{ return PlayerFFAItems; }

References PlayerFFAItems.

Referenced by hasItemFor().

GetPlayerNonQuestNonFFAConditionalItems()

QuestItemMap const & Loot::GetPlayerNonQuestNonFFAConditionalItems ( ) const

inline

{ return PlayerNonQuestNonFFAConditionalItems; }

References PlayerNonQuestNonFFAConditionalItems.

Referenced by hasItemFor().

GetPlayerQuestItems()

QuestItemMap const & Loot::GetPlayerQuestItems ( ) const

inline

{ return PlayerQuestItems; }

References PlayerQuestItems.

Referenced by hasItemFor(), and Player::StoreLootItem().

hasItemFor()

bool Loot::hasItemFor

(

Player *

player

)

const

{
    QuestItemMap const& lootPlayerQuestItems = GetPlayerQuestItems();
    QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(player->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)
        {
            const LootItem& item = quest_items[qi->index];
            if (!qi->is_looted && !item.is_looted)
                return true;
        }
    }
 
    QuestItemMap const& lootPlayerFFAItems = GetPlayerFFAItems();
    QuestItemMap::const_iterator ffa_itr = lootPlayerFFAItems.find(player->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)
        {
            const LootItem& item = items[fi->index];
            if (!fi->is_looted && !item.is_looted)
                return true;
        }
    }
 
    QuestItemMap const& lootPlayerNonQuestNonFFAConditionalItems = GetPlayerNonQuestNonFFAConditionalItems();
    QuestItemMap::const_iterator nn_itr = lootPlayerNonQuestNonFFAConditionalItems.find(player->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)
        {
            const LootItem& item = items[ci->index];
            if (!ci->is_looted && !item.is_looted)
                return true;
        }
    }
 
    return false;
}

References Object::GetGUID(), GetPlayerFFAItems(), GetPlayerNonQuestNonFFAConditionalItems(), GetPlayerQuestItems(), LootItem::is_looted, items, and quest_items.

Referenced by Player::isAllowedToLoot().

hasItemForAll()

bool Loot::hasItemForAll

(

)

const

{
    // Gold is always lootable
    if (gold)
    {
        return true;
    }
 
    for (LootItem const& item : items)
        if (!item.is_looted && !item.freeforall && item.conditions.empty())
            return true;
    return false;
}

References gold, and items.

Referenced by Player::isAllowedToLoot().

hasOverThresholdItem()

bool Loot::hasOverThresholdItem

(

)

const

{
    for (uint8 i = 0; i < items.size(); ++i)
    {
        if (!items[i].is_looted && !items[i].is_underthreshold && !items[i].freeforall)
            return true;
    }
 
    return false;
}

References items.

Referenced by Player::isAllowedToLoot(), and Group::SendLooter().

isLooted()

bool Loot::isLooted ( ) const

inline

{ return gold == 0 && unlootedCount == 0; }

References gold, and unlootedCount.

Referenced by LootItemStorage::AddNewStoredLoot(), Spell::CheckCast(), Group::CountTheRoll(), WorldSession::DoLootRelease(), WorldSession::HandleAutostoreLootItemOpcode(), gobject_commandscript::HandleGameObjectInfoCommand(), WorldSession::HandleLootMoneyOpcode(), Player::isAllowedToLoot(), Unit::Kill(), and Player::SendLoot().

LootItemInSlot()

LootItem * Loot::LootItemInSlot	(	uint32	lootslot,
		Player *	player,
		QuestItem **	qitem = nullptr,
		QuestItem **	ffaitem = nullptr,
		QuestItem **	conditem = nullptr
	)

{
    LootItem* item = nullptr;
    bool is_looted = true;
    if (lootSlot >= items.size())
    {
        uint32 questSlot = lootSlot - items.size();
        QuestItemMap::const_iterator itr = PlayerQuestItems.find(player->GetGUID());
        if (itr != PlayerQuestItems.end() && questSlot < itr->second->size())
        {
            QuestItem* qitem2 = &itr->second->at(questSlot);
            if (qitem)
                *qitem = qitem2;
            item = &quest_items[qitem2->index];
            if (item->follow_loot_rules && !item->AllowedForPlayer(player, sourceWorldObjectGUID)) // pussywizard: such items (follow_loot_rules) are added to every player, but not everyone is allowed, check it here
                return nullptr;
            is_looted = qitem2->is_looted;
        }
    }
    else
    {
        item = &items[lootSlot];
        is_looted = item->is_looted;
        if (item->freeforall)
        {
            QuestItemMap::const_iterator itr = PlayerFFAItems.find(player->GetGUID());
            if (itr != PlayerFFAItems.end())
            {
                for (QuestItemList::const_iterator iter = itr->second->begin(); iter != itr->second->end(); ++iter)
                    if (iter->index == lootSlot)
                    {
                        QuestItem* ffaitem2 = (QuestItem*) & (*iter);
                        if (ffaitem)
                            *ffaitem = ffaitem2;
                        is_looted = ffaitem2->is_looted;
                        break;
                    }
            }
        }
        else if (!item->conditions.empty())
        {
            QuestItemMap::const_iterator itr = PlayerNonQuestNonFFAConditionalItems.find(player->GetGUID());
            if (itr != PlayerNonQuestNonFFAConditionalItems.end())
            {
                for (QuestItemList::const_iterator iter = itr->second->begin(); iter != itr->second->end(); ++iter)
                {
                    if (iter->index == lootSlot)
                    {
                        QuestItem* conditem2 = (QuestItem*) & (*iter);
                        if (conditem)
                            *conditem = conditem2;
                        is_looted = conditem2->is_looted;
                        break;
                    }
                }
            }
        }
    }
 
    if (is_looted)
        return nullptr;
 
    return item;
}

References LootItem::AllowedForPlayer(), LootItem::conditions, LootItem::follow_loot_rules, LootItem::freeforall, Object::GetGUID(), QuestItem::index, LootItem::is_looted, QuestItem::is_looted, items, PlayerFFAItems, PlayerNonQuestNonFFAConditionalItems, PlayerQuestItems, quest_items, and sourceWorldObjectGUID.

Referenced by Player::AutoStoreLoot(), Group::CountTheRoll(), MailDraft::prepareItems(), and Player::StoreLootItem().

NotifyItemRemoved()

void Loot::NotifyItemRemoved

(

uint8

lootIndex

)

{
    // notify all players that are looting this that the item was removed
    // convert the index to the slot the player sees
    PlayersLootingSet::iterator i_next;
    for (PlayersLootingSet::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* player = ObjectAccessor::FindPlayer(*i))
            player->SendNotifyLootItemRemoved(lootIndex);
        else
            PlayersLooting.erase(i);
    }
}

References ObjectAccessor::FindPlayer(), PlayersLooting, and Player::SendNotifyLootItemRemoved().

Referenced by Group::CountTheRoll(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleLootMasterGiveOpcode(), and Player::StoreLootItem().

NotifyMoneyRemoved()

void Loot::NotifyMoneyRemoved

(

)

{
    // notify all players that are looting this that the money was removed
    PlayersLootingSet::iterator i_next;
    for (PlayersLootingSet::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* player = ObjectAccessor::FindPlayer(*i))
            player->SendNotifyLootMoneyRemoved();
        else
            PlayersLooting.erase(i);
    }
}

References ObjectAccessor::FindPlayer(), PlayersLooting, and Player::SendNotifyLootMoneyRemoved().

Referenced by WorldSession::HandleLootMoneyOpcode().

NotifyQuestItemRemoved()

void Loot::NotifyQuestItemRemoved

(

uint8

questIndex

)

{
    // when a free for all questitem is looted
    // all players will get notified of it being removed
    // (other questitems can be looted by each group member)
    // bit inefficient but isn't called often
 
    PlayersLootingSet::iterator i_next;
    for (PlayersLootingSet::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* player = ObjectAccessor::FindPlayer(*i))
        {
            QuestItemMap::const_iterator pq = PlayerQuestItems.find(player->GetGUID());
            if (pq != PlayerQuestItems.end() && pq->second)
            {
                // find where/if the player has the given item in it's vector
                QuestItemList& pql = *pq->second;
 
                uint8 j;
                for (j = 0; j < pql.size(); ++j)
                    if (pql[j].index == questIndex)
                        break;
 
                if (j < pql.size())
                    player->SendNotifyLootItemRemoved(items.size() + j);
            }
        }
        else
            PlayersLooting.erase(i);
    }
}

References ObjectAccessor::FindPlayer(), Object::GetGUID(), items, PlayerQuestItems, PlayersLooting, and Player::SendNotifyLootItemRemoved().

Referenced by Player::StoreLootItem().

RemoveLooter()

void Loot::RemoveLooter ( ObjectGuid  GUID )

inline

{ PlayersLooting.erase(GUID); }

References PlayersLooting.

Referenced by WorldSession::DoLootRelease().

Friends And Related Function Documentation

operator<<

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

friend

{
    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;
}

Member Data Documentation

containerGUID

ObjectGuid Loot::containerGUID

Referenced by LootItemStorage::AddNewStoredLoot(), FillFFALoot(), WorldSession::HandleLootMoneyOpcode(), LootItemStorage::LoadStoredLoot(), Player::SendLoot(), and Player::StoreLootItem().

gold

uint32 Loot::gold

Referenced by LootItemStorage::AddNewStoredLoot(), clear(), empty(), generateMoneyLoot(), WorldSession::HandleLootMoneyOpcode(), hasItemForAll(), isLooted(), LootItemStorage::LoadStoredLoot(), Player::RemovedInsignia(), and Player::SendLoot().

i_LootValidatorRefMgr

LootValidatorRefMgr Loot::i_LootValidatorRefMgr

private

Referenced by addLootValidatorRef(), and clear().

items

std::vector<LootItem> Loot::items

Referenced by AddItem(), LootItemStorage::AddNewStoredLoot(), clear(), Group::CountRollVote(), Group::CountTheRoll(), empty(), FillFFALoot(), FillLoot(), FillNonQuestNonFFAConditionalLoot(), FillNotNormalLootFor(), FillQuestLoot(), GetMaxSlotInLootFor(), Group::GroupLoot(), WorldSession::HandleLootMasterGiveOpcode(), hasItemFor(), hasItemForAll(), hasOverThresholdItem(), LootItemStorage::LoadStoredLoot(), LootItemInSlot(), Group::MasterLoot(), Group::NeedBeforeGreed(), NotifyQuestItemRemoved(), and LootGroupInvalidSelector::operator()().

loot_type

LootType Loot::loot_type {LOOT_NONE}

Referenced by Creature::AllLootRemovedFromCorpse(), clear(), WorldSession::DoLootRelease(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleLootMoneyOpcode(), Player::isAllowedToLoot(), Player::SendLoot(), and Player::UpdateLootAchievements().

lootOwnerGUID

ObjectGuid Loot::lootOwnerGUID

Referenced by AddItem(), and FillLoot().

PlayerFFAItems

QuestItemMap Loot::PlayerFFAItems

private

Referenced by clear(), FillFFALoot(), FillNotNormalLootFor(), GetPlayerFFAItems(), and LootItemInSlot().

PlayerNonQuestNonFFAConditionalItems

QuestItemMap Loot::PlayerNonQuestNonFFAConditionalItems

private

Referenced by clear(), FillNonQuestNonFFAConditionalLoot(), FillNotNormalLootFor(), GetPlayerNonQuestNonFFAConditionalItems(), and LootItemInSlot().

PlayerQuestItems

QuestItemMap Loot::PlayerQuestItems

private

Referenced by clear(), FillNotNormalLootFor(), FillQuestLoot(), GetMaxSlotInLootFor(), GetPlayerQuestItems(), LootItemInSlot(), and NotifyQuestItemRemoved().

PlayersLooting

PlayersLootingSet Loot::PlayersLooting

private

Referenced by AddLooter(), clear(), NotifyItemRemoved(), NotifyMoneyRemoved(), NotifyQuestItemRemoved(), and RemoveLooter().

quest_items

std::vector<LootItem> Loot::quest_items

Referenced by AddItem(), clear(), Group::CountTheRoll(), FillLoot(), FillNotNormalLootFor(), FillQuestLoot(), Group::GroupLoot(), WorldSession::HandleLootMasterGiveOpcode(), hasItemFor(), LootItemStorage::LoadStoredLoot(), LootItemInSlot(), Group::MasterLoot(), and Group::NeedBeforeGreed().

roundRobinPlayer

ObjectGuid Loot::roundRobinPlayer

Referenced by clear(), WorldSession::DoLootRelease(), FillLoot(), FillQuestLoot(), Player::isAllowedToLoot(), and Player::StoreLootItem().

sourceGameObject

GameObject* Loot::sourceGameObject {nullptr}

Referenced by GameObject::GameObject().

sourceWorldObjectGUID

ObjectGuid Loot::sourceWorldObjectGUID

Referenced by AddItem(), Creature::AddToWorld(), GameObject::AddToWorld(), CanRollOnItem(), FillNonQuestNonFFAConditionalLoot(), FillNotNormalLootFor(), FillQuestLoot(), WorldSession::HandleLootMasterGiveOpcode(), LootItemInSlot(), and Player::StoreLootItem().

unlootedCount

uint8 Loot::unlootedCount {0}

Referenced by AddItem(), clear(), Group::CountTheRoll(), FillFFALoot(), FillNonQuestNonFFAConditionalLoot(), FillQuestLoot(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleLootMasterGiveOpcode(), isLooted(), LootItemStorage::LoadStoredLoot(), LootItemStorage::RemoveStoredLootItem(), LootItemStorage::RemoveStoredLootMoney(), Player::SendLoot(), and Player::StoreLootItem().