AuctionHouseObject Class Reference

#include "AuctionHouseMgr.h"

Public Types
typedef std::map< uint32, AuctionEntry * >	AuctionEntryMap

Public Member Functions
	AuctionHouseObject ()
	~AuctionHouseObject ()
uint32	Getcount () const
AuctionEntryMap::iterator	GetAuctionsBegin ()
AuctionEntryMap::iterator	GetAuctionsEnd ()
AuctionEntryMap const &	GetAuctions ()
AuctionEntry *	GetAuction (uint32 id) const
void	AddAuction (AuctionEntry *auction)
bool	RemoveAuction (AuctionEntry *auction)
void	Update ()
void	BuildListBidderItems (WorldPacket &data, Player *player, uint32 &count, uint32 &totalcount)
void	BuildListOwnerItems (WorldPacket &data, Player *player, uint32 &count, uint32 &totalcount)
bool	BuildListAuctionItems (WorldPacket &data, Player *player, std::wstring const &searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, uint8 usable, uint32 inventoryType, uint32 itemClass, uint32 itemSubClass, uint32 quality, uint32 &count, uint32 &totalcount, uint8 getAll, AuctionSortOrderVector const &sortOrder)

Private Attributes
AuctionEntryMap	_auctionsMap
AuctionEntryMap::const_iterator	_next

Detailed Description

Member Typedef Documentation

AuctionEntryMap

typedef std::map<uint32, AuctionEntry*> AuctionHouseObject::AuctionEntryMap

Constructor & Destructor Documentation

AuctionHouseObject()

AuctionHouseObject::AuctionHouseObject ( )

inline

{ _next = _auctionsMap.begin(); }

References _auctionsMap, and _next.

~AuctionHouseObject()

AuctionHouseObject::~AuctionHouseObject ( )

inline

    {
        for (auto & itr : _auctionsMap)
            delete itr.second;
    }

References _auctionsMap.

Member Function Documentation

AddAuction()

void AuctionHouseObject::AddAuction

(

AuctionEntry *

auction

)

{
    ASSERT(auction);
 
    _auctionsMap[auction->Id] = auction;
    sScriptMgr->OnAuctionAdd(this, auction);
}

References _auctionsMap, ASSERT, AuctionEntry::Id, and sScriptMgr.

Referenced by WorldSession::HandleAuctionSellItem(), and AuctionHouseMgr::LoadAuctions().

BuildListAuctionItems()

bool AuctionHouseObject::BuildListAuctionItems	(	WorldPacket &	data,
		Player *	player,
		std::wstring const &	searchedname,
		uint32	listfrom,
		uint8	levelmin,
		uint8	levelmax,
		uint8	usable,
		uint32	inventoryType,
		uint32	itemClass,
		uint32	itemSubClass,
		uint32	quality,
		uint32 &	count,
		uint32 &	totalcount,
		uint8	getAll,
		AuctionSortOrderVector const &	sortOrder
	)

