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 ()
ObjectGuid const &	GetGUID () const
void	SetGUID (ObjectGuid const &guid)
void	DeleteLootItemFromContainerItemDB (uint32 itemID)
void	DeleteLootMoneyFromContainerItemDB ()
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)
void	AddItem (LootStoreItem const &item)
LootItem *	LootItemInSlot (uint32 lootslot, Player *player, QuestItem **qitem=NULL, QuestItem **ffaitem=NULL, QuestItem **conditem=NULL)
uint32	GetMaxSlotInLootFor (Player *player) const
bool	hasItemFor (Player *player) const
bool	hasOverThresholdItem () const
void	BuildLootResponse (WorldPackets::Loot::LootResponse &packet, Player *viewer, PermissionTypes permission=ALL_PERMISSION) const

Public Attributes
std::vector< LootItem >	items
std::vector< LootItem >	quest_items
uint32	gold
uint8	unlootedCount
ObjectGuid	roundRobinPlayer
LootType	loot_type
uint8	maxDuplicates
ObjectGuid	containerID

Private Member Functions
void	FillNotNormalLootFor (Player *player, bool presentAtLooting)
QuestItemList *	FillFFALoot (Player *player)
QuestItemList *	FillQuestLoot (Player *player)
QuestItemList *	FillNonQuestNonFFAConditionalLoot (Player *player, bool presentAtLooting)

Private Attributes
GuidSet	PlayersLooting
QuestItemMap	PlayerQuestItems
QuestItemMap	PlayerFFAItems
QuestItemMap	PlayerNonQuestNonFFAConditionalItems
LootValidatorRefManager	i_LootValidatorRefManager
ObjectGuid	_GUID
uint32	_difficultyBonusTreeMod

Constructor & Destructor Documentation

Loot::Loot ( uint32  _gold = 0 )

inline

: gold(_gold), unlootedCount(0), roundRobinPlayer(), loot_type(LOOT_CORPSE), maxDuplicates(1), _difficultyBonusTreeMod(0){ }

Loot::~Loot ( )

inline

{ clear(); }

Member Function Documentation

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());
 if (_difficultyBonusTreeMod)
 {
 std::set<uint32> bonusListIDs = sDB2Manager.GetItemBonusTree(generatedLoot.itemid, _difficultyBonusTreeMod);
 generatedLoot.BonusListIDs.insert(generatedLoot.BonusListIDs.end(), bonusListIDs.begin(), bonusListIDs.end());
 }

 lootItems.push_back(generatedLoot);
 count -= proto->GetMaxStackSize();

 // 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->GetFlags() & ITEM_FLAG_PARTY_LOOT))
 ++unlootedCount;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Loot::AddLooter ( ObjectGuid  GUID )

inline

{ PlayersLooting.insert(GUID); }

void Loot::addLootValidatorRef ( LootValidatorRef *  pLootValidatorRef )

inline

 {
 i_LootValidatorRefManager.insertFirst(pLootValidatorRef);
 }

Here is the caller graph for this function:

void Loot::BuildLootResponse	(	WorldPackets::Loot::LootResponse &	packet,
		Player *	viewer,
		PermissionTypes	permission = ALL_PERMISSION
	)		const

