AuctionHouseMgr Class Reference

#include "AuctionHouseMgr.h"

Public Types
typedef std::unordered_map< ObjectGuid, Item * >	ItemMap

Public Member Functions
AuctionHouseObject *	GetAuctionsMap (uint32 factionTemplateId)
AuctionHouseObject *	GetAuctionsMapByHouseId (AuctionHouseId auctionHouseId)
Item *	GetAItem (ObjectGuid itemGuid)
void	SendAuctionWonMail (AuctionEntry *auction, CharacterDatabaseTransaction trans, bool sendNotification=true, bool updateAchievementCriteria=true, bool sendMail=true)
void	SendAuctionSalePendingMail (AuctionEntry *auction, CharacterDatabaseTransaction trans, bool sendMail=true)
void	SendAuctionSuccessfulMail (AuctionEntry *auction, CharacterDatabaseTransaction trans, bool sendNotification=true, bool updateAchievementCriteria=true, bool sendMail=true)
void	SendAuctionExpiredMail (AuctionEntry *auction, CharacterDatabaseTransaction trans, bool sendNotification=true, bool sendMail=true)
void	SendAuctionOutbiddedMail (AuctionEntry *auction, uint32 newPrice, Player *newBidder, CharacterDatabaseTransaction trans, bool sendNotification=true, bool sendMail=true)
void	SendAuctionCancelledToBidderMail (AuctionEntry *auction, CharacterDatabaseTransaction trans, bool sendMail=true)
AuctionHouseSearcher *	GetAuctionHouseSearcher ()
void	LoadAuctionItems ()
void	LoadAuctions ()
void	AddAItem (Item *it)
bool	RemoveAItem (ObjectGuid itemGuid, bool deleteFromDB=false, CharacterDatabaseTransaction *trans=nullptr)
void	Update (uint32 const diff)

Static Public Member Functions
static AuctionHouseMgr *	instance ()
static uint32	GetAuctionDeposit (AuctionHouseEntry const *entry, uint32 time, Item *pItem, uint32 count)
static AuctionHouseFaction	GetAuctionHouseFactionFromHouseId (AuctionHouseId ahHouseId)
static AuctionHouseEntry const *	GetAuctionHouseEntryFromFactionTemplate (uint32 factionTemplateId)
static AuctionHouseEntry const *	GetAuctionHouseEntryFromHouse (AuctionHouseId ahHouseId)

Private Member Functions
	AuctionHouseMgr ()
	~AuctionHouseMgr ()

Private Attributes
AuctionHouseObject	_hordeAuctions
AuctionHouseObject	_allianceAuctions
AuctionHouseObject	_neutralAuctions
ItemMap	_mAitems
AuctionHouseSearcher *	_auctionHouseSearcher
IntervalTimer	_updateIntervalTimer

Detailed Description

Member Typedef Documentation

ItemMap

typedef std::unordered_map<ObjectGuid, Item*> AuctionHouseMgr::ItemMap

Constructor & Destructor Documentation

AuctionHouseMgr()

AuctionHouseMgr::AuctionHouseMgr ( )

private

                                 : _auctionHouseSearcher(new AuctionHouseSearcher())
{
    _updateIntervalTimer.SetInterval(MINUTE * IN_MILLISECONDS);
    _updateIntervalTimer.SetCurrent(MINUTE * IN_MILLISECONDS);
}

References _updateIntervalTimer, IN_MILLISECONDS, MINUTE, IntervalTimer::SetCurrent(), and IntervalTimer::SetInterval().

~AuctionHouseMgr()

AuctionHouseMgr::~AuctionHouseMgr ( )

private

{
    for (ItemMap::iterator itr = _mAitems.begin(); itr != _mAitems.end(); ++itr)
        delete itr->second;
 
    delete _auctionHouseSearcher;
}

References _auctionHouseSearcher, and _mAitems.

Member Function Documentation

AddAItem()

void AuctionHouseMgr::AddAItem

(

Item *

it

)

{
    ASSERT(it);
    ASSERT(_mAitems.find(it->GetGUID()) == _mAitems.end());
    _mAitems[it->GetGUID()] = it;
}