{
    uint32 itrcounter = 0;
 
    // Ensures that listfrom is not greater that auctions count
    listfrom = std::min(listfrom, static_cast<uint32>(GetAuctions().size()));
 
    std::vector<AuctionEntry*> auctionShortlist;
 
    // pussywizard: optimization, this is a simplified case
    if (itemClass == 0xffffffff && itemSubClass == 0xffffffff && inventoryType == 0xffffffff && quality == 0xffffffff && levelmin == 0x00 && levelmax == 0x00 && usable == 0x00 && wsearchedname.empty())
    {
        auto itr = GetAuctionsBegin();
        for (; itr != GetAuctionsEnd(); ++itr)
        {
            auctionShortlist.push_back(itr->second);
        }
    }
    else
    {
        auto curTime = GameTime::GetGameTime();
 
        int loc_idx = player->GetSession()->GetSessionDbLocaleIndex();
        int locdbc_idx = player->GetSession()->GetSessionDbcLocale();
 
        for (AuctionEntryMap::const_iterator itr = _auctionsMap.begin(); itr != _auctionsMap.end(); ++itr)
        {
            if (!AsyncAuctionListingMgr::IsAuctionListingAllowed())                                                    // pussywizard: World::Update is waiting for us...
            {
                if ((itrcounter++) % 100 == 0) // check condition every 100 iterations
                {
                    if (sWorldUpdateTime.GetAverageUpdateTime() >= 30 || GetMSTimeDiff(GameTime::GetGameTimeMS(), GetTimeMS()) >= 10ms) // pussywizard: stop immediately if diff is high or waiting too long
                    {
                        return false;
                    }
                }
            }
 
            AuctionEntry* Aentry = itr->second;
            // Skip expired auctions
            if (Aentry->expire_time < curTime.count())
            {
                continue;
            }
 
            Item* item = sAuctionMgr->GetAItem(Aentry->item_guid);
            if (!item)
            {
                continue;
            }
 
            ItemTemplate const* proto = item->GetTemplate();
            if (itemClass != 0xffffffff && proto->Class != itemClass)
            {
                continue;
            }
 
            if (itemSubClass != 0xffffffff && proto->SubClass != itemSubClass)
            {
                continue;
            }
 
            if (inventoryType != 0xffffffff && proto->InventoryType != inventoryType)
            {
                // xinef: exception, robes are counted as chests
                if (inventoryType != INVTYPE_CHEST || proto->InventoryType != INVTYPE_ROBE)
                {
                    continue;
                }
            }
 
            if (quality != 0xffffffff && proto->Quality < quality)
            {
                continue;
            }
 
            if (levelmin != 0x00 && (proto->RequiredLevel < levelmin || (levelmax != 0x00 && proto->RequiredLevel > levelmax)))
            {
                continue;
            }
 
            if (usable != 0x00)
            {
                if (player->CanUseItem(item) != EQUIP_ERR_OK)
                {
                    continue;
                }
 
                // xinef: check already learded recipes and pets
                if (proto->Spells[1].SpellTrigger == ITEM_SPELLTRIGGER_LEARN_SPELL_ID && player->HasSpell(proto->Spells[1].SpellId))
                {
                    continue;
                }
            }
 
            // Allow search by suffix (ie: of the Monkey) or partial name (ie: Monkey)
            // No need to do any of this if no search term was entered
            if (!wsearchedname.empty())
            {
                std::string name = proto->Name1;
                if (name.empty())
                {
                    continue;
                }
 
                // local name
                if (loc_idx >= 0)
                    if (ItemLocale const* il = sObjectMgr->GetItemLocale(proto->ItemId))
                        ObjectMgr::GetLocaleString(il->Name, loc_idx, name);
 
                // DO NOT use GetItemEnchantMod(proto->RandomProperty) as it may return a result
                //  that matches the search but it may not equal item->GetItemRandomPropertyId()
                //  used in BuildAuctionInfo() which then causes wrong items to be listed
                int32 propRefID = item->GetItemRandomPropertyId();
 
                if (propRefID)
                {
                    // Append the suffix to the name (ie: of the Monkey) if one exists
                    // These are found in ItemRandomSuffix.dbc and ItemRandomProperties.dbc
                    // even though the DBC name seems misleading
                    std::array<char const*, 16> const* suffix = nullptr;
 
                    if (propRefID < 0)
                    {
                        ItemRandomSuffixEntry const* itemRandEntry = sItemRandomSuffixStore.LookupEntry(-item->GetItemRandomPropertyId());
                        if (itemRandEntry)
                            suffix = &itemRandEntry->Name;
                    }
                    else
                    {
                        ItemRandomPropertiesEntry const* itemRandEntry = sItemRandomPropertiesStore.LookupEntry(item->GetItemRandomPropertyId());
                        if (itemRandEntry)
                            suffix = &itemRandEntry->Name;
                    }
 
                    // dbc local name
                    if (suffix)
                    {
                        // Append the suffix (ie: of the Monkey) to the name using localization
                        // or default enUS if localization is invalid
                        name += ' ';
                        name += (*suffix)[locdbc_idx >= 0 ? locdbc_idx : LOCALE_enUS];
                    }
                }
 
                // Perform the search (with or without suffix)
                if (!Utf8FitTo(name, wsearchedname))
                {
                    continue;
                }
            }
 
            auctionShortlist.push_back(Aentry);
        }
    }
 
    if (auctionShortlist.empty())
    {
        return true;
    }
 
    // Check if sort enabled, and first sort column is valid, if not don't sort
    if (!sortOrder.empty())
    {
        AuctionSortInfo const& sortInfo = *sortOrder.begin();
        if (sortInfo.sortOrder >= AUCTION_SORT_MINLEVEL && sortInfo.sortOrder < AUCTION_SORT_MAX && sortInfo.sortOrder != AUCTION_SORT_UNK4)
        {
            // Partial sort to improve performance a bit, but the last pages will burn
            if (listfrom + 50 <= auctionShortlist.size())
            {
                std::partial_sort(auctionShortlist.begin(), auctionShortlist.begin() + listfrom + 50, auctionShortlist.end(),
                    std::bind(SortAuction, std::placeholders::_1, std::placeholders::_2, sortOrder, player, sortInfo.sortOrder == AUCTION_SORT_BID));
            }
            else
            {
                std::sort(auctionShortlist.begin(), auctionShortlist.end(), std::bind(SortAuction, std::placeholders::_1, std::placeholders::_2, sortOrder,
                    player, sortInfo.sortOrder == AUCTION_SORT_BID));
            }
        }
    }
 
    for (auto auction : auctionShortlist)
    {
        // Add the item if no search term or if entered search term was found
        if (count < 50 && totalcount >= listfrom)
        {
            Item* item = sAuctionMgr->GetAItem(auction->item_guid);
            if (!item)
            {
                continue;
            }
 
            ++count;
            auction->BuildAuctionInfo(data);
        }
        ++totalcount;
    }
 
    return true;
}

