AuctionHouseMgr Class Reference

#include <AuctionHouseMgr.h>

Public Types
typedef std::unordered_map < ObjectGuid::LowType, Item * >	ItemMap
typedef std::vector < AuctionEntry * >	PlayerAuctions
typedef std::pair < PlayerAuctions *, uint32 >	AuctionPair

Public Member Functions
AuctionHouseObject *	GetAuctionsMap (uint32 factionTemplateId)
AuctionHouseObject *	GetBidsMap (uint32 factionTemplateId)
Item *	GetAItem (ObjectGuid::LowType id)
void	SendAuctionWonMail (AuctionEntry *auction, SQLTransaction &trans)
void	SendAuctionSalePendingMail (AuctionEntry *auction, SQLTransaction &trans)
void	SendAuctionSuccessfulMail (AuctionEntry *auction, SQLTransaction &trans)
void	SendAuctionExpiredMail (AuctionEntry *auction, SQLTransaction &trans)
void	SendAuctionOutbiddedMail (AuctionEntry *auction, uint32 newPrice, Player *newBidder, SQLTransaction &trans)
void	SendAuctionCancelledToBidderMail (AuctionEntry *auction, SQLTransaction &trans)
void	LoadAuctionItems ()
void	LoadAuctions ()
void	AddAItem (Item *it)
bool	RemoveAItem (ObjectGuid::LowType id, bool deleteItem=false)
void	PendingAuctionAdd (Player *player, AuctionEntry *aEntry)
uint32	PendingAuctionCount (const Player *player) const
void	PendingAuctionProcess (Player *player)
void	UpdatePendingAuctions ()
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)

Private Member Functions
	AuctionHouseMgr ()
	~AuctionHouseMgr ()

Private Attributes
AuctionHouseObject	mHordeAuctions
AuctionHouseObject	mAllianceAuctions
AuctionHouseObject	mNeutralAuctions
std::map< ObjectGuid, AuctionPair >	pendingAuctionMap
ItemMap	mAitems

Member Typedef Documentation

typedef std::pair<PlayerAuctions*, uint32> AuctionHouseMgr::AuctionPair

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

typedef std::vector<AuctionEntry*> AuctionHouseMgr::PlayerAuctions

Constructor & Destructor Documentation

AuctionHouseMgr::AuctionHouseMgr ( )

private

{ }

AuctionHouseMgr::~AuctionHouseMgr ( )

private

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

Member Function Documentation

void AuctionHouseMgr::AddAItem

(

Item *

it

)

{
 ASSERT(it);
 ASSERT(mAitems.count(it->GetGUID().GetCounter()) == 0);
 mAitems[it->GetGUID().GetCounter()] = it;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Item* AuctionHouseMgr::GetAItem ( ObjectGuid::LowType  id )

inline

 {
 ItemMap::const_iterator itr = mAitems.find(id);
 if (itr != mAitems.end())
 return itr->second;

 return NULL;
 }

Here is the caller graph for this function:

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

static

{
 uint32 MSV = pItem->GetTemplate()->GetSellPrice();

 if (MSV <= 0)
 return AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT);

 float multiplier = CalculatePct(float(entry->DepositRate), 3);
 uint32 timeHr = (((time / 60) / 60) / 12);
 uint32 deposit = uint32(MSV * multiplier * sWorld->getRate(RATE_AUCTION_DEPOSIT));
 float remainderbase = float(MSV * multiplier * sWorld->getRate(RATE_AUCTION_DEPOSIT)) - deposit;

 deposit *= timeHr * count;

 int i = count;
 while (i > 0 && (remainderbase * i) != uint32(remainderbase * i))
 i--;

 if (i)
 deposit += remainderbase * i * timeHr;

 TC_LOG_DEBUG("auctionHouse", "MSV: %u", MSV);
 TC_LOG_DEBUG("auctionHouse", "Items: %u", count);
 TC_LOG_DEBUG("auctionHouse", "Multiplier: %f", multiplier);
 TC_LOG_DEBUG("auctionHouse", "Deposit: %u", deposit);
 TC_LOG_DEBUG("auctionHouse", "Deposit rm: %f", remainderbase * count);

 if (deposit < AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT))
 return AH_MINIMUM_DEPOSIT * sWorld->getRate(RATE_AUCTION_DEPOSIT);
 else
 return deposit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AuctionHouseEntry const * AuctionHouseMgr::GetAuctionHouseEntry ( uint32  factionTemplateId )