References _mAitems, ASSERT, and Object::GetGUID().

Referenced by LoadAuctionItems().

GetAItem()

Item * AuctionHouseMgr::GetAItem ( ObjectGuid  itemGuid )

inline

    {
        ItemMap::const_iterator itr = _mAitems.find(itemGuid);
        if (itr != _mAitems.end())
            return itr->second;
 
        return nullptr;
    }

References _mAitems.

Referenced by SendAuctionExpiredMail(), and SendAuctionWonMail().

GetAuctionDeposit()

uint32 AuctionHouseMgr::GetAuctionDeposit ( AuctionHouseEntry const *  entry, uint32  time, Item *  pItem, uint32  count  )

static

{
    uint32 MSV = pItem->GetTemplate()->SellPrice;
 
    if (MSV <= 0)
        return AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT);
 
    float multiplier = CalculatePct(float(entry->depositPercent), 3);
    uint32 timeHr = (((time / 60) / 60) / 12);
    uint32 deposit = uint32(((multiplier * MSV * count / 3) * timeHr * 3) * sWorld->getRate(RATE_AUCTION_DEPOSIT));
 
    LOG_DEBUG("auctionHouse", "MSV:        {}", MSV);
    LOG_DEBUG("auctionHouse", "Items:      {}", count);
    LOG_DEBUG("auctionHouse", "Multiplier: {}", multiplier);
    LOG_DEBUG("auctionHouse", "Deposit:    {}", deposit);
 
    if (deposit < AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT))
        return AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT);
    else
        return deposit;
}

References AH_MINIMUM_DEPOSIT, CalculatePct(), AuctionHouseEntry::depositPercent, Item::GetTemplate(), LOG_DEBUG, RATE_AUCTION_DEPOSIT, ItemTemplate::SellPrice, and sWorld.

GetAuctionHouseEntryFromFactionTemplate()

AuctionHouseEntry const * AuctionHouseMgr::GetAuctionHouseEntryFromFactionTemplate ( uint32  factionTemplateId )

static

{
    AuctionHouseId houseid;
    FactionTemplateEntry const* uEntry = sFactionTemplateStore.LookupEntry(factionTemplateId);
 
    if (!uEntry || sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
        houseid = AuctionHouseId::Neutral;
    else if (uEntry->ourMask & FACTION_MASK_ALLIANCE)
        houseid = AuctionHouseId::Alliance;
    else if (uEntry->ourMask & FACTION_MASK_HORDE)
        houseid = AuctionHouseId::Horde;
    else
        houseid = AuctionHouseId::Neutral;
 
    return sAuctionHouseStore.LookupEntry((uint32)houseid);
}

References Alliance, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, FACTION_MASK_ALLIANCE, FACTION_MASK_HORDE, Horde, Neutral, FactionTemplateEntry::ourMask, sAuctionHouseStore, sFactionTemplateStore, and sWorld.

Referenced by WorldSession::HandleAuctionListBidderItems(), WorldSession::HandleAuctionListItems(), WorldSession::HandleAuctionListOwnerItems(), WorldSession::HandleAuctionSellItem(), and WorldSession::SendAuctionHello().

GetAuctionHouseEntryFromHouse()

AuctionHouseEntry const * AuctionHouseMgr::GetAuctionHouseEntryFromHouse ( AuctionHouseId  ahHouseId )

static

{
    return (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION)) ? sAuctionHouseStore.LookupEntry((uint32)AuctionHouseId::Neutral) : sAuctionHouseStore.LookupEntry((uint32)ahHouseId);
}

References CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, Neutral, sAuctionHouseStore, and sWorld.

Referenced by AuctionEntry::LoadFromDB().

GetAuctionHouseFactionFromHouseId()

AuctionHouseFaction AuctionHouseMgr::GetAuctionHouseFactionFromHouseId ( AuctionHouseId  ahHouseId )

static

{
    switch (ahHouseId)
    {
        case AuctionHouseId::Alliance:
            return AuctionHouseFaction::Alliance;
        case AuctionHouseId::Horde:
            return AuctionHouseFaction::Horde;
        case AuctionHouseId::Neutral:
            return AuctionHouseFaction::Neutral;
    }
    return AuctionHouseFaction::Neutral;
}

