LootItemStorage Class Reference

#include "LootItemStorage.h"

Public Member Functions
void	LoadStorageFromDB ()
void	RemoveEntryFromDB (ObjectGuid containerGUID, uint32 itemid, uint32 count, uint32 itemIndex)
void	AddNewStoredLoot (Loot *loot, Player *player)
bool	LoadStoredLoot (Item *item, Player *player)
void	RemoveStoredLootItem (ObjectGuid containerGUID, uint32 itemid, uint32 count, Loot *loot, uint32 itemIndex)
void	RemoveStoredLootMoney (ObjectGuid containerGUID, Loot *loot)
void	RemoveStoredLoot (ObjectGuid containerGUID)

Static Public Member Functions
static LootItemStorage *	instance ()

Private Member Functions
	LootItemStorage ()
	~LootItemStorage ()

Private Attributes
LootItemContainer	lootItemStore

Detailed Description

Constructor & Destructor Documentation

LootItemStorage()

LootItemStorage::LootItemStorage ( )

private

{
}

~LootItemStorage()

LootItemStorage::~LootItemStorage ( )

private

{
}

Member Function Documentation

AddNewStoredLoot()

void LootItemStorage::AddNewStoredLoot	(	Loot *	loot,
		Player *	player
	)

{
    if (lootItemStore.find(loot->containerGUID) != lootItemStore.end())
    {
        LOG_INFO("misc", "LootItemStorage::AddNewStoredLoot (A1) - {}!", loot->containerGUID.ToString());
        return;
    }
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    CharacterDatabasePreparedStatement* stmt = nullptr;
 
    StoredLootItemList& itemList = lootItemStore[loot->containerGUID];
 
    // Gold at first
    if (loot->gold)
    {
        itemList.push_back(StoredLootItem(0, 0, loot->gold, 0, 0, false, false, false, false, false, false, 0));
 
        uint8 index = 0;
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEMCONTAINER_SINGLE_ITEM);
        stmt->SetData(index++, loot->containerGUID.GetCounter());
        stmt->SetData(index++, 0);
        stmt->SetData(index++, 0);
        stmt->SetData(index++, loot->gold);
        stmt->SetData(index++, 0);
        stmt->SetData(index++, 0);
        stmt->SetData(index++, false);
        stmt->SetData(index++, false);
        stmt->SetData(index++, false);
        stmt->SetData(index++, false);
        stmt->SetData(index++, false);
        stmt->SetData(index++, false);
        stmt->SetData(index++, 0);
        trans->Append(stmt);
    }
 
    // And normal items
    if (!loot->isLooted())
        for (LootItemList::const_iterator li = loot->items.begin(); li != loot->items.end(); li++)
        {
            // Even if an item is not available for a specific player, it doesn't mean that
            // we are not able to trade this container to another player that is able to loot that item
            // if we don't save it then the item will be lost at player re-login.
            //if (!li->AllowedForPlayer(player))
            //    continue;
 
            ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(li->itemid);
            if (!itemTemplate || itemTemplate->IsCurrencyToken())
                continue;
 
            uint32 conditionLootId = 0;
            if (!li->conditions.empty())
            {
                conditionLootId = li->conditions.front()->SourceGroup;
            }
 
            itemList.push_back(StoredLootItem(li->itemid, li->itemIndex, li->count, li->randomPropertyId, li->randomSuffix, li->follow_loot_rules, li->freeforall, li->is_blocked, li->is_counted,
                li->is_underthreshold, li->needs_quest, conditionLootId));
 
            uint8 index = 0;
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ITEMCONTAINER_SINGLE_ITEM);
            stmt->SetData(index++, loot->containerGUID.GetCounter());
            stmt->SetData(index++, li->itemid);
            stmt->SetData(index++, li->itemIndex);
            stmt->SetData(index++, li->count);
            stmt->SetData (index++, li->randomPropertyId);
            stmt->SetData(index++, li->randomSuffix);
            stmt->SetData(index++, li->follow_loot_rules);
            stmt->SetData(index++, li->freeforall);
            stmt->SetData(index++, li->is_blocked);
            stmt->SetData(index++, li->is_counted);
            stmt->SetData(index++, li->is_underthreshold);
            stmt->SetData(index++, li->needs_quest);
            stmt->SetData(index++, conditionLootId);
 
            trans->Append(stmt);
        }
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_INS_ITEMCONTAINER_SINGLE_ITEM, CharacterDatabase, Loot::containerGUID, ObjectGuid::GetCounter(), Loot::gold, ItemTemplate::IsCurrencyToken(), Loot::isLooted(), Loot::items, LOG_INFO, lootItemStore, PreparedStatementBase::SetData(), sObjectMgr, and ObjectGuid::ToString().