static

{
 uint32 houseid = 7; // 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
 switch (factionTemplateId)
 {
 case 12: houseid = 1; break; // human
 case 29: houseid = 6; break; // orc, and generic for horde
 case 55: houseid = 2; break; // dwarf, and generic for alliance
 case 68: houseid = 4; break; // undead
 case 80: houseid = 3; break; // n-elf
 case 104: houseid = 5; break; // trolls
 case 120: houseid = 7; break; // booty bay, neutral
 case 474: houseid = 7; break; // gadgetzan, neutral
 case 855: houseid = 7; break; // everlook, neutral
 case 1604: houseid = 6; break; // b-elfs,
 default: // for unknown case
 {
 FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId);
 if (!u_entry)
 houseid = 7; // goblin auction house
 else if (u_entry->Mask & FACTION_MASK_ALLIANCE)
 houseid = 1; // human auction house
 else if (u_entry->Mask & FACTION_MASK_HORDE)
 houseid = 6; // orc auction house
 else
 houseid = 7; // goblin auction house
 break;
 }
 }
 }

 return sAuctionHouseStore.LookupEntry(houseid);
}

Here is the caller graph for this function:

AuctionHouseObject * AuctionHouseMgr::GetAuctionsMap

(

uint32

factionTemplateId

)

{
 if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
 return &mNeutralAuctions;

 // teams have linked auction houses
 FactionTemplateEntry const* uEntry = sFactionTemplateStore.LookupEntry(factionTemplateId);
 if (!uEntry)
 return &mNeutralAuctions;
 else if (uEntry->Mask & FACTION_MASK_ALLIANCE)
 return &mAllianceAuctions;
 else if (uEntry->Mask & FACTION_MASK_HORDE)
 return &mHordeAuctions;
 else
 return &mNeutralAuctions;
}

Here is the caller graph for this function:

AuctionHouseObject* AuctionHouseMgr::GetBidsMap

(

uint32

factionTemplateId

)

AuctionHouseMgr * AuctionHouseMgr::instance ( )

static

{
 static AuctionHouseMgr instance;
 return &instance;
}

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
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTION_ITEMS);
 PreparedQueryResult result = CharacterDatabase.Query(stmt);

 if (!result)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 auction items. DB table `auctionhouse` or `item_instance` is empty!");
 return;
 }

 uint32 count = 0;

 do
 {
 Field* fields = result->Fetch();

 ObjectGuid::LowType itemGuid = fields[0].GetUInt64();
 uint32 itemEntry = fields[1].GetUInt32();

 ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemEntry);
 if (!proto)
 {
 TC_LOG_ERROR("misc", "AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: " UI64FMTD " item entry: #%u) in auction, skipped.", itemGuid, itemEntry);
 continue;
 }

 Item* item = NewItemOrBag(proto);
 if (!item->LoadFromDB(itemGuid, ObjectGuid::Empty, fields, itemEntry))
 {
 delete item;
 continue;
 }
 AddAItem(item);

 ++count;
 }
 while (result->NextRow());

 TC_LOG_INFO("server.loading", ">> Loaded %u auction items in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}

Here is the call graph for this function:

void AuctionHouseMgr::LoadAuctions

(

)

{
 uint32 oldMSTime = getMSTime();

 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_AUCTIONS);
 PreparedQueryResult result = CharacterDatabase.Query(stmt);

 if (!result)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 auctions. DB table `auctionhouse` is empty.");
 return;
 }

 uint32 count = 0;

 SQLTransaction trans = CharacterDatabase.BeginTransaction();
 do
 {
 Field* fields = result->Fetch();

 AuctionEntry* aItem = new AuctionEntry();
 if (!aItem->LoadFromDB(fields))
 {
 aItem->DeleteFromDB(trans);
 delete aItem;
 continue;
 }

 GetAuctionsMap(aItem->factionTemplateId)->AddAuction(aItem);
 ++count;
 } while (result->NextRow());

 CharacterDatabase.CommitTransaction(trans);

 TC_LOG_INFO("server.loading", ">> Loaded %u auctions in %u ms", count, GetMSTimeDiffToNow(oldMSTime));

}