References Alliance, Horde, and Neutral.

Referenced by AuctionEntry::GetFactionId(), WorldSession::HandleAuctionListBidderItems(), WorldSession::HandleAuctionListItems(), and WorldSession::HandleAuctionListOwnerItems().

GetAuctionHouseSearcher()

AuctionHouseSearcher * AuctionHouseMgr::GetAuctionHouseSearcher ( )

inline

{ return _auctionHouseSearcher; }

References _auctionHouseSearcher.

GetAuctionsMap()

AuctionHouseObject * AuctionHouseMgr::GetAuctionsMap

(

uint32

factionTemplateId

)

{
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
        return &_neutralAuctions;
 
    // team have linked auction houses
    FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
    if (!u_entry)
        return &_neutralAuctions;
    else if (u_entry->ourMask & FACTION_MASK_ALLIANCE)
        return &_allianceAuctions;
    else if (u_entry->ourMask & FACTION_MASK_HORDE)
        return &_hordeAuctions;
 
    return &_neutralAuctions;
}

References _allianceAuctions, _hordeAuctions, _neutralAuctions, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, FACTION_MASK_ALLIANCE, FACTION_MASK_HORDE, FactionTemplateEntry::ourMask, sFactionTemplateStore, and sWorld.

GetAuctionsMapByHouseId()

AuctionHouseObject * AuctionHouseMgr::GetAuctionsMapByHouseId

(

AuctionHouseId

auctionHouseId

)

{
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
        return &_neutralAuctions;
 
    switch (auctionHouseId)
    {
        case AuctionHouseId::Alliance:
            return &_allianceAuctions;
        case AuctionHouseId::Horde:
            return &_hordeAuctions;
        case AuctionHouseId::Neutral:
        default:
            break;
    }
 
    return &_neutralAuctions;
}

References _allianceAuctions, _hordeAuctions, _neutralAuctions, Alliance, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, Horde, Neutral, and sWorld.

Referenced by LoadAuctions().

instance()

AuctionHouseMgr * AuctionHouseMgr::instance ( )

static

{
    static AuctionHouseMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadAuctionItems()

void AuctionHouseMgr::LoadAuctionItems

(

)

{
    uint32 oldMSTime = getMSTime();
 
    // need to clear in case we are reloading
    if (!_mAitems.empty())
    {
        for (ItemMap::iterator itr = _mAitems.begin(); itr != _mAitems.end(); ++itr)
            delete itr->second;
 
        _mAitems.clear();
    }
 
    // data needs to be at first place for Item::LoadFromDB
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTION_ITEMS);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 auction items. DB table `auctionhouse` or `item_instance` is empty!");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
 
        ObjectGuid::LowType item_guid = fields[11].Get<uint32>();
        uint32 item_template = fields[12].Get<uint32>();
 
        ItemTemplate const* proto = sObjectMgr->GetItemTemplate(item_template);
        if (!proto)
        {
            LOG_ERROR("auctionHouse", "AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: {} id: #{}) in auction, skipped.", item_guid, item_template);
            continue;
        }
 
        Item* item = NewItemOrBag(proto);
        if (!item->LoadFromDB(item_guid, ObjectGuid::Empty, fields, item_template))
        {
            delete item;
            continue;
        }
        AddAItem(item);
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} auction items in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _mAitems, AddAItem(), CHAR_SEL_AUCTION_ITEMS, CharacterDatabase, ObjectGuid::Empty, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), Item::LoadFromDB(), LOG_ERROR, LOG_INFO, LOG_WARN, NewItemOrBag(), and sObjectMgr.

LoadAuctions()

void AuctionHouseMgr::LoadAuctions

(

)

