/** * MaNGOS is a full featured server for World of Warcraft, supporting * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8 * * Copyright (C) 2005-2016 MaNGOS project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * World of Warcraft, and all World of Warcraft or Warcraft art, images, * and lore are copyrighted by Blizzard Entertainment, Inc. */ #include "AuctionHouseMgr.h" #include "Database/DatabaseEnv.h" #include "SQLStorages.h" #include "DBCStores.h" #include "ProgressBar.h" #include "AccountMgr.h" #include "Item.h" #include "Language.h" #include "Log.h" #include "ObjectMgr.h" #include "ObjectGuid.h" #include "Player.h" #include "World.h" #include "WorldPacket.h" #include "WorldSession.h" #include "Mail.h" #include "Policies/Singleton.h" /** \addtogroup auctionhouse * @{ * \file */ INSTANTIATE_SINGLETON_1(AuctionHouseMgr); AuctionHouseMgr::AuctionHouseMgr() { } AuctionHouseMgr::~AuctionHouseMgr() { for (ItemMap::const_iterator itr = mAitems.begin(); itr != mAitems.end(); ++itr) { delete itr->second; } } AuctionHouseObject* AuctionHouseMgr::GetAuctionsMap(AuctionHouseEntry const* house) { if (sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_AUCTION)) { return &mAuctions[AUCTION_HOUSE_NEUTRAL]; } // team have linked auction houses switch (GetAuctionHouseTeam(house)) { case ALLIANCE: return &mAuctions[AUCTION_HOUSE_ALLIANCE]; case HORDE: return &mAuctions[AUCTION_HOUSE_HORDE]; default: return &mAuctions[AUCTION_HOUSE_NEUTRAL]; } } uint32 AuctionHouseMgr::GetAuctionDeposit(AuctionHouseEntry const* entry, uint32 time, Item* pItem) { float deposit = float(pItem->GetProto()->SellPrice * pItem->GetCount() * (time / MIN_AUCTION_TIME)); deposit = deposit * entry->depositPercent / 100.0f; float min_deposit = float(sWorld.getConfig(CONFIG_UINT32_AUCTION_DEPOSIT_MIN)); if (deposit < min_deposit) { deposit = min_deposit; } return uint32(deposit * sWorld.getConfig(CONFIG_FLOAT_RATE_AUCTION_DEPOSIT)); } // does not clear ram void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry* auction) { Item* pItem = GetAItem(auction->itemGuidLow); if (!pItem) { return; } ObjectGuid bidder_guid = ObjectGuid(HIGHGUID_PLAYER, auction->bidder); Player* bidder = sObjectMgr.GetPlayer(bidder_guid); uint32 bidder_accId = 0; ObjectGuid ownerGuid = ObjectGuid(HIGHGUID_PLAYER, auction->owner); // data for gm.log if (sWorld.getConfig(CONFIG_BOOL_GM_LOG_TRADE)) { AccountTypes bidder_security = SEC_PLAYER; std::string bidder_name; if (bidder) { bidder_accId = bidder->GetSession()->GetAccountId(); bidder_security = bidder->GetSession()->GetSecurity(); bidder_name = bidder->GetName(); } else { bidder_accId = sObjectMgr.GetPlayerAccountIdByGUID(bidder_guid); bidder_security = bidder_accId ? sAccountMgr.GetSecurity(bidder_accId) : SEC_PLAYER; if (bidder_security > SEC_PLAYER) // not do redundant DB requests { if (!sObjectMgr.GetPlayerNameByGUID(bidder_guid, bidder_name)) { bidder_name = sObjectMgr.GetMangosStringForDBCLocale(LANG_UNKNOWN); } } } if (bidder_security > SEC_PLAYER) { std::string owner_name; if (ownerGuid && !sObjectMgr.GetPlayerNameByGUID(ownerGuid, owner_name)) { owner_name = sObjectMgr.GetMangosStringForDBCLocale(LANG_UNKNOWN); } uint32 owner_accid = sObjectMgr.GetPlayerAccountIdByGUID(ownerGuid); sLog.outCommand(bidder_accId, "GM %s (Account: %u) won item in auction (Entry: %u Count: %u) and pay money: %u. Original owner %s (Account: %u)", bidder_name.c_str(), bidder_accId, auction->itemTemplate, auction->itemCount, auction->bid, owner_name.c_str(), owner_accid); } } else if (!bidder) { bidder_accId = sObjectMgr.GetPlayerAccountIdByGUID(bidder_guid); } // receiver exist if (bidder || bidder_accId) { std::ostringstream msgAuctionWonSubject; msgAuctionWonSubject << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_WON; std::ostringstream msgAuctionWonBody; msgAuctionWonBody.width(16); msgAuctionWonBody << std::right << std::hex << auction->owner; msgAuctionWonBody << std::dec << ":" << auction->bid << ":" << auction->buyout; DEBUG_LOG("AuctionWon body string : %s", msgAuctionWonBody.str().c_str()); // set owner to bidder (to prevent delete item with sender char deleting) // owner in `data` will set at mail receive and item extracting CharacterDatabase.PExecute("UPDATE item_instance SET owner_guid = '%u' WHERE guid='%u'", auction->bidder, auction->itemGuidLow); if (bidder) { bidder->GetSession()->SendAuctionBidderNotification(auction, true); } RemoveAItem(auction->itemGuidLow); // we have to remove the item, before we delete it !! auction->itemGuidLow = 0; // pending list will not use guid data // will delete item or place to receiver mail list MailDraft(msgAuctionWonSubject.str(), msgAuctionWonBody.str()) .AddItem(pItem) .SendMailTo(MailReceiver(bidder, bidder_guid), auction, MAIL_CHECK_MASK_COPIED); } // receiver not exist else { CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid='%u'", auction->itemGuidLow); RemoveAItem(auction->itemGuidLow); // we have to remove the item, before we delete it !! auction->itemGuidLow = 0; delete pItem; } } // call this method to send mail to auction owner, when auction is successful, it does not clear ram void AuctionHouseMgr::SendAuctionSuccessfulMail(AuctionEntry* auction) { ObjectGuid owner_guid = ObjectGuid(HIGHGUID_PLAYER, auction->owner); Player* owner = sObjectMgr.GetPlayer(owner_guid); uint32 owner_accId = 0; if (!owner) { owner_accId = sObjectMgr.GetPlayerAccountIdByGUID(owner_guid); } // owner exist if (owner || owner_accId) { std::ostringstream msgAuctionSuccessfulSubject; msgAuctionSuccessfulSubject << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_SUCCESSFUL; std::ostringstream auctionSuccessfulBody; uint32 auctionCut = auction->GetAuctionCut(); auctionSuccessfulBody.width(16); auctionSuccessfulBody << std::right << std::hex << auction->bidder; auctionSuccessfulBody << std::dec << ":" << auction->bid << ":" << auction->buyout; auctionSuccessfulBody << ":" << auction->deposit << ":" << auctionCut; DEBUG_LOG("AuctionSuccessful body string : %s", auctionSuccessfulBody.str().c_str()); uint32 profit = auction->bid + auction->deposit - auctionCut; if (owner) { // send auction owner notification, bidder must be current! owner->GetSession()->SendAuctionOwnerNotification(auction, true); } MailDraft(msgAuctionSuccessfulSubject.str(), auctionSuccessfulBody.str()) .SetMoney(profit) .SendMailTo(MailReceiver(owner, owner_guid), auction, MAIL_CHECK_MASK_COPIED); } } // does not clear ram void AuctionHouseMgr::SendAuctionExpiredMail(AuctionEntry* auction) { // return an item in auction to its owner by mail Item* pItem = GetAItem(auction->itemGuidLow); if (!pItem) { sLog.outError("Auction item (GUID: %u) not found, and lost.", auction->itemGuidLow); return; } ObjectGuid owner_guid = ObjectGuid(HIGHGUID_PLAYER, auction->owner); Player* owner = sObjectMgr.GetPlayer(owner_guid); uint32 owner_accId = 0; if (!owner) { owner_accId = sObjectMgr.GetPlayerAccountIdByGUID(owner_guid); } // owner exist if (owner || owner_accId) { std::ostringstream subject; subject << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_EXPIRED; if (owner) { owner->GetSession()->SendAuctionOwnerNotification(auction, false); } RemoveAItem(auction->itemGuidLow); // we have to remove the item, before we delete it !! auction->itemGuidLow = 0; // will delete item or place to receiver mail list MailDraft(subject.str()) .AddItem(pItem) .SendMailTo(MailReceiver(owner, owner_guid), auction, MAIL_CHECK_MASK_COPIED); } // owner not found else { CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid='%u'", auction->itemGuidLow); RemoveAItem(auction->itemGuidLow); // we have to remove the item, before we delete it !! auction->itemGuidLow = 0; delete pItem; } } void AuctionHouseMgr::LoadAuctionItems() { // data needs to be at first place for Item::LoadFromDB 0 1 2 QueryResult* result = CharacterDatabase.Query("SELECT data,itemguid,item_template FROM auction JOIN item_instance ON itemguid = guid"); if (!result) { BarGoLink bar(1); bar.step(); sLog.outString(">> Loaded 0 auction items"); return; } BarGoLink bar(result->GetRowCount()); uint32 count = 0; Field* fields; do { bar.step(); fields = result->Fetch(); uint32 item_guid = fields[1].GetUInt32(); uint32 item_template = fields[2].GetUInt32(); ItemPrototype const* proto = ObjectMgr::GetItemPrototype(item_template); if (!proto) { sLog.outError("AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: %u id: #%u) in auction, skipped.", item_guid, item_template); continue; } Item* item = NewItemOrBag(proto); if (!item->LoadFromDB(item_guid, fields)) { delete item; continue; } AddAItem(item); ++count; } while (result->NextRow()); delete result; sLog.outString(">> Loaded %u auction items", count); sLog.outString(); } void AuctionHouseMgr::LoadAuctions() { QueryResult* result = CharacterDatabase.Query("SELECT COUNT(*) FROM auction"); if (!result) { BarGoLink bar(1); bar.step(); sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty."); return; } Field* fields = result->Fetch(); uint32 AuctionCount = fields[0].GetUInt32(); delete result; if (!AuctionCount) { BarGoLink bar(1); bar.step(); sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty."); return; } // 0 1 2 3 4 5 6 7 8 9 10 11 12 result = CharacterDatabase.Query("SELECT id,houseid,itemguid,item_template,item_count,item_randompropertyid,itemowner,buyoutprice,time,buyguid,lastbid,startbid,deposit FROM auction"); if (!result) { BarGoLink bar(1); bar.step(); sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty."); return; } BarGoLink bar(AuctionCount); do { fields = result->Fetch(); bar.step(); AuctionEntry* auction = new AuctionEntry; auction->Id = fields[0].GetUInt32(); uint32 houseid = fields[1].GetUInt32(); auction->itemGuidLow = fields[2].GetUInt32(); auction->itemTemplate = fields[3].GetUInt32(); auction->itemCount = fields[4].GetUInt32(); auction->itemRandomPropertyId = fields[5].GetUInt32(); auction->owner = fields[6].GetUInt32(); auction->buyout = fields[7].GetUInt32(); auction->expireTime = time_t(fields[8].GetUInt64()); auction->bidder = fields[9].GetUInt32(); auction->bid = fields[10].GetUInt32(); auction->startbid = fields[11].GetUInt32(); auction->deposit = fields[12].GetUInt32(); auction->auctionHouseEntry = NULL; // init later // check if sold item exists for guid // and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems) Item* pItem = GetAItem(auction->itemGuidLow); if (!pItem) { auction->DeleteFromDB(); sLog.outError("Auction %u has not a existing item : %u, deleted", auction->Id, auction->itemGuidLow); delete auction; continue; } // overwrite by real item data if ((auction->itemTemplate != pItem->GetEntry()) || (auction->itemCount != pItem->GetCount()) || (auction->itemRandomPropertyId != pItem->GetItemRandomPropertyId())) { auction->itemTemplate = pItem->GetEntry(); auction->itemCount = pItem->GetCount(); auction->itemRandomPropertyId = pItem->GetItemRandomPropertyId(); // No SQL injection (no strings) CharacterDatabase.PExecute("UPDATE auction SET item_template = %u, item_count = %u, item_randompropertyid = %i WHERE itemguid = %u", auction->itemTemplate, auction->itemCount, auction->itemRandomPropertyId, auction->itemGuidLow); } auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(houseid); if (!auction->auctionHouseEntry) { // need for send mail, use goblin auctionhouse auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(7); // Attempt send item back to owner std::ostringstream msgAuctionCanceledOwner; msgAuctionCanceledOwner << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_CANCELED; if (auction->itemGuidLow) { RemoveAItem(auction->itemGuidLow); auction->itemGuidLow = 0; // item will deleted or added to received mail list MailDraft(msgAuctionCanceledOwner.str(), "")// TODO: fix body .AddItem(pItem) .SendMailTo(MailReceiver(ObjectGuid(HIGHGUID_PLAYER, auction->owner)), auction, MAIL_CHECK_MASK_COPIED); } auction->DeleteFromDB(); delete auction; continue; } GetAuctionsMap(auction->auctionHouseEntry)->AddAuction(auction); } while (result->NextRow()); delete result; sLog.outString(">> Loaded %u auctions", AuctionCount); sLog.outString(); } void AuctionHouseMgr::AddAItem(Item* it) { MANGOS_ASSERT(it); MANGOS_ASSERT(mAitems.find(it->GetGUIDLow()) == mAitems.end()); mAitems[it->GetGUIDLow()] = it; } bool AuctionHouseMgr::RemoveAItem(uint32 id) { ItemMap::iterator i = mAitems.find(id); if (i == mAitems.end()) { return false; } mAitems.erase(i); return true; } void AuctionHouseMgr::Update() { for (int i = 0; i < MAX_AUCTION_HOUSE_TYPE; ++i) { mAuctions[i].Update(); } } uint32 AuctionHouseMgr::GetAuctionHouseTeam(AuctionHouseEntry const* house) { // auction houses have faction field pointing to PLAYER,* factions, // but player factions not have filled team field, and hard go from faction value to faction_template value, // so more easy just sort by auction house ids switch (house->houseId) { case 1: case 2: case 3: return ALLIANCE; case 4: case 5: case 6: return HORDE; case 7: default: return 0; // neutral } } AuctionHouseEntry const* AuctionHouseMgr::GetAuctionHouseEntry(Unit* unit) { uint32 houseid = 1; // dwarf auction house (used for normal cut/etc percents) if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_AUCTION)) { if (unit->GetTypeId() == TYPEID_UNIT) { // 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 uint32 factionTemplateId = unit->getFaction(); switch (factionTemplateId) { case 12: houseid = 1; break; // human case 29: houseid = 6; break; // orc, and generic for horde case 55: houseid = 2; break; // dwarf/gnome, 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 534: houseid = 2; break; // Alliance Generic case 855: houseid = 7; break; // everlook, neutral default: // for unknown case { FactionTemplateEntry const* u_entry = sFactionTemplateStore.LookupEntry(factionTemplateId); if (!u_entry) { houseid = 7; } // goblin auction house else if (u_entry->ourMask & FACTION_MASK_ALLIANCE) { houseid = 1; } // human auction house else if (u_entry->ourMask & FACTION_MASK_HORDE) { houseid = 6; } // orc auction house else { houseid = 7; } // goblin auction house break; } } } else { Player* player = (Player*)unit; if (player->GetAuctionAccessMode() > 0) { houseid = 7; } else { switch (((Player*)unit)->GetTeam()) { case ALLIANCE: houseid = player->GetAuctionAccessMode() == 0 ? 1 : 6; break; case HORDE: houseid = player->GetAuctionAccessMode() == 0 ? 6 : 1; break; default: break; } } } } return sAuctionHouseStore.LookupEntry(houseid); } void AuctionHouseObject::Update() { time_t curTime = sWorld.GetGameTime(); ///- Handle expired auctions for (AuctionEntryMap::iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end();) { AuctionEntryMap::iterator old = itr++; if (curTime > old->second->expireTime) { ///- perform the transaction if there was bidder if (old->second->bid) { old->second->AuctionBidWinning(); } ///- cancel the auction if there was no bidder and clear the auction else { sAuctionMgr.SendAuctionExpiredMail(old->second); old->second->DeleteFromDB(); sAuctionMgr.RemoveAItem(old->second->itemGuidLow); delete old->second; AuctionsMap.erase(old); continue; } } } } 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->bidder == player->GetGUIDLow()) { if (itr->second->BuildAuctionInfo(data)) { ++count; } ++totalcount; } } } 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->owner == player->GetGUIDLow()) { if (Aentry->BuildAuctionInfo(data)) { ++count; } ++totalcount; } } } void AuctionHouseObject::BuildListAuctionItems(WorldPacket& data, Player* player, std::wstring const& wsearchedname, uint32 listfrom, uint32 levelmin, uint32 levelmax, uint32 usable, uint32 inventoryType, uint32 itemClass, uint32 itemSubClass, uint32 quality, uint32& count, uint32& totalcount) { int loc_idx = player->GetSession()->GetSessionDbLocaleIndex(); for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr) { AuctionEntry* Aentry = itr->second; Item* item = sAuctionMgr.GetAItem(Aentry->itemGuidLow); if (!item) { continue; } { ItemPrototype const* proto = item->GetProto(); if (itemClass != 0xffffffff && proto->Class != itemClass) { continue; } if (itemSubClass != 0xffffffff && proto->SubClass != itemSubClass) { continue; } if (inventoryType != 0xffffffff && proto->InventoryType != inventoryType) { 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; if (proto->Class == ITEM_CLASS_RECIPE) { if (SpellEntry const* spell = sSpellStore.LookupEntry(proto->Spells[0].SpellId)) { if (player->HasSpell(spell->EffectTriggerSpell[EFFECT_INDEX_0])) continue; } } } std::string name = proto->Name1; sObjectMgr.GetItemLocaleStrings(proto->ItemId, loc_idx, &name); if (!wsearchedname.empty() && !Utf8FitTo(name, wsearchedname)) { continue; } if (count < 50 && totalcount >= listfrom) { ++count; Aentry->BuildAuctionInfo(data); } } ++totalcount; } } AuctionEntry* AuctionHouseObject::AddAuction(AuctionHouseEntry const* auctionHouseEntry, Item* newItem, uint32 etime, uint32 bid, uint32 buyout, uint32 deposit, Player* pl /*= NULL*/) { uint32 auction_time = uint32(etime * sWorld.getConfig(CONFIG_FLOAT_RATE_AUCTION_TIME)); AuctionEntry* AH = new AuctionEntry; AH->Id = sObjectMgr.GenerateAuctionID(); AH->itemGuidLow = newItem->GetObjectGuid().GetCounter(); AH->itemTemplate = newItem->GetEntry(); AH->itemCount = newItem->GetCount(); AH->itemRandomPropertyId = newItem->GetItemRandomPropertyId(); AH->owner = pl ? pl->GetGUIDLow() : 0; AH->startbid = bid; AH->bidder = 0; AH->bid = 0; AH->buyout = buyout; AH->expireTime = time(NULL) + auction_time; AH->deposit = deposit; AH->auctionHouseEntry = auctionHouseEntry; AddAuction(AH); sAuctionMgr.AddAItem(newItem); if (pl) { pl->MoveItemFromInventory(newItem->GetBagSlot(), newItem->GetSlot(), true); } CharacterDatabase.BeginTransaction(); if (pl) { newItem->DeleteFromInventoryDB(); } newItem->SaveToDB(); AH->SaveToDB(); if (pl) { pl->SaveInventoryAndGoldToDB(); } CharacterDatabase.CommitTransaction(); return AH; } // this function inserts to WorldPacket auction's data bool AuctionEntry::BuildAuctionInfo(WorldPacket& data) const { Item* pItem = sAuctionMgr.GetAItem(itemGuidLow); if (!pItem) { sLog.outError("auction to item, that doesn't exist !!!!"); return false; } data << uint32(Id); data << uint32(pItem->GetEntry()); // [-ZERO] no other infos about enchantment in 1.12 [?] // for (uint8 i = 0; i < MAX_INSPECTED_ENCHANTMENT_SLOT; ++i) //{ data << uint32(pItem->GetEnchantmentId(EnchantmentSlot(PERM_ENCHANTMENT_SLOT))); // data << uint32(pItem->GetEnchantmentDuration(EnchantmentSlot(i))); // data << uint32(pItem->GetEnchantmentCharges(EnchantmentSlot(i))); //} data << uint32(pItem->GetItemRandomPropertyId()); // random item property id data << uint32(pItem->GetItemSuffixFactor()); // SuffixFactor data << uint32(pItem->GetCount()); // item->count data << uint32(pItem->GetSpellCharges()); // item->charge FFFFFFF data << ObjectGuid(HIGHGUID_PLAYER, owner); // Auction->owner data << uint32(startbid); // Auction->startbid (not sure if useful) data << uint32(bid ? GetAuctionOutBid() : 0); // minimal outbid data << uint32(buyout); // auction->buyout data << uint32((expireTime - time(NULL))*IN_MILLISECONDS); // time left data << ObjectGuid(HIGHGUID_PLAYER, bidder); // auction->bidder current data << uint32(bid); // current bid return true; } uint32 AuctionEntry::GetAuctionCut() const { return uint32(auctionHouseEntry->cutPercent * bid * sWorld.getConfig(CONFIG_FLOAT_RATE_AUCTION_CUT) / 100.0f); } /// the sum of outbid is (1% from current bid)*5, if bid is very small, it is 1c uint32 AuctionEntry::GetAuctionOutBid() const { uint32 outbid = (bid / 100) * 5; if (!outbid) { outbid = 1; } return outbid; } void AuctionEntry::DeleteFromDB() const { // No SQL injection (Id is integer) CharacterDatabase.PExecute("DELETE FROM auction WHERE id = '%u'", Id); } void AuctionEntry::SaveToDB() const { // No SQL injection (no strings) CharacterDatabase.PExecute("INSERT INTO auction (id,houseid,itemguid,item_template,item_count,item_randompropertyid,itemowner,buyoutprice,time,buyguid,lastbid,startbid,deposit) " "VALUES ('%u', '%u', '%u', '%u', '%u', '%i', '%u', '%u', '" UI64FMTD "', '%u', '%u', '%u', '%u')", Id, auctionHouseEntry->houseId, itemGuidLow, itemTemplate, itemCount, itemRandomPropertyId, owner, buyout, (uint64)expireTime, bidder, bid, startbid, deposit); } void AuctionEntry::AuctionBidWinning(Player* newbidder) { sAuctionMgr.SendAuctionSuccessfulMail(this); sAuctionMgr.SendAuctionWonMail(this); sAuctionMgr.RemoveAItem(this->itemGuidLow); sAuctionMgr.GetAuctionsMap(this->auctionHouseEntry)->RemoveAuction(this->Id); CharacterDatabase.BeginTransaction(); this->DeleteFromDB(); if (newbidder) { newbidder->SaveInventoryAndGoldToDB(); } CharacterDatabase.CommitTransaction(); delete this; } bool AuctionEntry::UpdateBid(uint32 newbid, Player* newbidder /*=NULL*/) { Player* auction_owner = owner ? sObjectMgr.GetPlayer(ObjectGuid(HIGHGUID_PLAYER, owner)) : NULL; // bid can't be greater buyout if (buyout && newbid > buyout) { newbid = buyout; } if (newbidder && newbidder->GetGUIDLow() == bidder) { newbidder->ModifyMoney(-int32(newbid - bid)); } else { if (newbidder) { newbidder->ModifyMoney(-int32(newbid)); } if (bidder) // return money to old bidder if present { WorldSession::SendAuctionOutbiddedMail(this); } } bidder = newbidder ? newbidder->GetGUIDLow() : 0; bid = newbid; if ((newbid < buyout) || (buyout == 0)) // bid { if (auction_owner) { auction_owner->GetSession()->SendAuctionOwnerNotification(this, false); } // after this update we should save player's money ... CharacterDatabase.BeginTransaction(); CharacterDatabase.PExecute("UPDATE auction SET buyguid = '%u', lastbid = '%u' WHERE id = '%u'", bidder, bid, Id); if (newbidder) { newbidder->SaveInventoryAndGoldToDB(); } CharacterDatabase.CommitTransaction(); return true; } else // buyout { AuctionBidWinning(newbidder); return false; } } /** @} */