instance()

LootItemStorage * LootItemStorage::instance ( )

static

{
    static LootItemStorage instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadStorageFromDB()

void LootItemStorage::LoadStorageFromDB

(

)

{
    uint32 oldMSTime = getMSTime();
    lootItemStore.clear();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ITEMCONTAINER_ITEMS);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 stored items!");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        StoredLootItemList& itemList = lootItemStore[ObjectGuid::Create<HighGuid::Item>(fields[0].Get<uint32>())];
        itemList.push_back(StoredLootItem(fields[1].Get<uint32>(), fields[2].Get<uint32>(), fields[3].Get<uint32>(), fields[4].Get<int32>(), fields[5].Get<uint32>(), fields[6].Get<bool>(),
            fields[7].Get<bool>(), fields[8].Get<bool>(), fields[9].Get<bool>(), fields[10].Get<bool>(), fields[11].Get<bool>(), fields[12].Get<uint32>()));
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} stored items in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References CHAR_SEL_ITEMCONTAINER_ITEMS, CharacterDatabase, getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, LOG_WARN, and lootItemStore.

LoadStoredLoot()

bool LootItemStorage::LoadStoredLoot	(	Item *	item,
		Player *	player
	)

{
    ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item->GetEntry());
    if (!proto)
    {
        return false;
    }
 
    Loot* loot = &item->loot;
    LootItemContainer::iterator itr = lootItemStore.find(loot->containerGUID);
    if (itr == lootItemStore.end())
        return false;
 
    StoredLootItemList& itemList = itr->second;
    for (StoredLootItemList::iterator it2 = itemList.begin(); it2 != itemList.end(); ++it2)
    {
        if (it2->itemid == 0)
        {
            loot->gold = it2->count;
            continue;
        }
 
        if (LootTemplate const* lt = LootTemplates_Item.GetLootFor(item->GetEntry()))
        {
            LootItem li;
            li.itemid = it2->itemid;
            li.itemIndex = it2->itemIndex;
            li.count = it2->count;
            li.follow_loot_rules = it2->follow_loot_rules;
            li.freeforall = it2->freeforall;
            li.is_blocked = it2->is_blocked;
            li.is_counted = it2->is_counted;
            li.is_underthreshold = it2->is_underthreshold;
            li.is_looted = false;
            li.needs_quest = it2->needs_quest;
            li.randomPropertyId = it2->randomPropertyId;
            li.randomSuffix = it2->randomSuffix;
            li.rollWinnerGUID = ObjectGuid::Empty;
            li.groupid = 0;
 
            // Copy the extra loot conditions from the item in the loot template
            lt->CopyConditions(&li, it2->conditionLootId);
 
            if (li.needs_quest)
            {
                loot->quest_items.push_back(li);
            }
            else
            {
                loot->items.push_back(li);
            }
 
            // 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 ((!li.needs_quest && li.conditions.empty() && !(proto->Flags & ITEM_FLAG_MULTI_DROP)) || li.is_counted)
            {
                ++loot->unlootedCount;
            }
        }
    }
 
    if (loot->unlootedCount)
    {
        loot->FillNotNormalLootFor(player);
    }
 
    // Mark the item if it has loot so it won't be generated again on open
    item->m_lootGenerated = true;
    return true;
}