{
    uint32 oldMSTime = getMSTime();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTIONS);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    do
    {
        Field* fields = result->Fetch();
 
        AuctionEntry* aItem = new AuctionEntry();
        if (!aItem->LoadFromDB(fields))
        {
            aItem->DeleteFromDB(trans);
            delete aItem;
            continue;
        }
 
        GetAuctionsMapByHouseId(AuctionHouseId(aItem->houseId))->AddAuction(aItem);
        count++;
    } while (result->NextRow());
 
    CharacterDatabase.CommitTransaction(trans);
 
    LOG_INFO("server.loading", ">> Loaded {} auctions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References AuctionHouseObject::AddAuction(), CHAR_SEL_AUCTIONS, CharacterDatabase, AuctionEntry::DeleteFromDB(), GetAuctionsMapByHouseId(), getMSTime(), GetMSTimeDiffToNow(), AuctionEntry::houseId, AuctionEntry::LoadFromDB(), LOG_INFO, and LOG_WARN.

RemoveAItem()

bool AuctionHouseMgr::RemoveAItem	(	ObjectGuid	itemGuid,
		bool	deleteFromDB = false,
		CharacterDatabaseTransaction *	trans = nullptr
	)

{
    ItemMap::iterator i = _mAitems.find(itemGuid);
    if (i == _mAitems.end())
        return false;
 
    if (deleteFromDB)
    {
        ASSERT(trans);
        i->second->FSetState(ITEM_REMOVED);
        i->second->SaveToDB(*trans);
    }
 
    _mAitems.erase(i);
    return true;
}

References _mAitems, ASSERT, and ITEM_REMOVED.

SendAuctionCancelledToBidderMail()

void AuctionHouseMgr::SendAuctionCancelledToBidderMail	(	AuctionEntry *	auction,
		CharacterDatabaseTransaction	trans,
		bool	sendMail = true
	)

{
    Player* bidder = ObjectAccessor::FindConnectedPlayer(auction->bidder);
 
    uint32 bidder_accId = 0;
    if (!bidder)
    {
        bidder_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->bidder);
    }
 
    // bidder exist
    if (bidder || bidder_accId)
    {
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail(this, auction, bidder, bidder_accId, sendMail);
        if (sendMail) // can be changed in the hook
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_CANCELLED_TO_BIDDER), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, auction->deposit))
            .AddMoney(auction->bid)
            .SendMailTo(trans, MailReceiver(bidder, auction->bidder.GetCounter()), auction, MAIL_CHECK_MASK_COPIED);
    }
}

References MailDraft::AddMoney(), AUCTION_CANCELLED_TO_BIDDER, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, AuctionEntry::deposit, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, sCharacterCache, MailDraft::SendMailTo(), and sScriptMgr.

SendAuctionExpiredMail()

void AuctionHouseMgr::SendAuctionExpiredMail	(	AuctionEntry *	auction,
		CharacterDatabaseTransaction	trans,
		bool	sendNotification = true,
		bool	sendMail = true
	)

{
    //return an item in auction to its owner by mail
    Item* pItem = GetAItem(auction->item_guid);
    if (!pItem)
        return;
 
    Player* owner = ObjectAccessor::FindConnectedPlayer(auction->owner);
    uint32 owner_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->owner);
 
    // owner exist
    if (owner || owner_accId)
    {
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionExpiredMail(this, auction, owner, owner_accId, sendNotification, sendMail);
 
        if (owner && sendNotification) // can be changed in the hook
            owner->GetSession()->SendAuctionOwnerNotification(auction);
 
        if (sendMail) // can be changed in the hook
        {
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_EXPIRED), AuctionEntry::BuildAuctionMailBody(ObjectGuid::Empty, 0, auction->buyout, auction->deposit))
                .AddItem(pItem)
                .SendMailTo(trans, MailReceiver(owner, auction->owner.GetCounter()), auction, MAIL_CHECK_MASK_COPIED, 0);
        }
    }
    else
        sAuctionMgr->RemoveAItem(auction->item_guid, true, &trans);
}

References MailDraft::AddItem(), AUCTION_EXPIRED, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, AuctionEntry::deposit, ObjectGuid::Empty, ObjectAccessor::FindConnectedPlayer(), GetAItem(), ObjectGuid::GetCounter(), Player::GetSession(), AuctionEntry::item_guid, MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, sAuctionMgr, sCharacterCache, WorldSession::SendAuctionOwnerNotification(), MailDraft::SendMailTo(), and sScriptMgr.

SendAuctionOutbiddedMail()

