LootMgr.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "LootMgr.h"
#include "Containers.h"
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "ItemBonusMgr.h"
#include "ItemTemplate.h"
#include "Log.h"
#include "Loot.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "Random.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "World.h"
 
static Rates const qualityToRate[MAX_ITEM_QUALITY] =
{
 RATE_DROP_ITEM_POOR, // ITEM_QUALITY_POOR
 RATE_DROP_ITEM_NORMAL, // ITEM_QUALITY_NORMAL
 RATE_DROP_ITEM_UNCOMMON, // ITEM_QUALITY_UNCOMMON
 RATE_DROP_ITEM_RARE, // ITEM_QUALITY_RARE
 RATE_DROP_ITEM_EPIC, // ITEM_QUALITY_EPIC
 RATE_DROP_ITEM_LEGENDARY, // ITEM_QUALITY_LEGENDARY
 RATE_DROP_ITEM_ARTIFACT, // ITEM_QUALITY_ARTIFACT
};
 
LootStore LootTemplates_Creature("creature_loot_template", "creature entry", true);
LootStore LootTemplates_Disenchant("disenchant_loot_template", "item disenchant id", true);
LootStore LootTemplates_Fishing("fishing_loot_template", "area id", true);
LootStore LootTemplates_Gameobject("gameobject_loot_template", "gameobject entry", true);
LootStore LootTemplates_Item("item_loot_template", "item entry", true);
LootStore LootTemplates_Mail("mail_loot_template", "mail template id", false);
LootStore LootTemplates_Milling("milling_loot_template", "item entry (herb)", true);
LootStore LootTemplates_Pickpocketing("pickpocketing_loot_template", "creature pickpocket lootid", true);
LootStore LootTemplates_Prospecting("prospecting_loot_template", "item entry (ore)", true);
LootStore LootTemplates_Reference("reference_loot_template", "reference id", false);
LootStore LootTemplates_Skinning("skinning_loot_template", "creature skinning id", true);
LootStore LootTemplates_Spell("spell_loot_template", "spell id (random item creating)", false);
 
// Selects invalid loot items to be removed from group possible entries (before rolling)
struct LootGroupInvalidSelector
{
 explicit LootGroupInvalidSelector(uint16 lootMode, Player const* personalLooter) : _lootMode(lootMode), _personalLooter(personalLooter) { }
 
 bool operator()(LootStoreItem const* item) const
 {
 if (!(item->lootmode & _lootMode))
 return true;
 
 if (_personalLooter && !LootItem::AllowedForPlayer(_personalLooter, nullptr, item->itemid, item->needs_quest,
 !item->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(item->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 true, item->conditions))
 return true;
 
 return false;
 }
 
private:
 uint16 _lootMode;
 Player const* _personalLooter;
};
 
class LootTemplate::LootGroup // A set of loot definitions for items (refs are not allowed)
{
 public:
 LootGroup() = default;
 LootGroup(LootGroup const&) = delete;
 LootGroup(LootGroup&&) = delete;
 LootGroup& operator=(LootGroup const&) = delete;
 LootGroup& operator=(LootGroup&&) = delete;
 ~LootGroup();
 
 void AddEntry(LootStoreItem* item); // Adds an entry to the group (at loading stage)
 bool HasDropForPlayer(Player const* player, bool strictUsabilityCheck) const;
 bool HasQuestDrop() const; // True if group includes at least 1 quest drop entry
 bool HasQuestDropForPlayer(Player const* player) const;
 // The same for active quests of the player
 void Process(Loot& loot, uint16 lootMode,
 Player const* personalLooter = nullptr) const; // Rolls an item from the group (if any) and adds the item to the loot
 float RawTotalChance() const; // Overall chance for the group (without equal chanced items)
 float TotalChance() const; // Overall chance for the group
 
 void Verify(LootStore const& lootstore, uint32 id, uint8 group_id) const;
 void CheckLootRefs(LootTemplateMap const& store, LootIdSet* ref_set) const;
 LootStoreItemList* GetExplicitlyChancedItemList() { return &ExplicitlyChanced; }
 LootStoreItemList* GetEqualChancedItemList() { return &EqualChanced; }
 private:
 LootStoreItemList ExplicitlyChanced; // Entries with chances defined in DB
 LootStoreItemList EqualChanced; // Zero chances - every entry takes the same chance
 