{
 if (permission == NONE_PERMISSION)
 return;

 packet.Coins = gold;

 switch (permission)
 {
 case GROUP_PERMISSION:
 case MASTER_PERMISSION:
 case RESTRICTED_PERMISSION:
 {
 // 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 < items.size(); ++i)
 {
 if (!items[i].is_looted && !items[i].freeforall && items[i].conditions.empty() && items[i].AllowedForPlayer(viewer))
 {
 uint8 slot_type;

 if (items[i].is_blocked) // for ML & restricted is_blocked = !is_underthreshold
 {
 switch (permission)
 {
 case GROUP_PERMISSION:
 slot_type = LOOT_SLOT_TYPE_ROLL_ONGOING;
 break;
 case MASTER_PERMISSION:
 {
 if (viewer->GetGroup() && viewer->GetGroup()->GetMasterLooterGuid() == 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 (roundRobinPlayer.IsEmpty() || viewer->GetGUID() == roundRobinPlayer || !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;

 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.UIType = slot_type;
 lootItem.Quantity = items[i].count;
 lootItem.Loot.Initialize(items[i]);
 packet.Items.push_back(lootItem);
 }
 }
 break;
 }
 case ROUND_ROBIN_PERMISSION:
 {
 for (uint8 i = 0; i < items.size(); ++i)
 {
 if (!items[i].is_looted && !items[i].freeforall && items[i].conditions.empty() && items[i].AllowedForPlayer(viewer))
 {
 if (!roundRobinPlayer.IsEmpty() && viewer->GetGUID() != roundRobinPlayer)
 // item shall not be displayed.
 continue;

 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.UIType = LOOT_SLOT_TYPE_ALLOW_LOOT;
 lootItem.Quantity = items[i].count;
 lootItem.Loot.Initialize(items[i]);
 packet.Items.push_back(lootItem);
 }
 }
 break;
 }
 case ALL_PERMISSION:
 case OWNER_PERMISSION:
 {
 for (uint8 i = 0; i < items.size(); ++i)
 {
 if (!items[i].is_looted && !items[i].freeforall && items[i].conditions.empty() && items[i].AllowedForPlayer(viewer))
 {
 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.UIType = permission == OWNER_PERMISSION ? LOOT_SLOT_TYPE_OWNER : LOOT_SLOT_TYPE_ALLOW_LOOT;
 lootItem.Quantity = items[i].count;
 lootItem.Loot.Initialize(items[i]);
 packet.Items.push_back(lootItem);
 }
 }
 break;
 }
 default:
 return;
 }

 LootSlotType slotType = permission == OWNER_PERMISSION ? LOOT_SLOT_TYPE_OWNER : LOOT_SLOT_TYPE_ALLOW_LOOT;
 QuestItemMap const& lootPlayerQuestItems = GetPlayerQuestItems();
 QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(viewer->GetGUID().GetCounter());
 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 const& item = quest_items[qi->index];
 if (!qi->is_looted && !item.is_looted)
 {
 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.Quantity = item.count;
 lootItem.Loot.Initialize(item);

 if (item.follow_loot_rules)
 {
 switch (permission)
 {
 case MASTER_PERMISSION:
 lootItem.UIType = LOOT_SLOT_TYPE_MASTER;
 break;
 case RESTRICTED_PERMISSION:
 lootItem.UIType = item.is_blocked ? LOOT_SLOT_TYPE_LOCKED : LOOT_SLOT_TYPE_ALLOW_LOOT;
 break;
 case GROUP_PERMISSION:
 case ROUND_ROBIN_PERMISSION:
 if (!item.is_blocked)
 lootItem.UIType = LOOT_SLOT_TYPE_ALLOW_LOOT;
 else
 lootItem.UIType = LOOT_SLOT_TYPE_ROLL_ONGOING;
 break;
 default:
 lootItem.UIType = slotType;
 break;
 }
 }
 else
 lootItem.UIType = slotType;

 packet.Items.push_back(lootItem);
 }
 }
 }

 QuestItemMap const& lootPlayerFFAItems = GetPlayerFFAItems();
 QuestItemMap::const_iterator ffa_itr = lootPlayerFFAItems.find(viewer->GetGUID().GetCounter());
 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 const& item = items[fi->index];
 if (!fi->is_looted && !item.is_looted)
 {
 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.UIType = slotType;
 lootItem.Quantity = item.count;
 lootItem.Loot.Initialize(item);
 packet.Items.push_back(lootItem);
 }
 }
 }

 QuestItemMap const& lootPlayerNonQuestNonFFAConditionalItems = GetPlayerNonQuestNonFFAConditionalItems();
 QuestItemMap::const_iterator nn_itr = lootPlayerNonQuestNonFFAConditionalItems.find(viewer->GetGUID().GetCounter());
 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 const& item = items[ci->index];
 if (!ci->is_looted && !item.is_looted)
 {
 WorldPackets::Loot::LootItemData lootItem;
 lootItem.LootListID = packet.Items.size()+1;
 lootItem.Quantity = item.count;
 lootItem.Loot.Initialize(item);

 if (item.follow_loot_rules)
 {
 switch (permission)
 {
 case MASTER_PERMISSION:
 lootItem.UIType = LOOT_SLOT_TYPE_MASTER;
 break;
 case RESTRICTED_PERMISSION:
 lootItem.UIType = item.is_blocked ? LOOT_SLOT_TYPE_LOCKED : LOOT_SLOT_TYPE_ALLOW_LOOT;
 break;
 case GROUP_PERMISSION:
 case ROUND_ROBIN_PERMISSION:
 if (!item.is_blocked)
 lootItem.UIType = LOOT_SLOT_TYPE_ALLOW_LOOT;
 else
 lootItem.UIType = LOOT_SLOT_TYPE_ROLL_ONGOING;
 break;
 default:
 lootItem.UIType = slotType;
 break;
 }
 }
 else
 lootItem.UIType = slotType;

 packet.Items.push_back(lootItem);
 }
 }
 }
}

Here is the call graph for this function:

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();
 loot_type = LOOT_NONE;
 i_LootValidatorRefManager.clearReferences();
 _difficultyBonusTreeMod = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Loot::DeleteLootItemFromContainerItemDB