void AuctionHouseMgr::SendAuctionOutbiddedMail	(	AuctionEntry *	auction,
		uint32	newPrice,
		Player *	newBidder,
		CharacterDatabaseTransaction	trans,
		bool	sendNotification = true,
		bool	sendMail = true
	)

{
    Player* oldBidder = ObjectAccessor::FindConnectedPlayer(auction->bidder);
 
    uint32 oldBidder_accId = 0;
    if (!oldBidder)
        oldBidder_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->bidder);
 
    // old bidder exist
    if (oldBidder || oldBidder_accId)
    {
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail(this, auction, oldBidder, oldBidder_accId, newBidder, newPrice, sendNotification, sendMail);
 
        if (oldBidder && newBidder && sendNotification) // can be changed in the hook
            oldBidder->GetSession()->SendAuctionBidderNotification((uint32)auction->GetHouseId(), auction->Id, newBidder->GetGUID(), newPrice, AuctionEntry::CalculateAuctionOutBid(auction->bid), auction->item_template);
 
        if (sendMail) // can be changed in the hook
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_OUTBIDDED), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
            .AddMoney(auction->bid)
            .SendMailTo(trans, MailReceiver(oldBidder, auction->bidder.GetCounter()), auction, MAIL_CHECK_MASK_COPIED);
    }
}

References MailDraft::AddMoney(), AUCTION_OUTBIDDED, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, AuctionEntry::CalculateAuctionOutBid(), AuctionEntry::deposit, ObjectAccessor::FindConnectedPlayer(), AuctionEntry::GetAuctionCut(), ObjectGuid::GetCounter(), Object::GetGUID(), AuctionEntry::GetHouseId(), Player::GetSession(), AuctionEntry::Id, AuctionEntry::item_template, MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, sCharacterCache, WorldSession::SendAuctionBidderNotification(), MailDraft::SendMailTo(), and sScriptMgr.

SendAuctionSalePendingMail()

void AuctionHouseMgr::SendAuctionSalePendingMail	(	AuctionEntry *	auction,
		CharacterDatabaseTransaction	trans,
		bool	sendMail = true
	)

{
    Player* owner = ObjectAccessor::FindConnectedPlayer(auction->owner);
    uint32 owner_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->owner);
    // owner exist (online or offline)
    if (owner || owner_accId)
    {
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionSalePendingMail(this, auction, owner, owner_accId, sendMail);
 
        uint32 deliveryDelay = sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY);
 
        ByteBuffer timePacker;
        timePacker.AppendPackedTime(GameTime::GetGameTime().count() + time_t(deliveryDelay));
 
        if (sendMail) // can be changed in the hook
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_SALE_PENDING),
                AuctionEntry::BuildAuctionMailBody(auction->bidder, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut(), deliveryDelay, timePacker.read<uint32>()))
            .SendMailTo(trans, MailReceiver(owner, auction->owner.GetCounter()), auction, MAIL_CHECK_MASK_COPIED);
    }
}

References ByteBuffer::AppendPackedTime(), AUCTION_SALE_PENDING, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, CONFIG_MAIL_DELIVERY_DELAY, AuctionEntry::deposit, ObjectAccessor::FindConnectedPlayer(), AuctionEntry::GetAuctionCut(), ObjectGuid::GetCounter(), GameTime::GetGameTime(), MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, ByteBuffer::read(), sCharacterCache, MailDraft::SendMailTo(), sScriptMgr, and sWorld.

SendAuctionSuccessfulMail()

void AuctionHouseMgr::SendAuctionSuccessfulMail	(	AuctionEntry *	auction,
		CharacterDatabaseTransaction	trans,
		bool	sendNotification = true,
		bool	updateAchievementCriteria = true,
		bool	sendMail = true
	)