Here is the call graph for this function:

void AuctionHouseMgr::PendingAuctionAdd	(	Player *	player,
		AuctionEntry *	aEntry
	)

{
 PlayerAuctions* thisAH;
 auto itr = pendingAuctionMap.find(player->GetGUID());
 if (itr != pendingAuctionMap.end())
 thisAH = itr->second.first;
 else
 {
 thisAH = new PlayerAuctions;
 pendingAuctionMap[player->GetGUID()] = AuctionPair(thisAH, 0);
 }
 thisAH->push_back(aEntry);
}

uint32 AuctionHouseMgr::PendingAuctionCount

(

const Player *

player

)

const

{
 auto const itr = pendingAuctionMap.find(player->GetGUID());
 if (itr != pendingAuctionMap.end())
 return itr->second.first->size();

 return 0;
}

Here is the caller graph for this function:

void AuctionHouseMgr::PendingAuctionProcess

(

Player *

player

)

{
 auto iterMap = pendingAuctionMap.find(player->GetGUID());
 if (iterMap == pendingAuctionMap.end())
 return;

 PlayerAuctions* thisAH = iterMap->second.first;

 SQLTransaction trans = CharacterDatabase.BeginTransaction();

 uint32 totalItems = 0;
 for (auto itrAH = thisAH->begin(); itrAH != thisAH->end(); ++itrAH)
 {
 AuctionEntry* AH = (*itrAH);
 totalItems += AH->itemCount;
 }

 uint32 totaldeposit = 0;
 auto itr = (*thisAH->begin());

 if (Item* item = GetAItem(itr->itemGUIDLow))
 totaldeposit = GetAuctionDeposit(itr->auctionHouseEntry, itr->etime, item, totalItems);

 uint32 depositremain = totaldeposit;
 for (auto itr = thisAH->begin(); itr != thisAH->end(); ++itr)
 {
 AuctionEntry* AH = (*itr);

 if (next(itr) == thisAH->end())
 AH->deposit = depositremain;
 else
 {
 AH->deposit = totaldeposit / thisAH->size();
 depositremain -= AH->deposit;
 }

 AH->DeleteFromDB(trans);
 AH->SaveToDB(trans);
 }

 CharacterDatabase.CommitTransaction(trans);
 pendingAuctionMap.erase(player->GetGUID());
 delete thisAH;
 player->ModifyMoney(-int32(totaldeposit));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool AuctionHouseMgr::RemoveAItem	(	ObjectGuid::LowType	id,
		bool	deleteItem = false
	)

{
 ItemMap::iterator i = mAitems.find(id);
 if (i == mAitems.end())
 return false;

 if (deleteItem)
 {
 SQLTransaction trans = SQLTransaction(nullptr);
 i->second->FSetState(ITEM_REMOVED);
 i->second->SaveToDB(trans);
 }

 mAitems.erase(i);
 return true;
}

void AuctionHouseMgr::SendAuctionCancelledToBidderMail	(	AuctionEntry *	auction,
		SQLTransaction &	trans
	)

{
 ObjectGuid bidder_guid = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
 Player* bidder = ObjectAccessor::FindConnectedPlayer(bidder_guid);

 uint32 bidder_accId = 0;

 if (!bidder)
 bidder_accId = ObjectMgr::GetPlayerAccountIdByGUID(bidder_guid);

 // bidder exist
 if (bidder || bidder_accId)
 MailDraft(auction->BuildAuctionMailSubject(AUCTION_CANCELLED_TO_BIDDER), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, auction->deposit, 0))
 .AddMoney(auction->bid)
 .SendMailTo(trans, MailReceiver(bidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
}

Here is the call graph for this function:

void AuctionHouseMgr::SendAuctionExpiredMail	(	AuctionEntry *	auction,
		SQLTransaction &	trans
	)

{
 //return an item in auction to its owner by mail
 Item* item = GetAItem(auction->itemGUIDLow);
 if (!item)
 return;

 ObjectGuid owner_guid = ObjectGuid::Create<HighGuid::Player>(auction->owner);
 Player* owner = ObjectAccessor::FindConnectedPlayer(owner_guid);
 uint32 owner_accId = ObjectMgr::GetPlayerAccountIdByGUID(owner_guid);
 // owner exist
 if (owner || owner_accId)
 {
 if (owner)
 owner->GetSession()->SendAuctionClosedNotification(auction, 0.0f, false, item);

 MailDraft(auction->BuildAuctionMailSubject(AUCTION_EXPIRED), AuctionEntry::BuildAuctionMailBody(0, 0, auction->buyout, auction->deposit, 0))
 .AddItem(item)
 .SendMailTo(trans, MailReceiver(owner, auction->owner), auction, MAIL_CHECK_MASK_COPIED, 0);
 }
 else
 {
 // owner doesn't exist, delete the item
 sAuctionMgr->RemoveAItem(auction->itemGUIDLow, true);
 }
}

Here is the call graph for this function:

void AuctionHouseMgr::SendAuctionOutbiddedMail	(	AuctionEntry *	auction,
		uint32	newPrice,
		Player *	newBidder,
		SQLTransaction &	trans
	)

{
 ObjectGuid oldBidder_guid = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
 Player* oldBidder = ObjectAccessor::FindConnectedPlayer(oldBidder_guid);

 uint32 oldBidder_accId = 0;
 if (!oldBidder)
 oldBidder_accId = ObjectMgr::GetPlayerAccountIdByGUID(oldBidder_guid);

 Item* item = GetAItem(auction->itemGUIDLow);

 // old bidder exist
 if (oldBidder || oldBidder_accId)
 {
 if (oldBidder && item)
 oldBidder->GetSession()->SendAuctionOutBidNotification(auction, item);

 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), auction, MAIL_CHECK_MASK_COPIED);
 }
}