 // Rolls an item from the group, returns NULL if all miss their chances
 LootStoreItem const* Roll(uint16 lootMode, Player const* personalLooter = nullptr) const;
};
 
//Remove all data and free all memory
void LootStore::Clear()
{
 for (LootTemplateMap::const_iterator itr = m_LootTemplates.begin(); itr != m_LootTemplates.end(); ++itr)
 delete itr->second;
 m_LootTemplates.clear();
}
 
// Checks validity of the loot store
// Actual checks are done within LootTemplate::Verify() which is called for every template
void LootStore::Verify() const
{
 for (LootTemplateMap::const_iterator i = m_LootTemplates.begin(); i != m_LootTemplates.end(); ++i)
 i->second->Verify(*this, i->first);
}
 
// Loads a *_loot_template DB table into loot store
// All checks of the loaded template are called from here, no error reports at loot generation required
uint32 LootStore::LoadLootTable()
{
 LootTemplateMap::const_iterator tab;
 
 // Clearing store (for reloading case)
 Clear();
 
 // 0 1 2 3 4 5 6
 QueryResult result = WorldDatabase.PQuery("SELECT Entry, Item, Reference, Chance, QuestRequired, LootMode, GroupId, MinCount, MaxCount FROM {}", GetName());
 
 if (!result)
 return 0;
 
 uint32 count = 0;
 
 do
 {
 Field* fields = result->Fetch();
 
 uint32 entry = fields[0].GetUInt32();
 uint32 item = fields[1].GetUInt32();
 uint32 reference = fields[2].GetUInt32();
 float chance = fields[3].GetFloat();
 bool needsquest = fields[4].GetBool();
 uint16 lootmode = fields[5].GetUInt16();
 uint8 groupid = fields[6].GetUInt8();
 uint8 mincount = fields[7].GetUInt8();
 uint8 maxcount = fields[8].GetUInt8();
 
 if (groupid >= 1 << 7) // it stored in 7 bit field
 {
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: GroupId ({}) must be less {} - skipped", GetName(), entry, item, groupid, 1 << 7);
 return 0;
 }
 
 LootStoreItem* storeitem = new LootStoreItem(item, reference, chance, needsquest, lootmode, groupid, mincount, maxcount);
 
 if (!storeitem->IsValid(*this, entry)) // Validity checks
 {
 delete storeitem;
 continue;
 }
 
 // Looking for the template of the entry
 // often entries are put together
 if (m_LootTemplates.empty() || tab->first != entry)
 {
 // Searching the template (in case template Id changed)
 tab = m_LootTemplates.find(entry);
 if (tab == m_LootTemplates.end())
 {
 std::pair< LootTemplateMap::iterator, bool > pr = m_LootTemplates.insert(LootTemplateMap::value_type(entry, new LootTemplate()));
 tab = pr.first;
 }
 }
 // else is empty - template Id and iter are the same
 // finally iter refers to already existed or just created <entry, LootTemplate>
 
 // Adds current row to the template
 tab->second->AddEntry(storeitem);
 ++count;
 }
 while (result->NextRow());
 
 Verify(); // Checks validity of the loot store
 
 return count;
}
 
bool LootStore::HaveQuestLootFor(uint32 loot_id) const
{
 LootTemplateMap::const_iterator itr = m_LootTemplates.find(loot_id);
 if (itr == m_LootTemplates.end())
 return false;
 
 // scan loot for quest items
 return itr->second->HasQuestDrop(m_LootTemplates);
}
 
bool LootStore::HaveQuestLootForPlayer(uint32 loot_id, Player const* player) const
{
 LootTemplateMap::const_iterator tab = m_LootTemplates.find(loot_id);
 if (tab != m_LootTemplates.end())
 if (tab->second->HasQuestDropForPlayer(m_LootTemplates, player))
 return true;
 
 return false;
}
 
LootTemplate const* LootStore::GetLootFor(uint32 loot_id) const
{
 LootTemplateMap::const_iterator tab = m_LootTemplates.find(loot_id);
 
 if (tab == m_LootTemplates.end())
 return nullptr;
 
 return tab->second;
}
 
LootTemplate* LootStore::GetLootForConditionFill(uint32 loot_id)
{
 LootTemplateMap::iterator tab = m_LootTemplates.find(loot_id);
 
 if (tab == m_LootTemplates.end())
 return nullptr;
 
 return tab->second;
}
 
uint32 LootStore::LoadAndCollectLootIds(LootIdSet& lootIdSet)
{
 uint32 count = LoadLootTable();
 
 for (LootTemplateMap::const_iterator tab = m_LootTemplates.begin(); tab != m_LootTemplates.end(); ++tab)
 lootIdSet.insert(tab->first);
 
 return count;
}
 
void LootStore::CheckLootRefs(LootIdSet* ref_set) const
{
 for (LootTemplateMap::const_iterator ltItr = m_LootTemplates.begin(); ltItr != m_LootTemplates.end(); ++ltItr)
 ltItr->second->CheckLootRefs(m_LootTemplates, ref_set);
}
 
void LootStore::ReportUnusedIds(LootIdSet const& lootIdSet) const
{
 // all still listed ids isn't referenced
 for (LootIdSet::const_iterator itr = lootIdSet.begin(); itr != lootIdSet.end(); ++itr)
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} isn't {} and not referenced from loot, and thus useless.", GetName(), *itr, GetEntryName());
}
 