References _auctionsMap, AUCTION_SORT_BID, AUCTION_SORT_MAX, AUCTION_SORT_MINLEVEL, AUCTION_SORT_UNK4, Player::CanUseItem(), ItemTemplate::Class, EQUIP_ERR_OK, AuctionEntry::expire_time, GetAuctions(), GetAuctionsBegin(), GetAuctionsEnd(), UpdateTime::GetAverageUpdateTime(), GameTime::GetGameTime(), GameTime::GetGameTimeMS(), Item::GetItemRandomPropertyId(), ObjectMgr::GetLocaleString(), GetMSTimeDiff(), Player::GetSession(), WorldSession::GetSessionDbcLocale(), WorldSession::GetSessionDbLocaleIndex(), Item::GetTemplate(), GetTimeMS(), Player::HasSpell(), ItemTemplate::InventoryType, INVTYPE_CHEST, INVTYPE_ROBE, AsyncAuctionListingMgr::IsAuctionListingAllowed(), AuctionEntry::item_guid, ITEM_SPELLTRIGGER_LEARN_SPELL_ID, ItemTemplate::ItemId, LOCALE_enUS, ItemRandomPropertiesEntry::Name, ItemRandomSuffixEntry::Name, ItemTemplate::Name1, ItemTemplate::Quality, ItemTemplate::RequiredLevel, sAuctionMgr, sItemRandomPropertiesStore, sItemRandomSuffixStore, sObjectMgr, SortAuction(), AuctionSortInfo::sortOrder, _Spell::SpellId, ItemTemplate::Spells, _Spell::SpellTrigger, ItemTemplate::SubClass, sWorldUpdateTime, and Utf8FitTo().

Referenced by AuctionListItemsDelayEvent::Execute().

BuildListBidderItems()

void AuctionHouseObject::BuildListBidderItems	(	WorldPacket &	data,
		Player *	player,
		uint32 &	count,
		uint32 &	totalcount
	)

{
    for (AuctionEntryMap::const_iterator itr = _auctionsMap.begin(); itr != _auctionsMap.end(); ++itr)
    {
        AuctionEntry* Aentry = itr->second;
        if (Aentry && Aentry->bidder == player->GetGUID())
        {
            if (itr->second->BuildAuctionInfo(data))
                ++count;
 
            ++totalcount;
        }
    }
}

References _auctionsMap, AuctionEntry::bidder, and Object::GetGUID().

Referenced by WorldSession::HandleAuctionListBidderItems().

BuildListOwnerItems()

void AuctionHouseObject::BuildListOwnerItems	(	WorldPacket &	data,
		Player *	player,
		uint32 &	count,
		uint32 &	totalcount
	)

{
    for (AuctionEntryMap::const_iterator itr = _auctionsMap.begin(); itr != _auctionsMap.end(); ++itr)
    {
        AuctionEntry* Aentry = itr->second;
        if (Aentry && Aentry->owner == player->GetGUID())
        {
            if (Aentry->BuildAuctionInfo(data))
                ++count;
 
            ++totalcount;
        }
    }
}

References _auctionsMap, AuctionEntry::BuildAuctionInfo(), Object::GetGUID(), and AuctionEntry::owner.