References LootItem::conditions, Loot::containerGUID, LootItem::count, ObjectGuid::Empty, Loot::FillNotNormalLootFor(), ItemTemplate::Flags, LootItem::follow_loot_rules, LootItem::freeforall, Object::GetEntry(), LootStore::GetLootFor(), Loot::gold, LootItem::groupid, LootItem::is_blocked, LootItem::is_counted, LootItem::is_looted, LootItem::is_underthreshold, ITEM_FLAG_MULTI_DROP, LootItem::itemid, LootItem::itemIndex, Loot::items, Item::loot, lootItemStore, LootTemplates_Item, Item::m_lootGenerated, LootItem::needs_quest, Loot::quest_items, LootItem::randomPropertyId, LootItem::randomSuffix, LootItem::rollWinnerGUID, sObjectMgr, and Loot::unlootedCount.

RemoveEntryFromDB()

void LootItemStorage::RemoveEntryFromDB	(	ObjectGuid	containerGUID,
		uint32	itemid,
		uint32	count,
		uint32	itemIndex
	)

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEMCONTAINER_SINGLE_ITEM);
    stmt->SetData(0, containerGUID.GetCounter());
    stmt->SetData(1, itemid);
    stmt->SetData(2, count);
    stmt->SetData(3, itemIndex);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_ITEMCONTAINER_SINGLE_ITEM, CharacterDatabase, ObjectGuid::GetCounter(), and PreparedStatementBase::SetData().

Referenced by RemoveStoredLootItem(), and RemoveStoredLootMoney().

RemoveStoredLoot()

void LootItemStorage::RemoveStoredLoot

(

ObjectGuid

containerGUID

)

{
    lootItemStore.erase(containerGUID);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEMCONTAINER_CONTAINER);
    stmt->SetData(0, containerGUID.GetCounter());
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_ITEMCONTAINER_CONTAINER, CharacterDatabase, ObjectGuid::GetCounter(), lootItemStore, and PreparedStatementBase::SetData().

RemoveStoredLootItem()

void LootItemStorage::RemoveStoredLootItem	(	ObjectGuid	containerGUID,
		uint32	itemid,
		uint32	count,
		Loot *	loot,
		uint32	itemIndex
	)

{
    LootItemContainer::iterator itr = lootItemStore.find(containerGUID);
    if (itr == lootItemStore.end())
        return;
 
    StoredLootItemList& itemList = itr->second;
    for (StoredLootItemList::iterator it2 = itemList.begin(); it2 != itemList.end(); ++it2)
        if (it2->itemid == itemid && it2->count == count)
        {
            RemoveEntryFromDB(containerGUID, itemid, count, itemIndex);
            itemList.erase(it2);
            break;
        }
 
    // loot with empty itemList but unlootedCount > 0
    // must be deleted manually by the player or traded
    if (!loot->unlootedCount)
        lootItemStore.erase(itr);
}

References lootItemStore, RemoveEntryFromDB(), and Loot::unlootedCount.

RemoveStoredLootMoney()

void LootItemStorage::RemoveStoredLootMoney	(	ObjectGuid	containerGUID,
		Loot *	loot
	)

{
    LootItemContainer::iterator itr = lootItemStore.find(containerGUID);
    if (itr == lootItemStore.end())
        return;
 
    StoredLootItemList& itemList = itr->second;
    for (StoredLootItemList::iterator it2 = itemList.begin(); it2 != itemList.end(); ++it2)
        if (it2->itemid == 0)
        {
            RemoveEntryFromDB(containerGUID, 0, it2->count, 0);
            itemList.erase(it2);
            break;
        }
 
    // loot with empty itemList but unlootedCount > 0
    // must be deleted manually by the player or traded
    if (!loot->unlootedCount)
        lootItemStore.erase(itr);
}

References lootItemStore, RemoveEntryFromDB(), and Loot::unlootedCount.

Member Data Documentation

lootItemStore

LootItemContainer LootItemStorage::lootItemStore

private

Referenced by AddNewStoredLoot(), LoadStorageFromDB(), LoadStoredLoot(), RemoveStoredLoot(), RemoveStoredLootItem(), and RemoveStoredLootMoney().