void LootStore::ReportNonExistingId(uint32 lootId) const
{
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} does not exist", GetName(), lootId);
}
 
void LootStore::ReportNonExistingId(uint32 lootId, char const* ownerType, uint32 ownerId) const
{
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} does not exist but it is used by {} {}", GetName(), lootId, ownerType, ownerId);
}
 
//
// --------- LootStoreItem ---------
//
 
// Checks if the entry (quest, non-quest, reference) takes it's chance (at loot generation)
// RATE_DROP_ITEMS is no longer used for all types of entries
bool LootStoreItem::Roll(bool rate) const
{
 if (chance >= 100.0f)
 return true;
 
 if (reference > 0) // 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->GetQuality()]) : 1.0f;
 
 return roll_chance_f(chance * qualityModifier);
}
 
// Checks correctness of values
bool LootStoreItem::IsValid(LootStore const& store, uint32 entry) const
{
 if (mincount == 0)
 {
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: wrong MinCount ({}) - skipped", store.GetName(), entry, itemid, mincount);
 return false;
 }
 
 if (reference == 0) // item (quest or non-quest) entry, maybe grouped
 {
 ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemid);
 if (!proto)
 {
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: item does not exist - skipped", store.GetName(), entry, itemid);
 return false;
 }
 
 if (chance == 0 && groupid == 0) // Zero chance is allowed for grouped entries only
 {
 TC_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
 {
 TC_LOG_ERROR("sql.sql", "Table '{}' Entry {} Item {}: low chance ({}) - skipped",
 store.GetName(), entry, itemid, chance);
 return false;
 }
 
 if (maxcount < mincount) // wrong max count
 {
 TC_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)
 TC_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
 {
 TC_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
}
 
//
// --------- LootTemplate::LootGroup ---------
//
 
LootTemplate::LootGroup::~LootGroup()
{
 while (!ExplicitlyChanced.empty())
 {
 delete ExplicitlyChanced.back();
 ExplicitlyChanced.pop_back();
 }
 
 while (!EqualChanced.empty())
 {
 delete EqualChanced.back();
 EqualChanced.pop_back();
 }
}
 
// Adds an entry to the group (at loading stage)
void LootTemplate::LootGroup::AddEntry(LootStoreItem* item)
{
 if (item->chance != 0)
 ExplicitlyChanced.push_back(item);
 else
 EqualChanced.push_back(item);
}
 
// Rolls an item from the group, returns NULL if all miss their chances
LootStoreItem const* LootTemplate::LootGroup::Roll(uint16 lootMode, Player const* personalLooter /*= nullptr*/) const
{
 LootStoreItemList possibleLoot = ExplicitlyChanced;
 possibleLoot.remove_if(LootGroupInvalidSelector(lootMode, personalLooter));
 
 if (!possibleLoot.empty()) // First explicitly chanced entries are checked
 {
 float roll = 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;
 if (item->chance >= 100.0f)
 return item;
 
 roll -= item->chance;
 if (roll < 0)
 return item;
 }
 }
 
 possibleLoot = EqualChanced;
 possibleLoot.remove_if(LootGroupInvalidSelector(lootMode, personalLooter));
 if (!possibleLoot.empty()) // If nothing selected yet - an item is taken from equal-chanced part
 return Trinity::Containers::SelectRandomContainerElement(possibleLoot);
 
 return nullptr; // Empty drop from the group
}
 
bool LootTemplate::LootGroup::HasDropForPlayer(Player const* player, bool strictUsabilityCheck) const
{
 for (LootStoreItem const* lootStoreItem : ExplicitlyChanced)
 if (LootItem::AllowedForPlayer(player, nullptr, lootStoreItem->itemid, lootStoreItem->needs_quest,
 !lootStoreItem->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(lootStoreItem->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 strictUsabilityCheck, lootStoreItem->conditions))
 return true;
 
 for (LootStoreItem const* lootStoreItem : EqualChanced)
 if (LootItem::AllowedForPlayer(player, nullptr, lootStoreItem->itemid, lootStoreItem->needs_quest,
 !lootStoreItem->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(lootStoreItem->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 strictUsabilityCheck, lootStoreItem->conditions))
 return true;
 
 return false;
}
 
// True if group includes at least 1 quest drop entry
bool LootTemplate::LootGroup::HasQuestDrop() const
{
 for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
 if ((*i)->needs_quest)
 return true;
 
 for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
 if ((*i)->needs_quest)
 return true;
 
 return false;
}
 
// True if group includes at least 1 quest drop entry for active quests of the player
bool LootTemplate::LootGroup::HasQuestDropForPlayer(Player const* player) const
{
 for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
 if (player->HasQuestForItem((*i)->itemid))
 return true;
 
 for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
 if (player->HasQuestForItem((*i)->itemid))
 return true;
 
 return false;
}
 
// Rolls an item from the group (if any takes its chance) and adds the item to the loot
void LootTemplate::LootGroup::Process(Loot& loot, uint16 lootMode, Player const* personalLooter /*= nullptr*/) const
{
 if (LootStoreItem const* item = Roll(lootMode, personalLooter))
 loot.AddItem(*item);
}
 
// Overall chance for the group without equal chanced items
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;
}
 
// Overall chance for the group
float LootTemplate::LootGroup::TotalChance() const
{
 float result = RawTotalChance();
 
 if (!EqualChanced.empty() && result < 100.0f)
 return 100.0f;
 
 return result;
}
 
void LootTemplate::LootGroup::Verify(LootStore const& lootstore, uint32 id, uint8 group_id) const
{
 float chance = RawTotalChance();
 if (chance > 101.0f) 
 TC_LOG_ERROR("sql.sql", "Table '{}' entry {} group {} has total chance > 100% ({})", lootstore.GetName(), id, group_id, chance);
 
 if (chance >= 100.0f && !EqualChanced.empty())
 TC_LOG_ERROR("sql.sql", "Table '{}' entry {} group {} has items with chance=0% but group total chance >= 100% ({})", lootstore.GetName(), id, group_id, chance);
}
 
void LootTemplate::LootGroup::CheckLootRefs(LootTemplateMap const& /*store*/, LootIdSet* ref_set) const
{
 for (LootStoreItemList::const_iterator ieItr = ExplicitlyChanced.begin(); ieItr != ExplicitlyChanced.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 (LootStoreItemList::const_iterator ieItr = EqualChanced.begin(); ieItr != EqualChanced.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);
 }
 }
}
 
//
// --------- LootTemplate ---------
//
 
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];
}
 
