LootTemplate Class Reference

#include <LootMgr.h>

Classes
class	LootGroup

Public Member Functions
	LootTemplate ()
	~LootTemplate ()
void	AddEntry (LootStoreItem *item)
void	Process (Loot &loot, bool rate, uint16 lootMode, uint8 groupId=0) const
void	CopyConditions (const ConditionContainer &conditions)
void	CopyConditions (LootItem *li) 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)

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

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

Private Attributes
LootStoreItemList	Entries
LootGroups	Groups

Member Typedef Documentation

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

private

Constructor & Destructor Documentation

LootTemplate::LootTemplate ( )

inline

{ }

LootTemplate::~LootTemplate

(

)

{
 for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i)
 delete *i;

 for (size_t i = 0; i < Groups.size(); ++i)
 delete Groups[i];
}

LootTemplate::LootTemplate ( LootTemplate const &  )

private

Member Function Documentation

bool LootTemplate::addConditionItem

(

Condition *

cond

)

{
 if (!cond || !cond->isLoaded())//should never happen, checked at loading
 {
 TC_LOG_ERROR("loot", "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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void LootTemplate::AddEntry

(

LootStoreItem *

item

)

{
 if (item->groupid > 0 && item->reference == 0) // Group
 {
 if (item->groupid >= Groups.size())
 Groups.resize(item->groupid, NULL); // 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 and references are stored together
 Entries.push_back(item);
}

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 > 0)
 {
 if (!LootTemplates_Reference.GetLootFor(item->reference))
 LootTemplates_Reference.ReportNonExistingId(item->reference, "Reference", item->itemid);
 else if (ref_set)
 ref_set->erase(item->reference);
 }
 }

 for (LootGroups::const_iterator grItr = Groups.begin(); grItr != Groups.end(); ++grItr)
 if (LootGroup* group = *grItr)
 group->CheckLootRefs(store, ref_set);
}

Here is the call graph for this function:

void LootTemplate::CopyConditions

(

const ConditionContainer &

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

Here is the caller graph for this function:

void LootTemplate::CopyConditions

(

LootItem *

li

)

const

{
 // Copies the conditions list from a template item to a LootItemData
 for (LootStoreItemList::const_iterator _iter = Entries.begin(); _iter != Entries.end(); ++_iter)
 {
 LootStoreItem* item = *_iter;
 if (item->itemid != li->itemid)
 continue;

 li->conditions = item->conditions;
 break;
 }
}

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

 for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
 {
 LootStoreItem* item = *i;
 if (item->reference > 0) // References
 {
 LootTemplateMap::const_iterator Referenced = store.find(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())
 return true;

 return false;
}

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

 // Checking non-grouped entries
 for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
 {
 LootStoreItem* item = *i;
 if (item->reference > 0) // References processing
 {
 LootTemplateMap::const_iterator Referenced = store.find(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))
 return true;

 return false;
}

bool LootTemplate::isReference

(

uint32

id

)

{
 for (LootStoreItemList::const_iterator ieItr = Entries.begin(); ieItr != Entries.end(); ++ieItr)
 if ((*ieItr)->itemid == id && (*ieItr)->reference > 0)
 return true;

 return false;//not found or not reference
}

Here is the caller graph for this function:

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

private

void LootTemplate::Process	(	Loot &	loot,
		bool	rate,
		uint16	lootMode,
		uint8	groupId = 0
	)		const

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

 Groups[groupId - 1]->Process(loot, lootMode);
 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))
 continue; // Bad luck for the entry

 if (item->reference > 0) // References processing
 {
 LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(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));
 for (uint32 loop = 0; loop < maxcount; ++loop) // Ref multiplicator
 Referenced->Process(loot, rate, lootMode, item->groupid);
 }
 else // Plain entries (not a reference, not grouped)
 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)
 group->Process(loot, lootMode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

LootStoreItemList LootTemplate::Entries

private

LootGroups LootTemplate::Groups

private

---

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

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