(

uint32

itemID

)

{
 // Deletes a single item associated with an openable item from the DB
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEMCONTAINER_ITEM);
 stmt->setUInt64(0, containerID.GetCounter());
 stmt->setUInt32(1, itemID);
 CharacterDatabase.Execute(stmt);

 // Mark the item looted to prevent resaving
 for (LootItemList::iterator _itr = items.begin(); _itr != items.end(); ++_itr)
 {
 if (_itr->itemid != itemID)
 continue;

 _itr->canSave = true;
 break;
 }
}

Here is the call graph for this function:

void Loot::DeleteLootMoneyFromContainerItemDB

(

)

{
 // Deletes money loot associated with an openable item from the DB
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEMCONTAINER_MONEY);
 stmt->setUInt64(0, containerID.GetCounter());
 CharacterDatabase.Execute(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Loot::empty ( ) const

inline

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

Here is the caller graph for this function:

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))
 {
 ql->push_back(QuestItem(i));
 ++unlootedCount;
 }
 }
 if (ql->empty())
 {
 delete ql;
 return NULL;
 }

 PlayerFFAItems[player->GetGUID().GetCounter()] = ql;
 return ql;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
 // Must be provided
 if (!lootOwner)
 return false;

 LootTemplate const* tab = store.GetLootFor(lootId);

 if (!tab)
 {
 if (!noEmptyError)
 TC_LOG_ERROR("sql.sql", "Table '%s' loot id #%u used but it doesn't have records.", store.GetName(), lootId);
 return false;
 }

 _difficultyBonusTreeMod = lootOwner->GetMap()->GetDifficultyLootBonusTreeMod();

 items.reserve(MAX_NR_LOOT_ITEMS);
 quest_items.reserve(MAX_NR_QUEST_ITEMS);

 tab->Process(*this, store.IsRatesAllowed(), lootMode); // Processing is done there, callback via Loot::AddItem()

 // Setting access rights for group loot case
 Group* group = lootOwner->GetGroup();
 if (!personal && group)
 {
 roundRobinPlayer = lootOwner->GetGUID();

 for (GroupReference* itr = group->GetFirstMember(); itr != NULL; 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
 FillNotNormalLootFor(player, player->IsAtGroupRewardDistance(lootOwner));

 for (uint8 i = 0; i < items.size(); ++i)
 {
 if (ItemTemplate const* proto = sObjectMgr->GetItemTemplate(items[i].itemid))
 if (proto->GetQuality() < uint32(group->GetLootThreshold()))
 items[i].is_underthreshold = true;
 }
 }
 // ... for personal loot
 else
 FillNotNormalLootFor(lootOwner, true);

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

QuestItemList * Loot::FillNonQuestNonFFAConditionalLoot ( Player *  player, bool  presentAtLooting  )

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) || (item.follow_loot_rules && player->GetGroup() && ((player->GetGroup()->GetLootMethod() == MASTER_LOOT && player->GetGroup()->GetMasterLooterGuid() == player->GetGUID()) || player->GetGroup()->GetLootMethod() != MASTER_LOOT))))
 {
 if (presentAtLooting)
 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 NULL;
 }

 PlayerNonQuestNonFFAConditionalItems[player->GetGUID().GetCounter()] = ql;
 return ql;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Loot::FillNotNormalLootFor ( Player *  player, bool  presentAtLooting  )

private

{
 ObjectGuid::LowType plguid = player->GetGUID().GetCounter();

 QuestItemMap::const_iterator qmapitr = PlayerQuestItems.find(plguid);
 if (qmapitr == PlayerQuestItems.end())
 FillQuestLoot(player);

 qmapitr = PlayerFFAItems.find(plguid);
 if (qmapitr == PlayerFFAItems.end())
 FillFFALoot(player);

 qmapitr = PlayerNonQuestNonFFAConditionalItems.find(plguid);
 if (qmapitr == PlayerNonQuestNonFFAConditionalItems.end())
 FillNonQuestNonFFAConditionalLoot(player, presentAtLooting);

 // if not auto-processed player will have to come and pick it up manually
 if (!presentAtLooting)
 return;

 // Process currency items
 uint32 max_slot = GetMaxSlotInLootFor(player);
 LootItem const* item = NULL;
 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))
 if (ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item->itemid))
 if (proto->IsCurrencyToken())
 player->StoreLootItem(i, this);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

QuestItemList * Loot::FillQuestLoot ( Player *  player )

private