// Adds an entry to the group (at loading stage)
void LootTemplate::AddEntry(LootStoreItem* item)
{
 if (item->groupid > 0 && item->reference == 0) // Group
 {
 if (item->groupid >= Groups.size())
 Groups.resize(item->groupid, nullptr); // 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::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;
 }
}
 
// Rolls for every item in the template and adds the rolled items the the loot
void LootTemplate::Process(Loot& loot, bool rate, uint16 lootMode, uint8 groupId, Player const* personalLooter /*= nullptr*/) 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, personalLooter);
 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, personalLooter);
 }
 else
 {
 // Plain entries (not a reference, not grouped)
 // Chance is already checked, just add
 if (!personalLooter
 || LootItem::AllowedForPlayer(personalLooter, nullptr, item->itemid, item->needs_quest,
 !item->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(item->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 true, item->conditions))
 loot.AddItem(*item);
 }
 }
 
 // Now processing groups
 for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
 if (LootGroup* group = *i)
 group->Process(loot, lootMode, personalLooter);
}
 
void LootTemplate::ProcessPersonalLoot(std::unordered_map<Player*, std::unique_ptr<Loot>>& personalLoot, bool rate, uint16 lootMode) const
{
 auto getLootersForItem = [&personalLoot](auto&& predicate)
 {
 std::vector<Player*> lootersForItem;
 for (auto&& [looter, loot] : personalLoot)
 {
 if (predicate(looter))
 lootersForItem.push_back(looter);
 }
 return lootersForItem;
 };
 
 // Rolling non-grouped items
 for (LootStoreItem const* item : Entries)
 {
 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));
 std::vector<Player*> gotLoot;
 for (uint32 loop = 0; loop < maxcount; ++loop) // Ref multiplicator
 {
 std::vector<Player*> lootersForItem = getLootersForItem([&](Player const* looter)
 {
 return referenced->HasDropForPlayer(looter, item->groupid, true);
 });
 
 // nobody can loot this, skip it
 if (lootersForItem.empty())
 break;
 
 auto newEnd = std::remove_if(lootersForItem.begin(), lootersForItem.end(), [&](Player const* looter)
 {
 return std::find(gotLoot.begin(), gotLoot.end(), looter) != gotLoot.end();
 });
 
 if (lootersForItem.begin() == newEnd)
 {
 // if we run out of looters this means that there are more items dropped than players
 // start a new cycle adding one item to everyone
 gotLoot.clear();
 }
 else
 lootersForItem.erase(newEnd, lootersForItem.end());
 
 Player* chosenLooter = Trinity::Containers::SelectRandomContainerElement(lootersForItem);
 referenced->Process(*personalLoot[chosenLooter], rate, lootMode, item->groupid, chosenLooter);
 gotLoot.push_back(chosenLooter);
 }
 }
 else
 {
 // Plain entries (not a reference, not grouped)
 // Chance is already checked, just add
 std::vector<Player*> lootersForItem = getLootersForItem([&](Player const* looter)
 {
 return LootItem::AllowedForPlayer(looter, nullptr, item->itemid, item->needs_quest,
 !item->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(item->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 true, item->conditions);
 });
 
 if (!lootersForItem.empty())
 {
 Player* chosenLooter = Trinity::Containers::SelectRandomContainerElement(lootersForItem);
 personalLoot[chosenLooter]->AddItem(*item);
 }
 }
 }
 
 // Now processing groups
 for (LootGroup const* group : Groups)
 {
 if (group)
 {
 std::vector<Player*> lootersForGroup = getLootersForItem([&](Player const* looter)
 {
 return group->HasDropForPlayer(looter, true);
 });
 
 if (!lootersForGroup.empty())
 {
 Player* chosenLooter = Trinity::Containers::SelectRandomContainerElement(lootersForGroup);
 group->Process(*personalLoot[chosenLooter], lootMode);
 }
 }
 }
}
 