{
    Player* owner = ObjectAccessor::FindConnectedPlayer(auction->owner);
    uint32 owner_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->owner);
    // owner exist
    if (owner || owner_accId)
    {
        uint32 profit = auction->bid + auction->deposit - auction->GetAuctionCut();
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail(this, auction, owner, owner_accId, profit, sendNotification, updateAchievementCriteria, sendMail);
 
        if (owner)
        {
            if (updateAchievementCriteria) // can be changed in the hook
            {
                owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS, profit);
                owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD, auction->bid);
            }
 
            if (sendNotification) // can be changed in the hook
                owner->GetSession()->SendAuctionOwnerNotification(auction);
        }
        else if (updateAchievementCriteria)
        {
            sAchievementMgr->UpdateAchievementCriteriaForOfflinePlayer(auction->owner.GetCounter(), ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS, profit);
            sAchievementMgr->UpdateAchievementCriteriaForOfflinePlayer(auction->owner.GetCounter(), ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD, auction->bid);
        }
 
        if (sendMail) // can be changed in the hook
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_SUCCESSFUL), AuctionEntry::BuildAuctionMailBody(auction->bidder, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
            .AddMoney(profit)
            .SendMailTo(trans, MailReceiver(owner, auction->owner.GetCounter()), auction, MAIL_CHECK_MASK_COPIED, sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY));
 
        if (auction->bid >= 500 * GOLD)
            if (CharacterCacheEntry const* gpd = sCharacterCache->GetCharacterCacheByGuid(auction->bidder))
            {
                Player* bidder = ObjectAccessor::FindConnectedPlayer(auction->bidder);
                std::string owner_name = "";
                uint8 owner_level = 0;
                if (CharacterCacheEntry const* gpd_owner = sCharacterCache->GetCharacterCacheByGuid(auction->owner))
                {
                    owner_name = gpd_owner->Name;
                    owner_level = gpd_owner->Level;
                }
                CharacterDatabase.Execute("INSERT INTO log_money VALUES({}, {}, \"{}\", \"{}\", {}, \"{}\", {}, \"profit: {}g, bidder: {} {} lvl (guid: {}), seller: {} {} lvl (guid: {}), item {} ({})\", NOW(), {})",
                    gpd->AccountId, auction->bidder.GetCounter(), gpd->Name, bidder ? bidder->GetSession()->GetRemoteAddress() : "", owner_accId, owner_name, auction->bid, (profit / GOLD), gpd->Name, gpd->Level, auction->bidder.GetCounter(), owner_name, owner_level, auction->owner.GetCounter(), auction->item_template, auction->itemCount, 2);
            }
    }
}

References ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS, ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD, MailDraft::AddMoney(), AUCTION_SUCCESSFUL, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, CharacterDatabase, CONFIG_MAIL_DELIVERY_DELAY, AuctionEntry::deposit, ObjectAccessor::FindConnectedPlayer(), AuctionEntry::GetAuctionCut(), ObjectGuid::GetCounter(), WorldSession::GetRemoteAddress(), Player::GetSession(), GOLD, AuctionEntry::item_template, AuctionEntry::itemCount, MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, sAchievementMgr, sCharacterCache, WorldSession::SendAuctionOwnerNotification(), MailDraft::SendMailTo(), sScriptMgr, sWorld, and Player::UpdateAchievementCriteria().

SendAuctionWonMail()

void AuctionHouseMgr::SendAuctionWonMail	(	AuctionEntry *	auction,
		CharacterDatabaseTransaction	trans,
		bool	sendNotification = true,
		bool	updateAchievementCriteria = true,
		bool	sendMail = true
	)