Here is the call graph for this function:

void AuctionHouseMgr::SendAuctionSalePendingMail	(	AuctionEntry *	auction,
		SQLTransaction &	trans
	)

{
 ObjectGuid owner_guid = ObjectGuid::Create<HighGuid::Player>(auction->owner);
 Player* owner = ObjectAccessor::FindConnectedPlayer(owner_guid);
 uint32 owner_accId = ObjectMgr::GetPlayerAccountIdByGUID(owner_guid);
 // owner exist (online or offline)
 if (owner || owner_accId)
 MailDraft(auction->BuildAuctionMailSubject(AUCTION_SALE_PENDING), AuctionEntry::BuildAuctionMailBody(auction->bidder, auction->bid, auction->buyout, auction->deposit, auction->GetAuctionCut()))
 .SendMailTo(trans, MailReceiver(owner, auction->owner), auction, MAIL_CHECK_MASK_COPIED);
}

Here is the call graph for this function:

void AuctionHouseMgr::SendAuctionSuccessfulMail	(	AuctionEntry *	auction,
		SQLTransaction &	trans
	)

{
 ObjectGuid owner_guid = ObjectGuid::Create<HighGuid::Player>(auction->owner);
 Player* owner = ObjectAccessor::FindConnectedPlayer(owner_guid);
 uint32 owner_accId = ObjectMgr::GetPlayerAccountIdByGUID(owner_guid);
 Item* item = GetAItem(auction->itemGUIDLow);

 // owner exist
 if (owner || owner_accId)
 {
 uint32 profit = auction->bid + auction->deposit - auction->GetAuctionCut();

 //FIXME: what do if owner offline
 if (owner && item)
 {
 owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_EARNED_BY_AUCTIONS, profit);
 owner->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_AUCTION_SOLD, auction->bid);
 //send auction owner notification, bidder must be current!
 owner->GetSession()->SendAuctionClosedNotification(auction, (float)sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY), true, item);
 }

 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), auction, MAIL_CHECK_MASK_COPIED, sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY));
 }
}

Here is the call graph for this function:

void AuctionHouseMgr::SendAuctionWonMail	(	AuctionEntry *	auction,
		SQLTransaction &	trans
	)