// True if template includes at least 1 drop for the player
bool LootTemplate::HasDropForPlayer(Player const* player, uint8 groupId, bool strictUsabilityCheck) 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]->HasDropForPlayer(player, strictUsabilityCheck);
 }
 
 // Checking non-grouped entries
 for (LootStoreItem* lootStoreItem : Entries)
 {
 if (lootStoreItem->reference > 0) // References processing
 {
 LootTemplate const* referenced = LootTemplates_Reference.GetLootFor(lootStoreItem->reference);
 if (!referenced)
 continue; // Error message already printed at loading stage
 if (referenced->HasDropForPlayer(player, lootStoreItem->groupid, strictUsabilityCheck))
 return true;
 }
 else if (LootItem::AllowedForPlayer(player, nullptr, lootStoreItem->itemid, lootStoreItem->needs_quest,
 !lootStoreItem->needs_quest || ASSERT_NOTNULL(sObjectMgr->GetItemTemplate(lootStoreItem->itemid))->HasFlag(ITEM_FLAGS_CU_FOLLOW_LOOT_RULES),
 strictUsabilityCheck, lootStoreItem->conditions))
 return true; // active quest drop found
 }
 
 // Now checking groups
 for (LootGroup* group : Groups)
 if (group)
 if (group->HasDropForPlayer(player, strictUsabilityCheck))
 return true;
 
 return false;
}
 
// True if template includes at least 1 quest drop entry
bool LootTemplate::HasQuestDrop(LootTemplateMap const& store, uint8 groupId) 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;
}
 
// True if template includes at least 1 quest drop for an active quest of the player
bool LootTemplate::HasQuestDropForPlayer(LootTemplateMap const& store, Player const* player, uint8 groupId) 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;
}
 
// Checks integrity of the template
void LootTemplate::Verify(LootStore const& lootstore, uint32 id) const
{
 // Checking group chances
 for (uint32 i = 0; i < Groups.size(); ++i)
 if (Groups[i])
 Groups[i]->Verify(lootstore, id, i + 1);
 
}
 
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);
}
 