{
    Item* pItem = GetAItem(auction->item_guid);
    if (!pItem)
        return;
 
    uint32 bidder_accId = 0;
    Player* bidder = ObjectAccessor::FindConnectedPlayer(auction->bidder);
    if (bidder)
        bidder_accId = bidder->GetSession()->GetAccountId();
    else
        bidder_accId = sCharacterCache->GetCharacterAccountIdByGuid(auction->bidder);
 
    // receiver exist
    if (bidder || bidder_accId)
    {
        sScriptMgr->OnBeforeAuctionHouseMgrSendAuctionWonMail(this, auction, bidder, bidder_accId, sendNotification, updateAchievementCriteria, sendMail);
        // set owner to bidder (to prevent delete item with sender char deleting)
        // owner in `data` will set at mail receive and item extracting
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_OWNER);
        stmt->SetData(0, auction->bidder.GetCounter());
        stmt->SetData(1, pItem->GetGUID().GetCounter());
        trans->Append(stmt);
 
        if (bidder)
        {
            if (sendNotification) // can be changed in the hook
                bidder->GetSession()->SendAuctionBidderNotification((uint32)auction->GetHouseId(), auction->Id, auction->bidder, 0, 0, auction->item_template);
 
            if (updateAchievementCriteria) // can be changed in the hook
                bidder->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, 1);
        }
        else if (updateAchievementCriteria)
            sAchievementMgr->UpdateAchievementCriteriaForOfflinePlayer(auction->bidder.GetCounter(), ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, 1);
 
        if (sendMail) // can be changed in the hook
        {
            MailDraft(auction->BuildAuctionMailSubject(AUCTION_WON), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout))
                .AddItem(pItem)
                .SendMailTo(trans, MailReceiver(bidder, auction->bidder.GetCounter()), auction, MAIL_CHECK_MASK_COPIED);
        }
    }
    else
        sAuctionMgr->RemoveAItem(auction->item_guid, true, &trans);
}

References ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, MailDraft::AddItem(), AUCTION_WON, AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::BuildAuctionMailBody(), AuctionEntry::BuildAuctionMailSubject(), AuctionEntry::buyout, CHAR_UPD_ITEM_OWNER, CharacterDatabase, ObjectAccessor::FindConnectedPlayer(), WorldSession::GetAccountId(), GetAItem(), ObjectGuid::GetCounter(), Object::GetGUID(), AuctionEntry::GetHouseId(), Player::GetSession(), AuctionEntry::Id, AuctionEntry::item_guid, AuctionEntry::item_template, MAIL_CHECK_MASK_COPIED, AuctionEntry::owner, sAchievementMgr, sAuctionMgr, sCharacterCache, WorldSession::SendAuctionBidderNotification(), MailDraft::SendMailTo(), PreparedStatementBase::SetData(), sScriptMgr, and Player::UpdateAchievementCriteria().

Update()

void AuctionHouseMgr::Update

(

uint32 const

diff

)

{
    _updateIntervalTimer.Update(diff);
    if (_updateIntervalTimer.Passed())
    {
        sScriptMgr->OnBeforeAuctionHouseMgrUpdate();
 
        _hordeAuctions.Update();
        _allianceAuctions.Update();
        _neutralAuctions.Update();
 
        _updateIntervalTimer.Reset();
    }
 
    _auctionHouseSearcher->Update();
}

References _allianceAuctions, _auctionHouseSearcher, _hordeAuctions, _neutralAuctions, _updateIntervalTimer, IntervalTimer::Passed(), IntervalTimer::Reset(), sScriptMgr, AuctionHouseObject::Update(), AuctionHouseSearcher::Update(), and IntervalTimer::Update().

Member Data Documentation

_allianceAuctions

AuctionHouseObject AuctionHouseMgr::_allianceAuctions

private

Referenced by GetAuctionsMap(), GetAuctionsMapByHouseId(), and Update().

_auctionHouseSearcher

AuctionHouseSearcher* AuctionHouseMgr::_auctionHouseSearcher

private

Referenced by GetAuctionHouseSearcher(), Update(), and ~AuctionHouseMgr().

_hordeAuctions

AuctionHouseObject AuctionHouseMgr::_hordeAuctions

private

Referenced by GetAuctionsMap(), GetAuctionsMapByHouseId(), and Update().

_mAitems

ItemMap AuctionHouseMgr::_mAitems

private

Referenced by AddAItem(), GetAItem(), LoadAuctionItems(), RemoveAItem(), and ~AuctionHouseMgr().

_neutralAuctions

AuctionHouseObject AuctionHouseMgr::_neutralAuctions

private

Referenced by GetAuctionsMap(), GetAuctionsMapByHouseId(), and Update().

_updateIntervalTimer

IntervalTimer AuctionHouseMgr::_updateIntervalTimer

private

Referenced by AuctionHouseMgr(), and Update().

---

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

• azerothcore-wotlk/src/server/game/AuctionHouse/AuctionHouseMgr.h
• azerothcore-wotlk/src/server/game/AuctionHouse/AuctionHouseMgr.cpp