AuctionHouseMgr Class Reference

#include "AuctionHouseMgr.h"

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

Public Member Functions
AuctionHouseObject *	GetAuctionsMap (uint32 factionTemplateId)
AuctionHouseObject *	GetAuctionsMapByHouseId (uint8 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)
void	LoadAuctionItems ()
void	LoadAuctions ()
void	AddAItem (Item *it)
bool	RemoveAItem (ObjectGuid itemGuid, bool deleteFromDB=false, CharacterDatabaseTransaction *trans=nullptr)
void	Update ()

Static Public Member Functions
static AuctionHouseMgr *	instance ()
static uint32	GetAuctionDeposit (AuctionHouseEntry const *entry, uint32 time, Item *pItem, uint32 count)
static AuctionHouseEntry const *	GetAuctionHouseEntry (uint32 factionTemplateId)
static AuctionHouseEntry const *	GetAuctionHouseEntryFromHouse (uint8 houseId)

Private Member Functions
	AuctionHouseMgr ()
	~AuctionHouseMgr ()

Private Attributes
AuctionHouseObject	_hordeAuctions
AuctionHouseObject	_allianceAuctions
AuctionHouseObject	_neutralAuctions
ItemMap	_mAitems

Detailed Description

Member Typedef Documentation

ItemMap

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

Constructor & Destructor Documentation

AuctionHouseMgr()

AuctionHouseMgr::AuctionHouseMgr ( )

private

{
}

~AuctionHouseMgr()

AuctionHouseMgr::~AuctionHouseMgr ( )

private

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

References _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.

GetAuctionHouseEntry()

AuctionHouseEntry const * AuctionHouseMgr::GetAuctionHouseEntry ( uint32  factionTemplateId )

static

{
    uint32 houseid = AUCTIONHOUSE_NEUTRAL; // goblin auction house
 
    if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
    {
        //FIXME: found way for proper auctionhouse selection by another way
        // AuctionHouse.dbc have faction field with _player_ factions associated with auction house races.
        // but no easy way convert creature faction to player race faction for specific city
        FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
        if (!u_entry)
            houseid = AUCTIONHOUSE_NEUTRAL; // goblin auction house
        else if (u_entry->ourMask & FACTION_MASK_ALLIANCE)
            houseid = AUCTIONHOUSE_ALLIANCE; // human auction house
        else if (u_entry->ourMask & FACTION_MASK_HORDE)
            houseid = AUCTIONHOUSE_HORDE; // orc auction house
        else
            houseid = AUCTIONHOUSE_NEUTRAL; // goblin auction house
    }
 
    return sAuctionHouseStore.LookupEntry(houseid);
}

References AUCTIONHOUSE_ALLIANCE, AUCTIONHOUSE_HORDE, AUCTIONHOUSE_NEUTRAL, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, FACTION_MASK_ALLIANCE, FACTION_MASK_HORDE, FactionTemplateEntry::ourMask, sAuctionHouseStore, sFactionTemplateStore, and sWorld.

Referenced by WorldSession::HandleAuctionSellItem(), and WorldSession::SendAuctionHello().

GetAuctionHouseEntryFromHouse()

AuctionHouseEntry const * AuctionHouseMgr::GetAuctionHouseEntryFromHouse ( uint8  houseId )

static

{
    return (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION)) ? sAuctionHouseStore.LookupEntry(AUCTIONHOUSE_NEUTRAL) : sAuctionHouseStore.LookupEntry(houseId);
}

References AUCTIONHOUSE_NEUTRAL, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, sAuctionHouseStore, and sWorld.

Referenced by AuctionEntry::LoadFromDB().

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

(

uint8

auctionHouseId

)

{
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
        return &_neutralAuctions;
 
    switch (auctionHouseId)
    {
        case AUCTIONHOUSE_ALLIANCE:
            return &_allianceAuctions;
        case AUCTIONHOUSE_HORDE:
            return &_hordeAuctions;
            break;
    }
 
    return &_neutralAuctions;
}

References _allianceAuctions, _hordeAuctions, _neutralAuctions, AUCTIONHOUSE_ALLIANCE, AUCTIONHOUSE_HORDE, CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION, 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(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(auction->GetHouseId(), auction->Id, newBidder->GetGUID(), newPrice, auction->GetAuctionOutBid(), 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::deposit, ObjectAccessor::FindConnectedPlayer(), AuctionEntry::GetAuctionCut(), AuctionEntry::GetAuctionOutBid(), 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(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

(

)

{
    sScriptMgr->OnBeforeAuctionHouseMgrUpdate();
    _hordeAuctions.Update();
    _allianceAuctions.Update();
    _neutralAuctions.Update();
}

References _allianceAuctions, _hordeAuctions, _neutralAuctions, sScriptMgr, and AuctionHouseObject::Update().

Member Data Documentation

_allianceAuctions

AuctionHouseObject AuctionHouseMgr::_allianceAuctions

private

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

_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().