Referenced by WorldSession::HandleAuctionListOwnerItemsEvent().

GetAuction()

AuctionEntry * AuctionHouseObject::GetAuction ( uint32  id ) const

inline

    {
        AuctionEntryMap::const_iterator itr = _auctionsMap.find(id);
        return itr != _auctionsMap.end() ? itr->second : nullptr;
    }

References _auctionsMap.

Referenced by WorldSession::HandleAuctionListBidderItems(), WorldSession::HandleAuctionPlaceBid(), and WorldSession::HandleAuctionRemoveItem().

GetAuctions()

AuctionEntryMap const & AuctionHouseObject::GetAuctions ( )

inline

{ return _auctionsMap; }

References _auctionsMap.

Referenced by BuildListAuctionItems(), and WorldSession::HandleCharFactionOrRaceChangeCallback().

GetAuctionsBegin()

AuctionEntryMap::iterator AuctionHouseObject::GetAuctionsBegin ( )

inline

{ return _auctionsMap.begin(); }

References _auctionsMap.

Referenced by BuildListAuctionItems().

GetAuctionsEnd()

AuctionEntryMap::iterator AuctionHouseObject::GetAuctionsEnd ( )

inline

{ return _auctionsMap.end(); }

References _auctionsMap.

Referenced by BuildListAuctionItems().

Getcount()

uint32 AuctionHouseObject::Getcount ( ) const

inline

{ return _auctionsMap.size(); }

References _auctionsMap.

RemoveAuction()

bool AuctionHouseObject::RemoveAuction

(

AuctionEntry *

auction

)

{
    bool wasInMap = !!_auctionsMap.erase(auction->Id);
 
    sScriptMgr->OnAuctionRemove(this, auction);
 
    // we need to delete the entry, it is not referenced any more
    delete auction;
    auction = nullptr;
 
    return wasInMap;
}

References _auctionsMap, AuctionEntry::Id, and sScriptMgr.

Referenced by WorldSession::HandleAuctionPlaceBid(), WorldSession::HandleAuctionRemoveItem(), and Update().

Update()

void AuctionHouseObject::Update

(

)

• Handle expired auctions
• Either cancel the auction if there was no bidder
• Or perform the transaction
• In any case clear the auction

{
    time_t checkTime = GameTime::GetGameTime().count() + 60;
 
    // If storage is empty, no need to update. next == nullptr in this case.
    if (_auctionsMap.empty())
        return;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    for (AuctionEntryMap::iterator itr, iter = _auctionsMap.begin(); iter != _auctionsMap.end(); )
    {
        itr = iter++;
        AuctionEntry* auction = (*itr).second;
 
        if (auction->expire_time > checkTime)
            continue;
 
        if (!auction->bidder)
        {
            sAuctionMgr->SendAuctionExpiredMail(auction, trans);
            sScriptMgr->OnAuctionExpire(this, auction);
        }
        else
        {
            //we should send an "item sold" message if the seller is online
            //we send the item to the winner
            //we send the money to the seller
            sAuctionMgr->SendAuctionSuccessfulMail(auction, trans);
            sAuctionMgr->SendAuctionWonMail(auction, trans);
            sScriptMgr->OnAuctionSuccessful(this, auction);
        }
 
        auction->DeleteFromDB(trans);
 
        sAuctionMgr->RemoveAItem(auction->item_guid);
        RemoveAuction(auction);
    }
    CharacterDatabase.CommitTransaction(trans);
}

References _auctionsMap, AuctionEntry::bidder, CharacterDatabase, AuctionEntry::DeleteFromDB(), AuctionEntry::expire_time, GameTime::GetGameTime(), AuctionEntry::item_guid, RemoveAuction(), sAuctionMgr, and sScriptMgr.

Referenced by AuctionHouseMgr::Update().

Member Data Documentation

_auctionsMap

AuctionEntryMap AuctionHouseObject::_auctionsMap

private

Referenced by AddAuction(), AuctionHouseObject(), BuildListAuctionItems(), BuildListBidderItems(), BuildListOwnerItems(), GetAuction(), GetAuctions(), GetAuctionsBegin(), GetAuctionsEnd(), Getcount(), RemoveAuction(), Update(), and ~AuctionHouseObject().

_next

AuctionEntryMap::const_iterator AuctionHouseObject::_next

private

Referenced by AuctionHouseObject().