bool LootTemplate::LinkConditions(ConditionId const& id, ConditionsReference reference)
{
 if (!Entries.empty())
 {
 for (LootStoreItem* item : Entries)
 {
 if (item->itemid == uint32(id.SourceEntry))
 {
 item->conditions = std::move(reference);
 return true;
 }
 }
 }
 
 if (!Groups.empty())
 {
 for (LootGroup* group : Groups)
 {
 if (!group)
 continue;
 
 LootStoreItemList* itemList = group->GetExplicitlyChancedItemList();
 if (!itemList->empty())
 {
 for (LootStoreItem* item : *itemList)
 {
 if (item->itemid == uint32(id.SourceEntry))
 {
 item->conditions = std::move(reference);
 return true;
 }
 }
 }
 
 itemList = group->GetEqualChancedItemList();
 if (!itemList->empty())
 {
 for (LootStoreItem* item : *itemList)
 {
 if (item->itemid == uint32(id.SourceEntry))
 {
 item->conditions = std::move(reference);
 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
}
 
std::unordered_map<ObjectGuid, std::unique_ptr<Loot>> GenerateDungeonEncounterPersonalLoot(uint32 dungeonEncounterId, uint32 lootId, LootStore const& store,
 LootType type, WorldObject const* lootOwner, uint32 minMoney, uint32 maxMoney, uint16 lootMode, MapDifficultyEntry const* mapDifficulty,
 std::vector<Player*> const& tappers)
{
 std::unordered_map<Player*, std::unique_ptr<Loot>> tempLoot;
 
 for (Player* tapper : tappers)
 {
 if (tapper->IsLockedToDungeonEncounter(dungeonEncounterId))
 continue;
 
 std::unique_ptr<Loot>& loot = tempLoot[tapper];
 loot.reset(new Loot(lootOwner->GetMap(), lootOwner->GetGUID(), type, nullptr));
 loot->SetItemContext(ItemBonusMgr::GetContextForPlayer(mapDifficulty, tapper));
 loot->SetDungeonEncounterId(dungeonEncounterId);
 loot->generateMoneyLoot(minMoney, maxMoney);
 }
 
 if (LootTemplate const* tab = store.GetLootFor(lootId))
 tab->ProcessPersonalLoot(tempLoot, store.IsRatesAllowed(), lootMode);
 
 std::unordered_map<ObjectGuid, std::unique_ptr<Loot>> personalLoot;
 for (auto&& [looter, loot] : tempLoot)
 {
 loot->FillNotNormalLootFor(looter);
 
 if (loot->isLooted())
 continue;
 
 personalLoot[looter->GetGUID()] = std::move(loot);
 }
 
 return personalLoot;
}
 
void LoadLootTemplates_Creature()
{
 TC_LOG_INFO("server.loading", "Loading creature loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet, lootIdSetUsed;
 uint32 count = LootTemplates_Creature.LoadAndCollectLootIds(lootIdSet);
 
 // Remove real entries and check loot existence
 CreatureTemplateContainer const& ctc = sObjectMgr->GetCreatureTemplates();
 for (auto const& creatureTemplatePair : ctc)
 {
 for (auto const& [difficulty, creatureDifficulty] : creatureTemplatePair.second.difficultyStore)
 {
 if (uint32 lootid = creatureDifficulty.LootID)
 {
 if (!lootIdSet.count(lootid))
 LootTemplates_Creature.ReportNonExistingId(lootid, "Creature", creatureTemplatePair.first);
 else
 lootIdSetUsed.insert(lootid);
 }
 }
 }
 
 for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
 lootIdSet.erase(*itr);
 
 // 1 means loot for player corpse
 lootIdSet.erase(PLAYER_CORPSE_LOOT_ENTRY);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Creature.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} creature loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 creature loot templates. DB table `creature_loot_template` is empty");
}
 
void LoadLootTemplates_Disenchant()
{
 TC_LOG_INFO("server.loading", "Loading disenchanting loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet, lootIdSetUsed;
 uint32 count = LootTemplates_Disenchant.LoadAndCollectLootIds(lootIdSet);
 
 for (ItemDisenchantLootEntry const* disenchant : sItemDisenchantLootStore)
 {
 uint32 lootid = disenchant->ID;
 if (lootIdSet.find(lootid) == lootIdSet.end())
 LootTemplates_Disenchant.ReportNonExistingId(lootid);
 else
 lootIdSetUsed.insert(lootid);
 }
 
 for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
 lootIdSet.erase(*itr);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Disenchant.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} disenchanting loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 disenchanting loot templates. DB table `disenchant_loot_template` is empty");
}
 
void LoadLootTemplates_Fishing()
{
 TC_LOG_INFO("server.loading", "Loading fishing loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Fishing.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 for (AreaTableEntry const* areaTable : sAreaTableStore)
 if (lootIdSet.find(areaTable->ID) != lootIdSet.end())
 lootIdSet.erase(areaTable->ID);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Fishing.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} fishing loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 fishing loot templates. DB table `fishing_loot_template` is empty");
}
 
void LoadLootTemplates_Gameobject()
{
 TC_LOG_INFO("server.loading", "Loading gameobject loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet, lootIdSetUsed;
 uint32 count = LootTemplates_Gameobject.LoadAndCollectLootIds(lootIdSet);
 
 auto checkLootId = [&](uint32 lootId, uint32 gameObjectId)
 {
 if (!lootIdSet.count(lootId))
 LootTemplates_Gameobject.ReportNonExistingId(lootId, "Gameobject", gameObjectId);
 else
 lootIdSetUsed.insert(lootId);
 };
 
 // remove real entries and check existence loot
 GameObjectTemplateContainer const& gotc = sObjectMgr->GetGameObjectTemplates();
 for (auto const& [gameObjectId, gameObjectTemplate] : gotc)
 {
 if (uint32 lootid = gameObjectTemplate.GetLootId())
 checkLootId(lootid, gameObjectId);
 
 if (gameObjectTemplate.type == GAMEOBJECT_TYPE_CHEST)
 {
 if (gameObjectTemplate.chest.chestPersonalLoot)
 checkLootId(gameObjectTemplate.chest.chestPersonalLoot, gameObjectId);
 
 if (gameObjectTemplate.chest.chestPushLoot)
 checkLootId(gameObjectTemplate.chest.chestPushLoot, gameObjectId);
 }
 }
 
 for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
 lootIdSet.erase(*itr);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Gameobject.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} gameobject loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 gameobject loot templates. DB table `gameobject_loot_template` is empty");
}
 
void LoadLootTemplates_Item()
{
 TC_LOG_INFO("server.loading", "Loading item loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Item.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 ItemTemplateContainer const& its = sObjectMgr->GetItemTemplateStore();
 for (auto const& itemTemplatePair : its)
 if (lootIdSet.count(itemTemplatePair.first) > 0 && itemTemplatePair.second.HasFlag(ITEM_FLAG_HAS_LOOT))
 lootIdSet.erase(itemTemplatePair.first);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Item.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} item loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 item loot templates. DB table `item_loot_template` is empty");
}
 
void LoadLootTemplates_Milling()
{
 TC_LOG_INFO("server.loading", "Loading milling loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Milling.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 ItemTemplateContainer const& its = sObjectMgr->GetItemTemplateStore();
 for (auto const& itemTemplatePair : its)
 {
 if (!itemTemplatePair.second.HasFlag(ITEM_FLAG_IS_MILLABLE))
 continue;
 
 if (lootIdSet.count(itemTemplatePair.first) > 0)
 lootIdSet.erase(itemTemplatePair.first);
 }
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Milling.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} milling loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 milling loot templates. DB table `milling_loot_template` is empty");
}
 
void LoadLootTemplates_Pickpocketing()
{
 TC_LOG_INFO("server.loading", "Loading pickpocketing loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet, lootIdSetUsed;
 uint32 count = LootTemplates_Pickpocketing.LoadAndCollectLootIds(lootIdSet);
 
 // Remove real entries and check loot existence
 CreatureTemplateContainer const& ctc = sObjectMgr->GetCreatureTemplates();
 for (auto const& creatureTemplatePair : ctc)
 {
 for (auto const& [difficulty, creatureDifficulty] : creatureTemplatePair.second.difficultyStore)
 {
 if (uint32 lootid = creatureDifficulty.PickPocketLootID)
 {
 if (!lootIdSet.count(lootid))
 LootTemplates_Pickpocketing.ReportNonExistingId(lootid, "Creature", creatureTemplatePair.first);
 else
 lootIdSetUsed.insert(lootid);
 }
 }
 }
 
 for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
 lootIdSet.erase(*itr);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Pickpocketing.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} pickpocketing loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 pickpocketing loot templates. DB table `pickpocketing_loot_template` is empty");
}
 
void LoadLootTemplates_Prospecting()
{
 TC_LOG_INFO("server.loading", "Loading prospecting loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Prospecting.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 ItemTemplateContainer const& its = sObjectMgr->GetItemTemplateStore();
 for (auto const& itemTemplatePair : its)
 {
 if (!itemTemplatePair.second.HasFlag(ITEM_FLAG_IS_PROSPECTABLE))
 continue;
 
 if (lootIdSet.count(itemTemplatePair.first) > 0)
 lootIdSet.erase(itemTemplatePair.first);
 }
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Prospecting.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} prospecting loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 prospecting loot templates. DB table `prospecting_loot_template` is empty");
}
 
void LoadLootTemplates_Mail()
{
 TC_LOG_INFO("server.loading", "Loading mail loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Mail.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 for (uint32 i = 1; i < sMailTemplateStore.GetNumRows(); ++i)
 if (sMailTemplateStore.LookupEntry(i))
 if (lootIdSet.find(i) != lootIdSet.end())
 lootIdSet.erase(i);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Mail.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} mail loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 mail loot templates. DB table `mail_loot_template` is empty");
}
 
void LoadLootTemplates_Skinning()
{
 TC_LOG_INFO("server.loading", "Loading skinning loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet, lootIdSetUsed;
 uint32 count = LootTemplates_Skinning.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 CreatureTemplateContainer const& ctc = sObjectMgr->GetCreatureTemplates();
 for (auto const& creatureTemplatePair : ctc)
 {
 for (auto const& [difficulty, creatureDifficulty] : creatureTemplatePair.second.difficultyStore)
 {
 if (uint32 lootid = creatureDifficulty.SkinLootID)
 {
 if (!lootIdSet.count(lootid))
 LootTemplates_Skinning.ReportNonExistingId(lootid, "Creature", creatureTemplatePair.first);
 else
 lootIdSetUsed.insert(lootid);
 }
 }
 }
 
 for (LootIdSet::const_iterator itr = lootIdSetUsed.begin(); itr != lootIdSetUsed.end(); ++itr)
 lootIdSet.erase(*itr);
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Skinning.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} skinning loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 skinning loot templates. DB table `skinning_loot_template` is empty");
}
 
void LoadLootTemplates_Spell()
{
 // TODO: change this to use MiscValue from spell effect as id instead of spell id
 TC_LOG_INFO("server.loading", "Loading spell loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 uint32 count = LootTemplates_Spell.LoadAndCollectLootIds(lootIdSet);
 
 // remove real entries and check existence loot
 for (SpellNameEntry const* spellNameEntry : sSpellNameStore)
 {
 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellNameEntry->ID, DIFFICULTY_NONE);
 if (!spellInfo)
 continue;
 
 // possible cases
 if (!spellInfo->IsLootCrafting())
 continue;
 
 if (lootIdSet.find(spellInfo->Id) == lootIdSet.end())
 {
 // not report about not trainable spells (optionally supported by DB)
 // ignore 61756 (Northrend Inscription Research (FAST QA VERSION) for example
 if (!spellInfo->HasAttribute(SPELL_ATTR0_NOT_SHAPESHIFTED) || spellInfo->HasAttribute(SPELL_ATTR0_IS_TRADESKILL))
 LootTemplates_Spell.ReportNonExistingId(spellInfo->Id, "Spell", spellInfo->Id);
 }
 else
 lootIdSet.erase(spellInfo->Id);
 }
 
 // output error for any still listed (not referenced from appropriate table) ids
 LootTemplates_Spell.ReportUnusedIds(lootIdSet);
 
 if (count)
 TC_LOG_INFO("server.loading", ">> Loaded {} spell loot templates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
 else
 TC_LOG_INFO("server.loading", ">> Loaded 0 spell loot templates. DB table `spell_loot_template` is empty");
}
 
void LoadLootTemplates_Reference()
{
 TC_LOG_INFO("server.loading", "Loading reference loot templates...");
 
 uint32 oldMSTime = getMSTime();
 
 LootIdSet lootIdSet;
 LootTemplates_Reference.LoadAndCollectLootIds(lootIdSet);
 
 // check references and remove used
 LootTemplates_Creature.CheckLootRefs(&lootIdSet);
 LootTemplates_Fishing.CheckLootRefs(&lootIdSet);
 LootTemplates_Gameobject.CheckLootRefs(&lootIdSet);
 LootTemplates_Item.CheckLootRefs(&lootIdSet);
 LootTemplates_Milling.CheckLootRefs(&lootIdSet);
 LootTemplates_Pickpocketing.CheckLootRefs(&lootIdSet);
 LootTemplates_Skinning.CheckLootRefs(&lootIdSet);
 LootTemplates_Disenchant.CheckLootRefs(&lootIdSet);
 LootTemplates_Prospecting.CheckLootRefs(&lootIdSet);
 LootTemplates_Mail.CheckLootRefs(&lootIdSet);
 LootTemplates_Reference.CheckLootRefs(&lootIdSet);
 
 // output error for any still listed ids (not referenced from any loot table)
 LootTemplates_Reference.ReportUnusedIds(lootIdSet);
 
 TC_LOG_INFO("server.loading", ">> Loaded reference loot templates in {} ms", GetMSTimeDiffToNow(oldMSTime));
}
 
void LoadLootTables()
{
 LoadLootTemplates_Creature();
 LoadLootTemplates_Fishing();
 LoadLootTemplates_Gameobject();
 LoadLootTemplates_Item();
 LoadLootTemplates_Mail();
 LoadLootTemplates_Milling();
 LoadLootTemplates_Pickpocketing();
 LoadLootTemplates_Skinning();
 LoadLootTemplates_Disenchant();
 LoadLootTemplates_Prospecting();
 LoadLootTemplates_Spell();
 
 LoadLootTemplates_Reference();
}