{
 if (items.size() == MAX_NR_LOOT_ITEMS)
 return NULL;

 QuestItemList* ql = new QuestItemList();

 for (uint8 i = 0; i < quest_items.size(); ++i)
 {
 LootItem &item = quest_items[i];

 if (!item.is_looted && (item.AllowedForPlayer(player) || (item.follow_loot_rules && player->GetGroup() && ((player->GetGroup()->GetLootMethod() == MASTER_LOOT && player->GetGroup()->GetMasterLooterGuid() == player->GetGUID()) || player->GetGroup()->GetLootMethod() != MASTER_LOOT))))
 {
 ql->push_back(QuestItem(i));

 // quest items get blocked when they first appear in a
 // player's quest vector
 //
 // increase once if one looter only, looter-times if free for all
 if (item.freeforall || !item.is_blocked)
 ++unlootedCount;
 if (!player->GetGroup() || (player->GetGroup()->GetLootMethod() != GROUP_LOOT && player->GetGroup()->GetLootMethod() != ROUND_ROBIN))
 item.is_blocked = true;

 if (items.size() + ql->size() == MAX_NR_LOOT_ITEMS)
 break;
 }
 }
 if (ql->empty())
 {
 delete ql;
 return NULL;
 }

 PlayerQuestItems[player->GetGUID().GetCounter()] = ql;
 return ql;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid const& Loot::GetGUID ( ) const

inline

{ return _GUID; }

Here is the caller graph for this function:

uint32 Loot::GetMaxSlotInLootFor

(

Player *

player

)

const

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

Here is the caller graph for this function:

QuestItemMap const& Loot::GetPlayerFFAItems ( ) const

inline

{ return PlayerFFAItems; }

Here is the caller graph for this function:

QuestItemMap const& Loot::GetPlayerNonQuestNonFFAConditionalItems ( ) const

inline

{ return PlayerNonQuestNonFFAConditionalItems; }

Here is the caller graph for this function:

QuestItemMap const& Loot::GetPlayerQuestItems ( ) const

inline

{ return PlayerQuestItems; }

Here is the caller graph for this function:

bool Loot::hasItemFor

(

Player *

player

)

const

{
    QuestItemMap const& lootPlayerQuestItems = GetPlayerQuestItems();
    QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(player->GetGUID().GetCounter());
    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().GetCounter());
    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().GetCounter());
    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;
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

bool Loot::isLooted ( ) const

inline

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

Here is the caller graph for this function:

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

{
    LootItem* item = NULL;
    bool is_looted = true;
    if (lootSlot >= items.size())
    {
        uint32 questSlot = lootSlot - items.size();
        QuestItemMap::const_iterator itr = PlayerQuestItems.find(player->GetGUID().GetCounter());
        if (itr != PlayerQuestItems.end() && questSlot < itr->second->size())
        {
            QuestItem* qitem2 = &itr->second->at(questSlot);
            if (qitem)
                *qitem = qitem2;
            item = &quest_items[qitem2->index];
            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().GetCounter());
            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().GetCounter());
            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 NULL;

    return item;
}

Here is the caller graph for this function:

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
    GuidSet::iterator i_next;
    for (GuidSet::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* player = ObjectAccessor::FindPlayer(*i))
            player->SendNotifyLootItemRemoved(player->GetLootGUID(), GetGUID(), lootIndex);
        else
            PlayersLooting.erase(i);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Loot::NotifyMoneyRemoved

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

    GuidSet::iterator i_next;
    for (GuidSet::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().GetCounter());
            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(player->GetLootGUID(), GetGUID(), items.size()+j);
            }
        }
        else
            PlayersLooting.erase(i);
    }
}

Here is the call graph for this function:

void Loot::RemoveLooter ( ObjectGuid  GUID )

inline

{ PlayersLooting.erase(GUID); }

Here is the caller graph for this function:

void Loot::SetGUID ( ObjectGuid const &  guid )

inline

{ _GUID = guid; }

Here is the caller graph for this function:

Member Data Documentation

uint32 Loot::_difficultyBonusTreeMod

private

ObjectGuid Loot::_GUID

private

ObjectGuid Loot::containerID

uint32 Loot::gold

LootValidatorRefManager Loot::i_LootValidatorRefManager

private

std::vector<LootItem> Loot::items

LootType Loot::loot_type

uint8 Loot::maxDuplicates

QuestItemMap Loot::PlayerFFAItems

private

QuestItemMap Loot::PlayerNonQuestNonFFAConditionalItems

private

QuestItemMap Loot::PlayerQuestItems

private

GuidSet Loot::PlayersLooting

private

std::vector<LootItem> Loot::quest_items

ObjectGuid Loot::roundRobinPlayer

uint8 Loot::unlootedCount

---

The documentation for this struct was generated from the following files:

• src/server/game/Loot/LootMgr.h
• src/server/game/Loot/LootMgr.cpp