{
 Item* item = GetAItem(auction->itemGUIDLow);
 if (!item)
 return;

 uint32 bidderAccId = 0;
 ObjectGuid bidderGuid = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
 Player* bidder = ObjectAccessor::FindConnectedPlayer(bidderGuid);
 // data for gm.log
 std::string bidderName;
 bool logGmTrade = false;

 if (bidder)
 {
 bidderAccId = bidder->GetSession()->GetAccountId();
 bidderName = bidder->GetName();
 logGmTrade = bidder->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE);
 }
 else
 {
 bidderAccId = ObjectMgr::GetPlayerAccountIdByGUID(bidderGuid);
 logGmTrade = AccountMgr::HasPermission(bidderAccId, rbac::RBAC_PERM_LOG_GM_TRADE, realm.Id.Realm);

 if (logGmTrade && !ObjectMgr::GetPlayerNameByGUID(bidderGuid, bidderName))
 bidderName = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);
 }

 if (logGmTrade)
 {
 ObjectGuid ownerGuid = ObjectGuid::Create<HighGuid::Player>(auction->owner);
 std::string ownerName;
 if (!ObjectMgr::GetPlayerNameByGUID(ownerGuid, ownerName))
 ownerName = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);

 uint32 ownerAccId = ObjectMgr::GetPlayerAccountIdByGUID(ownerGuid);

 sLog->outCommand(bidderAccId, "GM %s (Account: %u) won item in auction: %s (Entry: %u Count: %u) and pay money: %u. Original owner %s (Account: %u)",
 bidderName.c_str(), bidderAccId, item->GetTemplate()->GetDefaultLocaleName(), item->GetEntry(), item->GetCount(), auction->bid, ownerName.c_str(), ownerAccId);
 }

 // receiver exist
 if (bidder || bidderAccId)
 {
 // set owner to bidder (to prevent delete item with sender char deleting)
 // owner in `data` will set at mail receive and item extracting
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_OWNER);
 stmt->setUInt64(0, auction->bidder);
 stmt->setUInt64(1, item->GetGUID().GetCounter());
 trans->Append(stmt);

 if (bidder)
 {
 bidder->GetSession()->SendAuctionWonNotification(auction, item);
 // FIXME: for offline player need also
 bidder->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, 1);
 }

 MailDraft(auction->BuildAuctionMailSubject(AUCTION_WON), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, 0, 0))
 .AddItem(item)
 .SendMailTo(trans, MailReceiver(bidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
 }
 else
 {
 // bidder doesn't exist, delete the item
 sAuctionMgr->RemoveAItem(auction->itemGUIDLow, true);
 }
}

Here is the call graph for this function:

void AuctionHouseMgr::Update

(

)

{
 mHordeAuctions.Update();
 mAllianceAuctions.Update();
 mNeutralAuctions.Update();
}

Here is the call graph for this function:

void AuctionHouseMgr::UpdatePendingAuctions

(

)

{
 for (auto itr = pendingAuctionMap.begin(); itr != pendingAuctionMap.end();)
 {
 ObjectGuid playerGUID = itr->first;
 if (Player* player = ObjectAccessor::FindConnectedPlayer(playerGUID))
 {
 // Check if there were auctions since last update process if not
 if (PendingAuctionCount(player) == itr->second.second)
 {
 ++itr;
 PendingAuctionProcess(player);
 }
 else
 {
 ++itr;
 pendingAuctionMap[playerGUID].second = PendingAuctionCount(player);
 }
 }
 else
 {
 // Expire any auctions that we couldn't get a deposit for
 TC_LOG_WARN("auctionHouse", "Player %s was offline, unable to retrieve deposit!", playerGUID.ToString().c_str());
 PlayerAuctions* thisAH = itr->second.first;
 ++itr;
 SQLTransaction trans = CharacterDatabase.BeginTransaction();
 for (auto AHitr = thisAH->begin(); AHitr != thisAH->end();)
 {
 AuctionEntry* AH = (*AHitr);
 ++AHitr;
 AH->expire_time = time(NULL);
 AH->DeleteFromDB(trans);
 AH->SaveToDB(trans);
 }
 CharacterDatabase.CommitTransaction(trans);
 pendingAuctionMap.erase(playerGUID);
 delete thisAH;
 }
 }
}

Here is the call graph for this function:

Member Data Documentation

ItemMap AuctionHouseMgr::mAitems

private

AuctionHouseObject AuctionHouseMgr::mAllianceAuctions

private

AuctionHouseObject AuctionHouseMgr::mHordeAuctions

private

AuctionHouseObject AuctionHouseMgr::mNeutralAuctions

private

std::map<ObjectGuid, AuctionPair> AuctionHouseMgr::pendingAuctionMap

private

---

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

• src/server/game/AuctionHouse/AuctionHouseMgr.h
• src/server/game/AuctionHouse/AuctionHouseMgr.cpp